dexie 4.0.8 → 4.1.0-alpha.2

package/dist/modern/dexie.mjs

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.0.8, Wed Jul 10 2024
+ * Version 4.1.0-alpha.2, Fri Oct 04 2024
  *
  * https://dexie.org
  *
@@ -1094,7 +1094,7 @@ function tempTransaction(db, mode, storeNames, fn) {
     }
 }
 
-const DEXIE_VERSION = '4.0.8';
+const DEXIE_VERSION = '4.1.0-alpha.2';
 const maxString = String.fromCharCode(65535);
 const minKey = -Infinity;
 const INVALID_KEY_ARGUMENT = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.";
@@ -1212,6 +1212,89 @@ function getUint8Array(a) {
     return new Uint8Array(a);
 }
 
+function getDocCache(db) {
+    return db._novip['_docCache'] ??= {
+        cache: {},
+        get size() {
+            return Object.keys(this.cache).length;
+        },
+        find(table, primaryKey, ydocProp) {
+            const cacheKey = getYDocCacheKey(table, primaryKey, ydocProp);
+            const docRef = this.cache[cacheKey];
+            return docRef ? docRef.deref() : undefined;
+        },
+        add(doc) {
+            const { parentTable, parentId, parentProp } = doc.meta;
+            if (!parentTable || !parentProp || parentId == null)
+                throw new Error(`Missing Dexie-related metadata in Y.Doc`);
+            const cacheKey = getYDocCacheKey(parentTable, parentId, parentProp);
+            this.cache[cacheKey] = new WeakRef(doc);
+            docRegistry.register(doc, { cache: this.cache, key: cacheKey });
+        },
+        delete(doc) {
+            docRegistry.unregister(doc);
+            delete this.cache[getYDocCacheKey(doc.meta.parentTable, doc.meta.parentId, doc.meta.parentProp)];
+        },
+    };
+}
+const docRegistry = new FinalizationRegistry(({ cache, key }) => {
+    delete cache[key];
+});
+const destroyedDocs = new WeakSet();
+function throwIfDestroyed(doc) {
+    if (destroyedDocs.has(doc))
+        throw new Error('Y.Doc has been destroyed');
+}
+function getYDocCacheKey(table, primaryKey, ydocProp) {
+    return `${table}[${primaryKey}].${ydocProp}`;
+}
+
+function createYDocProperty(db, Y, table, prop, updatesTable) {
+    const pkKeyPath = table.schema.primKey.keyPath;
+    const docCache = getDocCache(db);
+    return {
+        get() {
+            const id = getByKeyPath(this, pkKeyPath);
+            let doc = docCache.find(table.name, id, prop);
+            if (doc)
+                return doc;
+            doc = new Y.Doc({
+                meta: {
+                    db,
+                    updatesTable,
+                    parentProp: prop,
+                    parentTable: table.name,
+                    parentId: id
+                },
+            });
+            docCache.add(doc);
+            doc.on('destroy', () => {
+                destroyedDocs.add(doc);
+                docCache.delete(doc);
+            });
+            return doc;
+        },
+    };
+}
+
+function builtInDeletionTrigger(table, keys, res) {
+    const { yProps } = table.schema;
+    if (!yProps)
+        return res;
+    if (keys && res.numFailures > 0)
+        keys = keys.filter((_, i) => !res.failures[i]);
+    return Promise.all(yProps.map(({ updatesTable }) => keys
+        ? table.db.table(updatesTable).where('k').anyOf(keys).delete()
+        : table.db.table(updatesTable).clear())).then(() => res);
+}
+
+function getYLibrary(db) {
+    const Y = db._options.Y;
+    if (!Y)
+        throw new exceptions.MissingAPI('Y library not supplied to Dexie constructor');
+    return Y;
+}
+
 class Table {
     _trans(mode, fn, writeLocked) {
         const trans = this._tx || PSD.trans;
@@ -1347,6 +1430,14 @@ class Table {
                 table() { return tableName; }
             };
         }
+        if (this.schema.yProps) {
+            const Y = getYLibrary(db);
+            constructor = class extends constructor {
+            };
+            this.schema.yProps.forEach(({ prop, updatesTable }) => {
+                Object.defineProperty(constructor.prototype, prop, createYDocProperty(db, Y, this, prop, updatesTable));
+            });
+        }
         const inheritedProps = new Set();
         for (let proto = constructor.prototype; proto; proto = getProto(proto)) {
             Object.getOwnPropertyNames(proto).forEach(propName => inheritedProps.add(propName));
@@ -1425,11 +1516,13 @@ class Table {
         });
     }
     delete(key) {
-        return this._trans('readwrite', trans => this.core.mutate({ trans, type: 'delete', keys: [key] }))
-            .then(res => res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined);
+        return this._trans('readwrite', trans => this.core.mutate({ trans, type: 'delete', keys: [key] })
+            .then(res => builtInDeletionTrigger(this, [key], res))
+            .then(res => res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined));
     }
     clear() {
-        return this._trans('readwrite', trans => this.core.mutate({ trans, type: 'deleteRange', range: AnyRange }))
+        return this._trans('readwrite', trans => this.core.mutate({ trans, type: 'deleteRange', range: AnyRange })
+            .then(res => builtInDeletionTrigger(this, null, res)))
             .then(res => res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined);
     }
     bulkGet(keys) {
@@ -1545,7 +1638,8 @@ class Table {
     bulkDelete(keys) {
         const numKeys = keys.length;
         return this._trans('readwrite', trans => {
-            return this.core.mutate({ trans, type: 'delete', keys: keys });
+            return this.core.mutate({ trans, type: 'delete', keys: keys })
+                .then(res => builtInDeletionTrigger(this, keys, res));
         }).then(({ numFailures, lastResult, failures }) => {
             if (numFailures === 0)
                 return lastResult;
@@ -2053,45 +2147,48 @@ class Collection {
                     totalFailures.push(failures[pos]);
                 }
             };
+            const isUnconditionalDelete = changes === deleteCallback;
             return this.clone().primaryKeys().then(keys => {
                 const criteria = isPlainKeyRange(ctx) &&
                     ctx.limit === Infinity &&
-                    (typeof changes !== 'function' || changes === deleteCallback) && {
+                    (typeof changes !== 'function' || isUnconditionalDelete) && {
                     index: ctx.index,
                     range: ctx.range
                 };
                 const nextChunk = (offset) => {
                     const count = Math.min(limit, keys.length - offset);
-                    return coreTable.getMany({
+                    const keysInChunk = keys.slice(offset, offset + count);
+                    return (isUnconditionalDelete ? Promise.resolve([]) : coreTable.getMany({
                         trans,
-                        keys: keys.slice(offset, offset + count),
+                        keys: keysInChunk,
                         cache: "immutable"
-                    }).then(values => {
+                    })).then(values => {
                         const addValues = [];
                         const putValues = [];
                         const putKeys = outbound ? [] : null;
-                        const deleteKeys = [];
-                        for (let i = 0; i < count; ++i) {
-                            const origValue = values[i];
-                            const ctx = {
-                                value: deepClone(origValue),
-                                primKey: keys[offset + i]
-                            };
-                            if (modifyer.call(ctx, ctx.value, ctx) !== false) {
-                                if (ctx.value == null) {
-                                    deleteKeys.push(keys[offset + i]);
-                                }
-                                else if (!outbound && cmp(extractKey(origValue), extractKey(ctx.value)) !== 0) {
-                                    deleteKeys.push(keys[offset + i]);
-                                    addValues.push(ctx.value);
-                                }
-                                else {
-                                    putValues.push(ctx.value);
-                                    if (outbound)
-                                        putKeys.push(keys[offset + i]);
+                        const deleteKeys = isUnconditionalDelete ? keysInChunk : [];
+                        if (!isUnconditionalDelete)
+                            for (let i = 0; i < count; ++i) {
+                                const origValue = values[i];
+                                const ctx = {
+                                    value: deepClone(origValue),
+                                    primKey: keys[offset + i]
+                                };
+                                if (modifyer.call(ctx, ctx.value, ctx) !== false) {
+                                    if (ctx.value == null) {
+                                        deleteKeys.push(keys[offset + i]);
+                                    }
+                                    else if (!outbound && cmp(extractKey(origValue), extractKey(ctx.value)) !== 0) {
+                                        deleteKeys.push(keys[offset + i]);
+                                        addValues.push(ctx.value);
+                                    }
+                                    else {
+                                        putValues.push(ctx.value);
+                                        if (outbound)
+                                            putKeys.push(keys[offset + i]);
+                                    }
                                 }
                             }
-                        }
                         return Promise.resolve(addValues.length > 0 &&
                             coreTable.mutate({ trans, type: 'add', values: addValues })
                                 .then(res => {
@@ -2109,14 +2206,15 @@ class Collection {
                                 changeSpec: typeof changes !== 'function'
                                     && changes,
                                 isAdditionalChunk: offset > 0
-                            }).then(res => applyMutateResult(putValues.length, res))).then(() => (deleteKeys.length > 0 || (criteria && changes === deleteCallback)) &&
+                            }).then(res => applyMutateResult(putValues.length, res))).then(() => (deleteKeys.length > 0 || (criteria && isUnconditionalDelete)) &&
                             coreTable.mutate({
                                 trans,
                                 type: 'delete',
                                 keys: deleteKeys,
                                 criteria,
                                 isAdditionalChunk: offset > 0
-                            }).then(res => applyMutateResult(deleteKeys.length, res))).then(() => {
+                            }).then(res => builtInDeletionTrigger(ctx.table, deleteKeys, res))
+                                .then(res => applyMutateResult(deleteKeys.length, res))).then(() => {
                             return keys.length > offset + count && nextChunk(offset + limit);
                         });
                     });
@@ -2132,6 +2230,7 @@ class Collection {
     delete() {
         var ctx = this._ctx, range = ctx.range;
         if (isPlainKeyRange(ctx) &&
+            !ctx.table.schema.yProps &&
             (ctx.isPrimKey || range.type === 3 ))
          {
             return this._write(trans => {
@@ -2139,7 +2238,7 @@ class Collection {
                 const coreRange = range;
                 return ctx.table.core.count({ trans, query: { index: primaryKey, range: coreRange } }).then(count => {
                     return ctx.table.core.mutate({ trans, type: 'deleteRange', range: coreRange })
-                        .then(({ failures, lastResult, results, numFailures }) => {
+                        .then(({ failures, numFailures }) => {
                         if (numFailures)
                             throw new ModifyError("Could not delete some values", Object.keys(failures).map(pos => failures[pos]), count - numFailures);
                         return count - numFailures;
@@ -2723,6 +2822,12 @@ class Transaction {
 
 function createTransactionConstructor(db) {
     return makeClassConstructor(Transaction.prototype, function Transaction(mode, storeNames, dbschema, chromeTransactionDurability, parent) {
+        if (mode !== 'readonly')
+            storeNames.forEach(storeName => {
+                const yProps = dbschema[storeName]?.yProps;
+                if (yProps)
+                    storeNames = storeNames.concat(yProps.map(p => p.updatesTable));
+            });
         this.db = db;
         this.mode = mode;
         this.storeNames = storeNames;
@@ -2758,7 +2863,7 @@ function createTransactionConstructor(db) {
     });
 }
 
-function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey) {
+function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey, type) {
     return {
         name,
         keyPath,
@@ -2766,7 +2871,8 @@ function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey
         multi,
         auto,
         compound,
-        src: (unique && !isPrimKey ? '&' : '') + (multi ? '*' : '') + (auto ? "++" : "") + nameFromKeyPath(keyPath)
+        src: (unique && !isPrimKey ? '&' : '') + (multi ? '*' : '') + (auto ? "++" : "") + nameFromKeyPath(keyPath),
+        type
     };
 }
 function nameFromKeyPath(keyPath) {
@@ -2775,13 +2881,17 @@ function nameFromKeyPath(keyPath) {
         keyPath ? ('[' + [].join.call(keyPath, '+') + ']') : "";
 }
 
-function createTableSchema(name, primKey, indexes) {
+function createTableSchema(name, primKey, indexes, yProps) {
     return {
         name,
         primKey,
         indexes,
         mappedClass: null,
-        idxByName: arrayToObject(indexes, index => [index.name, index])
+        yProps: yProps?.map((prop) => ({
+            prop,
+            updatesTable: `$${name}.${prop}_updates`,
+        })),
+        idxByName: arrayToObject(indexes, (index) => [index.name, index]),
     };
 }
 
@@ -3507,49 +3617,68 @@ function adjustToExistingIndexNames(db, schema, idbtrans) {
 }
 function parseIndexSyntax(primKeyAndIndexes) {
     return primKeyAndIndexes.split(',').map((index, indexNum) => {
-        index = index.trim();
+        const typeSplit = index.split(':');
+        const type = typeSplit[1]?.trim();
+        index = typeSplit[0].trim();
+        if (type && type !== 'Y')
+            throw new exceptions.Schema(`Unsupported type '${type}'`);
         const name = index.replace(/([&*]|\+\+)/g, "");
         const keyPath = /^\[/.test(name) ? name.match(/^\[(.*)\]$/)[1].split('+') : name;
-        return createIndexSpec(name, keyPath || null, /\&/.test(index), /\*/.test(index), /\+\+/.test(index), isArray(keyPath), indexNum === 0);
+        return createIndexSpec(name, keyPath || null, /\&/.test(index), /\*/.test(index), /\+\+/.test(index), isArray(keyPath), indexNum === 0, type);
     });
 }
 
 class Version {
     _parseStoresSpec(stores, outSchema) {
-        keys(stores).forEach(tableName => {
+        keys(stores).forEach((tableName) => {
             if (stores[tableName] !== null) {
-                var indexes = parseIndexSyntax(stores[tableName]);
-                var primKey = indexes.shift();
+                let indexes = parseIndexSyntax(stores[tableName]);
+                const yProps = indexes.filter((idx) => idx.type === 'Y').map((idx) => idx.name);
+                indexes = indexes.filter((idx) => idx.type !== 'Y');
+                const primKey = indexes.shift();
+                if (!primKey) {
+                    throw new exceptions.Schema('Invalid schema for table ' + tableName + ': ' + stores[tableName]);
+                }
                 primKey.unique = true;
                 if (primKey.multi)
-                    throw new exceptions.Schema("Primary key cannot be multi-valued");
-                indexes.forEach(idx => {
+                    throw new exceptions.Schema('Primary key cannot be multiEntry*');
+                indexes.forEach((idx) => {
                     if (idx.auto)
-                        throw new exceptions.Schema("Only primary key can be marked as autoIncrement (++)");
+                        throw new exceptions.Schema('Only primary key can be marked as autoIncrement (++)');
                     if (!idx.keyPath)
-                        throw new exceptions.Schema("Index must have a name and cannot be an empty string");
+                        throw new exceptions.Schema('Index must have a name and cannot be an empty string');
                 });
-                outSchema[tableName] = createTableSchema(tableName, primKey, indexes);
+                const tblSchema = createTableSchema(tableName, primKey, indexes, yProps.length ? yProps : undefined);
+                outSchema[tableName] = tblSchema;
+                for (const yProp of tblSchema.yProps || []) {
+                    this._parseStoresSpec(
+                    { [yProp.updatesTable]: '++i,k' }, outSchema);
+                }
             }
         });
     }
     stores(stores) {
         const db = this.db;
-        this._cfg.storesSource = this._cfg.storesSource ?
-            extend(this._cfg.storesSource, stores) :
-            stores;
+        this._cfg.storesSource = this._cfg.storesSource
+            ? extend(this._cfg.storesSource, stores)
+            : stores;
         const versions = db._versions;
         const storesSpec = {};
         let dbschema = {};
-        versions.forEach(version => {
+        versions.forEach((version) => {
             extend(storesSpec, version._cfg.storesSource);
-            dbschema = (version._cfg.dbschema = {});
+            dbschema = version._cfg.dbschema = {};
             version._parseStoresSpec(storesSpec, dbschema);
         });
         db._dbSchema = dbschema;
         removeTablesApi(db, [db._allTables, db, db.Transaction.prototype]);
         setApiOnPlace(db, [db._allTables, db, db.Transaction.prototype, this._cfg.tables], keys(dbschema), dbschema);
         db._storeNames = keys(dbschema);
+        db._storeNames.forEach((tableName) => {
+            if (dbschema[tableName].yProps) {
+                db.table(tableName).mapToClass(dbschema[tableName].mappedClass || Object);
+            }
+        });
         return this;
     }
     upgrade(upgradeFunction) {
@@ -5119,6 +5248,124 @@ function vipify(target, vipDb) {
     });
 }
 
+function compressYDocs(db, interval) {
+    let p = Promise.resolve();
+    for (const table of db.tables) {
+        for (const yProp of table.schema.yProps || []) {
+            p = p.then(() => compressYDocsTable(db, yProp, interval));
+        }
+    }
+    return p;
+}
+function compressYDocsTable(db, { updatesTable }, skipIfRunnedSince
+) {
+    const updTbl = db.table(updatesTable);
+    return Promise.all([
+        updTbl
+            .where('i')
+            .startsWith('')
+            .toArray(),
+        db.transaction('rw', updatesTable, () => updTbl.get(0).then((lastCompressed) => {
+            if (lastCompressed &&
+                skipIfRunnedSince &&
+                lastCompressed.lastRun.getTime() > Date.now() - skipIfRunnedSince) {
+                return null;
+            }
+            lastCompressed = lastCompressed || { i: 0, lastCompressed: 0 };
+            return updTbl
+                .put({
+                ...lastCompressed,
+                lastRun: new Date(),
+            })
+                .then(() => lastCompressed);
+        })),
+    ]).then(([syncers, stamp]) => {
+        if (!stamp)
+            return;
+        const lastCompressedUpdate = stamp.lastCompressed;
+        const unsyncedFrom = Math.min(...syncers.map((s) => Math.min(s.unsentFrom || Infinity, s.receivedUntil != null ? s.receivedUntil + 1 : Infinity)));
+        return updTbl
+            .where('i')
+            .between(lastCompressedUpdate, Infinity, false)
+            .toArray((addedUpdates) => {
+            if (addedUpdates.length <= 1)
+                return;
+            const docsToCompress = [];
+            let lastUpdateToCompress = lastCompressedUpdate + 1;
+            for (let j = 0; j < addedUpdates.length; ++j) {
+                const updateRow = addedUpdates[j];
+                const { i, f, k } = updateRow;
+                if (i >= unsyncedFrom && (f & 0x01))
+                    break;
+                const entry = docsToCompress.find((entry) => cmp(entry.docId, k) === 0);
+                if (entry)
+                    entry.updates.push(updateRow);
+                else
+                    docsToCompress.push({ docId: k, updates: [updateRow] });
+                lastUpdateToCompress = i;
+            }
+            let p = Promise.resolve();
+            for (const { docId, updates } of docsToCompress) {
+                p = p.then(() => compressUpdatesForDoc(db, updatesTable, docId, updates));
+            }
+            return p.then(() => {
+                return db.transaction('rw', updTbl, () => updTbl.get(0).then((current) => updTbl.put({
+                    ...current,
+                    lastCompressed: Math.max(lastUpdateToCompress, current?.lastCompressed || 0),
+                })));
+            });
+        });
+    });
+}
+function compressUpdatesForDoc(db, updatesTable, parentId, addedUpdatesToCompress) {
+    if (addedUpdatesToCompress.length < 1)
+        throw new Error('Invalid input');
+    return db.transaction('rw', updatesTable, (tx) => {
+        const updTbl = tx.table(updatesTable);
+        return updTbl.where({ k: parentId }).first((mainUpdate) => {
+            const updates = [mainUpdate].concat(addedUpdatesToCompress);
+            const Y = getYLibrary(db);
+            const doc = new Y.Doc({ gc: true });
+            updates.forEach((update) => {
+                Y.applyUpdateV2(doc, update.u);
+            });
+            const compressedUpdate = Y.encodeStateAsUpdateV2(doc);
+            const lastUpdate = updates.pop();
+            return updTbl
+                .put({
+                i: lastUpdate.i,
+                k: parentId,
+                u: compressedUpdate,
+            })
+                .then(() => updTbl.bulkDelete(updates.map((update) => update.i)));
+        });
+    });
+}
+
+const INTERVAL = 10000;
+function periodicGC(db) {
+    let timer = null;
+    db.on('ready', (db) => {
+        if (db.tables.some(tbl => tbl.schema.yProps)) {
+            const gc = () => {
+                if (!db.isOpen())
+                    return;
+                compressYDocs(db, INTERVAL).catch(err => {
+                    console.debug('Error during periodic GC', err);
+                }).then(() => {
+                    timer = setTimeout(gc, INTERVAL);
+                });
+            };
+            timer = setTimeout(gc, INTERVAL);
+        }
+    }, true);
+    db.on('close', () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+    });
+}
+
 class Dexie$1 {
     constructor(name, options) {
         this._middlewares = {};
@@ -5164,7 +5411,14 @@ class Dexie$1 {
         });
         this._state = state;
         this.name = name;
-        this.on = Events(this, "populate", "blocked", "versionchange", "close", { ready: [promisableChain, nop] });
+        this.on = Events(this, "populate", "blocked", "versionchange", "close", "y", { ready: [promisableChain, nop] });
+        this.once = (event, callback) => {
+            const fn = (...args) => {
+                this.on(event).unsubscribe(fn);
+                callback.apply(this, args);
+            };
+            return this.on(event, fn);
+        };
         this.on.ready.subscribe = override(this.on.ready.subscribe, subscribe => {
             return (subscriber, bSticky) => {
                 Dexie$1.vip(() => {
@@ -5243,6 +5497,8 @@ class Dexie$1 {
             }
         });
         this.vip = vipDB;
+        if (options?.Y)
+            periodicGC(this);
         addons.forEach(addon => addon(this));
     }
     version(versionNumber) {
@@ -5299,6 +5555,7 @@ class Dexie$1 {
         () => dexieOpen(this));
     }
     _close() {
+        this.on.close.fire(new CustomEvent('close'));
         const state = this._state;
         const idx = connections.indexOf(this);
         if (idx >= 0)
@@ -5447,6 +5704,9 @@ class Dexie$1 {
         }
         return this._allTables[tableName];
     }
+    gc() {
+        return compressYDocs(this);
+    }
 }
 
 const symbolObservable = typeof Symbol !== "undefined" && "observable" in Symbol
@@ -5765,8 +6025,170 @@ function replacePrefix(a, b) {
     return new PropModification({ replacePrefix: [a, b] });
 }
 
+function observeYDocUpdates(provider, doc, db, parentTableName, updatesTableName, parentId, Y) {
+    let lastUpdateId = 0;
+    let initial = true;
+    const subscription = liveQuery(() => {
+        throwIfDestroyed(doc);
+        const updatesTable = db.table(updatesTableName);
+        return Promise.all([
+            (lastUpdateId > 0
+                ? updatesTable
+                    .where('i')
+                    .between(lastUpdateId, Infinity, false)
+                    .toArray()
+                    .then((updates) => updates.filter((update) => cmp(update.k, parentId) === 0))
+                : updatesTable.where({ k: parentId }).toArray()).then((updates) => {
+                if (updates.length > 0)
+                    lastUpdateId = updates[updates.length - 1].i;
+                return updates;
+            }),
+            db.table(parentTableName).where(':id').equals(parentId).toArray(),
+        ]);
+    }).subscribe(([updates, parentRow]) => {
+        if (parentRow.length === 0) {
+            doc.destroy();
+            return;
+        }
+        throwIfDestroyed(doc);
+        if (updates.length > 0) {
+            Y.transact(doc, () => {
+                updates.forEach((update) => {
+                    try {
+                        DexieYProvider.currentUpdateRow = update;
+                        Y.applyUpdateV2(doc, update.u);
+                    }
+                    finally {
+                        DexieYProvider.currentUpdateRow = null;
+                    }
+                });
+            }, provider, false);
+        }
+        if (initial) {
+            initial = false;
+            doc.emit('load', [doc]);
+        }
+    }, (error) => {
+        provider.on('error').fire(error);
+    });
+    const onUpdate = (update, origin) => {
+        if (origin === provider)
+            return;
+        db.table(updatesTableName)
+            .add({
+            k: parentId,
+            u: update,
+            f: 1,
+        })
+            .then((i) => {
+            if (i === lastUpdateId - 1)
+                ++lastUpdateId;
+        })
+            .catch((error) => {
+            provider.on('error').fire(error);
+        });
+    };
+    const stopObserving = () => {
+        subscription.unsubscribe();
+        doc.off('updateV2', onUpdate);
+        doc.off('destroy', stopObserving);
+    };
+    doc.on('updateV2', onUpdate);
+    doc.on('destroy', stopObserving);
+    return stopObserving;
+}
+
+const wm = new WeakMap();
+function createEvents() {
+    return Events(null, 'load', 'sync', 'error');
+}
+class DexieYProvider {
+    static load(doc) {
+        let p = wm.get(doc);
+        if (p) {
+            ++p.refCount;
+        }
+        else {
+            p = new DexieYProvider(doc);
+            wm.set(doc, p);
+        }
+        return p;
+    }
+    static release(doc, options) {
+        if (destroyedDocs.has(doc))
+            return;
+        const p = wm.get(doc);
+        if (!p) {
+            if (--p.refCount === 0) {
+                if (isNaN(options?.gracePeriod)) {
+                    doc.destroy();
+                }
+                else {
+                    setTimeout(() => p.refCount || doc.destroy(),
+                    options.gracePeriod
+                    );
+                }
+            }
+        }
+        else {
+            doc.destroy();
+        }
+    }
+    static for(doc) {
+        return wm.get(doc);
+    }
+    constructor(doc) {
+        this.refCount = 1;
+        this.cleanupHandlers = [];
+        this.destroyed = false;
+        const { meta: { db, parentTable, parentId, updatesTable }, } = doc || {};
+        if (!db || !parentTable || !updatesTable)
+            throw new Error('Y.Doc not generated by Dexie');
+        if (!db.table(parentTable) || !db.table(updatesTable)) {
+            throw new Error(`Table ${parentTable} or ${updatesTable} not found in db`);
+        }
+        throwIfDestroyed(doc);
+        const Y = getYLibrary(db);
+        this.on = createEvents();
+        this.doc = doc;
+        this.off = (name, f) => this.on[name]?.unsubscribe(f);
+        this.whenLoaded = new Promise((resolve, reject) => {
+            this.on('load', resolve);
+            this.on('error', reject);
+        });
+        this.whenSynced = new Promise((resolve, reject) => {
+            this.on('sync', resolve);
+            this.on('error', reject);
+        });
+        if ('dispose' in Symbol) {
+            this[Symbol.dispose] = this.dispose;
+        }
+        this.stopObserving = observeYDocUpdates(this, doc, db, parentTable, updatesTable, parentId, Y);
+        doc.on('load', () => this.on('load').fire());
+        doc.on('sync', (sync) => sync !== false && this.on('sync').fire());
+        doc.on('destroy', this.destroy.bind(this));
+        db.on.y.fire(this, Y);
+    }
+    destroy() {
+        wm.delete(this.doc);
+        this.doc = null;
+        this.destroyed = true;
+        this.refCount = 0;
+        this.stopObserving?.();
+        this.on = createEvents();
+        this.cleanupHandlers.forEach((cleanup) => cleanup());
+    }
+    addCleanupHandler(cleanupHandler) {
+        this.cleanupHandlers.push(typeof cleanupHandler === 'function'
+            ? cleanupHandler
+            : () => cleanupHandler.unsubscribe());
+    }
+}
+DexieYProvider.getDocCache = getDocCache;
+DexieYProvider.currentUpdateRow = null;
+
 DexiePromise.rejectionMapper = mapError;
 setDebug(debug);
 
-export { Dexie$1 as Dexie, Entity, PropModSymbol, PropModification, RangeSet, add, cmp, Dexie$1 as default, liveQuery, mergeRanges, rangesOverlap, remove, replacePrefix };
+export { Dexie$1 as Dexie, DexieYProvider, Entity, PropModSymbol, PropModification, RangeSet, add, cmp, Dexie$1 as default, liveQuery, mergeRanges, rangesOverlap, remove, replacePrefix };
 //# sourceMappingURL=dexie.mjs.map