tinybase
Version:
A reactive data store and sync engine.
1,601 lines (1,583 loc) • 119 kB
JavaScript
const getTypeOf = (thing) => typeof thing;
const EMPTY_STRING = '';
const STRING = getTypeOf(EMPTY_STRING);
const BOOLEAN = getTypeOf(true);
const NUMBER = getTypeOf(0);
const FUNCTION = getTypeOf(getTypeOf);
const TYPE = 'type';
const DEFAULT = 'default';
const SUM = 'sum';
const AVG = 'avg';
const MIN = 'min';
const MAX = 'max';
const LISTENER = 'Listener';
const RESULT = 'Result';
const GET = 'get';
const SET = 'set';
const ADD = 'add';
const DEL = 'del';
const HAS = 'Has';
const IDS = 'Ids';
const TABLE = 'Table';
const TABLES = TABLE + 's';
const TABLE_IDS = TABLE + IDS;
const ROW = 'Row';
const ROW_COUNT = ROW + 'Count';
const ROW_IDS = ROW + IDS;
const SORTED_ROW_IDS = 'Sorted' + ROW + IDS;
const CELL = 'Cell';
const CELL_IDS = CELL + IDS;
const VALUE = 'Value';
const VALUES = VALUE + 's';
const VALUE_IDS = VALUE + IDS;
const TRANSACTION = 'Transaction';
const id = (key) => EMPTY_STRING + key;
const strStartsWith = (str, prefix) => str.startsWith(prefix);
const strEndsWith = (str, suffix) => str.endsWith(suffix);
const strSplit = (str, separator = EMPTY_STRING, limit) =>
str.split(separator, limit);
const GLOBAL = globalThis;
const math = Math;
const mathMax = math.max;
const mathMin = math.min;
const mathFloor = math.floor;
const isFiniteNumber = isFinite;
const isInstanceOf = (thing, cls) => thing instanceof cls;
const isUndefined = (thing) => thing == void 0;
const ifNotUndefined = (value, then, otherwise) =>
isUndefined(value) ? otherwise?.() : then(value);
const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
const isString = (thing) => getTypeOf(thing) == STRING;
const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
const isArray = (thing) => Array.isArray(thing);
const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
const size = (arrayOrString) => arrayOrString.length;
const test = (regex, subject) => regex.test(subject);
const getUndefined = () => void 0;
const arrayHas = (array, value) => array.includes(value);
const arrayEvery = (array, cb) => array.every(cb);
const arrayIsEqual = (array1, array2) =>
size(array1) === size(array2) &&
arrayEvery(array1, (value1, index) => array2[index] === value1);
const arrayIsSorted = (array, sorter) =>
arrayEvery(
array,
(value, index) => index == 0 || sorter(array[index - 1], value) <= 0,
);
const arraySort = (array, sorter) => array.sort(sorter);
const arrayForEach = (array, cb) => array.forEach(cb);
const arrayMap = (array, cb) => array.map(cb);
const arraySum = (array) => arrayReduce(array, (i, j) => i + j, 0);
const arrayIsEmpty = (array) => size(array) == 0;
const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
const arrayClear = (array, to) => array.splice(0, to);
const arrayPush = (array, ...values) => array.push(...values);
const arrayPop = (array) => array.pop();
const arrayUnshift = (array, ...values) => array.unshift(...values);
const arrayShift = (array) => array.shift();
const getCellOrValueType = (cellOrValue) => {
const type = getTypeOf(cellOrValue);
return isTypeStringOrBoolean(type) ||
(type == NUMBER && isFiniteNumber(cellOrValue))
? type
: void 0;
};
const isCellOrValueOrNullOrUndefined = (cellOrValue) =>
isUndefined(cellOrValue) || !isUndefined(getCellOrValueType(cellOrValue));
const setOrDelCell = (store, tableId, rowId, cellId, cell) =>
isUndefined(cell)
? store.delCell(tableId, rowId, cellId, true)
: store.setCell(tableId, rowId, cellId, cell);
const setOrDelValue = (store, valueId, value) =>
isUndefined(value) ? store.delValue(valueId) : store.setValue(valueId, value);
const collSizeN = (collSizer) => (coll) =>
arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
const collSize = (coll) => coll?.size ?? 0;
const collSize2 = collSizeN(collSize);
const collSize3 = collSizeN(collSize2);
const collSize4 = collSizeN(collSize3);
const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
const collValues = (coll) => [...(coll?.values() ?? [])];
const collClear = (coll) => coll.clear();
const collForEach = (coll, cb) => coll?.forEach(cb);
const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
const object = Object;
const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
const objEntries = object.entries;
const objFrozen = object.isFrozen;
const isObject = (obj) =>
!isUndefined(obj) &&
ifNotUndefined(
getPrototypeOf(obj),
(objPrototype) =>
objPrototype == object.prototype ||
isUndefined(getPrototypeOf(objPrototype)),
/* istanbul ignore next */
() => true,
);
const objIds = object.keys;
const objFreeze = object.freeze;
const objNew = (entries = []) => object.fromEntries(entries);
const objHas = (obj, id) => id in obj;
const objDel = (obj, id) => {
delete obj[id];
return obj;
};
const objForEach = (obj, cb) =>
arrayForEach(objEntries(obj), ([id, value]) => cb(value, id));
const objToArray = (obj, cb) =>
arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
const objMap = (obj, cb) =>
objNew(objToArray(obj, (value, id) => [id, cb(value, id)]));
const objSize = (obj) => size(objIds(obj));
const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
const objEnsure = (obj, id, getDefaultValue) => {
if (!objHas(obj, id)) {
obj[id] = getDefaultValue();
}
return obj[id];
};
const objValidate = (obj, validateChild, onInvalidObj, emptyIsValid = 0) => {
if (
isUndefined(obj) ||
!isObject(obj) ||
(!emptyIsValid && objIsEmpty(obj)) ||
objFrozen(obj)
) {
onInvalidObj?.();
return false;
}
objForEach(obj, (child, id) => {
if (!validateChild(child, id)) {
objDel(obj, id);
}
});
return emptyIsValid ? true : !objIsEmpty(obj);
};
const mapNew = (entries) => new Map(entries);
const mapKeys = (map) => [...(map?.keys() ?? [])];
const mapGet = (map, key) => map?.get(key);
const mapForEach = (map, cb) =>
collForEach(map, (value, key) => cb(key, value));
const mapMap = (coll, cb) =>
arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
const mapSet = (map, key, value) =>
isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
if (!collHas(map, key)) {
mapSet(map, key, getDefaultValue());
} else {
hadExistingValue?.(mapGet(map, key));
}
return mapGet(map, key);
};
const mapMatch = (map, obj, set, del = mapSet) => {
objMap(obj, (value, id) => set(map, id, value));
mapForEach(map, (id) => (objHas(obj, id) ? 0 : del(map, id)));
return map;
};
const mapToObj = (map, valueMapper, excludeMapValue, excludeObjValue) => {
const obj = {};
collForEach(map, (mapValue, id) => {
if (!excludeMapValue?.(mapValue, id)) {
const objValue = valueMapper ? valueMapper(mapValue, id) : mapValue;
if (!excludeObjValue?.(objValue)) {
obj[id] = objValue;
}
}
});
return obj;
};
const mapToObj2 = (map, valueMapper, excludeMapValue) =>
mapToObj(
map,
(childMap) => mapToObj(childMap, valueMapper, excludeMapValue),
collIsEmpty,
objIsEmpty,
);
const mapToObj3 = (map, valueMapper, excludeMapValue) =>
mapToObj(
map,
(childMap) => mapToObj2(childMap, valueMapper, excludeMapValue),
collIsEmpty,
objIsEmpty,
);
const mapClone = (map, mapValue) => {
const map2 = mapNew();
collForEach(map, (value, key) => map2.set(key, mapValue?.(value) ?? value));
return map2;
};
const mapClone2 = (map) => mapClone(map, mapClone);
const mapClone3 = (map) => mapClone(map, mapClone2);
const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
ifNotUndefined(
(ensureLeaf ? mapEnsure : mapGet)(
node,
path[p],
p > size(path) - 2 ? ensureLeaf : mapNew,
),
(nodeOrLeaf) => {
if (p > size(path) - 2) {
if (pruneLeaf?.(nodeOrLeaf)) {
mapSet(node, path[p]);
}
return nodeOrLeaf;
}
const leaf = visitTree(nodeOrLeaf, path, ensureLeaf, pruneLeaf, p + 1);
if (collIsEmpty(nodeOrLeaf)) {
mapSet(node, path[p]);
}
return leaf;
},
);
const setNew = (entryOrEntries) =>
new Set(
isArray(entryOrEntries) || isUndefined(entryOrEntries)
? entryOrEntries
: [entryOrEntries],
);
const setAdd = (set, value) => set?.add(value);
const getDefinableFunctions = (
store,
getDefaultThing,
validateRowValue,
addListener,
callListeners,
) => {
const hasRow = store.hasRow;
const tableIds = mapNew();
const things = mapNew();
const thingIdListeners = mapNew();
const allRowValues = mapNew();
const allSortKeys = mapNew();
const storeListenerIds = mapNew();
const getStore = () => store;
const getThingIds = () => mapKeys(tableIds);
const forEachThing = (cb) => mapForEach(things, cb);
const hasThing = (id) => collHas(things, id);
const getTableId = (id) => mapGet(tableIds, id);
const getThing = (id) => mapGet(things, id);
const setThing = (id, thing) => mapSet(things, id, thing);
const addStoreListeners = (id, andCall, ...listenerIds) => {
const set = mapEnsure(storeListenerIds, id, setNew);
arrayForEach(
listenerIds,
(listenerId) =>
setAdd(set, listenerId) && andCall && store.callListener(listenerId),
);
return listenerIds;
};
const delStoreListeners = (id, ...listenerIds) =>
ifNotUndefined(mapGet(storeListenerIds, id), (allListenerIds) => {
arrayForEach(
arrayIsEmpty(listenerIds) ? collValues(allListenerIds) : listenerIds,
(listenerId) => {
store.delListener(listenerId);
collDel(allListenerIds, listenerId);
},
);
if (collIsEmpty(allListenerIds)) {
mapSet(storeListenerIds, id);
}
});
const setDefinition = (id, tableId) => {
mapSet(tableIds, id, tableId);
if (!collHas(things, id)) {
mapSet(things, id, getDefaultThing());
mapSet(allRowValues, id, mapNew());
mapSet(allSortKeys, id, mapNew());
callListeners(thingIdListeners);
}
};
const setDefinitionAndListen = (
id,
tableId,
onChanged,
getRowValue,
getSortKey,
) => {
setDefinition(id, tableId);
const changedRowValues = mapNew();
const changedSortKeys = mapNew();
const rowValues = mapGet(allRowValues, id);
const sortKeys = mapGet(allSortKeys, id);
const processRow = (rowId) => {
const getCell = (cellId) => store.getCell(tableId, rowId, cellId);
const oldRowValue = mapGet(rowValues, rowId);
const newRowValue = hasRow(tableId, rowId)
? validateRowValue(getRowValue(getCell, rowId))
: void 0;
if (
!(
oldRowValue === newRowValue ||
(isArray(oldRowValue) &&
isArray(newRowValue) &&
arrayIsEqual(oldRowValue, newRowValue))
)
) {
mapSet(changedRowValues, rowId, [oldRowValue, newRowValue]);
}
if (!isUndefined(getSortKey)) {
const oldSortKey = mapGet(sortKeys, rowId);
const newSortKey = hasRow(tableId, rowId)
? getSortKey(getCell, rowId)
: void 0;
if (oldSortKey != newSortKey) {
mapSet(changedSortKeys, rowId, newSortKey);
}
}
};
const processTable = (force) => {
onChanged(
() => {
collForEach(changedRowValues, ([, newRowValue], rowId) =>
mapSet(rowValues, rowId, newRowValue),
);
collForEach(changedSortKeys, (newSortKey, rowId) =>
mapSet(sortKeys, rowId, newSortKey),
);
},
changedRowValues,
changedSortKeys,
rowValues,
sortKeys,
force,
);
collClear(changedRowValues);
collClear(changedSortKeys);
};
mapForEach(rowValues, processRow);
if (store.hasTable(tableId)) {
arrayForEach(store.getRowIds(tableId), (rowId) => {
if (!collHas(rowValues, rowId)) {
processRow(rowId);
}
});
}
processTable(true);
delStoreListeners(id);
addStoreListeners(
id,
0,
store.addRowListener(tableId, null, (_store, _tableId, rowId) =>
processRow(rowId),
),
store.addTableListener(tableId, () => processTable()),
);
};
const delDefinition = (id) => {
mapSet(tableIds, id);
mapSet(things, id);
mapSet(allRowValues, id);
mapSet(allSortKeys, id);
delStoreListeners(id);
callListeners(thingIdListeners);
};
const addThingIdsListener = (listener) =>
addListener(listener, thingIdListeners);
const destroy = () => mapForEach(storeListenerIds, delDefinition);
return [
getStore,
getThingIds,
forEachThing,
hasThing,
getTableId,
getThing,
setThing,
setDefinition,
setDefinitionAndListen,
delDefinition,
addThingIdsListener,
destroy,
addStoreListeners,
delStoreListeners,
];
};
const getRowCellFunction = (getRowCell, defaultCellValue) =>
isString(getRowCell)
? (getCell) => getCell(getRowCell)
: (getRowCell ?? (() => defaultCellValue ?? EMPTY_STRING));
const getCreateFunction = (getFunction, initFunction) => {
const thingsByStore = /* @__PURE__ */ new WeakMap();
return (store) => {
if (!thingsByStore.has(store)) {
thingsByStore.set(store, getFunction(store));
}
const thing = thingsByStore.get(store);
initFunction?.(thing);
return thing;
};
};
const INTEGER = /^\d+$/;
const getPoolFunctions = () => {
const pool = [];
let nextId = 0;
return [
(reuse) => (reuse ? arrayShift(pool) : null) ?? EMPTY_STRING + nextId++,
(id) => {
if (test(INTEGER, id) && size(pool) < 1e3) {
arrayPush(pool, id);
}
},
];
};
const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
const leaves = [];
const deep = (node, p) =>
p == size(path)
? arrayPush(leaves, node)
: path[p] === null
? collForEach(node, (node2) => deep(node2, p + 1))
: arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));
deep(deepIdSet, 0);
return leaves;
};
const getListenerFunctions = (getThing) => {
let thing;
const [getId, releaseId] = getPoolFunctions();
const allListeners = mapNew();
const addListener = (
listener,
idSetNode,
path,
pathGetters = [],
extraArgsGetter = () => [],
) => {
thing ??= getThing();
const id = getId(1);
mapSet(allListeners, id, [
listener,
idSetNode,
path,
pathGetters,
extraArgsGetter,
]);
setAdd(visitTree(idSetNode, path ?? [EMPTY_STRING], setNew), id);
return id;
};
const callListeners = (idSetNode, ids, ...extraArgs) =>
arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>
collForEach(set, (id) =>
mapGet(allListeners, id)[0](thing, ...(ids ?? []), ...extraArgs),
),
);
const delListener = (id) =>
ifNotUndefined(mapGet(allListeners, id), ([, idSetNode, idOrNulls]) => {
visitTree(idSetNode, idOrNulls ?? [EMPTY_STRING], void 0, (idSet) => {
collDel(idSet, id);
return collIsEmpty(idSet) ? 1 : 0;
});
mapSet(allListeners, id);
releaseId(id);
return idOrNulls;
});
const callListener = (id) =>
ifNotUndefined(
mapGet(allListeners, id),
([listener, , path = [], pathGetters, extraArgsGetter]) => {
const callWithIds = (...ids) => {
const index = size(ids);
if (index == size(path)) {
listener(thing, ...ids, ...extraArgsGetter(ids));
} else if (isUndefined(path[index])) {
arrayForEach(pathGetters[index]?.(...ids) ?? [], (id2) =>
callWithIds(...ids, id2),
);
} else {
callWithIds(...ids, path[index]);
}
};
callWithIds();
},
);
return [addListener, callListeners, delListener, callListener];
};
const createCheckpoints = getCreateFunction(
(store) => {
let backwardIdsSize = 100;
let currentId;
let cellsDelta = mapNew();
let valuesDelta = mapNew();
let listening = 1;
let nextCheckpointId;
let checkpointsChanged;
const checkpointIdsListeners = mapNew();
const checkpointListeners = mapNew();
const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
() => checkpoints,
);
const deltas = mapNew();
const labels = mapNew();
const backwardIds = [];
const forwardIds = [];
const updateStore = (oldOrNew, checkpointId) => {
listening = 0;
store.transaction(() => {
const [cellsDelta2, valuesDelta2] = mapGet(deltas, checkpointId);
collForEach(cellsDelta2, (table, tableId) =>
collForEach(table, (row, rowId) =>
collForEach(row, (oldNew, cellId) =>
setOrDelCell(store, tableId, rowId, cellId, oldNew[oldOrNew]),
),
),
);
collForEach(valuesDelta2, (oldNew, valueId) =>
setOrDelValue(store, valueId, oldNew[oldOrNew]),
);
});
listening = 1;
};
const clearCheckpointId = (checkpointId) => {
mapSet(deltas, checkpointId);
mapSet(labels, checkpointId);
callListeners(checkpointListeners, [checkpointId]);
};
const clearCheckpointIds = (checkpointIds, to) =>
arrayForEach(
arrayClear(checkpointIds, to ?? size(checkpointIds)),
clearCheckpointId,
);
const trimBackwardsIds = () =>
clearCheckpointIds(backwardIds, size(backwardIds) - backwardIdsSize);
const storeChanged = () =>
ifNotUndefined(currentId, () => {
arrayPush(backwardIds, currentId);
trimBackwardsIds();
clearCheckpointIds(forwardIds);
currentId = void 0;
checkpointsChanged = 1;
});
const storeUnchanged = () => {
currentId = arrayPop(backwardIds);
checkpointsChanged = 1;
};
let cellListenerId;
let valueListenerId;
const addCheckpointImpl = (label = EMPTY_STRING) => {
if (isUndefined(currentId)) {
currentId = EMPTY_STRING + nextCheckpointId++;
mapSet(deltas, currentId, [cellsDelta, valuesDelta]);
setCheckpoint(currentId, label);
cellsDelta = mapNew();
valuesDelta = mapNew();
checkpointsChanged = 1;
}
return currentId;
};
const goBackwardImpl = () => {
if (!arrayIsEmpty(backwardIds)) {
arrayUnshift(forwardIds, addCheckpointImpl());
updateStore(0, currentId);
currentId = arrayPop(backwardIds);
checkpointsChanged = 1;
}
};
const goForwardImpl = () => {
if (!arrayIsEmpty(forwardIds)) {
arrayPush(backwardIds, currentId);
currentId = arrayShift(forwardIds);
updateStore(1, currentId);
checkpointsChanged = 1;
}
};
const callListenersIfChanged = () => {
if (checkpointsChanged) {
callListeners(checkpointIdsListeners);
checkpointsChanged = 0;
}
};
const setSize = (size2) => {
backwardIdsSize = size2;
trimBackwardsIds();
return checkpoints;
};
const addCheckpoint = (label) => {
const id = addCheckpointImpl(label);
callListenersIfChanged();
return id;
};
const setCheckpoint = (checkpointId, label) => {
if (
hasCheckpoint(checkpointId) &&
mapGet(labels, checkpointId) !== label
) {
mapSet(labels, checkpointId, label);
callListeners(checkpointListeners, [checkpointId]);
}
return checkpoints;
};
const getStore = () => store;
const getCheckpointIds = () => [
[...backwardIds],
currentId,
[...forwardIds],
];
const forEachCheckpoint = (checkpointCallback) =>
mapForEach(labels, checkpointCallback);
const hasCheckpoint = (checkpointId) => collHas(deltas, checkpointId);
const getCheckpoint = (checkpointId) => mapGet(labels, checkpointId);
const goBackward = () => {
goBackwardImpl();
callListenersIfChanged();
return checkpoints;
};
const goForward = () => {
goForwardImpl();
callListenersIfChanged();
return checkpoints;
};
const goTo = (checkpointId) => {
const action = arrayHas(backwardIds, checkpointId)
? goBackwardImpl
: arrayHas(forwardIds, checkpointId)
? goForwardImpl
: null;
while (!isUndefined(action) && checkpointId != currentId) {
action();
}
callListenersIfChanged();
return checkpoints;
};
const addCheckpointIdsListener = (listener) =>
addListener(listener, checkpointIdsListeners);
const addCheckpointListener = (checkpointId, listener) =>
addListener(listener, checkpointListeners, [checkpointId]);
const delListener = (listenerId) => {
delListenerImpl(listenerId);
return checkpoints;
};
const clear = () => {
clearCheckpointIds(backwardIds);
clearCheckpointIds(forwardIds);
if (!isUndefined(currentId)) {
clearCheckpointId(currentId);
}
currentId = void 0;
nextCheckpointId = 0;
addCheckpoint();
return checkpoints;
};
const clearForward = () => {
if (!arrayIsEmpty(forwardIds)) {
clearCheckpointIds(forwardIds);
callListeners(checkpointIdsListeners);
}
return checkpoints;
};
const destroy = () => {
store.delListener(cellListenerId);
store.delListener(valueListenerId);
};
const getListenerStats = () => ({
checkpointIds: collSize2(checkpointIdsListeners),
checkpoint: collSize2(checkpointListeners),
});
const _registerListeners = () => {
cellListenerId = store.addCellListener(
null,
null,
null,
(_store, tableId, rowId, cellId, newCell, oldCell) => {
if (listening) {
storeChanged();
const table = mapEnsure(cellsDelta, tableId, mapNew);
const row = mapEnsure(table, rowId, mapNew);
const oldNew = mapEnsure(row, cellId, () => [oldCell, void 0]);
oldNew[1] = newCell;
if (
oldNew[0] === newCell &&
collIsEmpty(mapSet(row, cellId)) &&
collIsEmpty(mapSet(table, rowId)) &&
collIsEmpty(mapSet(cellsDelta, tableId))
) {
storeUnchanged();
}
callListenersIfChanged();
}
},
);
valueListenerId = store.addValueListener(
null,
(_store, valueId, newValue, oldValue) => {
if (listening) {
storeChanged();
const oldNew = mapEnsure(valuesDelta, valueId, () => [
oldValue,
void 0,
]);
oldNew[1] = newValue;
if (
oldNew[0] === newValue &&
collIsEmpty(mapSet(valuesDelta, valueId))
) {
storeUnchanged();
}
callListenersIfChanged();
}
},
);
};
const checkpoints = {
setSize,
addCheckpoint,
setCheckpoint,
getStore,
getCheckpointIds,
forEachCheckpoint,
hasCheckpoint,
getCheckpoint,
goBackward,
goForward,
goTo,
addCheckpointIdsListener,
addCheckpointListener,
delListener,
clear,
clearForward,
destroy,
getListenerStats,
_registerListeners,
};
return objFreeze(checkpoints.clear());
},
(checkpoints) => checkpoints._registerListeners(),
);
const MASK6 = 63;
const ENCODE = /* @__PURE__ */ strSplit(
'-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz',
);
const DECODE = /* @__PURE__ */ mapNew(
/* @__PURE__ */ arrayMap(ENCODE, (char, index) => [char, index]),
);
const encode = (num) => ENCODE[num & MASK6];
const decode = (str, pos) => mapGet(DECODE, str[pos]) ?? 0;
const getRandomValues = GLOBAL.crypto
? (array) => GLOBAL.crypto.getRandomValues(array)
: /* istanbul ignore next */
(array) => arrayMap(array, () => mathFloor(math.random() * 256));
const defaultSorter = (sortKey1, sortKey2) =>
(sortKey1 ?? 0) < (sortKey2 ?? 0) ? -1 : 1;
const getUniqueId = (length = 16) =>
arrayReduce(
getRandomValues(new Uint8Array(length)),
(uniqueId, number) => uniqueId + encode(number),
'',
);
const createIndexes = getCreateFunction((store) => {
const sliceIdsListeners = mapNew();
const sliceRowIdsListeners = mapNew();
const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
() => indexes,
);
const [
getStore,
getIndexIds,
forEachIndexImpl,
hasIndex,
getTableId,
getIndex,
setIndex,
,
setDefinitionAndListen,
delDefinition,
addIndexIdsListener,
destroy,
] = getDefinableFunctions(
store,
mapNew,
(value) =>
isUndefined(value)
? EMPTY_STRING
: isArray(value)
? arrayMap(value, id)
: id(value),
addListener,
callListeners,
);
const hasSlice = (indexId, sliceId) => collHas(getIndex(indexId), sliceId);
const setIndexDefinition = (
indexId,
tableId,
getSliceIdOrIds,
getSortKey,
sliceIdSorter,
rowIdSorter = defaultSorter,
) => {
const sliceIdArraySorter = isUndefined(sliceIdSorter)
? void 0
: ([id1], [id2]) => sliceIdSorter(id1, id2);
setDefinitionAndListen(
indexId,
tableId,
(change, changedSliceIds, changedSortKeys, sliceIds, sortKeys, force) => {
let sliceIdsChanged = 0;
const changedSlices = setNew();
const unsortedSlices = setNew();
const index = getIndex(indexId);
collForEach(
changedSliceIds,
([oldSliceIdOrIds, newSliceIdOrIds], rowId) => {
const oldSliceIds = setNew(oldSliceIdOrIds);
const newSliceIds = setNew(newSliceIdOrIds);
collForEach(oldSliceIds, (oldSliceId) =>
collDel(newSliceIds, oldSliceId)
? collDel(oldSliceIds, oldSliceId)
: 0,
);
collForEach(oldSliceIds, (oldSliceId) => {
setAdd(changedSlices, oldSliceId);
ifNotUndefined(mapGet(index, oldSliceId), (oldSlice) => {
collDel(oldSlice, rowId);
if (collIsEmpty(oldSlice)) {
mapSet(index, oldSliceId);
sliceIdsChanged = 1;
}
});
});
collForEach(newSliceIds, (newSliceId) => {
setAdd(changedSlices, newSliceId);
if (!collHas(index, newSliceId)) {
mapSet(index, newSliceId, setNew());
sliceIdsChanged = 1;
}
setAdd(mapGet(index, newSliceId), rowId);
if (!isUndefined(getSortKey)) {
setAdd(unsortedSlices, newSliceId);
}
});
},
);
change();
if (!collIsEmpty(sortKeys)) {
if (force) {
mapForEach(index, (sliceId) => setAdd(unsortedSlices, sliceId));
} else {
mapForEach(changedSortKeys, (rowId) =>
ifNotUndefined(mapGet(sliceIds, rowId), (sliceId) =>
setAdd(unsortedSlices, sliceId),
),
);
}
collForEach(unsortedSlices, (sliceId) => {
const rowIdArraySorter = (rowId1, rowId2) =>
rowIdSorter(
mapGet(sortKeys, rowId1),
mapGet(sortKeys, rowId2),
sliceId,
);
const sliceArray = [...mapGet(index, sliceId)];
if (!arrayIsSorted(sliceArray, rowIdArraySorter)) {
mapSet(
index,
sliceId,
setNew(arraySort(sliceArray, rowIdArraySorter)),
);
setAdd(changedSlices, sliceId);
}
});
}
if (sliceIdsChanged || force) {
if (!isUndefined(sliceIdArraySorter)) {
const indexArray = [...index];
if (!arrayIsSorted(indexArray, sliceIdArraySorter)) {
setIndex(
indexId,
mapNew(arraySort(indexArray, sliceIdArraySorter)),
);
sliceIdsChanged = 1;
}
}
}
if (sliceIdsChanged) {
callListeners(sliceIdsListeners, [indexId]);
}
collForEach(changedSlices, (sliceId) =>
callListeners(sliceRowIdsListeners, [indexId, sliceId]),
);
},
getRowCellFunction(getSliceIdOrIds),
ifNotUndefined(getSortKey, getRowCellFunction),
);
return indexes;
};
const forEachIndex = (indexCallback) =>
forEachIndexImpl((indexId, slices) =>
indexCallback(indexId, (sliceCallback) =>
forEachSliceImpl(indexId, sliceCallback, slices),
),
);
const forEachSlice = (indexId, sliceCallback) =>
forEachSliceImpl(indexId, sliceCallback, getIndex(indexId));
const forEachSliceImpl = (indexId, sliceCallback, slices) => {
const tableId = getTableId(indexId);
collForEach(slices, (rowIds, sliceId) =>
sliceCallback(sliceId, (rowCallback) =>
collForEach(rowIds, (rowId) =>
rowCallback(rowId, (cellCallback) =>
store.forEachCell(tableId, rowId, cellCallback),
),
),
),
);
};
const delIndexDefinition = (indexId) => {
delDefinition(indexId);
return indexes;
};
const getSliceIds = (indexId) => mapKeys(getIndex(indexId));
const getSliceRowIds = (indexId, sliceId) =>
collValues(mapGet(getIndex(indexId), sliceId));
const addSliceIdsListener = (indexId, listener) =>
addListener(listener, sliceIdsListeners, [indexId]);
const addSliceRowIdsListener = (indexId, sliceId, listener) =>
addListener(listener, sliceRowIdsListeners, [indexId, sliceId]);
const delListener = (listenerId) => {
delListenerImpl(listenerId);
return indexes;
};
const getListenerStats = () => ({
sliceIds: collSize2(sliceIdsListeners),
sliceRowIds: collSize3(sliceRowIdsListeners),
});
const indexes = {
setIndexDefinition,
delIndexDefinition,
getStore,
getIndexIds,
forEachIndex,
forEachSlice,
hasIndex,
hasSlice,
getTableId,
getSliceIds,
getSliceRowIds,
addIndexIdsListener,
addSliceIdsListener,
addSliceRowIdsListener,
delListener,
destroy,
getListenerStats,
};
return objFreeze(indexes);
});
const numericAggregators = /* @__PURE__ */ mapNew([
[
AVG,
[
(numbers, length) => arraySum(numbers) / length,
(metric, add, length) => metric + (add - metric) / (length + 1),
(metric, remove, length) => metric + (metric - remove) / (length - 1),
(metric, add, remove, length) => metric + (add - remove) / length,
],
],
[
MAX,
[
(numbers) => mathMax(...numbers),
(metric, add) => mathMax(add, metric),
(metric, remove) => (remove == metric ? void 0 : metric),
(metric, add, remove) =>
remove == metric ? void 0 : mathMax(add, metric),
],
],
[
MIN,
[
(numbers) => mathMin(...numbers),
(metric, add) => mathMin(add, metric),
(metric, remove) => (remove == metric ? void 0 : metric),
(metric, add, remove) =>
remove == metric ? void 0 : mathMin(add, metric),
],
],
[
SUM,
[
(numbers) => arraySum(numbers),
(metric, add) => metric + add,
(metric, remove) => metric - remove,
(metric, add, remove) => metric - remove + add,
],
],
]);
const getAggregateValue = (
aggregateValue,
oldLength,
newValues,
changedValues,
aggregators,
force = false,
) => {
if (collIsEmpty(newValues)) {
return void 0;
}
const [aggregate, aggregateAdd, aggregateRemove, aggregateReplace] =
aggregators;
force ||= isUndefined(aggregateValue);
collForEach(changedValues, ([oldValue, newValue]) => {
if (!force) {
aggregateValue = isUndefined(oldValue)
? aggregateAdd?.(aggregateValue, newValue, oldLength++)
: isUndefined(newValue)
? aggregateRemove?.(aggregateValue, oldValue, oldLength--)
: aggregateReplace?.(aggregateValue, newValue, oldValue, oldLength);
force ||= isUndefined(aggregateValue);
}
});
return force
? aggregate(collValues(newValues), collSize(newValues))
: aggregateValue;
};
const createMetrics = getCreateFunction((store) => {
const metricListeners = mapNew();
const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
() => metrics,
);
const [
getStore,
getMetricIds,
forEachMetric,
hasMetric,
getTableId,
getMetric,
setMetric,
,
setDefinitionAndListen,
delDefinition,
addMetricIdsListener,
destroy,
] = getDefinableFunctions(
store,
getUndefined,
(value) =>
isNaN(value) ||
isUndefined(value) ||
value === true ||
value === false ||
value === EMPTY_STRING
? void 0
: value * 1,
addListener,
callListeners,
);
const setMetricDefinition = (
metricId,
tableId,
aggregate,
getNumber,
aggregateAdd,
aggregateRemove,
aggregateReplace,
) => {
const aggregators = isFunction(aggregate)
? [aggregate, aggregateAdd, aggregateRemove, aggregateReplace]
: (mapGet(numericAggregators, aggregate) ??
mapGet(numericAggregators, SUM));
setDefinitionAndListen(
metricId,
tableId,
(change, changedNumbers, _changedSortKeys, numbers, _sortKeys, force) => {
const oldMetric = getMetric(metricId);
const oldLength = collSize(numbers);
force ||= isUndefined(oldMetric);
change();
let newMetric = getAggregateValue(
oldMetric,
oldLength,
numbers,
changedNumbers,
aggregators,
force,
);
if (!isFiniteNumber(newMetric)) {
newMetric = void 0;
}
if (newMetric != oldMetric) {
setMetric(metricId, newMetric);
callListeners(metricListeners, [metricId], newMetric, oldMetric);
}
},
getRowCellFunction(getNumber, 1),
);
return metrics;
};
const delMetricDefinition = (metricId) => {
delDefinition(metricId);
return metrics;
};
const addMetricListener = (metricId, listener) =>
addListener(listener, metricListeners, [metricId]);
const delListener = (listenerId) => {
delListenerImpl(listenerId);
return metrics;
};
const getListenerStats = () => ({
metric: collSize2(metricListeners),
});
const metrics = {
setMetricDefinition,
delMetricDefinition,
getStore,
getMetricIds,
forEachMetric,
hasMetric,
getTableId,
getMetric,
addMetricIdsListener,
addMetricListener,
delListener,
destroy,
getListenerStats,
};
return objFreeze(metrics);
});
const createQueries = getCreateFunction((store) => {
const createStore = store.createStore;
const preStore = createStore();
const resultStore = createStore();
const preStoreListenerIds = mapNew();
const {
addListener,
callListeners,
delListener: delListenerImpl,
} = resultStore;
const [
getStore,
getQueryIds,
forEachQuery,
hasQuery,
getTableId,
,
,
setDefinition,
,
delDefinition,
addQueryIdsListenerImpl,
destroy,
addStoreListeners,
delStoreListeners,
] = getDefinableFunctions(
store,
() => true,
getUndefined,
addListener,
callListeners,
);
const addPreStoreListener = (preStore2, queryId, ...listenerIds) =>
arrayForEach(listenerIds, (listenerId) =>
setAdd(
mapEnsure(
mapEnsure(preStoreListenerIds, queryId, mapNew),
preStore2,
setNew,
),
listenerId,
),
);
const resetPreStores = (queryId) => {
ifNotUndefined(
mapGet(preStoreListenerIds, queryId),
(queryPreStoreListenerIds) => {
mapForEach(queryPreStoreListenerIds, (preStore2, listenerIds) =>
collForEach(listenerIds, (listenerId) =>
preStore2.delListener(listenerId),
),
);
collClear(queryPreStoreListenerIds);
},
);
arrayForEach([resultStore, preStore], (store2) => store2.delTable(queryId));
};
const synchronizeTransactions = (queryId, fromStore, toStore) =>
addPreStoreListener(
fromStore,
queryId,
fromStore.addStartTransactionListener(toStore.startTransaction),
fromStore.addDidFinishTransactionListener(() =>
toStore.finishTransaction(),
),
);
const setQueryDefinition = (queryId, tableId, build) => {
setDefinition(queryId, tableId);
resetPreStores(queryId);
const selectEntries = [];
const joinEntries = [[null, [tableId, null, null, [], mapNew()]]];
const wheres = [];
const groupEntries = [];
const havings = [];
const select = (arg1, arg2) => {
const selectEntry = isFunction(arg1)
? [size(selectEntries) + EMPTY_STRING, arg1]
: [
isUndefined(arg2) ? arg1 : arg2,
(getTableCell) => getTableCell(arg1, arg2),
];
arrayPush(selectEntries, selectEntry);
return {as: (selectedCellId) => (selectEntry[0] = selectedCellId)};
};
const join = (joinedTableId, arg1, arg2) => {
const fromIntermediateJoinedTableId =
isUndefined(arg2) || isFunction(arg1) ? null : arg1;
const onArg = isUndefined(fromIntermediateJoinedTableId) ? arg1 : arg2;
const joinEntry = [
joinedTableId,
[
joinedTableId,
fromIntermediateJoinedTableId,
isFunction(onArg) ? onArg : (getCell) => getCell(onArg),
[],
mapNew(),
],
];
arrayPush(joinEntries, joinEntry);
return {as: (joinedTableId2) => (joinEntry[0] = joinedTableId2)};
};
const where = (arg1, arg2, arg3) =>
arrayPush(
wheres,
isFunction(arg1)
? arg1
: isUndefined(arg3)
? (getTableCell) => getTableCell(arg1) === arg2
: (getTableCell) => getTableCell(arg1, arg2) === arg3,
);
const group = (
selectedCellId,
aggregate,
aggregateAdd,
aggregateRemove,
aggregateReplace,
) => {
const groupEntry = [
selectedCellId,
[
selectedCellId,
isFunction(aggregate)
? [aggregate, aggregateAdd, aggregateRemove, aggregateReplace]
: (mapGet(numericAggregators, aggregate) ?? [
(_cells, length) => length,
]),
],
];
arrayPush(groupEntries, groupEntry);
return {as: (groupedCellId) => (groupEntry[0] = groupedCellId)};
};
const having = (arg1, arg2) =>
arrayPush(
havings,
isFunction(arg1)
? arg1
: (getSelectedOrGroupedCell) =>
getSelectedOrGroupedCell(arg1) === arg2,
);
build({select, join, where, group, having});
const selects = mapNew(selectEntries);
if (collIsEmpty(selects)) {
return queries;
}
const joins = mapNew(joinEntries);
mapForEach(joins, (asTableId, [, fromAsTableId]) =>
ifNotUndefined(mapGet(joins, fromAsTableId), ({3: toAsTableIds}) =>
isUndefined(asTableId) ? 0 : arrayPush(toAsTableIds, asTableId),
),
);
const groups = mapNew(groupEntries);
let selectJoinWhereStore = preStore;
if (collIsEmpty(groups) && arrayIsEmpty(havings)) {
selectJoinWhereStore = resultStore;
} else {
synchronizeTransactions(queryId, selectJoinWhereStore, resultStore);
const groupedSelectedCellIds = mapNew();
mapForEach(groups, (groupedCellId, [selectedCellId, aggregators]) =>
setAdd(mapEnsure(groupedSelectedCellIds, selectedCellId, setNew), [
groupedCellId,
aggregators,
]),
);
const groupBySelectedCellIds = setNew();
mapForEach(selects, (selectedCellId) =>
collHas(groupedSelectedCellIds, selectedCellId)
? 0
: setAdd(groupBySelectedCellIds, selectedCellId),
);
const tree = mapNew();
const writeGroupRow = (
leaf,
changedGroupedSelectedCells,
selectedRowId,
forceRemove,
) =>
ifNotUndefined(
leaf,
([selectedCells, selectedRowIds, groupRowId, groupRow]) => {
mapForEach(
changedGroupedSelectedCells,
(selectedCellId, [newCell]) => {
const selectedCell = mapEnsure(
selectedCells,
selectedCellId,
mapNew,
);
const oldLeafCell = mapGet(selectedCell, selectedRowId);
const newLeafCell = forceRemove ? void 0 : newCell;
if (oldLeafCell !== newLeafCell) {
const oldNewSet = setNew([[oldLeafCell, newLeafCell]]);
const oldLength = collSize(selectedCell);
mapSet(selectedCell, selectedRowId, newLeafCell);
collForEach(
mapGet(groupedSelectedCellIds, selectedCellId),
([groupedCellId, aggregators]) => {
const aggregateValue = getAggregateValue(
groupRow[groupedCellId],
oldLength,
selectedCell,
oldNewSet,
aggregators,
);
groupRow[groupedCellId] = isUndefined(
getCellOrValueType(aggregateValue),
)
? null
: aggregateValue;
},
);
}
},
);
if (
collIsEmpty(selectedRowIds) ||
!arrayEvery(havings, (having2) =>
having2((cellId) => groupRow[cellId]),
)
) {
resultStore.delRow(queryId, groupRowId);
} else if (isUndefined(groupRowId)) {
leaf[2] = resultStore.addRow(queryId, groupRow);
} else {
resultStore.setRow(queryId, groupRowId, groupRow);
}
},
);
addPreStoreListener(
selectJoinWhereStore,
queryId,
selectJoinWhereStore.addRowListener(
queryId,
null,
(_store, _tableId, selectedRowId, getCellChange) => {
const oldPath = [];
const newPath = [];
const changedGroupedSelectedCells = mapNew();
const rowExists = selectJoinWhereStore.hasRow(
queryId,
selectedRowId,
);
let changedLeaf = !rowExists;
collForEach(groupBySelectedCellIds, (selectedCellId) => {
const [changed, oldCell, newCell] = getCellChange(
queryId,
selectedRowId,
selectedCellId,
);
arrayPush(oldPath, oldCell);
arrayPush(newPath, newCell);
changedLeaf ||= changed;
});
mapForEach(groupedSelectedCellIds, (selectedCellId) => {
const [changed, , newCell] = getCellChange(
queryId,
selectedRowId,
selectedCellId,
);
if (changedLeaf || changed) {
mapSet(changedGroupedSelectedCells, selectedCellId, [newCell]);
}
});
if (changedLeaf) {
writeGroupRow(
visitTree(tree, oldPath, void 0, ([, selectedRowIds]) => {
collDel(selectedRowIds, selectedRowId);
return collIsEmpty(selectedRowIds);
}),
changedGroupedSelectedCells,
selectedRowId,
1,
);
}
if (rowExists) {
writeGroupRow(
visitTree(
tree,
newPath,
() => {
const groupRow = {};
collForEach(
groupBySelectedCellIds,
(selectedCellId) =>
(groupRow[selectedCellId] =
selectJoinWhereStore.getCell(
queryId,
selectedRowId,
selectedCellId,
)),
);
return [mapNew(), setNew(), void 0, groupRow];
},
([, selectedRowIds]) => {
setAdd(selectedRowIds, selectedRowId);
},
),
changedGroupedSelectedCells,
selectedRowId,
);
}
},
),
);
}
synchronizeTransactions(queryId, store, selectJoinWhereStore);
const writeSelectRow = (rootRowId) => {
const getTableCell = (arg1, arg2) =>
store.getCell(
...(isUndefined(arg2)
? [tableId, rootRowId, arg1]
: arg1 === tableId
? [tableId, rootRowId, arg2]
: [
mapGet(joins, arg1)?.[0],
mapGet(mapGet(joins, arg1)?.[4], rootRowId)?.[0],
arg2,
]),
);
selectJoinWhereStore.transaction(() =>
arrayEvery(wheres, (where2) => where2(getTableCell))
? mapForEach(selects, (asCellId, tableCellGetter) =>
setOrDelCell(
selectJoinWhereStore,
queryId,
rootRowId,
asCellId,
tableCellGetter(getTableCell, rootRowId),
),
)
: selectJoinWhereStore.delRow(queryId, rootRowId),
);
};
const listenToTable = (rootRowId, tableId2, rowId, joinedTableIds2) => {
const getCell = (cellId) => store.getCell(tableId2, rowId, cellId);
arrayForEach(joinedTableIds2, (remoteAsTableId) => {
const [realJoinedTableId, , on, nextJoinedTableIds, remoteIdPair] =
mapGet(joins, remoteAsTableId);
const remoteRowId = on?.(getCell, rootRowId);
const [previousRemoteRowId, previousRemoteListenerId] =
mapGet(remoteIdPair, rootRowId) ?? [];
if (remoteRowId != previousRemoteRowId) {
if (!isUndefined(previousRemoteListenerId)) {
delStoreListeners(queryId, previousRemoteListenerId);
}
mapSet(
remoteIdPair,
rootRowId,
isUndefined(remoteRowId)
? null
: [
remoteRowId,
...addStoreListeners(
queryId,
1,
store.addRowListener(realJoinedTableId, remoteRowId, () =>
listenToTable(
rootRowId,
realJoinedTableId,
remoteRowId,
nextJoinedTableIds,
),
),
),
],
);
}
});
writeSelectRow(rootRowId);
};
const {3: joinedTableIds} = mapGet(joins, null);
selectJoinWhereStore.transaction(() =>
addStoreListeners(
queryId,
1,
store.addRowListener(tableId, null, (_store, _tableId, rootRowId) => {
if (store.hasRow(tableId, rootRowId)) {
listenToTable(rootRowId, tableId, rootRowId, joinedTableIds);
} else {
selectJoinWhereStore.delRow(queryId, rootRowId);
collForEach(joins, ({4: idsByRootRowId}) =>
ifNotUndefined(
mapGet(idsByRootRowId, rootRowId),
([, listenerId]) => {
delStoreListeners(queryId, listenerId);
mapSet(idsByRootRowId, rootRowId);
},
),
);
}
}),
),
);
return queries;
};
const delQueryDefinition = (queryId) => {
resetPreStores(queryId);
delDefinition(queryId);
return queries;
};
const addQueryIdsListener = (listener) =>
addQueryIdsListenerImpl(() => listener(queries));
const delListener = (listenerId) => {
delListenerImpl(listenerId);
return queries;
};
const getListenerStats = () => {
const {
tables: _1,
tableIds: _2,
transaction: _3,
...stats
} = resultStore.getListenerStats();
return stats;
};
const queries = {
setQueryDefinition,
delQueryDefinition,
getStore,
getQueryIds,
forEachQuery,
hasQuery,
getTableId,
addQueryIdsListener,
delListener,
destroy,
getListenerStats,
};
objMap(
{
[TABLE]: [1, 1],
[TABLE + CELL_IDS]: [0, 1],
[ROW_COUNT]: [0, 1],
[ROW_IDS]: [0, 1],
[SORTED_ROW_IDS]: [0, 5],
[ROW]: [1, 2],
[CELL_IDS]: [0, 2],
[CELL]: [1, 3],
},
([hasAndForEach, argumentCount], gettable) => {
arrayForEach(
hasAndForEach ? [GET, 'has', 'forEach'] : [GET],
(prefix) =>
(queries[prefix + RESULT + gettable] = (...args) =>
resultStore[prefix + gettable](...args)),
);
queries[ADD + RESULT + gettable + LISTENER] = (...args) =>
resultStore[ADD + gettable + LISTENER](
...slice(args, 0, argumentCount),
(_stor