dexie 4.0.8 → 4.0.9-alpha.1

package/dist/dexie.js

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.0.8, Wed Jul 10 2024
+ * Version 4.0.9-alpha.1, Fri Aug 23 2024
  *
  * https://dexie.org
  *
@@ -1150,7 +1150,7 @@
         }
     }
 
-    var DEXIE_VERSION = '4.0.8';
+    var DEXIE_VERSION = '4.0.9-alpha.1';
     var maxString = String.fromCharCode(65535);
     var minKey = -Infinity;
     var INVALID_KEY_ARGUMENT = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.";
@@ -1268,6 +1268,95 @@
         return new Uint8Array(a);
     }
 
+    function getDocCache(db) {
+        var _a;
+        var _b;
+        return (_a = (_b = db._novip)['_docCache']) !== null && _a !== void 0 ? _a : (_b['_docCache'] = {
+            cache: {},
+            get size() {
+                return Object.keys(this.cache).length;
+            },
+            find: function (table, primaryKey, ydocProp) {
+                var cacheKey = getYDocCacheKey(table, primaryKey, ydocProp);
+                var docRef = this.cache[cacheKey];
+                return docRef ? docRef.deref() : undefined;
+            },
+            add: function (doc) {
+                var _a = doc.meta, parentTable = _a.parentTable, parentId = _a.parentId, parentProp = _a.parentProp;
+                if (!parentTable || !parentProp || parentId == null)
+                    throw new Error("Missing Dexie-related metadata in Y.Doc");
+                var cacheKey = getYDocCacheKey(parentTable, parentId, parentProp);
+                this.cache[cacheKey] = new WeakRef(doc);
+                docRegistry.register(doc, { cache: this.cache, key: cacheKey });
+            },
+            delete: function (doc) {
+                docRegistry.unregister(doc);
+                delete this.cache[getYDocCacheKey(doc.meta.parentTable, doc.meta.parentId, doc.meta.parentProp)];
+            },
+        });
+    }
+    var docRegistry = new FinalizationRegistry(function (_a) {
+        var cache = _a.cache, key = _a.key;
+        delete cache[key];
+    });
+    var destroyed = new WeakSet();
+    function throwIfDestroyed(doc) {
+        if (destroyed.has(doc))
+            throw new Error('Y.Doc has been destroyed');
+    }
+    function getYDocCacheKey(table, primaryKey, ydocProp) {
+        return "".concat(table, "[").concat(primaryKey, "].").concat(ydocProp);
+    }
+
+    function createYDocProperty(db, Y, table, prop, updatesTable) {
+        var pkKeyPath = table.schema.primKey.keyPath;
+        var docCache = getDocCache(db);
+        return {
+            get: function () {
+                var id = getByKeyPath(this, pkKeyPath);
+                var doc = docCache.find(table.name, id, prop);
+                if (doc)
+                    return doc;
+                doc = new Y.Doc({
+                    meta: {
+                        db: db,
+                        updatesTable: updatesTable,
+                        parentProp: prop,
+                        parentTable: table.name,
+                        parentId: id
+                    },
+                });
+                docCache.add(doc);
+                doc.on('destroy', function () {
+                    destroyed.add(doc);
+                    docCache.delete(doc);
+                });
+                return doc;
+            },
+        };
+    }
+
+    function builtInDeletionTrigger(table, keys, res) {
+        var yProps = table.schema.yProps;
+        if (!yProps)
+            return res;
+        if (keys && res.numFailures > 0)
+            keys = keys.filter(function (_, i) { return !res.failures[i]; });
+        return Promise.all(yProps.map(function (_a) {
+            var updatesTable = _a.updatesTable;
+            return keys
+                ? table.db.table(updatesTable).where('k').anyOf(keys).delete()
+                : table.db.table(updatesTable).clear();
+        })).then(function () { return res; });
+    }
+
+    function getYLibrary(db) {
+        var Y = db._options.Y;
+        if (!Y)
+            throw new exceptions.MissingAPI('Y library not supplied to Dexie constructor');
+        return Y;
+    }
+
     var Table =  (function () {
         function Table() {
         }
@@ -1399,6 +1488,7 @@
             return this.toCollection().reverse();
         };
         Table.prototype.mapToClass = function (constructor) {
+            var _this = this;
             var _a = this, db = _a.db, tableName = _a.name;
             this.schema.mappedClass = constructor;
             if (constructor.prototype instanceof Entity) {
@@ -1416,6 +1506,20 @@
                     return class_1;
                 }(constructor));
             }
+            if (this.schema.yProps) {
+                var Y_1 = getYLibrary(db);
+                constructor =  (function (_super) {
+                    __extends(class_2, _super);
+                    function class_2() {
+                        return _super !== null && _super.apply(this, arguments) || this;
+                    }
+                    return class_2;
+                }(constructor));
+                this.schema.yProps.forEach(function (_a) {
+                    var prop = _a.prop, updatesTable = _a.updatesTable;
+                    Object.defineProperty(constructor.prototype, prop, createYDocProperty(db, Y_1, _this, prop, updatesTable));
+                });
+            }
             var inheritedProps = new Set();
             for (var proto = constructor.prototype; proto; proto = getProto(proto)) {
                 Object.getOwnPropertyNames(proto).forEach(function (propName) { return inheritedProps.add(propName); });
@@ -1497,12 +1601,14 @@
         };
         Table.prototype.delete = function (key) {
             var _this = this;
-            return this._trans('readwrite', function (trans) { return _this.core.mutate({ trans: trans, type: 'delete', keys: [key] }); })
-                .then(function (res) { return res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined; });
+            return this._trans('readwrite', function (trans) { return _this.core.mutate({ trans: trans, type: 'delete', keys: [key] })
+                .then(function (res) { return builtInDeletionTrigger(_this, [key], res); })
+                .then(function (res) { return res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined; }); });
         };
         Table.prototype.clear = function () {
             var _this = this;
-            return this._trans('readwrite', function (trans) { return _this.core.mutate({ trans: trans, type: 'deleteRange', range: AnyRange }); })
+            return this._trans('readwrite', function (trans) { return _this.core.mutate({ trans: trans, type: 'deleteRange', range: AnyRange })
+                .then(function (res) { return builtInDeletionTrigger(_this, null, res); }); })
                 .then(function (res) { return res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined; });
         };
         Table.prototype.bulkGet = function (keys) {
@@ -1629,7 +1735,8 @@
             var _this = this;
             var numKeys = keys.length;
             return this._trans('readwrite', function (trans) {
-                return _this.core.mutate({ trans: trans, type: 'delete', keys: keys });
+                return _this.core.mutate({ trans: trans, type: 'delete', keys: keys })
+                    .then(function (res) { return builtInDeletionTrigger(_this, keys, res); });
             }).then(function (_a) {
                 var numFailures = _a.numFailures, lastResult = _a.lastResult, failures = _a.failures;
                 if (numFailures === 0)
@@ -2153,45 +2260,48 @@
                         totalFailures.push(failures[pos]);
                     }
                 };
+                var isUnconditionalDelete = changes === deleteCallback;
                 return _this.clone().primaryKeys().then(function (keys) {
                     var criteria = isPlainKeyRange(ctx) &&
                         ctx.limit === Infinity &&
-                        (typeof changes !== 'function' || changes === deleteCallback) && {
+                        (typeof changes !== 'function' || isUnconditionalDelete) && {
                         index: ctx.index,
                         range: ctx.range
                     };
                     var nextChunk = function (offset) {
                         var count = Math.min(limit, keys.length - offset);
-                        return coreTable.getMany({
+                        var keysInChunk = keys.slice(offset, offset + count);
+                        return (isUnconditionalDelete ? Promise.resolve([]) : coreTable.getMany({
                             trans: trans,
-                            keys: keys.slice(offset, offset + count),
+                            keys: keysInChunk,
                             cache: "immutable"
-                        }).then(function (values) {
+                        })).then(function (values) {
                             var addValues = [];
                             var putValues = [];
                             var putKeys = outbound ? [] : null;
-                            var deleteKeys = [];
-                            for (var i = 0; i < count; ++i) {
-                                var origValue = values[i];
-                                var ctx_1 = {
-                                    value: deepClone(origValue),
-                                    primKey: keys[offset + i]
-                                };
-                                if (modifyer.call(ctx_1, ctx_1.value, ctx_1) !== false) {
-                                    if (ctx_1.value == null) {
-                                        deleteKeys.push(keys[offset + i]);
-                                    }
-                                    else if (!outbound && cmp(extractKey(origValue), extractKey(ctx_1.value)) !== 0) {
-                                        deleteKeys.push(keys[offset + i]);
-                                        addValues.push(ctx_1.value);
-                                    }
-                                    else {
-                                        putValues.push(ctx_1.value);
-                                        if (outbound)
-                                            putKeys.push(keys[offset + i]);
+                            var deleteKeys = isUnconditionalDelete ? keysInChunk : [];
+                            if (!isUnconditionalDelete)
+                                for (var i = 0; i < count; ++i) {
+                                    var origValue = values[i];
+                                    var ctx_1 = {
+                                        value: deepClone(origValue),
+                                        primKey: keys[offset + i]
+                                    };
+                                    if (modifyer.call(ctx_1, ctx_1.value, ctx_1) !== false) {
+                                        if (ctx_1.value == null) {
+                                            deleteKeys.push(keys[offset + i]);
+                                        }
+                                        else if (!outbound && cmp(extractKey(origValue), extractKey(ctx_1.value)) !== 0) {
+                                            deleteKeys.push(keys[offset + i]);
+                                            addValues.push(ctx_1.value);
+                                        }
+                                        else {
+                                            putValues.push(ctx_1.value);
+                                            if (outbound)
+                                                putKeys.push(keys[offset + i]);
+                                        }
                                     }
                                 }
-                            }
                             return Promise.resolve(addValues.length > 0 &&
                                 coreTable.mutate({ trans: trans, type: 'add', values: addValues })
                                     .then(function (res) {
@@ -2209,14 +2319,15 @@
                                     changeSpec: typeof changes !== 'function'
                                         && changes,
                                     isAdditionalChunk: offset > 0
-                                }).then(function (res) { return applyMutateResult(putValues.length, res); }); }).then(function () { return (deleteKeys.length > 0 || (criteria && changes === deleteCallback)) &&
+                                }).then(function (res) { return applyMutateResult(putValues.length, res); }); }).then(function () { return (deleteKeys.length > 0 || (criteria && isUnconditionalDelete)) &&
                                 coreTable.mutate({
                                     trans: trans,
                                     type: 'delete',
                                     keys: deleteKeys,
                                     criteria: criteria,
                                     isAdditionalChunk: offset > 0
-                                }).then(function (res) { return applyMutateResult(deleteKeys.length, res); }); }).then(function () {
+                                }).then(function (res) { return builtInDeletionTrigger(ctx.table, deleteKeys, res); })
+                                    .then(function (res) { return applyMutateResult(deleteKeys.length, res); }); }).then(function () {
                                 return keys.length > offset + count && nextChunk(offset + limit);
                             });
                         });
@@ -2232,6 +2343,7 @@
         Collection.prototype.delete = function () {
             var ctx = this._ctx, range = ctx.range;
             if (isPlainKeyRange(ctx) &&
+                !ctx.table.schema.yProps &&
                 (ctx.isPrimKey || range.type === 3 ))
              {
                 return this._write(function (trans) {
@@ -2240,7 +2352,7 @@
                     return ctx.table.core.count({ trans: trans, query: { index: primaryKey, range: coreRange } }).then(function (count) {
                         return ctx.table.core.mutate({ trans: trans, type: 'deleteRange', range: coreRange })
                             .then(function (_a) {
-                            var failures = _a.failures; _a.lastResult; _a.results; var numFailures = _a.numFailures;
+                            var failures = _a.failures, numFailures = _a.numFailures;
                             if (numFailures)
                                 throw new ModifyError("Could not delete some values", Object.keys(failures).map(function (pos) { return failures[pos]; }), count - numFailures);
                             return count - numFailures;
@@ -2842,6 +2954,13 @@
     function createTransactionConstructor(db) {
         return makeClassConstructor(Transaction.prototype, function Transaction(mode, storeNames, dbschema, chromeTransactionDurability, parent) {
             var _this = this;
+            if (mode !== 'readonly')
+                storeNames.forEach(function (storeName) {
+                    var _a;
+                    var yProps = (_a = dbschema[storeName]) === null || _a === void 0 ? void 0 : _a.yProps;
+                    if (yProps)
+                        storeNames = storeNames.concat(yProps.map(function (p) { return p.updatesTable; }));
+                });
             this.db = db;
             this.mode = mode;
             this.storeNames = storeNames;
@@ -2877,7 +2996,7 @@
         });
     }
 
-    function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey) {
+    function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey, type) {
         return {
             name: name,
             keyPath: keyPath,
@@ -2885,7 +3004,8 @@
             multi: multi,
             auto: auto,
             compound: compound,
-            src: (unique && !isPrimKey ? '&' : '') + (multi ? '*' : '') + (auto ? "++" : "") + nameFromKeyPath(keyPath)
+            src: (unique && !isPrimKey ? '&' : '') + (multi ? '*' : '') + (auto ? "++" : "") + nameFromKeyPath(keyPath),
+            type: type
         };
     }
     function nameFromKeyPath(keyPath) {
@@ -2894,13 +3014,17 @@
             keyPath ? ('[' + [].join.call(keyPath, '+') + ']') : "";
     }
 
-    function createTableSchema(name, primKey, indexes) {
+    function createTableSchema(name, primKey, indexes, yProps) {
         return {
             name: name,
             primKey: primKey,
             indexes: indexes,
             mappedClass: null,
-            idxByName: arrayToObject(indexes, function (index) { return [index.name, index]; })
+            yProps: yProps === null || yProps === void 0 ? void 0 : yProps.map(function (prop) { return ({
+                prop: prop,
+                updatesTable: "$".concat(name, ".").concat(prop, "_updates"),
+            }); }),
+            idxByName: arrayToObject(indexes, function (index) { return [index.name, index]; }),
         };
     }
 
@@ -3644,10 +3768,15 @@
     }
     function parseIndexSyntax(primKeyAndIndexes) {
         return primKeyAndIndexes.split(',').map(function (index, indexNum) {
-            index = index.trim();
+            var _a;
+            var typeSplit = index.split(':');
+            var type = (_a = typeSplit[1]) === null || _a === void 0 ? void 0 : _a.trim();
+            index = typeSplit[0].trim();
+            if (type && type !== 'Y')
+                throw new exceptions.Schema("Unsupported type '".concat(type, "'"));
             var name = index.replace(/([&*]|\+\+)/g, "");
             var 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);
         });
     }
 
@@ -3655,40 +3784,57 @@
         function Version() {
         }
         Version.prototype._parseStoresSpec = function (stores, outSchema) {
+            var _this = this;
             keys(stores).forEach(function (tableName) {
+                var _a;
                 if (stores[tableName] !== null) {
                     var indexes = parseIndexSyntax(stores[tableName]);
+                    var yProps = indexes.filter(function (idx) { return idx.type === 'Y'; }).map(function (idx) { return idx.name; });
+                    indexes = indexes.filter(function (idx) { return idx.type !== 'Y'; });
                     var 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");
+                        throw new exceptions.Schema('Primary key cannot be multiEntry*');
                     indexes.forEach(function (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);
+                    var tblSchema = createTableSchema(tableName, primKey, indexes, yProps.length ? yProps : undefined);
+                    outSchema[tableName] = tblSchema;
+                    for (var _i = 0, _b = tblSchema.yProps || []; _i < _b.length; _i++) {
+                        var yProp = _b[_i];
+                        _this._parseStoresSpec((_a = {}, _a[yProp.updatesTable] = '++i,k', _a), outSchema);
+                    }
                 }
             });
         };
         Version.prototype.stores = function (stores) {
             var 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;
             var versions = db._versions;
             var storesSpec = {};
             var dbschema = {};
             versions.forEach(function (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(function (tableName) {
+                if (dbschema[tableName].yProps) {
+                    db.table(tableName).mapToClass(dbschema[tableName].mappedClass || Object);
+                }
+            });
             return this;
         };
         Version.prototype.upgrade = function (upgradeFunction) {
@@ -5235,6 +5381,140 @@
         });
     }
 
+    function compressYDocs(db, interval) {
+        var p = Promise.resolve();
+        for (var _i = 0, _a = db.tables; _i < _a.length; _i++) {
+            var table = _a[_i];
+            var _loop_1 = function (yProp) {
+                p = p.then(function () { return compressYDocsTable(db, yProp, interval); });
+            };
+            for (var _b = 0, _c = table.schema.yProps || []; _b < _c.length; _b++) {
+                var yProp = _c[_b];
+                _loop_1(yProp);
+            }
+        }
+        return p;
+    }
+    function compressYDocsTable(db, _a, skipIfRunnedSince
+    ) {
+        var updatesTable = _a.updatesTable;
+        var updTbl = db.table(updatesTable);
+        return Promise.all([
+            updTbl
+                .where('i')
+                .startsWith('')
+                .toArray(),
+            db.transaction('rw', updatesTable, function () {
+                return updTbl.get(0).then(function (lastCompressed) {
+                    if (lastCompressed &&
+                        skipIfRunnedSince &&
+                        lastCompressed.lastRun.getTime() > Date.now() - skipIfRunnedSince) {
+                        return null;
+                    }
+                    lastCompressed = lastCompressed || { i: 0, lastCompressed: 0 };
+                    return updTbl
+                        .put(__assign(__assign({}, lastCompressed), { lastRun: new Date() }))
+                        .then(function () { return lastCompressed; });
+                });
+            }),
+        ]).then(function (_a) {
+            var syncers = _a[0], stamp = _a[1];
+            if (!stamp)
+                return;
+            var lastCompressedUpdate = stamp.lastCompressed;
+            var unsentFrom = Math.min.apply(Math, syncers.map(function (s) { return s.unsentFrom || Infinity; }));
+            return updTbl
+                .where('i')
+                .between(lastCompressedUpdate, Infinity, false)
+                .toArray(function (addedUpdates) {
+                if (addedUpdates.length <= 1)
+                    return;
+                var docsToCompress = [];
+                var lastUpdateToCompress = lastCompressedUpdate + 1;
+                var _loop_2 = function (j) {
+                    var updateRow = addedUpdates[j];
+                    var i = updateRow.i, f = updateRow.f, k = updateRow.k;
+                    if (i >= unsentFrom && (f & 0x01))
+                        return "break";
+                    var entry = docsToCompress.find(function (entry) { return cmp(entry.docId, k) === 0; });
+                    if (entry)
+                        entry.updates.push(updateRow);
+                    else
+                        docsToCompress.push({ docId: k, updates: [updateRow] });
+                    lastUpdateToCompress = i;
+                };
+                for (var j = 0; j < addedUpdates.length; ++j) {
+                    var state_1 = _loop_2(j);
+                    if (state_1 === "break")
+                        break;
+                }
+                var p = Promise.resolve();
+                var _loop_3 = function (docId, updates) {
+                    p = p.then(function () { return compressUpdatesForDoc(db, updatesTable, docId, updates); });
+                };
+                for (var _i = 0, docsToCompress_1 = docsToCompress; _i < docsToCompress_1.length; _i++) {
+                    var _a = docsToCompress_1[_i], docId = _a.docId, updates = _a.updates;
+                    _loop_3(docId, updates);
+                }
+                return p.then(function () {
+                    return db.transaction('rw', updTbl, function () {
+                        return updTbl.get(0).then(function (current) {
+                            return updTbl.put(__assign(__assign({}, current), { lastCompressed: Math.max(lastUpdateToCompress, (current === null || current === void 0 ? void 0 : current.lastCompressed) || 0) }));
+                        });
+                    });
+                });
+            });
+        });
+    }
+    function compressUpdatesForDoc(db, updatesTable, parentId, addedUpdatesToCompress) {
+        if (addedUpdatesToCompress.length < 1)
+            throw new Error('Invalid input');
+        return db.transaction('rw', updatesTable, function (tx) {
+            var updTbl = tx.table(updatesTable);
+            return updTbl.where({ k: parentId }).first(function (mainUpdate) {
+                var updates = [mainUpdate].concat(addedUpdatesToCompress);
+                var Y = getYLibrary(db);
+                var doc = new Y.Doc({ gc: true });
+                updates.forEach(function (update) {
+                    Y.applyUpdateV2(doc, update.u);
+                });
+                var compressedUpdate = Y.encodeStateAsUpdateV2(doc);
+                var lastUpdate = updates.pop();
+                return updTbl
+                    .put({
+                    i: lastUpdate.i,
+                    k: parentId,
+                    u: compressedUpdate,
+                })
+                    .then(function () { return updTbl.bulkDelete(updates.map(function (update) { return update.i; })); });
+            });
+        });
+    }
+
+    var INTERVAL = 10000;
+    function periodicGC(db) {
+        var timer = null;
+        db.on('ready', function (db) {
+            if (db.tables.some(function (tbl) { return tbl.schema.yProps; })) {
+                var gc_1 = function () {
+                    if (!db.isOpen())
+                        return;
+                    compressYDocs(db, INTERVAL).catch(function (err) {
+                        console.debug('Error during periodic GC', err);
+                    }).then(function () {
+                        timer = setTimeout(gc_1, INTERVAL);
+                    });
+                };
+                timer = setTimeout(gc_1, INTERVAL);
+            }
+        }, true);
+        db.on('close', function () {
+            if (timer)
+                clearTimeout(timer);
+            timer = null;
+        });
+    }
+
     var Dexie$1 =  (function () {
         function Dexie(name, options) {
             var _this = this;
@@ -5276,7 +5556,18 @@
             });
             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 = function (event, callback) {
+                var fn = function () {
+                    var args = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        args[_i] = arguments[_i];
+                    }
+                    _this.on(event).unsubscribe(fn);
+                    callback.apply(_this, args);
+                };
+                return _this.on(event, fn);
+            };
             this.on.ready.subscribe = override(this.on.ready.subscribe, function (subscribe) {
                 return function (subscriber, bSticky) {
                     Dexie.vip(function () {
@@ -5355,6 +5646,8 @@
                 }
             });
             this.vip = vipDB;
+            if (options === null || options === void 0 ? void 0 : options.Y)
+                periodicGC(this);
             addons.forEach(function (addon) { return addon(_this); });
         }
         Dexie.prototype.version = function (versionNumber) {
@@ -5417,6 +5710,7 @@
             function () { return dexieOpen(_this); });
         };
         Dexie.prototype._close = function () {
+            this.on.close.fire(new CustomEvent('close'));
             var state = this._state;
             var idx = connections.indexOf(this);
             if (idx >= 0)
@@ -5574,6 +5868,9 @@
             }
             return this._allTables[tableName];
         };
+        Dexie.prototype.gc = function () {
+            return compressYDocs(this);
+        };
         return Dexie;
     }());
 
@@ -5874,6 +6171,116 @@
         return new PropModification({ replacePrefix: [a, b] });
     }
 
+    function observeYDocUpdates(provider, doc, db, parentTableName, updatesTableName, parentId, Y) {
+        var lastUpdateId = 0;
+        var initial = true;
+        var subscription = liveQuery(function () {
+            throwIfDestroyed(doc);
+            var updatesTable = db.table(updatesTableName);
+            return Promise.all([
+                (lastUpdateId > 0
+                    ? updatesTable
+                        .where('i')
+                        .between(lastUpdateId, Infinity, false)
+                        .toArray()
+                        .then(function (updates) {
+                        return updates.filter(function (update) { return cmp(update.k, parentId) === 0; });
+                    })
+                    : updatesTable.where({ k: parentId }).toArray()).then(function (updates) {
+                    if (updates.length > 0)
+                        lastUpdateId = updates[updates.length - 1].i;
+                    return updates;
+                }),
+                db.table(parentTableName).where(':id').equals(parentId).toArray(),
+            ]);
+        }).subscribe(function (_a) {
+            var updates = _a[0], parentRow = _a[1];
+            if (parentRow.length === 0) {
+                doc.destroy();
+                return;
+            }
+            throwIfDestroyed(doc);
+            if (updates.length > 0) {
+                Y.transact(doc, function () {
+                    updates.forEach(function (update) {
+                        Y.applyUpdateV2(doc, update.u);
+                    });
+                }, provider, false);
+            }
+            if (initial) {
+                initial = false;
+                provider.on('load').fire(provider);
+                doc.emit('load', [doc]);
+            }
+        }, function (error) {
+            provider.on('error').fire(error);
+        });
+        var onUpdate = function (update, origin) {
+            if (origin === provider)
+                return;
+            db.table(updatesTableName)
+                .add({
+                k: parentId,
+                u: update,
+                f: 1,
+            })
+                .then(function (i) {
+                if (i === lastUpdateId - 1)
+                    ++lastUpdateId;
+            })
+                .catch(function (error) {
+                provider.on('error').fire(error);
+            });
+        };
+        var stopObserving = function () {
+            subscription.unsubscribe();
+            doc.off('updateV2', onUpdate);
+            doc.off('destroy', stopObserving);
+        };
+        doc.on('updateV2', onUpdate);
+        doc.on('destroy', stopObserving);
+        return stopObserving;
+    }
+
+    function DexieYProvider(doc) {
+        var _a = (doc || {}).meta, db = _a.db, parentTable = _a.parentTable, parentId = _a.parentId, updatesTable = _a.updatesTable;
+        if (!db || !parentTable || !updatesTable)
+            throw new Error('Y.Doc not generated by Dexie');
+        if (!db.table(parentTable) || !db.table(updatesTable)) {
+            throw new Error("Table ".concat(parentTable, " or ").concat(updatesTable, " not found in db"));
+        }
+        throwIfDestroyed(doc);
+        var Y = getYLibrary(db);
+        function createEvents() {
+            return Events(null, "load", "sync", "error");
+        }
+        var on = createEvents();
+        var provider = {
+            destroyed: false,
+            doc: doc,
+            on: on,
+            off: function (name, f) { var _a; (_a = on[name]) === null || _a === void 0 ? void 0 : _a.unsubscribe(f); },
+            whenLoaded: new Promise(function (resolve, reject) {
+                on('load', resolve);
+                on('error', reject);
+            }),
+            whenSynced: new Promise(function (resolve, reject) {
+                on('sync', resolve);
+                on('error', reject);
+            }),
+            destroy: function () {
+                this.destroyed = true;
+                stopObserving();
+                on = this.on = createEvents();
+            }
+        };
+        var stopObserving = observeYDocUpdates(provider, doc, db, parentTable, updatesTable, parentId, Y);
+        doc.on('destroy', provider.destroy.bind(provider));
+        db.on.y.fire(provider, Y);
+        return provider;
+    }
+    DexieYProvider.getDocCache = getDocCache;
+
     DexiePromise.rejectionMapper = mapError;
     setDebug(debug);
 
@@ -5891,7 +6298,8 @@
         'default': Dexie$1,
         RangeSet: RangeSet,
         mergeRanges: mergeRanges,
-        rangesOverlap: rangesOverlap
+        rangesOverlap: rangesOverlap,
+        DexieYProvider: DexieYProvider
     });
 
     __assign(Dexie$1, namedExports, { default: Dexie$1 });