localdb-ces6q 0.0.5 → 0.2.0

package/LocalDB.js

@@ -1,966 +1,980 @@
-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]));
-            }
-        }
-        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]);
-    }
-    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]));
-            }
-        }
-    }
-}
+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]));
+            }
+        }
+    }
+}