tinybase 4.4.0-beta.0 → 4.4.0-beta.1

package/lib/debug/tinybase.js

@@ -27,6 +27,7 @@ const CELL_IDS = CELL + IDS;
 const VALUE = 'Value';
 const VALUES = VALUE + 's';
 const VALUE_IDS = VALUE + IDS;
+const HAS = 'Has';
 const id = (key) => EMPTY_STRING + key;
 
 const mathMax = Math.max;
@@ -41,13 +42,14 @@ 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) =>
-  arrayLength(array1) === arrayLength(array2) &&
+  size(array1) === size(array2) &&
   arrayEvery(array1, (value1, index) => array2[index] === value1);
 const arrayIsSorted = (array, sorter) =>
   arrayEvery(
@@ -58,8 +60,7 @@ 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 arrayLength = (array) => array.length;
-const arrayIsEmpty = (array) => arrayLength(array) == 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);
@@ -68,11 +69,19 @@ const arrayUnshift = (array, ...values) => array.unshift(...values);
 const arrayShift = (array) => array.shift();
 
 const object = Object;
+const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
 const objIds = object.keys;
 const objFrozen = object.isFrozen;
 const objFreeze = object.freeze;
 const isObject = (obj) =>
-  isInstanceOf(obj, object) && obj.constructor == object;
+  !isUndefined(obj) &&
+  ifNotUndefined(
+    getPrototypeOf(obj),
+    (objPrototype) =>
+      objPrototype == object.prototype ||
+      isUndefined(getPrototypeOf(objPrototype)),
+    () => true,
+  );
 const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
 const objHas = (obj, id) => !isUndefined(objGet(obj, id));
 const objDel = (obj, id) => {
@@ -81,7 +90,7 @@ const objDel = (obj, id) => {
 };
 const objMap = (obj, cb) =>
   arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
-const objSize = (obj) => arrayLength(objIds(obj));
+const objSize = (obj) => size(objIds(obj));
 const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
 
 const collSizeN = (collSizer) => (coll) =>
@@ -149,10 +158,10 @@ const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
     (ensureLeaf ? mapEnsure : mapGet)(
       node,
       path[p],
-      p > arrayLength(path) - 2 ? ensureLeaf : mapNew,
+      p > size(path) - 2 ? ensureLeaf : mapNew,
     ),
     (nodeOrLeaf) => {
-      if (p > arrayLength(path) - 2) {
+      if (p > size(path) - 2) {
         if (pruneLeaf?.(nodeOrLeaf)) {
           mapSet(node, path[p]);
         }
@@ -364,7 +373,7 @@ const getPoolFunctions = () => {
   return [
     (reuse) => (reuse ? arrayShift(pool) : null) ?? EMPTY_STRING + nextId++,
     (id) => {
-      if (test(INTEGER, id) && arrayLength(pool) < 1e3) {
+      if (test(INTEGER, id) && size(pool) < 1e3) {
         arrayPush(pool, id);
       }
     },
@@ -374,7 +383,7 @@ const getPoolFunctions = () => {
 const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
   const leaves = [];
   const deep = (node, p) =>
-    p == arrayLength(path)
+    p == size(path)
       ? arrayPush(leaves, node)
       : path[p] === null
       ? collForEach(node, (node2) => deep(node2, p + 1))
@@ -426,8 +435,8 @@ const getListenerFunctions = (getThing) => {
       mapGet(allListeners, id),
       ([listener, , path = [], pathGetters, extraArgsGetter]) => {
         const callWithIds = (...ids) => {
-          const index = arrayLength(ids);
-          index == arrayLength(path)
+          const index = size(ids);
+          index == size(path)
             ? listener(thing, ...ids, ...extraArgsGetter(ids))
             : isUndefined(path[index])
             ? arrayForEach(pathGetters[index]?.(...ids) ?? [], (id2) =>
@@ -482,11 +491,11 @@ const createCheckpoints = getCreateFunction((store) => {
   };
   const clearCheckpointIds = (checkpointIds, to) =>
     arrayForEach(
-      arrayClear(checkpointIds, to ?? arrayLength(checkpointIds)),
+      arrayClear(checkpointIds, to ?? size(checkpointIds)),
       clearCheckpointId,
     );
   const trimBackwardsIds = () =>
-    clearCheckpointIds(backwardIds, arrayLength(backwardIds) - backwardIdsSize);
+    clearCheckpointIds(backwardIds, size(backwardIds) - backwardIdsSize);
   const storeChanged = () =>
     ifNotUndefined(currentId, () => {
       arrayPush(backwardIds, currentId);
@@ -575,8 +584,8 @@ const createCheckpoints = getCreateFunction((store) => {
       checkpointsChanged = 0;
     }
   };
-  const setSize = (size) => {
-    backwardIdsSize = size;
+  const setSize = (size2) => {
+    backwardIdsSize = size2;
     trimBackwardsIds();
     return checkpoints;
   };
@@ -1050,6 +1059,7 @@ const createCustomPersister = (
   addPersisterListener,
   delPersisterListener,
   onIgnoredError,
+  [getThing, thing] = [],
   scheduleId = [],
 ) => {
   let listenerId;
@@ -1166,6 +1176,7 @@ const createCustomPersister = (
     },
     stopAutoSave: () => {
       ifNotUndefined(listenerId, store.delListener);
+      listenerId = void 0;
       return persister;
     },
     schedule: async (...actions) => {
@@ -1177,6 +1188,9 @@ const createCustomPersister = (
     destroy: () => persister.stopAutoLoad().stopAutoSave(),
     getStats: () => ({loads, saves}),
   };
+  if (getThing) {
+    persister[getThing] = () => thing;
+  }
   return objFreeze(persister);
 };
 
@@ -1256,7 +1270,7 @@ const createQueries = getCreateFunction((store) => {
     const havings = [];
     const select = (arg1, arg2) => {
       const selectEntry = isFunction(arg1)
-        ? [arrayLength(selectEntries) + EMPTY_STRING, arg1]
+        ? [size(selectEntries) + EMPTY_STRING, arg1]
         : [
             isUndefined(arg2) ? arg1 : arg2,
             (getTableCell) => getTableCell(arg1, arg2),
@@ -1630,6 +1644,7 @@ const createQueries = getCreateFunction((store) => {
           ...slice(args, 0, argumentCount),
           (_store, ...listenerArgs) =>
             args[argumentCount](queries, ...listenerArgs),
+          true,
         );
     },
   );
@@ -1862,6 +1877,8 @@ const createStore = () => {
   let hasValuesSchema;
   let cellsTouched = false;
   let valuesTouched = false;
+  let hadTables = false;
+  let hadValues = false;
   let transactions = 0;
   const changedTableIds = mapNew();
   const changedTableCellIds = mapNew();
@@ -1882,20 +1899,27 @@ const createStore = () => {
   const tableCellIds = mapNew();
   const tablesMap = mapNew();
   const valuesMap = mapNew();
+  const hasTablesListeners = pairNewMap();
   const tablesListeners = pairNewMap();
   const tableIdsListeners = pairNewMap();
+  const hasTableListeners = pairNewMap();
   const tableListeners = pairNewMap();
   const tableCellIdsListeners = pairNewMap();
+  const hasTableCellListeners = pairNewMap();
   const rowCountListeners = pairNewMap();
   const rowIdsListeners = pairNewMap();
   const sortedRowIdsListeners = pairNewMap();
+  const hasRowListeners = pairNewMap();
   const rowListeners = pairNewMap();
   const cellIdsListeners = pairNewMap();
+  const hasCellListeners = pairNewMap();
   const cellListeners = pairNewMap();
   const invalidCellListeners = pairNewMap();
   const invalidValueListeners = pairNewMap();
+  const hasValuesListeners = pairNewMap();
   const valuesListeners = pairNewMap();
   const valueIdsListeners = pairNewMap();
+  const hasValueListeners = pairNewMap();
   const valueListeners = pairNewMap();
   const startTransactionListeners = mapNew();
   const finishTransactionListeners = pairNewMap();
@@ -2290,29 +2314,45 @@ const createStore = () => {
             ),
         )
       : 0;
-  const callIdsListenersIfChanged = (listeners, changedIds, ids) => {
+  const callIdsAndHasListenersIfChanged = (
+    changedIds,
+    idListeners,
+    hasListeners,
+    ids,
+  ) => {
     if (!collIsEmpty(changedIds)) {
-      callListeners(listeners, ids, () => mapToObj(changedIds));
+      callListeners(idListeners, ids, () => mapToObj(changedIds));
+      mapForEach(changedIds, (changedId, changed) =>
+        callListeners(hasListeners, [...(ids ?? []), changedId], changed == 1),
+      );
       return 1;
     }
   };
   const callTabularListenersForChanges = (mutator) => {
+    const hasTablesNow = hasTables();
+    if (hasTablesNow != hadTables) {
+      callListeners(hasTablesListeners[mutator], void 0, hasTablesNow);
+    }
     const emptySortedRowIdListeners = collIsEmpty(
       sortedRowIdsListeners[mutator],
     );
-    const emptyIdListeners =
+    const emptyIdAndHasListeners =
       collIsEmpty(cellIdsListeners[mutator]) &&
+      collIsEmpty(hasCellListeners[mutator]) &&
+      collIsEmpty(rowIdsListeners[mutator]) &&
+      collIsEmpty(hasRowListeners[mutator]) &&
       collIsEmpty(tableCellIdsListeners[mutator]) &&
+      collIsEmpty(hasTableCellListeners[mutator]) &&
       collIsEmpty(rowCountListeners[mutator]) &&
-      collIsEmpty(rowIdsListeners[mutator]) &&
       emptySortedRowIdListeners &&
-      collIsEmpty(tableIdsListeners[mutator]);
+      collIsEmpty(tableIdsListeners[mutator]) &&
+      collIsEmpty(hasTableListeners[mutator]);
     const emptyOtherListeners =
       collIsEmpty(cellListeners[mutator]) &&
       collIsEmpty(rowListeners[mutator]) &&
       collIsEmpty(tableListeners[mutator]) &&
       collIsEmpty(tablesListeners[mutator]);
-    if (!emptyIdListeners || !emptyOtherListeners) {
+    if (!emptyIdAndHasListeners || !emptyOtherListeners) {
       const changes = mutator
         ? [
             mapClone(changedTableIds),
@@ -2330,12 +2370,17 @@ const createStore = () => {
             changedCellIds,
             changedCells,
           ];
-      if (!emptyIdListeners) {
-        callIdsListenersIfChanged(tableIdsListeners[mutator], changes[0]);
+      if (!emptyIdAndHasListeners) {
+        callIdsAndHasListenersIfChanged(
+          changes[0],
+          tableIdsListeners[mutator],
+          hasTableListeners[mutator],
+        );
         collForEach(changes[1], (changedIds, tableId) =>
-          callIdsListenersIfChanged(
-            tableCellIdsListeners[mutator],
+          callIdsAndHasListenersIfChanged(
             changedIds,
+            tableCellIdsListeners[mutator],
+            hasTableCellListeners[mutator],
             [tableId],
           ),
         );
@@ -2351,9 +2396,12 @@ const createStore = () => {
         const calledSortableTableIds = setNew();
         collForEach(changes[3], (changedIds, tableId) => {
           if (
-            callIdsListenersIfChanged(rowIdsListeners[mutator], changedIds, [
-              tableId,
-            ]) &&
+            callIdsAndHasListenersIfChanged(
+              changedIds,
+              rowIdsListeners[mutator],
+              hasRowListeners[mutator],
+              [tableId],
+            ) &&
             !emptySortedRowIdListeners
           ) {
             callListeners(sortedRowIdsListeners[mutator], [tableId, null]);
@@ -2382,10 +2430,12 @@ const createStore = () => {
         }
         collForEach(changes[4], (rowCellIds, tableId) =>
           collForEach(rowCellIds, (changedIds, rowId) =>
-            callIdsListenersIfChanged(cellIdsListeners[mutator], changedIds, [
-              tableId,
-              rowId,
-            ]),
+            callIdsAndHasListenersIfChanged(
+              changedIds,
+              cellIdsListeners[mutator],
+              hasCellListeners[mutator],
+              [tableId, rowId],
+            ),
           ),
         );
       }
@@ -2425,17 +2475,27 @@ const createStore = () => {
       }
     }
   };
-  const callKeyedValuesListenersForChanges = (mutator) => {
-    const emptyIdListeners = collIsEmpty(valueIdsListeners[mutator]);
+  const callValuesListenersForChanges = (mutator) => {
+    const hasValuesNow = hasValues();
+    if (hasValuesNow != hadValues) {
+      callListeners(hasValuesListeners[mutator], void 0, hasValuesNow);
+    }
+    const emptyIdAndHasListeners =
+      collIsEmpty(valueIdsListeners[mutator]) &&
+      collIsEmpty(hasValueListeners[mutator]);
     const emptyOtherListeners =
       collIsEmpty(valueListeners[mutator]) &&
       collIsEmpty(valuesListeners[mutator]);
-    if (!emptyIdListeners || !emptyOtherListeners) {
+    if (!emptyIdAndHasListeners || !emptyOtherListeners) {
       const changes = mutator
         ? [mapClone(changedValueIds), mapClone(changedValues)]
         : [changedValueIds, changedValues];
-      if (!emptyIdListeners) {
-        callIdsListenersIfChanged(valueIdsListeners[mutator], changes[0]);
+      if (!emptyIdAndHasListeners) {
+        callIdsAndHasListenersIfChanged(
+          changes[0],
+          valueIdsListeners[mutator],
+          hasValueListeners[mutator],
+        );
       }
       if (!emptyOtherListeners) {
         let valuesChanged;
@@ -2808,7 +2868,7 @@ const createStore = () => {
         }
         callInvalidValueListeners(1);
         if (valuesTouched) {
-          callKeyedValuesListenersForChanges(1);
+          callValuesListenersForChanges(1);
         }
         if (doRollback?.(getTransactionChanges, getTransactionLog)) {
           collForEach(changedCells, (table, tableId) =>
@@ -2836,7 +2896,7 @@ const createStore = () => {
         }
         callInvalidValueListeners(0);
         if (valuesTouched) {
-          callKeyedValuesListenersForChanges(0);
+          callValuesListenersForChanges(0);
         }
         callListeners(
           finishTransactionListeners[1],
@@ -2846,6 +2906,8 @@ const createStore = () => {
         );
         transactions = 0;
         cellsTouched = valuesTouched = false;
+        hadTables = hasTables();
+        hadValues = hasValues();
         arrayForEach(
           [
             changedTableIds,
@@ -2942,19 +3004,26 @@ const createStore = () => {
     return store;
   };
   const getListenerStats = () => ({
+    hasTables: pairCollSize2(hasTablesListeners),
     tables: pairCollSize2(tablesListeners),
     tableIds: pairCollSize2(tableIdsListeners),
-    tableCellIds: pairCollSize2(tableCellIdsListeners),
+    hasTable: pairCollSize2(hasTableListeners),
     table: pairCollSize2(tableListeners),
+    tableCellIds: pairCollSize2(tableCellIdsListeners),
+    hasTableCell: pairCollSize2(hasTableCellListeners, collSize3),
     rowCount: pairCollSize2(rowCountListeners),
     rowIds: pairCollSize2(rowIdsListeners),
     sortedRowIds: pairCollSize2(sortedRowIdsListeners),
+    hasRow: pairCollSize2(hasRowListeners, collSize3),
     row: pairCollSize2(rowListeners, collSize3),
     cellIds: pairCollSize2(cellIdsListeners, collSize3),
+    hasCell: pairCollSize2(hasCellListeners, collSize4),
     cell: pairCollSize2(cellListeners, collSize4),
     invalidCell: pairCollSize2(invalidCellListeners, collSize4),
+    hasValues: pairCollSize2(hasValuesListeners),
     values: pairCollSize2(valuesListeners),
     valueIds: pairCollSize2(valueIdsListeners),
+    hasValue: pairCollSize2(hasValueListeners),
     value: pairCollSize2(valueListeners),
     invalidValue: pairCollSize2(invalidValueListeners),
     transaction:
@@ -3039,14 +3108,39 @@ const createStore = () => {
   };
   objMap(
     {
+      [HAS + TABLES]: [0, hasTablesListeners, [], () => [hasTables()]],
       [TABLES]: [0, tablesListeners],
       [TABLE_IDS]: [0, tableIdsListeners],
+      [HAS + TABLE]: [
+        1,
+        hasTableListeners,
+        [getTableIds],
+        (ids) => [hasTable(...ids)],
+      ],
       [TABLE]: [1, tableListeners, [getTableIds]],
       [TABLE + CELL_IDS]: [1, tableCellIdsListeners, [getTableIds]],
+      [HAS + TABLE + CELL]: [
+        2,
+        hasTableCellListeners,
+        [getTableIds, getTableCellIds],
+        (ids) => [hasTableCell(...ids)],
+      ],
       [ROW_COUNT]: [1, rowCountListeners, [getTableIds]],
       [ROW_IDS]: [1, rowIdsListeners, [getTableIds]],
+      [HAS + ROW]: [
+        2,
+        hasRowListeners,
+        [getTableIds, getRowIds],
+        (ids) => [hasRow(...ids)],
+      ],
       [ROW]: [2, rowListeners, [getTableIds, getRowIds]],
       [CELL_IDS]: [2, cellIdsListeners, [getTableIds, getRowIds]],
+      [HAS + CELL]: [
+        3,
+        hasCellListeners,
+        [getTableIds, getRowIds, getCellIds],
+        (ids) => [hasCell(...ids)],
+      ],
       [CELL]: [
         3,
         cellListeners,
@@ -3054,8 +3148,15 @@ const createStore = () => {
         (ids) => pairNew(getCell(...ids)),
       ],
       InvalidCell: [3, invalidCellListeners],
+      [HAS + VALUES]: [0, hasValuesListeners, [], () => [hasValues()]],
       [VALUES]: [0, valuesListeners],
       [VALUE_IDS]: [0, valueIdsListeners],
+      [HAS + VALUE]: [
+        1,
+        hasValueListeners,
+        [getValueIds],
+        (ids) => [hasValue(...ids)],
+      ],
       [VALUE]: [
         1,
         valueListeners,

package/lib/debug/tools.js

@@ -25,12 +25,14 @@ const VALUE_IDS = VALUE + IDS;
 
 const promise = Promise;
 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 isArray = (thing) => Array.isArray(thing);
 const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
+const size = (arrayOrString) => arrayOrString.length;
 const promiseAll = async (promises) => promise.all(promises);
 
 const getCellOrValueType = (cell) => {
@@ -45,7 +47,6 @@ const arraySort = (array, sorter) => array.sort(sorter);
 const arrayForEach = (array, cb) => array.forEach(cb);
 const arrayJoin = (array, sep = EMPTY_STRING) => array.join(sep);
 const arrayMap = (array, cb) => array.map(cb);
-const arrayLength = (array) => array.length;
 const arrayFilter = (array, cb) => array.filter(cb);
 const arrayPush = (array, ...values) => array.push(...values);
 const arrayPop = (array) => array.pop();
@@ -53,13 +54,21 @@ const arrayUnshift = (array, ...values) => array.unshift(...values);
 const arrayShift = (array) => array.shift();
 
 const object = Object;
+const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
 const objIds = object.keys;
 const objFreeze = object.freeze;
 const isObject = (obj) =>
-  isInstanceOf(obj, object) && obj.constructor == object;
+  !isUndefined(obj) &&
+  ifNotUndefined(
+    getPrototypeOf(obj),
+    (objPrototype) =>
+      objPrototype == object.prototype ||
+      isUndefined(getPrototypeOf(objPrototype)),
+    () => true,
+  );
 const objMap = (obj, cb) =>
   arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
-const objSize = (obj) => arrayLength(objIds(obj));
+const objSize = (obj) => size(objIds(obj));
 const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
 
 const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
@@ -250,7 +259,7 @@ const mapUnique = (map, id, value, index = 1) => {
 };
 const formatJsDoc = (file) =>
   file.replace(JSDOC, (_, indent, text) => {
-    const lineLength = 77 - length(indent);
+    const lineLength = 77 - size(indent);
     return `${indent}/**
 ${text.replace(
   new RegExp(`([^\\n]{1,${lineLength}})(\\s|$)`, 'g'),
@@ -258,7 +267,6 @@ ${text.replace(
 `,
 )}${indent} */`;
   });
-const length = (str) => str.length;
 const flat = (array) => array.flat(1e3);
 const camel = (str, firstCap = 0) =>
   arrayJoin(
@@ -2872,8 +2880,8 @@ const createTools = getCreateFunction((store) => {
       totalTables,
       totalRows,
       totalCells,
-      totalValues: arrayLength(store.getValueIds()),
-      jsonLength: length(store.getJson()),
+      totalValues: size(store.getValueIds()),
+      jsonLength: size(store.getJson()),
       ...(detail ? {detail: {tables}} : {}),
     };
   };
@@ -2909,7 +2917,7 @@ const createTools = getCreateFunction((store) => {
           collForEach(cellsMeta, ([type, , [, maxValue], count], cellId) => {
             tablesSchema[tableId][cellId] = {
               [TYPE]: type,
-              ...(count == arrayLength(rowIds) ? {[DEFAULT]: maxValue} : {}),
+              ...(count == size(rowIds) ? {[DEFAULT]: maxValue} : {}),
             };
           });
           return 1;