localdb-ces6q 0.2.23 → 0.2.24

package/LocalDB.js

@@ -1,980 +0,0 @@
-import { BTree } from 'bplustree-mq4uj/btree.js';
-import { Debounce } from 'util-3gcvv/class/Debounce.js';
-import { deepEqual } from 'util-3gcvv/deepEqual.js';
-import { objectEmpty, objectKeys } from 'util-3gcvv/object.js';
-import { randomString } from 'util-3gcvv/string.js';
-import { defaultComparators } from './comparators.js';
-import { LocalDBState } from './LocalDBState.js';
-// TODO
-// composite index
-// index filter / sort
-// watch filtered/sorted collection
-export class LocalDB {
-    constructor(config, initialData, options) {
-        this._txChangedFields = {};
-        this._txChanges = {};
-        this._txKey = null;
-        this._txOps = [];
-        this._txRollbacks = [];
-        this._txSnapshot = null;
-        this._txOptions = null;
-        this._noEvent = false;
-        this._undoable = false;
-        this._inUndoOrRedo = false;
-        this._opQueue = [];
-        this._commiting = false;
-        this._listenerId = 0;
-        this._dbListeners = [];
-        this._colListeners = [];
-        this._docListeners = [];
-        this._fieldListeners = [];
-        this.state = new LocalDBState({ history: [], historyIndex: 0 }, {});
-        this.saveDebounced = new Debounce(this.saveToStorage, 300, this);
-        this._options = options;
-        this._collectionNames = [];
-        this._collections = {};
-        this._config = {};
-        this._fields = {};
-        this._saveCols = {};
-        this._indexes = {};
-        const colNames = objectKeys(config);
-        for (let i = 0, il = colNames.length; i < il; i += 1) {
-            const col = colNames[i];
-            this.defineCollection(col, config[col], initialData?.[col]);
-        }
-    }
-    destroy() {
-        this.saveDebounced.destroy();
-        this._options = undefined;
-        this._collectionNames = [];
-        this._collections = {};
-        this._config = {};
-        this._fields = {};
-        for (let col in this._saveCols) {
-            this._saveCols[col]?.destroy();
-        }
-        this._saveCols = {};
-        for (let col in this._indexes) {
-            const indexes = this._indexes[col];
-            for (let name in indexes) {
-                indexes[name].clear();
-            }
-        }
-        this._indexes = {};
-        this._txChangedFields = {};
-        this._txChanges = {};
-        this._txKey = null;
-        this._txOps = [];
-        this._txRollbacks = [];
-        this._txSnapshot = null;
-        this._txOptions = null;
-        this.state.$destroy();
-        this._dbListeners = [];
-        this._colListeners = [];
-        this._docListeners = [];
-        this._fieldListeners = [];
-        this._opQueue = [];
-        this._listenerId = 0;
-    }
-    toJSON() {
-        return this._collections;
-    }
-    equals(other) {
-        return deepEqual(this._collections, other);
-    }
-    //
-    // Config
-    //
-    defineCollection(colName, config, initialData) {
-        const col = colName;
-        if (col in this._config) {
-            throw new Error(`Collection, "${col}", is already defined`);
-        }
-        // config
-        this._config[col] = config;
-        // collection name
-        this._collectionNames.push(col);
-        // field names
-        const fieldNames = objectKeys(config.fields);
-        this._fields[col] = fieldNames;
-        // save data to storage
-        this._saveCols[col] = new Debounce(() => this.saveCollectionToStorage(col), config.localStorageSetWait ?? 300);
-        // initial data
-        const { localStorageKey } = config;
-        let colData = {};
-        if (initialData) {
-            colData = initialData;
-        }
-        else if (localStorageKey) {
-            const snapshot = localStorage.getItem(localStorageKey);
-            if (snapshot) {
-                colData = JSON.parse(snapshot);
-            }
-        }
-        this._collections = { ...this._collections, [col]: colData };
-        // indexes
-        const docs = [];
-        if (colData) {
-            for (let id in colData) {
-                const doc = colData[id];
-                docs.push(doc);
-            }
-        }
-        const fieldIndexes = {};
-        for (let fi = 0, fl = fieldNames.length; fi < fl; fi += 1) {
-            const field = fieldNames[fi];
-            const { type, compare, index } = config.fields[field];
-            if (index) {
-                let comparator;
-                if (compare) {
-                    comparator = index === 'desc' ? (a, b) => compare(b, a) : compare;
-                }
-                else {
-                    comparator = defaultComparators[type]?.[index];
-                }
-                if (!comparator) {
-                    throw new Error(`Comparator must be set to index ${col}/${field}`);
-                }
-                fieldIndexes[field] = new BTree(docs.map((d) => [d, d]), (a, b) => comparator(a[field], b[field]));
-            }
-        }
-        const { indexes } = config;
-        if (indexes) {
-            for (const name in indexes) {
-                const { compare } = indexes[name];
-                fieldIndexes[name] = new BTree(docs.map((d) => [d, d]), compare);
-            }
-        }
-        this._indexes[col] = fieldIndexes;
-    }
-    deleteCollection(col) {
-        if (!(col in this._config)) {
-            throw new Error(`Collection, "${col}", does not exist`);
-        }
-        delete this._config[col];
-        this._collectionNames = this._collectionNames.filter((x) => x !== col);
-        delete this._fields[col];
-        delete this._saveCols[col];
-        const next = { ...this._collections };
-        delete next[col];
-        this._collections = next;
-    }
-    existsCollection(col) {
-        return col in this._config;
-    }
-    get collectionNames() {
-        return this._collectionNames.slice();
-    }
-    //
-    // Transaction
-    //
-    beginTx(options = this._options) {
-        if (this._txKey == null) {
-            const key = randomString();
-            this._txChangedFields = {};
-            this._txChanges = {};
-            this._txKey = key;
-            this._txOps = [];
-            this._txRollbacks = [];
-            this._txSnapshot = this._collections;
-            this._txOptions = options || null;
-            this._noEvent = !!options?.noEvent;
-            this._undoable = !!options?.undoable;
-            return key;
-        }
-        return null;
-    }
-    endTx(txKey) {
-        if (txKey != null && this._txKey === txKey) {
-            try {
-                this._commitChanges();
-            }
-            catch (e) {
-                this._rollback();
-                throw e;
-            }
-            this._pushHistory();
-            // reset
-            this._txChangedFields = {};
-            this._txChanges = {};
-            this._txKey = null;
-            this._txOps = [];
-            this._txRollbacks = [];
-            this._txSnapshot = null;
-            this._txOptions = null;
-            this._noEvent = false;
-            this._undoable = false;
-            this._flushQueue();
-        }
-    }
-    _rollback() {
-        if (this._txSnapshot) {
-            this._collections = this._txSnapshot;
-            for (let i = 0, il = this._txRollbacks.length; i < il; i += 1) {
-                this._txRollbacks[i]();
-            }
-            // reset
-            this._txChangedFields = {};
-            this._txChanges = {};
-            this._txKey = null;
-            this._txOps = [];
-            this._txRollbacks = [];
-            this._txSnapshot = null;
-            this._noEvent = false;
-            this._undoable = false;
-        }
-    }
-    tx(fn, options) {
-        const txKey = this.beginTx(options);
-        if (txKey == null) {
-            throw new Error('Already in transaction');
-        }
-        try {
-            fn();
-        }
-        catch (e) {
-            this._rollback();
-            throw e;
-        }
-        this.endTx(txKey);
-    }
-    undoableTx(fn, options) {
-        return this.tx(fn, { ...options, undoable: true });
-    }
-    //
-    // Listeners
-    //
-    subToDB(handler) {
-        const lid = this._listenerId++;
-        this._dbListeners.push({ lid, handler });
-        return () => this.unsubFromDB(lid);
-    }
-    unsubFromDB(lid) {
-        this._dbListeners = this._dbListeners.filter((x) => x.lid !== lid);
-    }
-    subToCol(collection, handler) {
-        const lid = this._listenerId++;
-        this._colListeners.push({ lid, collection, handler });
-        return () => this.unsubFromCol(lid);
-    }
-    unsubFromCol(lid) {
-        this._colListeners = this._colListeners.filter((x) => x.lid !== lid);
-    }
-    subToDoc(collection, id, handler) {
-        const lid = this._listenerId++;
-        this._docListeners.push({ lid, collection, id, handler });
-        return () => this.unsubFromDoc(lid);
-    }
-    unsubFromDoc(lid) {
-        this._docListeners = this._docListeners.filter((x) => x.lid !== lid);
-    }
-    subToField(collection, id, field, handler) {
-        const lid = this._listenerId++;
-        this._fieldListeners.push({ lid, collection, id, field, handler });
-        return () => this.unsubFromField(lid);
-    }
-    unsubFromField(lid) {
-        this._fieldListeners = this._fieldListeners.filter((x) => x.lid !== lid);
-    }
-    //
-    // Get
-    //
-    collection(colName) {
-        return this._collections[colName];
-    }
-    doc(colName, id) {
-        return this._collections[colName][id];
-    }
-    docs(colName, ids) {
-        const col = this._collections[colName];
-        return ids.map((id) => col[id]);
-    }
-    getIndex(colName, index) {
-        const col = this._indexes[colName];
-        if (!(index in col)) {
-            throw new Error(`index ${colName}/${index} not found`);
-        }
-        return col[index];
-    }
-    docsOrderBy(colName, index) {
-        const col = this._indexes[colName];
-        if (!(index in col)) {
-            throw new Error(`index ${colName}/${index} not found`);
-        }
-        return col[index].valuesArray();
-    }
-    query({ collection, orderBy, limit, startAfter, startAt, endAfter, endAt, }) {
-        const col = this._indexes[collection];
-        if (!(orderBy in col)) {
-            throw new Error(`index ${collection}/${orderBy} not found`);
-        }
-        const index = col[orderBy];
-        // TODO
-        return index.valuesArray();
-    }
-    //
-    // Set / Update
-    //
-    setDoc(colName, doc, options) {
-        if (this._commiting) {
-            this._opQueue.push({ op: 'setDoc', args: [colName, doc] });
-            return;
-        }
-        const { id } = doc;
-        const keys = this._fields[colName];
-        const collections = this._collections;
-        const prev = collections[colName][id] || null;
-        if (prev != null) {
-            const copy = {};
-            // delete unset fields
-            for (let i = 0, il = keys.length; i < il; i += 1) {
-                const key = keys[i];
-                if (key in doc) {
-                    copy[key] = doc[key];
-                }
-                else {
-                    // undefined -> delete field
-                    copy[key] = undefined;
-                }
-            }
-            return this.updateDoc(colName, id, copy, options);
-        }
-        // begin tx
-        const txKey = this.beginTx(options);
-        const _txChange = this._txChanges;
-        const _txChangedFields = this._txChangedFields;
-        const next = {};
-        for (let i = 0, il = keys.length; i < il; i += 1) {
-            const key = keys[i];
-            if (key in doc && doc[key] !== undefined) {
-                next[key] = doc[key];
-                // set changes
-                const changeMapCol = _txChangedFields[colName] || (_txChangedFields[colName] = {});
-                changeMapCol[key] = true;
-                const changeCol = _txChange[colName] || (_txChange[colName] = {});
-                const changeDoc = changeCol[id] || (changeCol[id] = {});
-                changeDoc[key] = doc[key];
-            }
-        }
-        // update data
-        this._collections = {
-            ...collections,
-            [colName]: {
-                ...collections[colName],
-                [id]: next,
-            },
-        };
-        // update indexes
-        const indexes = this._indexes[colName];
-        for (let indexName in indexes) {
-            indexes[indexName].set(next, next, true);
-        }
-        this._txRollbacks.push(() => {
-            const indexes = this._indexes[colName];
-            for (let indexName in indexes) {
-                indexes[indexName].delete(next);
-            }
-        });
-        // update undo history
-        if (this._undoable && !this._inUndoOrRedo) {
-            this._txOps.push({
-                undo: { op: 'deleteDoc', args: [colName, id] },
-                redo: { op: 'setDoc', args: [colName, doc] },
-            });
-        }
-        this._config[colName].foreignComputes?.forEach((compute) => {
-            compute.compute(this, [{ next, prev }]);
-        });
-        // end tx
-        this.endTx(txKey);
-    }
-    setDocs(colName, docs, options) {
-        if (!docs.length)
-            return;
-        if (this._commiting) {
-            this._opQueue.push({ op: 'setDocs', args: [colName, docs] });
-            return;
-        }
-        // begin tx
-        const txKey = this.beginTx(options);
-        // TODO undo, computes
-        for (let i = 0, il = docs.length; i < il; i += 1) {
-            this.setDoc(colName, docs[i], options);
-        }
-        // end tx
-        this.endTx(txKey);
-    }
-    _updateDoc(colName, prev, update) {
-        //
-        // Normalize Update
-        //
-        const config = this._config[colName];
-        const keys = this._fields[colName];
-        let next = { ...prev };
-        let changed = false;
-        let updateNormalized = {};
-        for (let ki = 0, kl = keys.length; ki < kl; ki += 1) {
-            const key = keys[ki];
-            if (!(key in update))
-                continue;
-            let nextVal = update[key];
-            const { normalize, equals } = config.fields[key];
-            if (normalize) {
-                nextVal = normalize(nextVal, next);
-            }
-            if (equals ? equals(nextVal, prev[key]) : nextVal === prev[key]) {
-                // noop
-            }
-            else {
-                changed = true;
-                updateNormalized[key] = nextVal;
-                if (nextVal === undefined) {
-                    delete next[key];
-                }
-                else {
-                    next[key] = nextVal;
-                }
-            }
-        }
-        if (!changed)
-            return null;
-        //
-        // Computes
-        //
-        const { computes } = config;
-        if (computes) {
-            // previous doc state before update before this iteration
-            let docBeforeUpdate = prev;
-            // update before this iteration
-            let updateBeforeIter = updateNormalized;
-            // docBeforeUpdate + updateBeforeIter
-            let docBeforeIter = next;
-            let updateByThisIter = {};
-            // docBeforeUpdate + updateBeforeIter + updateByThisIter
-            let docAfterIter = { ...next };
-            let changedByIter = false;
-            let count = 0;
-            while (true) {
-                for (let ci = 0, cl = computes.length; ci < cl; ci += 1) {
-                    const { compute } = computes[ci];
-                    // check deps has changed
-                    let depsChanged = false;
-                    const deps = computes[ci].deps;
-                    for (let di = 0, dl = deps.length; di < dl; di += 1) {
-                        const dep = deps[di];
-                        if (dep in updateBeforeIter) {
-                            depsChanged = true;
-                        }
-                    }
-                    if (!depsChanged)
-                        continue;
-                    const computedUpdate = compute(docBeforeIter, docBeforeUpdate);
-                    if (!computedUpdate)
-                        continue;
-                    for (let ki = 0, kl = keys.length; ki < kl; ki += 1) {
-                        const key = keys[ki];
-                        if (!(key in computedUpdate))
-                            continue;
-                        let nextVal = computedUpdate[key];
-                        const { normalize, equals } = config.fields[key];
-                        if (normalize) {
-                            nextVal = normalize(nextVal, docAfterIter);
-                        }
-                        if (equals
-                            ? equals(nextVal, docBeforeIter[key])
-                            : nextVal === docBeforeIter[key]) {
-                            // noop
-                        }
-                        else {
-                            changedByIter = true;
-                            updateByThisIter[key] = nextVal;
-                            if (nextVal === undefined) {
-                                delete docAfterIter[key];
-                            }
-                            else {
-                                docAfterIter[key] = nextVal;
-                            }
-                        }
-                    }
-                }
-                if (changedByIter) {
-                    docBeforeUpdate = docBeforeIter;
-                    updateBeforeIter = updateByThisIter;
-                    docBeforeIter = docAfterIter;
-                    updateByThisIter = {};
-                    docAfterIter = { ...docAfterIter };
-                    changedByIter = false;
-                }
-                else {
-                    next = docAfterIter;
-                    break;
-                }
-                if (count++ > 100) {
-                    throw new Error('too many compute loops');
-                }
-            }
-        }
-        if (!changed)
-            return null;
-        const changedKeys = keys.filter((key) => next[key] !== prev[key]);
-        if (!changedKeys.length)
-            return null;
-        return { next, changedKeys };
-    }
-    updateDoc(colName, id, updater, options) {
-        if (this._commiting) {
-            this._opQueue.push({ op: 'updateDoc', args: [colName, id, updater] });
-            return;
-        }
-        const collections = this._collections;
-        const prev = collections[colName][id];
-        if (prev == null) {
-            if (options?.ignoreNotFound || this._txOptions?.ignoreNotFound)
-                return;
-            this._rollback();
-            throw new Error(`Cannot update non-existing document, ${colName}/${id}`);
-        }
-        const update = typeof updater === 'function' ? updater(prev) : updater;
-        if (prev === update || update == null || objectEmpty(update))
-            return;
-        // begin tx
-        const txKey = this.beginTx(options);
-        const result = this._updateDoc(colName, prev, update);
-        if (result) {
-            const { next, changedKeys } = result;
-            const _txChange = this._txChanges;
-            const _txChangedFields = this._txChangedFields;
-            const prevFields = {};
-            const nextFields = {};
-            for (let ki = 0, kl = changedKeys.length; ki < kl; ki += 1) {
-                const key = changedKeys[ki];
-                const nextVal = next[key];
-                const prevVal = prev[key];
-                // update field
-                prevFields[key] = prevVal;
-                nextFields[key] = nextVal;
-                // set changes
-                const changeMapCol = _txChangedFields[colName] || (_txChangedFields[colName] = {});
-                changeMapCol[key] = true;
-                const changeCol = _txChange[colName] || (_txChange[colName] = {});
-                const changeDoc = changeCol[id] || (changeCol[id] = {});
-                changeDoc[key] = nextVal;
-            }
-            this._collections = {
-                ...collections,
-                [colName]: {
-                    ...collections[colName],
-                    [id]: next,
-                },
-            };
-            // update indexes
-            const indexes = this._indexes[colName];
-            for (let indexName in indexes) {
-                indexes[indexName].delete(prev);
-                indexes[indexName].set(next, next, true);
-            }
-            this._txRollbacks.push(() => {
-                const indexes = this._indexes[colName];
-                for (let indexName in indexes) {
-                    indexes[indexName].delete(next);
-                    indexes[indexName].set(prev, prev, true);
-                }
-            });
-            // update undo history
-            if (this._undoable && !this._inUndoOrRedo) {
-                this._txOps.push({
-                    undo: { op: 'updateDoc', args: [colName, id, prevFields] },
-                    redo: { op: 'updateDoc', args: [colName, id, nextFields] },
-                });
-            }
-            this._config[colName].foreignComputes?.forEach((compute) => {
-                compute.compute(this, [{ next, prev }]);
-            });
-        }
-        // end tx
-        this.endTx(txKey);
-    }
-    updateDocs(colName, updater, options) {
-        if (this._commiting) {
-            this._opQueue.push({ op: 'updateDocs', args: [colName, updater] });
-            return;
-        }
-        const collections = this._collections;
-        const prevCol = collections[colName];
-        const update = typeof updater === 'function' ? updater(prevCol) : updater;
-        if (prevCol === update || update == null || objectEmpty(update))
-            return;
-        const nextCol = { ...prevCol };
-        // begin tx
-        const txKey = this.beginTx(options);
-        const _txChange = this._txChanges;
-        const _txChangedFields = this._txChangedFields;
-        const prevUpdateMap = {};
-        const nextUpdateMap = {};
-        const prevDocs = [];
-        const nextDocs = [];
-        const foreignComputeArgs = [];
-        let changed = false;
-        const ignoreNotFound = !!(options?.ignoreNotFound || this._txOptions?.ignoreNotFound);
-        const ids = objectKeys(update);
-        for (let i = 0, il = ids.length; i < il; i += 1) {
-            const id = ids[i];
-            const prevDoc = prevCol[id];
-            if (prevDoc == null) {
-                if (ignoreNotFound)
-                    continue;
-                this._rollback();
-                throw new Error(`Cannot update non-existing document, ${colName}/${id}`);
-            }
-            const updateDoc = update[id];
-            if (updateDoc == null || objectEmpty(updateDoc))
-                continue;
-            const result = this._updateDoc(colName, prevDoc, updateDoc);
-            if (!result)
-                continue;
-            changed = true;
-            const { next: nextDoc, changedKeys } = result;
-            const prevFields = {};
-            const nextFields = {};
-            for (let ki = 0, kl = changedKeys.length; ki < kl; ki += 1) {
-                const key = changedKeys[ki];
-                const nextVal = nextDoc[key];
-                const prevVal = prevDoc[key];
-                // update field
-                prevFields[key] = prevVal;
-                nextFields[key] = nextVal;
-                // set changes
-                const changeMapCol = _txChangedFields[colName] || (_txChangedFields[colName] = {});
-                changeMapCol[key] = true;
-                const changeCol = _txChange[colName] || (_txChange[colName] = {});
-                const changeDoc = changeCol[id] || (changeCol[id] = {});
-                changeDoc[key] = nextVal;
-            }
-            nextCol[id] = nextDoc;
-            prevUpdateMap[id] = prevFields;
-            nextUpdateMap[id] = nextFields;
-            prevDocs.push(prevDoc);
-            nextDocs.push(nextDoc);
-            foreignComputeArgs.push({ next: nextDoc, prev: prevDoc });
-        }
-        // update data
-        if (changed) {
-            this._collections = {
-                ...collections,
-                [colName]: nextCol,
-            };
-            // update indexes
-            const indexes = this._indexes[colName];
-            for (let indexName in indexes) {
-                indexes[indexName].deleteKeys(prevDocs);
-                indexes[indexName].setPairs(nextDocs.map((doc) => [doc, doc]), true);
-            }
-            this._txRollbacks.push(() => {
-                const indexes = this._indexes[colName];
-                for (let indexName in indexes) {
-                    indexes[indexName].deleteKeys(nextDocs);
-                    indexes[indexName].setPairs(prevDocs.map((doc) => [doc, doc]), true);
-                }
-            });
-            // update undo history
-            if (this._undoable && !this._inUndoOrRedo) {
-                this._txOps.push({
-                    undo: { op: 'updateDocs', args: [colName, prevUpdateMap] },
-                    redo: { op: 'updateDocs', args: [colName, nextUpdateMap] },
-                });
-            }
-            this._config[colName].foreignComputes?.forEach((compute) => {
-                compute.compute(this, foreignComputeArgs);
-            });
-        }
-        // end tx
-        this.endTx(txKey);
-    }
-    deleteDoc(colName, id, options) {
-        if (this._commiting) {
-            this._opQueue.push({ op: 'deleteDoc', args: [colName, id] });
-            return;
-        }
-        const collections = this._collections;
-        const prev = collections[colName][id];
-        if (prev == null) {
-            if (options?.idempotent || this._txOptions?.idempotent)
-                return;
-            this._rollback();
-            throw new Error(`Cannot delete non-existing document, ${colName}/${id}`);
-        }
-        // begin tx
-        const txKey = this.beginTx(options);
-        // changes
-        const _txChange = this._txChanges;
-        const _txChangedFields = this._txChangedFields;
-        const keys = this._fields[colName];
-        for (let i = 0, il = keys.length; i < il; i += 1) {
-            const key = keys[i];
-            if (key in prev && prev[key] !== undefined) {
-                // set changes
-                const changeMapCol = _txChangedFields[colName] || (_txChangedFields[colName] = {});
-                changeMapCol[key] = true;
-            }
-        }
-        const changeCol = _txChange[colName] || (_txChange[colName] = {});
-        changeCol[id] = null;
-        // update data
-        const nextCol = { ...collections[colName] };
-        delete nextCol[id];
-        this._collections = {
-            ...collections,
-            [colName]: nextCol,
-        };
-        // update indexes
-        const indexes = this._indexes[colName];
-        for (let indexName in indexes) {
-            indexes[indexName].delete(prev);
-        }
-        this._txRollbacks.push(() => {
-            const indexes = this._indexes[colName];
-            for (let indexName in indexes) {
-                indexes[indexName].set(prev, prev, true);
-            }
-        });
-        // update undo history
-        if (this._undoable && !this._inUndoOrRedo) {
-            this._txOps.push({
-                undo: { op: 'setDoc', args: [colName, prev] },
-                redo: { op: 'deleteDoc', args: [colName, id] },
-            });
-        }
-        this._config[colName].foreignComputes?.forEach((compute) => {
-            compute.compute(this, [{ next: null, prev }]);
-        });
-        // end tx
-        this.endTx(txKey);
-    }
-    deleteDocs(colName, ids, options) {
-        if (!ids?.length)
-            return;
-        if (this._commiting) {
-            this._opQueue.push({ op: 'deleteDocs', args: [colName, ids] });
-            return;
-        }
-        // begin tx
-        const txKey = this.beginTx(options);
-        const idempotent = !!(options?.idempotent || this._txOptions?.idempotent);
-        const _txChange = this._txChanges;
-        const _txChangedFields = this._txChangedFields;
-        const collections = this._collections;
-        const prevCol = collections[colName];
-        const nextCol = { ...prevCol };
-        const fields = this._fields[colName];
-        const prevDocs = [];
-        const foreignComputeArgs = [];
-        for (let i = 0, il = ids.length; i < il; i += 1) {
-            const id = ids[i];
-            const prev = prevCol[id];
-            if (prev == null) {
-                if (idempotent)
-                    continue;
-                this._rollback();
-                throw new Error(`Cannot delete non-existing document, ${colName}/${id}`);
-            }
-            // changes
-            for (let fi = 0, fl = fields.length; fi < fl; fi += 1) {
-                const key = fields[fi];
-                if (key in prev && prev[key] !== undefined) {
-                    // set changes
-                    const changeMapCol = _txChangedFields[colName] || (_txChangedFields[colName] = {});
-                    changeMapCol[key] = true;
-                }
-            }
-            const changeCol = _txChange[colName] || (_txChange[colName] = {});
-            changeCol[id] = null;
-            delete nextCol[id];
-            prevDocs.push(prev);
-            foreignComputeArgs.push({ next: null, prev });
-        }
-        // update data
-        this._collections = {
-            ...collections,
-            [colName]: nextCol,
-        };
-        // update indexes
-        const indexes = this._indexes[colName];
-        for (let indexName in indexes) {
-            indexes[indexName].deleteKeys(prevDocs);
-        }
-        this._txRollbacks.push(() => {
-            const indexes = this._indexes[colName];
-            for (let indexName in indexes) {
-                indexes[indexName].setPairs(prevDocs.map((d) => [d, d]), true);
-            }
-        });
-        // update undo history
-        if (this._undoable && !this._inUndoOrRedo) {
-            this._txOps.push({
-                undo: { op: 'setDocs', args: [colName, prevDocs] },
-                redo: { op: 'deleteDocs', args: [colName, ids] },
-            });
-        }
-        this._config[colName].foreignComputes?.forEach((compute) => {
-            compute.compute(this, foreignComputeArgs);
-        });
-        // end tx
-        this.endTx(txKey);
-    }
-    _commitChanges() {
-        if (this._commiting)
-            return;
-        const prev = this._txSnapshot;
-        const next = this._collections;
-        if (prev === next || prev == null)
-            return;
-        this._commiting = true;
-        const _txChanges = this._txChanges;
-        const _txChangedFields = this._txChangedFields;
-        const txContext = this._txOptions?.context || {};
-        // listeners
-        const fieldListeners = this._fieldListeners;
-        for (let i = 0, il = fieldListeners.length; i < il; i += 1) {
-            const { collection, id, field, handler } = fieldListeners[i];
-            const field2 = field;
-            const nextDoc = next[collection][id];
-            const prevDoc = prev[collection][id];
-            if (nextDoc?.[field2] !== prevDoc?.[field2]) {
-                handler(nextDoc?.[field2], prevDoc?.[field2], nextDoc, prevDoc, txContext);
-            }
-        }
-        const docListeners = this._docListeners;
-        for (let i = 0, il = docListeners.length; i < il; i += 1) {
-            const { collection, id, handler } = docListeners[i];
-            if (next[collection][id] !== prev[collection][id]) {
-                handler(next[collection][id], prev[collection][id], _txChanges[collection][id], txContext);
-            }
-        }
-        const colListeners = this._colListeners;
-        for (let i = 0, il = colListeners.length; i < il; i += 1) {
-            const { collection, handler } = colListeners[i];
-            if (next[collection] !== prev[collection]) {
-                handler(next[collection], prev[collection], _txChanges[collection], _txChangedFields[collection], txContext);
-            }
-        }
-        const dbListeners = this._dbListeners;
-        for (let i = 0, il = dbListeners.length; i < il; i += 1) {
-            const { handler } = dbListeners[i];
-            handler(next, prev, _txChanges, _txChangedFields, txContext);
-        }
-        // save to storage
-        const cols = this._collectionNames;
-        for (let i = 0, il = cols.length; i < il; i += 1) {
-            const col = cols[i];
-            if (next[col] !== prev[col]) {
-                this._saveCols[col].debounced();
-            }
-        }
-        this._commiting = false;
-    }
-    //
-    // Queue
-    //
-    _flushQueue() {
-        let count = 0;
-        while (this._opQueue.length) {
-            const { op, args } = this._opQueue.shift();
-            this[op].apply(this, args);
-            if (count++ > 100) {
-                throw new Error('too much');
-            }
-        }
-    }
-    //
-    // History
-    //
-    _pushHistory() {
-        if (!this._inUndoOrRedo && this._txOps.length) {
-            this.state.$update(({ history, historyIndex }) => {
-                const nextHistory = [...history.slice(0, historyIndex), this._txOps];
-                return {
-                    history: nextHistory,
-                    historyIndex: nextHistory.length,
-                };
-            });
-            this._txOps = [];
-        }
-    }
-    undo() {
-        if (this._txKey) {
-            throw new Error('Cannot undo during transaction');
-        }
-        const { undoItem } = this.state;
-        if (undoItem) {
-            this._inUndoOrRedo = true;
-            this.tx(() => {
-                for (let i = undoItem.length - 1; i >= 0; i -= 1) {
-                    const { undo } = undoItem[i];
-                    this[undo.op].apply(this, undo.args);
-                }
-                this.state.historyIndex--;
-            });
-            this._inUndoOrRedo = false;
-        }
-    }
-    redo() {
-        if (this._txKey) {
-            throw new Error('Cannot redo during transaction');
-        }
-        const { redoItem } = this.state;
-        if (redoItem) {
-            this._inUndoOrRedo = true;
-            this.tx(() => {
-                for (let i = 0, il = redoItem.length; i < il; i += 1) {
-                    const { redo } = redoItem[i];
-                    this[redo.op].apply(this, redo.args);
-                }
-                this.state.historyIndex++;
-            });
-            this._inUndoOrRedo = false;
-        }
-    }
-    // Local Storage
-    loadCollectionFromStorage(collection) {
-        if (collection in this._config) {
-            const { localStorageKey } = this._config[collection];
-            if (localStorageKey) {
-                const snapshot = localStorage.getItem(localStorageKey);
-                if (snapshot) {
-                    return JSON.parse(snapshot);
-                }
-            }
-            return undefined;
-        }
-    }
-    saveCollectionToStorage(collection) {
-        if (collection in this._config) {
-            const { localStorageKey } = this._config[collection];
-            if (localStorageKey) {
-                localStorage.setItem(localStorageKey, JSON.stringify(this._collections[collection]));
-            }
-        }
-    }
-    loadFromStorage() {
-        const data = this._collections;
-        const cols = this._collectionNames;
-        for (let i = 0, il = cols.length; i < il; i += 1) {
-            const col = cols[i];
-            const colData = this.loadCollectionFromStorage(col);
-            if (colData) {
-                data[col] = colData;
-            }
-        }
-    }
-    saveToStorage() {
-        const data = this._collections;
-        const cols = this._collectionNames;
-        for (let i = 0, il = cols.length; i < il; i += 1) {
-            const col = cols[i];
-            const { localStorageKey } = this._config[col];
-            if (localStorageKey) {
-                localStorage.setItem(localStorageKey, JSON.stringify(data[col]));
-            }
-        }
-    }
-}