Y IndexedDB

https://github.com/yjs/y-indexeddb
Admin
Y IndexedDB is an IndexedDB database adapter for Yjs that stores shared data persistently in the...
Tokens:19,693
Snippets:140
Trust Score:8.1
License:MIT
Update:1 week ago
Show doc for...
Tokens:
Raw
### get usage example - basic call

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Demonstrates retrieving a value previously stored with set. Logs the retrieved value.

```javascript
import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'

const provider = new IndexeddbPersistence('my-document', new Y.Doc())
await provider.whenSynced
await provider.set('owner', 'alice')

const owner = await provider.get('owner')
console.log('owner is', owner) // 'alice'
```

--------------------------------

### Basic usage example

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Creates a Y.Doc and an IndexeddbPersistence provider, then logs when the document is synced.

```javascript
import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'

const doc = new Y.Doc()
const provider = new IndexeddbPersistence('my-document', doc)

provider.whenSynced.then(() => {
  console.log('content from the database is loaded, synced =', provider.synced)
})
```

--------------------------------

### Example: storing meta-information with set

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Example usage of the set method to store an app version and a last-seen date. Requires a provider instance and awaiting whenSynced.

```javascript
import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'

const provider = new IndexeddbPersistence('my-document', new Y.Doc())
await provider.whenSynced

await provider.set('app-version', '2.1.0')
await provider.set('last-seen', new Date())

console.log(await provider.get('app-version')) // '2.1.0'
```

--------------------------------

### get usage example - missing key / non-synced meta data

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Shows that get returns undefined for a missing key and notes that meta data is local only and not synced to other peers.

```javascript
const doc = new Y.Doc()
const provider = new IndexeddbPersistence('my-document', doc)
await provider.whenSynced

const missing = await provider.get('does-not-exist')
console.log(missing) // undefined

// Meta data is local only: it is NOT part of the Yjs update log and is never
// synced to other peers.
```

--------------------------------

### Install y-indexeddb with npm

Source: https://github.com/yjs/y-indexeddb/blob/master/README.md

Install the y-indexeddb package using npm. Run this command in your project directory before importing the provider.

```sh
npm i --save y-indexeddb
```

--------------------------------

### Example - reset before a fresh session

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/functions.md

Deletes the database, then creates a new IndexeddbPersistence provider and waits for it to sync, ensuring a fresh, empty database is ready.

```javascript
import { IndexeddbPersistence, clearDocument } from 'y-indexeddb'

await clearDocument('my-document')

const provider = new IndexeddbPersistence('my-document', new Y.Doc())
await provider.whenSynced
console.log('fresh, empty database is ready')
```

--------------------------------

### Manual teardown example

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Shows how to manually destroy the provider after waiting for the 'synced' event. The database connection is closed but data is retained.

```javascript
import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'

const doc = new Y.Doc()
const provider = new IndexeddbPersistence('my-document', doc)

await provider.whenSynced
await provider.destroy()
console.log('database connection closed, data retained')
```

--------------------------------

### Example: removing a stored value with del

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Example usage of the del method to remove a previously stored value. Shows that get returns undefined after deletion.

```javascript
import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'

const provider = new IndexeddbPersistence('my-document', new Y.Doc())
await provider.whenSynced
await provider.set('temp', 'value')
await provider.del('temp')

console.log(await provider.get('temp')) // undefined
```

--------------------------------

### Example - wiping a document's database

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/functions.md

Imports clearDocument and deletes all persisted data for a document, independent of any live provider.

```javascript
import { clearDocument } from 'y-indexeddb'

// Remove all persisted data for a document, independent of any live provider.
await clearDocument('my-document')
```

--------------------------------

### clearData usage example

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Shows how to use clearData to wipe all persisted data for a document after syncing. Logs a message after the database is removed.

```javascript
import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'

const doc = new Y.Doc()
const provider = new IndexeddbPersistence('my-document', doc)
await provider.whenSynced
doc.getArray('list').insert(0, ['offline edit'])

// Wipe all persisted data for this document.
await provider.clearData()
console.log('database removed; the next session starts empty')
```

--------------------------------

### get method implementation

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Retrieves a value from the custom object store using the given key. Returns a Promise that resolves with the stored value or undefined if not found.

```javascript
  /**
   * @param {String | number | ArrayBuffer | Date} key
   * @return {Promise<String | number | ArrayBuffer | Date | any>}
   */
  get (key) {
    return this._db.then(db => {
      const [custom] = idb.transact(db, [customStoreName], 'readonly')
      return idb.get(custom, key)
    })
  }
```

--------------------------------

### get (key) => Promise<String | number | ArrayBuffer | Date | any>

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Retrieves a value previously stored with `set` from the `custom` object store.

```APIDOC
## get

### Description
Retrieves a value previously stored with `set` from the `custom` object store.

### Method
No HTTP method (instance method)

### Endpoint
N/A

### Parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `key` | `String \| number \| ArrayBuffer \| Date` | yes | — | The key under which the value was stored. |

### Return
`Promise<String | number | ArrayBuffer | Date | any>` — resolves with the stored value, or `undefined` if no value exists for the key.

### Example — basic call
```js
import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'

const provider = new IndexeddbPersistence('my-document', new Y.Doc())
await provider.whenSynced
await provider.set('owner', 'alice')

const owner = await provider.get('owner')
console.log('owner is', owner) // 'alice'
```

### Example — missing key / non-synced meta data
```js
const doc = new Y.Doc()
const provider = new IndexeddbPersistence('my-document', doc)
await provider.whenSynced

const missing = await provider.get('does-not-exist')
console.log(missing) // undefined

// Meta data is local only: it is NOT part of the Yjs update log and is never
// synced to other peers.
```
```

--------------------------------

### fetchUpdates with Callbacks

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/functions.md

Demonstrates calling fetchUpdates with before and after callbacks. The before callback logs before applying updates; the after callback logs after applying and shows the resulting _dbsize.

```js
import { IndexeddbPersistence, fetchUpdates } from 'y-indexeddb'

const provider = new IndexeddbPersistence('my-document', doc)
await provider.whenSynced

await fetchUpdates(
  provider,
  (updatesStore) => console.log('about to apply updates'),
  (updatesStore) => console.log('applied updates; store size =', provider._dbsize)
)
```

--------------------------------

### Basic fetchUpdates Usage

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/functions.md

Demonstrates a basic fetchUpdates call. Creates a provider, waits for sync, then fetches any pending updates from the store and applies them. No callbacks are provided.

```js
import * as Y from 'yjs'
import { IndexeddbPersistence, fetchUpdates } from 'y-indexeddb'

const provider = new IndexeddbPersistence('my-document', new Y.Doc())
await provider.whenSynced

// Pull any updates written by another session and apply them to the doc.
await fetchUpdates(provider)
console.log('consumed all currently available updates')
```

--------------------------------

### provider.on('synced', callback)

Source: https://github.com/yjs/y-indexeddb/blob/master/README.md

Listens for the 'synced' event to know when the database connection is established and content is loaded.

```APIDOC
## provider.on('synced', callback)

### Description
Registers a listener for the 'synced' event, which is fired when the connection to the database has been established and all available content has been loaded. The event is also fired if no content is found for the given doc name.

### Event
`'synced'`

### Callback Parameters
- **idbPersistence** (IndexeddbPersistence) - The provider instance.

### Example
```js
provider.on('synced', () => {
  console.log('content from the database is loaded')
})
```
```

--------------------------------

### fetchUpdates(idbPersistence, beforeApplyUpdatesCallback?, afterApplyUpdatesCallback?)

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/functions.md

Reads all pending updates from the `updates` store and applies them to the provider's document. Only updates whose auto-increment key is strictly greater than `_dbref` are fetched, making the function incremental and allowing multiple provider instances to converge without re-applying already-consumed updates.

```APIDOC
## fetchUpdates(idbPersistence, beforeApplyUpdatesCallback?, afterApplyUpdatesCallback?)

### Description
Reads all pending updates from the `updates` store and applies them to the provider's document. Only updates whose auto-increment key is strictly greater than `_dbref` (via `createIDBKeyRangeLowerBound(idbPersistence._dbref, false)`) are fetched — this makes the function incremental and lets multiple provider instances converge without re-applying already-consumed updates.

### Parameters
- `idbPersistence` (IndexeddbPersistence) - Required - The provider instance whose `db`, `_dbref`, `_dbsize`, `_destroyed`, and `doc` fields are used.
- `beforeApplyUpdatesCallback` (function(IDBObjectStore): void) - Optional - Default: `() => {}` - Invoked with the `updates` store **before** the fetched updates are applied to the document.
- `afterApplyUpdatesCallback` (function(IDBObjectStore): void) - Optional - Default: `() => {}` - Invoked with the `updates` store **after** the fetched updates are applied. The provider's own sync logic uses this to set `synced = true` and emit `'synced'`.

### Return
`Promise<IDBObjectStore>` — resolves with the `updates` object store.

### Side effects
- Applies all fetched updates to `idbPersistence.doc` inside a `Y.transact(..., idbPersistence, false)` — the provider instance is the transaction origin and the transaction is **non-local** (`false`), so local observers are not notified.
- Advances `_dbref` to `lastKey + 1` and refreshes `_dbsize` from the store record count.
- No-ops the apply step when `idbPersistence._destroyed` is `true`.

### Example — basic call
```js
import * as Y from 'yjs'
import { IndexeddbPersistence, fetchUpdates } from 'y-indexeddb'

const provider = new IndexeddbPersistence('my-document', new Y.Doc())
await provider.whenSynced

// Pull any updates written by another session and apply them to the doc.
await fetchUpdates(provider)
console.log('consumed all currently available updates')
```

### Example — with callbacks
```js
import { IndexeddbPersistence, fetchUpdates } from 'y-indexeddb'

const provider = new IndexeddbPersistence('my-document', doc)
await provider.whenSynced

await fetchUpdates(
  provider,
  (updatesStore) => console.log('about to apply updates'),
  (updatesStore) => console.log('applied updates; store size =', provider._dbsize)
)
```
```

--------------------------------

### Create IndexedDB object stores

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/configuration.md

Constructor code that opens the IndexedDB database and creates the object stores: 'updates' with autoIncrement: true and 'custom' with default configuration. The store names are module-internal constants and are not exported.

```javascript
    this._db = idb.openDB(name, db =>
      idb.createStores(db, [
        ['updates', { autoIncrement: true }],
        ['custom']
      ])
    )
```

--------------------------------

### Error handling / destroy before sync

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Demonstrates destroying the provider before the database finishes opening, which prevents the 'synced' event from firing. Includes a guard to avoid an unresolved promise.

```javascript
import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'

const doc = new Y.Doc()
const provider = new IndexeddbPersistence('my-document', doc)

// Destroying before the DB finishes opening means 'synced' never fires.
provider.destroy()
await provider.whenSynced.catch(() => {}) // guard against never resolving
```

--------------------------------

### Create IndexeddbPersistence provider and listen for synced event

Source: https://github.com/yjs/y-indexeddb/blob/master/README.md

Creates an IndexeddbPersistence provider for the given document name and Y.Doc instance. The 'synced' event fires when the connection to the database has been established and content from the database is loaded.

```js
const provider = new IndexeddbPersistence(docName, ydoc)

provider.on('synced', () => {
  console.log('content from the database is loaded')
})
```

--------------------------------

### Constructor signature

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Shows the constructor signature with JSDoc type annotations for name and doc parameters.

```javascript
  /**
   * @param {string} name
   * @param {Y.Doc} doc
   */
  constructor (name, doc) {
```

--------------------------------

### provider.get(key)

Source: https://github.com/yjs/y-indexeddb/blob/master/README.md

Retrieves a stored value from the provider instance.

```APIDOC
## provider.get(key)

### Description
Retrieves a stored value from the provider instance.

### Method
`provider.get(key: any): Promise<any>`

### Parameters
- **key** (any) - Required - The key of the value to retrieve.

### Returns
- **Promise<any>** - A promise that resolves to the stored value.
```

--------------------------------

### Import y-indexeddb public API

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/index.md

Imports the main public symbols from the y-indexeddb package: IndexeddbPersistence, clearDocument, fetchUpdates, storeState, and PREFERRED_TRIM_SIZE. Use this to access the adapter's core functionality.

```javascript
import { IndexeddbPersistence, clearDocument, fetchUpdates, storeState, PREFERRED_TRIM_SIZE } from 'y-indexeddb'
```

--------------------------------

### IndexeddbPersistence (class)

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Documentation for the IndexeddbPersistence class constructor.

```APIDOC
## IndexeddbPersistence (class)

### Description
Main provider class that binds a `Y.Doc` to an IndexedDB database, persists the document's update log, restores content on startup, and emits a `'synced'` event once stored content has been loaded.

### Import Path
```js
import { IndexeddbPersistence } from 'y-indexeddb'
```

### Extends
- `Observable<string>` from `lib0/observable`
  - Inherits `on`, `off`, and `emit` event primitives
  - Event name type: `string`
  - Emits `'synced'` event
  - Listens on the document for `'update'` and `'destroy'` events

### Constructor

#### Signature
```js
constructor(name: string, doc: Y.Doc)
```

#### Parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `name` | `string` | yes | — | A unique string identifying this document / database. The IndexedDB database is created/opened under this name. Typically the same identifier used as the room-name in the connection provider. |
| `doc` | `Y.Doc` | yes | — | The Yjs document to persist. Its update log is stored and reapplied; its `'update'` and `'destroy'` events drive persistence and teardown. |

#### Behavior
- Opens (or creates) an IndexedDB database named `name` with two object stores: `updates` (`{ autoIncrement: true }`) and `custom` (see `configuration.md`).
- Initializes all instance state (see Properties).
- Sets `_storeTimeout` to `1000` ms (the debounce window before compaction).
- Registers `this._storeUpdate` as an `'update'` listener on the document and registers the bound `destroy` method on the document's `'destroy'` event.
- Starts the async sync-in sequence: when the DB resolves, it appends the current doc state, applies stored updates, and emits `'synced'`.

#### Properties Set by the Constructor
| Property | Type | Initial value | Description |
|----------|------|---------------|-------------|
| `doc` | `Y.Doc` | argument | The bound Yjs document. |
| `name` | `string` | argument | Database/document identifier. |
| `_dbref` | `number` | `0` | Watermark for the highest update key already consumed. |
| `_dbsize` | `number` | `0` | Current record count in the `updates` store. |
| `_destroyed` | `boolean` | `false` | Set to `true` by `destroy()`; guards further writes/applies. |
| `db` | `IDBDatabase \| null` | `null` | Resolved database handle once `_db` settles. |
| `synced` | `boolean` | `false` | Becomes `true` when the `'synced'` event fires. |
| `_db` | `Promise<IDBDatabase>` | `idb.openDB(name, ...)` | Promise that resolves with the opened `IDBDatabase`. |
| `whenSynced` | `Promise<IndexeddbPersistence>` | `promise.create(...)` | Promise that resolves with this instance once `'synced'` fires. |
| `_storeTimeout` | `number` | `1000` | Debounce timeout (ms) before a compaction `storeState` runs. |
| `_storeTimeoutId` | `any` | `null` | Handle of the pending debounce timer. |
| `_storeUpdate` | `(update: Uint8Array, origin: any) => void` | bound handler | Writes document updates to the `updates` store; debounces compaction. |

#### Example — Basic Use
```js
import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'

const doc = new Y.Doc()
const provider = new IndexeddbPersistence('my-document', doc)

provider.whenSynced.then(() => {
  console.log('content from the database is loaded, synced =', provider.synced)
})
```
```

--------------------------------

### destroy() method implementation

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

The destroy() method clears the pending compaction timer, removes update and destroy listeners, sets _destroyed, and closes the database connection. Returns a Promise that resolves once the database is closed.

```javascript
  destroy () {
    if (this._storeTimeoutId) {
      clearTimeout(this._storeTimeoutId)
    }
    this.doc.off('update', this._storeUpdate)
    this.doc.off('destroy', this.destroy)
    this._destroyed = true
    return this._db.then(db => {
      db.close()
    })
  }
```

--------------------------------

### IndexeddbPersistence Provider: Events and destroy()

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Documentation for the 'synced' event and the destroy() method of the IndexeddbPersistence provider.

```APIDOC
## Event: 'synced'

### Description
Emitted after the database connection is established and all stored updates have been applied to the document. Also fired when no content exists for the given name.

### Event Name
`'synced'`

### Emitted By
Constructor's `afterApplyUpdatesCallback`

### Payload
- **provider** (IndexeddbPersistence) - The provider instance, passed as `[this]`.

### Example

```js
provider.on('synced', (provider) => {
  console.log('stored content applied; doc has', provider.doc.getArray('t').length, 'items')
})
```

### Notes
- Resolves `whenSynced` promise.
- If the provider is destroyed before the DB finishes opening, the event is never emitted.

---

## destroy

### Description
Closes the connection to the database and stops syncing the document.

### Method
`destroy()`

### Parameters
None.

### Return
`Promise<void>` - Resolves once the opened IndexedDB database has been closed.

### Behavior
- Clears any pending compaction timer.
- Removes the 'update' and 'destroy' listeners from the document.
- Sets `_destroyed = true` to prevent further updates.
- Closes the database connection.

### Notes
- The constructor binds `this.destroy = this.destroy.bind(this)` and registers it on `doc.on('destroy', this.destroy)`, so destroying the `Y.Doc` automatically destroys the provider.
- Data is not deleted; the database survives for the next session.

### Example - Manual teardown

```js
import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'

const doc = new Y.Doc()
const provider = new IndexeddbPersistence('my-document', doc)

await provider.whenSynced
await provider.destroy()
console.log('database connection closed, data retained')
```

### Example - Error handling / destroy before sync

```js
import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'

const doc = new Y.Doc()
const provider = new IndexeddbPersistence('my-document', doc)

provider.destroy()
await provider.whenSynced.catch(() => {}) // guard against never resolving
```
```

--------------------------------

### storeState(idbPersistence, forceStore)

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/functions.md

Compacts the update log: applies pending updates, appends a full state snapshot, and deletes prior records. Optionally forces the merge regardless of store size.

```APIDOC
## storeState(idbPersistence, forceStore)

### Description
Compacts the update log: applies pending updates, appends a full state snapshot, and deletes prior records. Optionally forces the merge regardless of store size.

### Method
Function

### Signature
```js
storeState(idbPersistence, forceStore = true)
```

### Parameters
- `idbPersistence` (IndexeddbPersistence) - Required - The provider instance to compact.
- `forceStore` (boolean) - Optional - Default: `true`. If `true`, the merge always runs. If `false`, the merge runs only when `_dbsize >= PREFERRED_TRIM_SIZE`.

### Return
`Promise<undefined>` - Resolves after the merge is performed (or skipped because `forceStore` is `false` and the store is below the trim threshold).

### Example — manual forced compaction
```js
import * as Y from 'yjs'
import { IndexeddbPersistence, storeState } from 'y-indexeddb'

const provider = new IndexeddbPersistence('my-document', new Y.Doc())
await provider.whenSynced

// Merge the whole log into a single snapshot right now.
await storeState(provider, true)
console.log('updates store compacted; size =', provider._dbsize)
```

### Example — conditional compaction (as used internally)
```js
import { IndexeddbPersistence, storeState } from 'y-indexeddb'

const provider = new IndexeddbPersistence('my-document', new Y.Doc())
await provider.whenSynced

// Only compact if the store has grown past PREFERRED_TRIM_SIZE.
await storeState(provider, false)
```
```

--------------------------------

### set method implementation

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Implementation of the set method that writes a custom property to the 'custom' object store using idb.put. The value is not synced with other peers.

```javascript
  /**
   * @param {String | number | ArrayBuffer | Date} key
   * @param {String | number | ArrayBuffer | Date} value
   * @return {Promise<String | number | ArrayBuffer | Date>}
   */
  set (key, value) {
    return this._db.then(db => {
      const [custom] = idb.transact(db, [customStoreName])
      return idb.put(custom, value, key)
    })
  }
```

--------------------------------

### set(key, value)

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/types.md

Stores a value in the custom object store under the given key. Returns a promise that resolves to the stored value.

```APIDOC
## set(key, value)

### Description
Stores a value in the custom object store under the given key. Returns a promise that resolves to the stored value.

### Method
SET

### Endpoint
N/A (SDK method)

### Parameters
#### Path Parameters
- **key** (String | number | ArrayBuffer | Date) - Required - The key under which to store the value.

#### Request Body
- **value** (String | number | ArrayBuffer | Date) - Required - The value to store.

### Response
#### Success Response (200)
- **value** (String | number | ArrayBuffer | Date) - The stored value.

#### Response Example
```json
{
  "value": "example"
}
```
```

--------------------------------

### Log PREFERRED_TRIM_SIZE Constant Value

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/functions.md

Imports the constant and logs its value for debugging or informational purposes.

```js
import { PREFERRED_TRIM_SIZE } from 'y-indexeddb'
console.log('compaction triggers at', PREFERRED_TRIM_SIZE, 'stored updates')
```

--------------------------------

### Listen to 'synced' event

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Registers a listener for the 'synced' event, which fires after the database connection is established and all stored updates are applied. The payload is the provider instance.

```javascript
provider.on('synced', (provider) => {
  console.log('stored content applied; doc has', provider.doc.getArray('t').length, 'items')
})
```

--------------------------------

### fetchUpdates Function Definition

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/functions.md

Exports the fetchUpdates function. It reads pending updates from the updates store and applies them to the provider's document. Uses a lower-bound key range on _dbref for incremental fetching, skips the apply step if _destroyed is true, and updates _dbref and _dbsize after processing. Passes the updates store to the optional before and after callbacks.

```js
/**
 * @param {IndexeddbPersistence} idbPersistence
 * @param {function(IDBObjectStore):void} [beforeApplyUpdatesCallback]
 * @param {function(IDBObjectStore):void} [afterApplyUpdatesCallback]
 */
export const fetchUpdates = (idbPersistence, beforeApplyUpdatesCallback = () => {}, afterApplyUpdatesCallback = () => {}) => {
  const [updatesStore] = idb.transact(/** @type {IDBDatabase} */ (idbPersistence.db), [updatesStoreName]) // , 'readonly')
  return idb.getAll(updatesStore, idb.createIDBKeyRangeLowerBound(idbPersistence._dbref, false)).then(updates => {
    if (!idbPersistence._destroyed) {
      beforeApplyUpdatesCallback(updatesStore)
      Y.transact(idbPersistence.doc, () => {
        updates.forEach(val => Y.applyUpdate(idbPersistence.doc, val))
      }, idbPersistence, false)
      afterApplyUpdatesCallback(updatesStore)
    }
  })
    .then(() => idb.getLastKey(updatesStore).then(lastKey => { idbPersistence._dbref = lastKey + 1 }))
    .then(() => idb.count(updatesStore).then(cnt => { idbPersistence._dbsize = cnt }))
    .then(() => updatesStore)
}
```

--------------------------------

### External imports in src/y-indexeddb.js

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/index.md

Shows the three external imports used by the module: yjs, lib0/indexeddb, lib0/promise, and lib0/observable. These provide the core Yjs document operations, IndexedDB helpers, promise utilities, and the Observable base class.

```javascript
import * as Y from 'yjs'                    // Y.Doc, Y.transact, Y.applyUpdate, Y.encodeStateAsUpdate
import * as idb from 'lib0/indexeddb'       // openDB, createStores, transact, get, put, del, getAll,
                                            // getLastKey, count, addAutoKey, deleteDB,
                                            // createIDBKeyRangeLowerBound, createIDBKeyRangeUpperBound
import * as promise from 'lib0/promise'     // promise.create (used for whenSynced)
import { Observable } from 'lib0/observable' // base class of IndexeddbPersistence
```

--------------------------------

### Import IndexeddbPersistence

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Imports the IndexeddbPersistence class from the 'y-indexeddb' package.

```javascript
import { IndexeddbPersistence } from 'y-indexeddb'
```

--------------------------------

### provider.set(key, value)

Source: https://github.com/yjs/y-indexeddb/blob/master/README.md

Stores a custom property on the provider instance for meta-information.

```APIDOC
## provider.set(key, value)

### Description
Sets a custom property on the provider instance. This can be used to store relevant meta-information for the persisted document. The content will not be synced with other peers.

### Method
`provider.set(key: any, value: any): Promise<any>`

### Parameters
- **key** (any) - Required - The key under which to store the value.
- **value** (any) - Required - The value to store.

### Returns
- **Promise<any>** - A promise that resolves when the operation completes.
```

--------------------------------

### fetchUpdates

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/index.md

Fetches all updates from IndexedDB and applies them to the Yjs document. Accepts optional callbacks that run before and after applying updates.

```APIDOC
## fetchUpdates Function

### Description
Fetches all updates from IndexedDB and applies them to the Yjs document. Accepts optional callbacks that run before and after applying updates.

### Signature
`fetchUpdates(idbPersistence, beforeApplyUpdatesCallback?, afterApplyUpdatesCallback?) => Promise<IDBObjectStore>`

### Parameters
- **idbPersistence** (IndexeddbPersistence) - Required - The persistence instance to fetch updates from.
- **beforeApplyUpdatesCallback** (function) - Optional - Called before applying updates to the document.
- **afterApplyUpdatesCallback** (function) - Optional - Called after applying updates to the document.

### Returns
- **Promise<IDBObjectStore>** - Resolves with the IDBObjectStore after updates are applied.

```

--------------------------------

### new IndexeddbPersistence(docName, ydoc)

Source: https://github.com/yjs/y-indexeddb/blob/master/README.md

Creates a new IndexeddbPersistence provider instance to store Yjs documents in IndexedDB.

```APIDOC
## new IndexeddbPersistence(docName, ydoc)

### Description
Creates a y-indexeddb persistence provider that stores shared data persistently in the browser using IndexedDB.

### Constructor
`new IndexeddbPersistence(docName: string, ydoc: Y.Doc)`

### Parameters
- **docName** (string) - Required - A unique string that identifies this document. In most cases, use the same identifier as the room-name in the connection provider.
- **ydoc** (Y.Doc) - Required - The Yjs document to persist.

### Example
```js
const provider = new IndexeddbPersistence(docName, ydoc)
```
```

--------------------------------

### clearData method implementation

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Destroys the instance and removes all data from IndexedDB by calling destroy() and then idb.deleteDB(this.name). Returns a Promise that resolves after the database is deleted.

```javascript
  /**
   * Destroys this instance and removes all data from indexeddb.
   *
   * @return {Promise<void>}
   */
  clearData () {
    return this.destroy().then(() => {
      idb.deleteDB(this.name)
    })
  }
```

--------------------------------

### IndexeddbPersistence class definition

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Shows the class declaration extending Observable<string> with a comment indicating the constructor parameters.

```javascript
/**
 * @extends Observable<string>
 */
export class IndexeddbPersistence extends Observable {
  // ...
}
```

--------------------------------

### Export PREFERRED_TRIM_SIZE constant

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/configuration.md

Exported constant that defines the record count in the updates store at which compaction is triggered (see storeState's forceStore = false path, line 39). Also used in _storeUpdate (line 111) to decide when to schedule compaction.

```javascript
export const PREFERRED_TRIM_SIZE = 500
```

--------------------------------

### _storeUpdate(update, origin)

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/types.md

Handles Yjs update events. Stores the update and skips updates originating from the provider itself.

```APIDOC
## _storeUpdate(update, origin)

### Description
Handles Yjs update events. Stores the update and skips updates originating from the provider itself.

### Method
HANDLER

### Endpoint
N/A (SDK method)

### Parameters
#### Path Parameters
- **update** (Uint8Array) - Required - The binary update data.
- **origin** (any) - Required - The transaction origin; updates with origin === this are skipped.

### Response
#### Success Response (200)
No return value (undefined).
```

--------------------------------

### PREFERRED_TRIM_SIZE (constant)

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/functions.md

A numeric constant that defines the threshold for triggering a compaction of the updates store. When the number of stored updates reaches this value, the provider schedules a debounced storeState call to merge the update log into a single full-state snapshot.

```APIDOC
## PREFERRED_TRIM_SIZE (constant)

### Description
The number of records in the `updates` store that triggers a compaction. When `_dbsize` reaches this threshold, the provider schedules a debounced `storeState` call (after `_storeTimeout` ms) to merge the whole update log into a single full-state snapshot.

### Type
`number`

### Value
`500`

### Example
```js
import { PREFERRED_TRIM_SIZE } from 'y-indexeddb'
console.log('compaction triggers at', PREFERRED_TRIM_SIZE, 'stored updates')
```
```

--------------------------------

### provider.destroy()

Source: https://github.com/yjs/y-indexeddb/blob/master/README.md

Closes the database connection and stops syncing the document.

```APIDOC
## provider.destroy()

### Description
Closes the connection to the database and stops syncing the document. This method is automatically called when the Yjs document is destroyed (e.g. ydoc.destroy()).

### Method
`provider.destroy(): Promise`

### Returns
- **Promise** - A promise that resolves when the destruction is complete.
```

--------------------------------

### provider.clearData()

Source: https://github.com/yjs/y-indexeddb/blob/master/README.md

Destroys the database and removes all stored data and meta-information.

```APIDOC
## provider.clearData()

### Description
Destroys this database and removes the stored document and all related meta-information from the database.

### Method
`provider.clearData(): Promise`

### Returns
- **Promise** - A promise that resolves when the data is cleared.
```

--------------------------------

### Internal module constants in src/y-indexeddb.js

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/index.md

Defines the two internal store names used by the provider: 'custom' for metadata and 'updates' for the raw Yjs update log.

```javascript
const customStoreName = 'custom'     // store for provider.set/get/del meta data
const updatesStoreName = 'updates'   // store holding the raw Yjs update log (autoIncrement key)
```

--------------------------------

### clearData () => Promise<void>

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Destroys this instance and removes all data from indexeddb.

```APIDOC
## clearData

### Description
Destroys this instance and removes all data from indexeddb.

### Method
No HTTP method (instance method)

### Endpoint
N/A

### Parameters
None.

### Return
`Promise<void>` — resolves after the instance is destroyed and the database has been deleted (`idb.deleteDB(this.name)`).

### Behavior
Calls `destroy()` (closing the connection and unsubscribing), then deletes the entire IndexedDB database identified by `name`. Any later `IndexeddbPersistence` instance created with the same `name` starts from an empty store.

### Example
```js
import * as Y from 'yjs'
import { IndexeddbPersistence } from 'y-indexeddb'

const doc = new Y.Doc()
const provider = new IndexeddbPersistence('my-document', doc)
await provider.whenSynced
doc.getArray('list').insert(0, ['offline edit'])

// Wipe all persisted data for this document.
await provider.clearData()
console.log('database removed; the next session starts empty')
```
```

--------------------------------

### Set _storeTimeout debounce value

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/configuration.md

Instance property that sets the debounce window (in milliseconds) before a scheduled storeState(this, false) compaction runs after the updates store reaches the trim threshold. Setting it to 0 makes compaction run on the next timer tick. It is read at src/y-indexeddb.js line 119 via setTimeout(..., this._storeTimeout).

```javascript
    /**
     * Timeout in ms until data is merged and persisted in idb.
     */
    this._storeTimeout = 1000
```

--------------------------------

### del method implementation

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/indexeddb-persistence.md

Implementation of the del method that deletes a value from the 'custom' object store using idb.del.

```javascript
  /**
   * @param {String | number | ArrayBuffer | Date} key
   * @return {Promise<undefined>}
   */
  del (key) {
    return this._db.then(db => {
      const [custom] = idb.transact(db, [customStoreName])
      return idb.del(custom, key)
    })
  }
```

--------------------------------

### IndexeddbPersistence class declaration extending Observable<string>

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/types.md

Declares the IndexeddbPersistence provider class as extending Observable<string> from lib0/observable. This class is used as a parameter type in fetchUpdates and storeState, and is constructable via new IndexeddbPersistence(name, doc).

```javascript
/**
 * @extends Observable<string>
 */
export class IndexeddbPersistence extends Observable {
```

--------------------------------

### Import Exported Members from y-indexeddb

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/functions.md

Imports all the module's exported members. Necessary before using any of the functions or the constant.

```js
import { fetchUpdates, storeState, clearDocument, PREFERRED_TRIM_SIZE } from 'y-indexeddb'
```

--------------------------------

### del(key)

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/types.md

Deletes a value from the custom object store by key. Returns a promise that resolves to undefined.

```APIDOC
## del(key)

### Description
Deletes a value from the custom object store by key. Returns a promise that resolves to undefined.

### Method
DEL

### Endpoint
N/A (SDK method)

### Parameters
#### Path Parameters
- **key** (String | number | ArrayBuffer | Date) - Required - The key of the value to delete.

### Response
#### Success Response (200)
- **undefined** - No content.

#### Response Example
```json
{}
```
```

--------------------------------

### clearDocument function definition

Source: https://github.com/yjs/y-indexeddb/blob/master/_autodocs/api-reference/functions.md

Exported helper that deletes the entire IndexedDB database identified by name, including the 'updates' and 'custom' object stores. Equivalent to provider.clearData() but standalone.

```javascript
/**
 * @param {string} name
 */
export const clearDocument = name => idb.deleteDB(name)
```

--------------------------------

### provider.del(key)

Source: https://github.com/yjs/y-indexeddb/blob/master/README.md

Deletes a stored value from the provider instance.

```APIDOC
## provider.del(key)

### Description
Deletes a stored value from the provider instance.

### Method
`provider.del(key: any): Promise<undefined>`

### Parameters
- **key** (any) - Required - The key of the value to delete.

### Returns
- **Promise<undefined>** - A promise that resolves when the deletion completes.
```
Tokens:
Raw