dexie 4.0.7 → 4.0.9-alpha.1

package/dist/dexie.mjs

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.0.7, Sun May 26 2024
+ * Version 4.0.9-alpha.1, Fri Aug 23 2024
  *
  * https://dexie.org
  *
@@ -1144,7 +1144,7 @@ function tempTransaction(db, mode, storeNames, fn) {
     }
 }
 
-var DEXIE_VERSION = '4.0.7';
+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>.";
@@ -1262,6 +1262,95 @@ function getUint8Array(a) {
     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() {
     }
@@ -1393,6 +1482,7 @@ var Table =  (function () {
         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) {
@@ -1410,6 +1500,20 @@ var Table =  (function () {
                 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); });
@@ -1491,12 +1595,14 @@ var Table =  (function () {
     };
     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) {
@@ -1623,7 +1729,8 @@ var Table =  (function () {
         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)
@@ -2147,45 +2254,48 @@ var Collection =  (function () {
                     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) {
@@ -2203,14 +2313,15 @@ var Collection =  (function () {
                                 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);
                         });
                     });
@@ -2226,6 +2337,7 @@ var Collection =  (function () {
     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) {
@@ -2234,7 +2346,7 @@ var Collection =  (function () {
                 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;
@@ -2836,6 +2948,13 @@ var Transaction =  (function () {
 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;
@@ -2871,7 +2990,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: name,
         keyPath: keyPath,
@@ -2879,7 +2998,8 @@ function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey
         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) {
@@ -2888,13 +3008,17 @@ function nameFromKeyPath(keyPath) {
         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]; }),
     };
 }
 
@@ -3638,10 +3762,15 @@ function adjustToExistingIndexNames(db, schema, idbtrans) {
 }
 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);
     });
 }
 
@@ -3649,40 +3778,57 @@ var Version =  (function () {
     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) {
@@ -3793,6 +3939,10 @@ props(RangeSet.prototype, (_a = {
             var _this = this;
             keys.forEach(function (key) { return addRange(_this, key, key); });
             return this;
+        },
+        hasKey: function (key) {
+            var node = getRangeSetIterator(this).next(key).value;
+            return node && cmp(node.from, key) <= 0 && cmp(node.to, key) >= 0;
         }
     },
     _a[iteratorSymbol] = function () {
@@ -4854,19 +5004,23 @@ function applyOptimisticOps(result, req, ops, table, cacheEntry, immutable) {
     var extractLowLevelIndex = (index.lowLevelIndex || index).extractKey;
     var finalResult = ops.reduce(function (result, op) {
         var modifedResult = result;
-        var includedValues = op.type === 'add' || op.type === 'put'
-            ? op.values.filter(function (v) {
-                var key = extractIndex(v);
-                return multiEntry && isArray(key)
+        var includedValues = [];
+        if (op.type === 'add' || op.type === 'put') {
+            var includedPKs = new RangeSet();
+            for (var i = op.values.length - 1; i >= 0; --i) {
+                var value = op.values[i];
+                var pk = extractPrimKey(value);
+                if (includedPKs.hasKey(pk))
+                    continue;
+                var key = extractIndex(value);
+                if (multiEntry && isArray(key)
                     ? key.some(function (k) { return isWithinRange(k, queryRange); })
-                    : isWithinRange(key, queryRange);
-            }).map(function (v) {
-                v = deepClone(v);
-                if (immutable)
-                    Object.freeze(v);
-                return v;
-            })
-            : [];
+                    : isWithinRange(key, queryRange)) {
+                    includedPKs.addKey(pk);
+                    includedValues.push(value);
+                }
+            }
+        }
         switch (op.type) {
             case 'add':
                 modifedResult = result.concat(req.values
@@ -4876,20 +5030,16 @@ function applyOptimisticOps(result, req, ops, table, cacheEntry, immutable) {
             case 'put':
                 var keySet_1 = new RangeSet().addKeys(op.values.map(function (v) { return extractPrimKey(v); }));
                 modifedResult = result
-                    .filter(function (item) {
-                    var key = req.values ? extractPrimKey(item) : item;
-                    return !rangesOverlap(new RangeSet(key), keySet_1);
-                })
-                    .concat(req.values
+                    .filter(
+                function (item) { return !keySet_1.hasKey(req.values ? extractPrimKey(item) : item); })
+                    .concat(
+                req.values
                     ? includedValues
                     : includedValues.map(function (v) { return extractPrimKey(v); }));
                 break;
             case 'delete':
                 var keysToDelete_1 = new RangeSet().addKeys(op.keys);
-                modifedResult = result.filter(function (item) {
-                    var key = req.values ? extractPrimKey(item) : item;
-                    return !rangesOverlap(new RangeSet(key), keysToDelete_1);
-                });
+                modifedResult = result.filter(function (item) { return !keysToDelete_1.hasKey(req.values ? extractPrimKey(item) : item); });
                 break;
             case 'deleteRange':
                 var range_1 = op.range;
@@ -5225,6 +5375,140 @@ function vipify(target, vipDb) {
     });
 }
 
+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;
@@ -5266,7 +5550,18 @@ var Dexie$1 =  (function () {
         });
         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 () {
@@ -5345,6 +5640,8 @@ var Dexie$1 =  (function () {
             }
         });
         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) {
@@ -5407,6 +5704,7 @@ var Dexie$1 =  (function () {
         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)
@@ -5564,6 +5862,9 @@ var Dexie$1 =  (function () {
         }
         return this._allTables[tableName];
     };
+    Dexie.prototype.gc = function () {
+        return compressYDocs(this);
+    };
     return Dexie;
 }());
 
@@ -5864,8 +6165,118 @@ function replacePrefix(a, b) {
     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);
 
-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