@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/cjs/plugins/storage-memory/binary-search-bounds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-search-bounds.js","names":["ge","a","y","c","l","h","i","m","x","p","undefined","gt","lt","le","eq","norm","f","length","boundGE","boundGT","boundLT","boundLE","boundEQ"],"sources":["../../../../src/plugins/storage-memory/binary-search-bounds.ts"],"sourcesContent":["/**\r\n * Everything in this file was copied and adapted from\r\n * @link https://github.com/mikolalysenko/binary-search-bounds\r\n *\r\n * We should use the original npm module instead when this bug is fixed:\r\n * @link https://github.com/mikolalysenko/binary-search-bounds/pull/14\r\n */\r\n\r\n\r\n\r\ntype Compare<T> = ((a: T, b: T) => number | null | undefined);\r\n\r\nfunction ge<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {\r\n    let i: number = h + 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1;\r\n        const x: any = a[m];\r\n        const p: any = (c !== undefined) ? c(x, y) : (x - (y as any));\r\n        if (p >= 0) {\r\n            i = m; h = m - 1;\r\n        } else {\r\n            l = m + 1;\r\n        }\r\n    }\r\n    return i;\r\n}\r\n\r\nfunction gt<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {\r\n    let i = h + 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1;\r\n        const x = a[m];\r\n        const p: any = (c !== undefined) ? c(x, y) : ((x as any) - (y as any));\r\n        if (p > 0) {\r\n            i = m; h = m - 1;\r\n        } else {\r\n            l = m + 1;\r\n        }\r\n    }\r\n    return i;\r\n}\r\n\r\nfunction lt<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {\r\n    let i = l - 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1, x = a[m];\r\n        const p: any = (c !== undefined) ? c(x, y) : ((x as any) - (y as any));\r\n        if (p < 0) {\r\n            i = m; l = m + 1;\r\n        } else {\r\n            h = m - 1;\r\n        }\r\n    }\r\n    return i;\r\n}\r\n\r\nfunction le<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {\r\n    let i = l - 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1, x = a[m];\r\n        const p: any = (c !== undefined) ? c(x, y) : ((x as any) - (y as any));\r\n        if (p <= 0) {\r\n            i = m; l = m + 1;\r\n        } else {\r\n            h = m - 1;\r\n        }\r\n    }\r\n    return i;\r\n}\r\n\r\nfunction eq<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any): number {\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1, x = a[m];\r\n        const p: any = (c !== undefined) ? c(x, y) : ((x as any) - (y as any));\r\n        if (p === 0) {\r\n            return m;\r\n        }\r\n        if (p <= 0) {\r\n            l = m + 1;\r\n        } else {\r\n            h = m - 1;\r\n        }\r\n    }\r\n    return -1;\r\n}\r\n\r\nfunction norm<T>(a: T[], y: T, c: Compare<T>, l: any, h: any, f: any) {\r\n    return f(a, y, c, (l === undefined) ? 0 : l | 0, (h === undefined) ? a.length - 1 : h | 0);\r\n}\r\n\r\n\r\nexport function boundGE<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any) {\r\n    return norm(a, y, c, l, h, ge);\r\n}\r\nexport function boundGT<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any) {\r\n    return norm(a, y, c, l, h, gt);\r\n}\r\nexport function boundLT<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any) {\r\n    return norm(a, y, c, l, h, lt);\r\n}\r\nexport function boundLE<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any) {\r\n    return norm(a, y, c, l, h, le);\r\n}\r\nexport function boundEQ<T>(a: T[], y: T, c: Compare<T>, l?: any, h?: any) {\r\n    return norm(a, y, c, l, h, eq);\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/plugins/storage-memory/index.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  getRxStorageMemory: true
+};
+exports.getRxStorageMemory = getRxStorageMemory;
+var _rxStorageHelper = require("../../rx-storage-helper.js");
+var _utilsRxdbVersion = require("../utils/utils-rxdb-version.js");
+var _rxStorageInstanceMemory = require("./rx-storage-instance-memory.js");
+Object.keys(_rxStorageInstanceMemory).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _rxStorageInstanceMemory[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _rxStorageInstanceMemory[key];
+    }
+  });
+});
+var _memoryHelper = require("./memory-helper.js");
+Object.keys(_memoryHelper).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _memoryHelper[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _memoryHelper[key];
+    }
+  });
+});
+var _binarySearchBounds = require("./binary-search-bounds.js");
+Object.keys(_binarySearchBounds).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _binarySearchBounds[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _binarySearchBounds[key];
+    }
+  });
+});
+var _memoryTypes = require("./memory-types.js");
+Object.keys(_memoryTypes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _memoryTypes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _memoryTypes[key];
+    }
+  });
+});
+var _memoryIndexes = require("./memory-indexes.js");
+Object.keys(_memoryIndexes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _memoryIndexes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _memoryIndexes[key];
+    }
+  });
+});
+/**
+ * Keep the state even when the storage instance is closed.
+ * This makes it easier to use the memory storage
+ * to test filesystem-like and multiInstance behaviors.
+ */
+var COLLECTION_STATES = new Map();
+function getRxStorageMemory(settings = {}) {
+  var storage = {
+    name: 'memory',
+    rxdbVersion: _utilsRxdbVersion.RXDB_VERSION,
+    collectionStates: COLLECTION_STATES,
+    createStorageInstance(params) {
+      (0, _rxStorageHelper.ensureRxStorageInstanceParamsAreCorrect)(params);
+      var useSettings = Object.assign({}, settings, params.options);
+      return (0, _rxStorageInstanceMemory.createMemoryStorageInstance)(this, params, useSettings);
+    }
+  };
+  return storage;
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/plugins/storage-memory/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_rxStorageHelper","require","_utilsRxdbVersion","_rxStorageInstanceMemory","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_memoryHelper","_binarySearchBounds","_memoryTypes","_memoryIndexes","COLLECTION_STATES","Map","getRxStorageMemory","settings","storage","name","rxdbVersion","RXDB_VERSION","collectionStates","createStorageInstance","params","ensureRxStorageInstanceParamsAreCorrect","useSettings","assign","options","createMemoryStorageInstance"],"sources":["../../../../src/plugins/storage-memory/index.ts"],"sourcesContent":["import { ensureRxStorageInstanceParamsAreCorrect } from '../../rx-storage-helper.ts';\r\nimport type { RxStorageInstanceCreationParams } from '../../types/index.d.ts';\r\nimport { RXDB_VERSION } from '../utils/utils-rxdb-version.ts';\r\nimport type {\r\n    RxStorageMemory,\r\n    RxStorageMemoryInstanceCreationOptions,\r\n    RxStorageMemorySettings\r\n} from './memory-types.ts';\r\nimport {\r\n    createMemoryStorageInstance,\r\n    RxStorageInstanceMemory\r\n} from './rx-storage-instance-memory.ts';\r\n\r\n/**\r\n * Keep the state even when the storage instance is closed.\r\n * This makes it easier to use the memory storage\r\n * to test filesystem-like and multiInstance behaviors.\r\n */\r\nconst COLLECTION_STATES = new Map();\r\n\r\nexport function getRxStorageMemory(\r\n    settings: RxStorageMemorySettings = {}\r\n): RxStorageMemory {\r\n\r\n    const storage: RxStorageMemory = {\r\n        name: 'memory',\r\n        rxdbVersion: RXDB_VERSION,\r\n        collectionStates: COLLECTION_STATES,\r\n        createStorageInstance<RxDocType>(\r\n            params: RxStorageInstanceCreationParams<RxDocType, RxStorageMemoryInstanceCreationOptions>\r\n        ): Promise<RxStorageInstanceMemory<RxDocType>> {\r\n            ensureRxStorageInstanceParamsAreCorrect(params);\r\n            const useSettings = Object.assign(\r\n                {},\r\n                settings,\r\n                params.options\r\n            );\r\n\r\n\r\n            return createMemoryStorageInstance(this, params, useSettings);\r\n        }\r\n    };\r\n\r\n    return storage;\r\n}\r\n\r\n\r\nexport * from './memory-helper.ts';\r\nexport * from './binary-search-bounds.ts';\r\nexport * from './memory-types.ts';\r\nexport * from './memory-indexes.ts';\r\nexport * from './rx-storage-instance-memory.ts';\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/plugins/storage-memory/memory-helper.js

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.attachmentMapKey = attachmentMapKey;
+exports.bulkInsertToState = bulkInsertToState;
+exports.compareDocsWithIndex = compareDocsWithIndex;
+exports.ensureNotRemoved = ensureNotRemoved;
+exports.getMemoryCollectionKey = getMemoryCollectionKey;
+exports.putWriteRowToState = putWriteRowToState;
+exports.removeDocFromState = removeDocFromState;
+var _arrayPushAtSortPosition = require("array-push-at-sort-position");
+var _rxError = require("../../rx-error.js");
+var _binarySearchBounds = require("./binary-search-bounds.js");
+function getMemoryCollectionKey(databaseName, collectionName, schemaVersion) {
+  return [databaseName, collectionName, schemaVersion].join('--memory--');
+}
+function ensureNotRemoved(instance) {
+  if (instance.internals.removed) {
+    throw new Error('removed already ' + instance.databaseName + ' - ' + instance.collectionName + ' - ' + instance.schema.version);
+  }
+}
+function attachmentMapKey(documentId, attachmentId) {
+  return documentId + '||' + attachmentId;
+}
+function sortByIndexStringComparator(a, b) {
+  if (a[0] < b[0]) {
+    return -1;
+  } else {
+    return 1;
+  }
+}
+
+/**
+ * @hotPath
+ */
+function putWriteRowToState(docId, state, stateByIndex, document, docInState) {
+  state.documents.set(docId, document);
+  for (var i = 0; i < stateByIndex.length; ++i) {
+    var byIndex = stateByIndex[i];
+    var docsWithIndex = byIndex.docsWithIndex;
+    var getIndexableString = byIndex.getIndexableString;
+    var newIndexString = getIndexableString(document);
+    var insertPosition = (0, _arrayPushAtSortPosition.pushAtSortPosition)(docsWithIndex, [newIndexString, document, docId], sortByIndexStringComparator, 0);
+
+    /**
+     * Remove previous if it was in the state
+     */
+    if (docInState) {
+      var previousIndexString = getIndexableString(docInState);
+      if (previousIndexString === newIndexString) {
+        /**
+         * Performance shortcut.
+         * If index was not changed -> The old doc must be before or after the new one.
+         */
+        var prev = docsWithIndex[insertPosition - 1];
+        if (prev && prev[2] === docId) {
+          docsWithIndex.splice(insertPosition - 1, 1);
+        } else {
+          var next = docsWithIndex[insertPosition + 1];
+          if (next[2] === docId) {
+            docsWithIndex.splice(insertPosition + 1, 1);
+          } else {
+            throw (0, _rxError.newRxError)('SNH', {
+              document,
+              args: {
+                byIndex
+              }
+            });
+          }
+        }
+      } else {
+        /**
+         * Index changed, we must search for the old one and remove it.
+         */
+        var indexBefore = (0, _binarySearchBounds.boundEQ)(docsWithIndex, [previousIndexString], compareDocsWithIndex);
+        docsWithIndex.splice(indexBefore, 1);
+      }
+    }
+  }
+}
+
+/**
+ * @hotPath
+ * Efficiently inserts multiple documents into the state at once.
+ * Instead of inserting one-by-one with Array.splice() (O(n) per insert),
+ * this pre-computes all index entries, sorts them, and merges them into
+ * the existing sorted arrays in a single pass (O(n log n + n + m)).
+ */
+function bulkInsertToState(primaryPath, state, stateByIndex, docs) {
+  var docsLength = docs.length;
+
+  // Extract documents and docIds once, store in Map
+  var documents = new Array(docsLength);
+  var docIds = new Array(docsLength);
+  for (var i = 0; i < docsLength; ++i) {
+    var doc = docs[i].document;
+    var docId = doc[primaryPath];
+    documents[i] = doc;
+    docIds[i] = docId;
+    state.documents.set(docId, doc);
+  }
+
+  // For each index, batch-compute entries, sort, and merge
+  for (var indexI = 0; indexI < stateByIndex.length; ++indexI) {
+    var byIndex = stateByIndex[indexI];
+    var docsWithIndex = byIndex.docsWithIndex;
+    var getIndexableString = byIndex.getIndexableString;
+
+    // Build new entries
+    var newEntries = new Array(docsLength);
+    for (var _i = 0; _i < docsLength; ++_i) {
+      var _doc = documents[_i];
+      newEntries[_i] = [getIndexableString(_doc), _doc, docIds[_i]];
+    }
+
+    // Sort by index string
+    newEntries.sort(sortByIndexStringComparator);
+    if (docsWithIndex.length === 0) {
+      // Index is empty, just assign sorted entries
+      byIndex.docsWithIndex = newEntries;
+    } else {
+      // Merge sorted arrays
+      byIndex.docsWithIndex = mergeSortedArrays(docsWithIndex, newEntries, sortByIndexStringComparator);
+    }
+  }
+}
+
+/**
+ * Merges two sorted arrays into a single sorted array.
+ * Runs in O(n + m) where n and m are the lengths of the input arrays.
+ */
+function mergeSortedArrays(a, b, comparator) {
+  var aLen = a.length;
+  var bLen = b.length;
+  var result = new Array(aLen + bLen);
+  var ai = 0;
+  var bi = 0;
+  var ri = 0;
+  while (ai < aLen && bi < bLen) {
+    if (comparator(a[ai], b[bi]) <= 0) {
+      result[ri++] = a[ai++];
+    } else {
+      result[ri++] = b[bi++];
+    }
+  }
+  while (ai < aLen) {
+    result[ri++] = a[ai++];
+  }
+  while (bi < bLen) {
+    result[ri++] = b[bi++];
+  }
+  return result;
+}
+function removeDocFromState(primaryPath, schema, state, doc) {
+  var docId = doc[primaryPath];
+  state.documents.delete(docId);
+  Object.values(state.byIndex).forEach(byIndex => {
+    var docsWithIndex = byIndex.docsWithIndex;
+    var indexString = byIndex.getIndexableString(doc);
+    var positionInIndex = (0, _binarySearchBounds.boundEQ)(docsWithIndex, [indexString], compareDocsWithIndex);
+    docsWithIndex.splice(positionInIndex, 1);
+  });
+}
+function compareDocsWithIndex(a, b) {
+  var indexStringA = a[0];
+  var indexStringB = b[0];
+  if (indexStringA < indexStringB) {
+    return -1;
+  } else if (indexStringA === indexStringB) {
+    return 0;
+  } else {
+    return 1;
+  }
+}
+//# sourceMappingURL=memory-helper.js.map

package/dist/cjs/plugins/storage-memory/memory-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-helper.js","names":["_arrayPushAtSortPosition","require","_rxError","_binarySearchBounds","getMemoryCollectionKey","databaseName","collectionName","schemaVersion","join","ensureNotRemoved","instance","internals","removed","Error","schema","version","attachmentMapKey","documentId","attachmentId","sortByIndexStringComparator","a","b","putWriteRowToState","docId","state","stateByIndex","document","docInState","documents","set","i","length","byIndex","docsWithIndex","getIndexableString","newIndexString","insertPosition","pushAtSortPosition","previousIndexString","prev","splice","next","newRxError","args","indexBefore","boundEQ","compareDocsWithIndex","bulkInsertToState","primaryPath","docs","docsLength","Array","docIds","doc","indexI","newEntries","sort","mergeSortedArrays","comparator","aLen","bLen","result","ai","bi","ri","removeDocFromState","delete","Object","values","forEach","indexString","positionInIndex","indexStringA","indexStringB"],"sources":["../../../../src/plugins/storage-memory/memory-helper.ts"],"sourcesContent":["import type {\r\n    BulkWriteRow,\r\n    RxDocumentData,\r\n    RxJsonSchema\r\n} from '../../types/index.d.ts';\r\nimport type {\r\n    DocWithIndexString,\r\n    MemoryStorageInternals,\r\n    MemoryStorageInternalsByIndex\r\n} from './memory-types.ts';\r\nimport type { RxStorageInstanceMemory } from './rx-storage-instance-memory.ts';\r\nimport {\r\n    pushAtSortPosition\r\n} from 'array-push-at-sort-position';\r\nimport { newRxError } from '../../rx-error.ts';\r\nimport { boundEQ } from './binary-search-bounds.ts';\r\n\r\n\r\nexport function getMemoryCollectionKey(\r\n    databaseName: string,\r\n    collectionName: string,\r\n    schemaVersion: number\r\n): string {\r\n    return [\r\n        databaseName,\r\n        collectionName,\r\n        schemaVersion\r\n    ].join('--memory--');\r\n}\r\n\r\n\r\nexport function ensureNotRemoved(\r\n    instance: RxStorageInstanceMemory<any>\r\n) {\r\n    if (instance.internals.removed) {\r\n        throw new Error(\r\n            'removed already ' +\r\n            instance.databaseName + ' - ' + instance.collectionName +\r\n            ' - ' + instance.schema.version\r\n        );\r\n    }\r\n}\r\n\r\nexport function attachmentMapKey(documentId: string, attachmentId: string): string {\r\n    return documentId + '||' + attachmentId;\r\n}\r\n\r\n\r\nfunction sortByIndexStringComparator<RxDocType>(a: DocWithIndexString<RxDocType>, b: DocWithIndexString<RxDocType>) {\r\n    if (a[0] < b[0]) {\r\n        return -1;\r\n    } else {\r\n        return 1;\r\n    }\r\n}\r\n\r\n\r\n\r\n/**\r\n * @hotPath\r\n */\r\nexport function putWriteRowToState<RxDocType>(\r\n    docId: string,\r\n    state: MemoryStorageInternals<RxDocType>,\r\n    stateByIndex: MemoryStorageInternalsByIndex<RxDocType>[],\r\n    document: RxDocumentData<RxDocType>,\r\n    docInState?: RxDocumentData<RxDocType>\r\n) {\r\n    state.documents.set(docId, document as any);\r\n    for (let i = 0; i < stateByIndex.length; ++i) {\r\n        const byIndex = stateByIndex[i];\r\n        const docsWithIndex = byIndex.docsWithIndex;\r\n        const getIndexableString = byIndex.getIndexableString;\r\n        const newIndexString = getIndexableString(document as any);\r\n        const insertPosition = pushAtSortPosition(\r\n            docsWithIndex,\r\n            [\r\n                newIndexString,\r\n                document,\r\n                docId,\r\n            ],\r\n            sortByIndexStringComparator,\r\n            0\r\n        );\r\n\r\n        /**\r\n         * Remove previous if it was in the state\r\n         */\r\n        if (docInState) {\r\n            const previousIndexString = getIndexableString(docInState);\r\n            if (previousIndexString === newIndexString) {\r\n                /**\r\n                 * Performance shortcut.\r\n                 * If index was not changed -> The old doc must be before or after the new one.\r\n                 */\r\n                const prev = docsWithIndex[insertPosition - 1];\r\n                if (prev && prev[2] === docId) {\r\n                    docsWithIndex.splice(insertPosition - 1, 1);\r\n                } else {\r\n                    const next = docsWithIndex[insertPosition + 1];\r\n                    if (next[2] === docId) {\r\n                        docsWithIndex.splice(insertPosition + 1, 1);\r\n                    } else {\r\n                        throw newRxError('SNH', {\r\n                            document,\r\n                            args: {\r\n                                byIndex\r\n                            }\r\n                        });\r\n                    }\r\n                }\r\n            } else {\r\n                /**\r\n                 * Index changed, we must search for the old one and remove it.\r\n                 */\r\n                const indexBefore = boundEQ(\r\n                    docsWithIndex,\r\n                    [\r\n                        previousIndexString\r\n                    ] as any,\r\n                    compareDocsWithIndex\r\n                );\r\n                docsWithIndex.splice(indexBefore, 1);\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * @hotPath\r\n * Efficiently inserts multiple documents into the state at once.\r\n * Instead of inserting one-by-one with Array.splice() (O(n) per insert),\r\n * this pre-computes all index entries, sorts them, and merges them into\r\n * the existing sorted arrays in a single pass (O(n log n + n + m)).\r\n */\r\nexport function bulkInsertToState<RxDocType>(\r\n    primaryPath: string,\r\n    state: MemoryStorageInternals<RxDocType>,\r\n    stateByIndex: MemoryStorageInternalsByIndex<RxDocType>[],\r\n    docs: { document: RxDocumentData<RxDocType> }[]\r\n) {\r\n    const docsLength = docs.length;\r\n\r\n    // Extract documents and docIds once, store in Map\r\n    const documents: RxDocumentData<RxDocType>[] = new Array(docsLength);\r\n    const docIds: string[] = new Array(docsLength);\r\n    for (let i = 0; i < docsLength; ++i) {\r\n        const doc = docs[i].document;\r\n        const docId: string = (doc as any)[primaryPath];\r\n        documents[i] = doc;\r\n        docIds[i] = docId;\r\n        state.documents.set(docId, doc as any);\r\n    }\r\n\r\n    // For each index, batch-compute entries, sort, and merge\r\n    for (let indexI = 0; indexI < stateByIndex.length; ++indexI) {\r\n        const byIndex = stateByIndex[indexI];\r\n        const docsWithIndex = byIndex.docsWithIndex;\r\n        const getIndexableString = byIndex.getIndexableString;\r\n\r\n        // Build new entries\r\n        const newEntries: DocWithIndexString<RxDocType>[] = new Array(docsLength);\r\n        for (let i = 0; i < docsLength; ++i) {\r\n            const doc = documents[i];\r\n            newEntries[i] = [\r\n                getIndexableString(doc as any),\r\n                doc,\r\n                docIds[i]\r\n            ];\r\n        }\r\n\r\n        // Sort by index string\r\n        newEntries.sort(sortByIndexStringComparator);\r\n\r\n        if (docsWithIndex.length === 0) {\r\n            // Index is empty, just assign sorted entries\r\n            byIndex.docsWithIndex = newEntries;\r\n        } else {\r\n            // Merge sorted arrays\r\n            byIndex.docsWithIndex = mergeSortedArrays(docsWithIndex, newEntries, sortByIndexStringComparator);\r\n        }\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * Merges two sorted arrays into a single sorted array.\r\n * Runs in O(n + m) where n and m are the lengths of the input arrays.\r\n */\r\nfunction mergeSortedArrays<T>(\r\n    a: T[],\r\n    b: T[],\r\n    comparator: (x: T, y: T) => number\r\n): T[] {\r\n    const aLen = a.length;\r\n    const bLen = b.length;\r\n    const result: T[] = new Array(aLen + bLen);\r\n    let ai = 0;\r\n    let bi = 0;\r\n    let ri = 0;\r\n\r\n    while (ai < aLen && bi < bLen) {\r\n        if (comparator(a[ai], b[bi]) <= 0) {\r\n            result[ri++] = a[ai++];\r\n        } else {\r\n            result[ri++] = b[bi++];\r\n        }\r\n    }\r\n\r\n    while (ai < aLen) {\r\n        result[ri++] = a[ai++];\r\n    }\r\n    while (bi < bLen) {\r\n        result[ri++] = b[bi++];\r\n    }\r\n\r\n    return result;\r\n}\r\n\r\nexport function removeDocFromState<RxDocType>(\r\n    primaryPath: string,\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>,\r\n    state: MemoryStorageInternals<RxDocType>,\r\n    doc: RxDocumentData<RxDocType>\r\n) {\r\n    const docId: string = (doc as any)[primaryPath];\r\n    state.documents.delete(docId);\r\n\r\n    Object.values(state.byIndex).forEach(byIndex => {\r\n        const docsWithIndex = byIndex.docsWithIndex;\r\n        const indexString = byIndex.getIndexableString(doc);\r\n\r\n        const positionInIndex = boundEQ(\r\n            docsWithIndex,\r\n            [\r\n                indexString\r\n            ] as any,\r\n            compareDocsWithIndex\r\n        );\r\n        docsWithIndex.splice(positionInIndex, 1);\r\n    });\r\n}\r\n\r\n\r\nexport function compareDocsWithIndex<RxDocType>(\r\n    a: DocWithIndexString<RxDocType>,\r\n    b: DocWithIndexString<RxDocType>\r\n): 1 | 0 | -1 {\r\n    const indexStringA = a[0];\r\n    const indexStringB = b[0];\r\n    if (indexStringA < indexStringB) {\r\n        return -1;\r\n    } else if (indexStringA === indexStringB) {\r\n        return 0;\r\n    } else {\r\n        return 1;\r\n    }\r\n}\r\n"],"mappings":";;;;;;;;;;;;AAWA,IAAAA,wBAAA,GAAAC,OAAA;AAGA,IAAAC,QAAA,GAAAD,OAAA;AACA,IAAAE,mBAAA,GAAAF,OAAA;AAGO,SAASG,sBAAsBA,CAClCC,YAAoB,EACpBC,cAAsB,EACtBC,aAAqB,EACf;EACN,OAAO,CACHF,YAAY,EACZC,cAAc,EACdC,aAAa,CAChB,CAACC,IAAI,CAAC,YAAY,CAAC;AACxB;AAGO,SAASC,gBAAgBA,CAC5BC,QAAsC,EACxC;EACE,IAAIA,QAAQ,CAACC,SAAS,CAACC,OAAO,EAAE;IAC5B,MAAM,IAAIC,KAAK,CACX,kBAAkB,GAClBH,QAAQ,CAACL,YAAY,GAAG,KAAK,GAAGK,QAAQ,CAACJ,cAAc,GACvD,KAAK,GAAGI,QAAQ,CAACI,MAAM,CAACC,OAC5B,CAAC;EACL;AACJ;AAEO,SAASC,gBAAgBA,CAACC,UAAkB,EAAEC,YAAoB,EAAU;EAC/E,OAAOD,UAAU,GAAG,IAAI,GAAGC,YAAY;AAC3C;AAGA,SAASC,2BAA2BA,CAAYC,CAAgC,EAAEC,CAAgC,EAAE;EAChH,IAAID,CAAC,CAAC,CAAC,CAAC,GAAGC,CAAC,CAAC,CAAC,CAAC,EAAE;IACb,OAAO,CAAC,CAAC;EACb,CAAC,MAAM;IACH,OAAO,CAAC;EACZ;AACJ;;AAIA;AACA;AACA;AACO,SAASC,kBAAkBA,CAC9BC,KAAa,EACbC,KAAwC,EACxCC,YAAwD,EACxDC,QAAmC,EACnCC,UAAsC,EACxC;EACEH,KAAK,CAACI,SAAS,CAACC,GAAG,CAACN,KAAK,EAAEG,QAAe,CAAC;EAC3C,KAAK,IAAII,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGL,YAAY,CAACM,MAAM,EAAE,EAAED,CAAC,EAAE;IAC1C,IAAME,OAAO,GAAGP,YAAY,CAACK,CAAC,CAAC;IAC/B,IAAMG,aAAa,GAAGD,OAAO,CAACC,aAAa;IAC3C,IAAMC,kBAAkB,GAAGF,OAAO,CAACE,kBAAkB;IACrD,IAAMC,cAAc,GAAGD,kBAAkB,CAACR,QAAe,CAAC;IAC1D,IAAMU,cAAc,GAAG,IAAAC,2CAAkB,EACrCJ,aAAa,EACb,CACIE,cAAc,EACdT,QAAQ,EACRH,KAAK,CACR,EACDJ,2BAA2B,EAC3B,CACJ,CAAC;;IAED;AACR;AACA;IACQ,IAAIQ,UAAU,EAAE;MACZ,IAAMW,mBAAmB,GAAGJ,kBAAkB,CAACP,UAAU,CAAC;MAC1D,IAAIW,mBAAmB,KAAKH,cAAc,EAAE;QACxC;AAChB;AACA;AACA;QACgB,IAAMI,IAAI,GAAGN,aAAa,CAACG,cAAc,GAAG,CAAC,CAAC;QAC9C,IAAIG,IAAI,IAAIA,IAAI,CAAC,CAAC,CAAC,KAAKhB,KAAK,EAAE;UAC3BU,aAAa,CAACO,MAAM,CAACJ,cAAc,GAAG,CAAC,EAAE,CAAC,CAAC;QAC/C,CAAC,MAAM;UACH,IAAMK,IAAI,GAAGR,aAAa,CAACG,cAAc,GAAG,CAAC,CAAC;UAC9C,IAAIK,IAAI,CAAC,CAAC,CAAC,KAAKlB,KAAK,EAAE;YACnBU,aAAa,CAACO,MAAM,CAACJ,cAAc,GAAG,CAAC,EAAE,CAAC,CAAC;UAC/C,CAAC,MAAM;YACH,MAAM,IAAAM,mBAAU,EAAC,KAAK,EAAE;cACpBhB,QAAQ;cACRiB,IAAI,EAAE;gBACFX;cACJ;YACJ,CAAC,CAAC;UACN;QACJ;MACJ,CAAC,MAAM;QACH;AAChB;AACA;QACgB,IAAMY,WAAW,GAAG,IAAAC,2BAAO,EACvBZ,aAAa,EACb,CACIK,mBAAmB,CACtB,EACDQ,oBACJ,CAAC;QACDb,aAAa,CAACO,MAAM,CAACI,WAAW,EAAE,CAAC,CAAC;MACxC;IACJ;EACJ;AACJ;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,iBAAiBA,CAC7BC,WAAmB,EACnBxB,KAAwC,EACxCC,YAAwD,EACxDwB,IAA+C,EACjD;EACE,IAAMC,UAAU,GAAGD,IAAI,CAAClB,MAAM;;EAE9B;EACA,IAAMH,SAAsC,GAAG,IAAIuB,KAAK,CAACD,UAAU,CAAC;EACpE,IAAME,MAAgB,GAAG,IAAID,KAAK,CAACD,UAAU,CAAC;EAC9C,KAAK,IAAIpB,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGoB,UAAU,EAAE,EAAEpB,CAAC,EAAE;IACjC,IAAMuB,GAAG,GAAGJ,IAAI,CAACnB,CAAC,CAAC,CAACJ,QAAQ;IAC5B,IAAMH,KAAa,GAAI8B,GAAG,CAASL,WAAW,CAAC;IAC/CpB,SAAS,CAACE,CAAC,CAAC,GAAGuB,GAAG;IAClBD,MAAM,CAACtB,CAAC,CAAC,GAAGP,KAAK;IACjBC,KAAK,CAACI,SAAS,CAACC,GAAG,CAACN,KAAK,EAAE8B,GAAU,CAAC;EAC1C;;EAEA;EACA,KAAK,IAAIC,MAAM,GAAG,CAAC,EAAEA,MAAM,GAAG7B,YAAY,CAACM,MAAM,EAAE,EAAEuB,MAAM,EAAE;IACzD,IAAMtB,OAAO,GAAGP,YAAY,CAAC6B,MAAM,CAAC;IACpC,IAAMrB,aAAa,GAAGD,OAAO,CAACC,aAAa;IAC3C,IAAMC,kBAAkB,GAAGF,OAAO,CAACE,kBAAkB;;IAErD;IACA,IAAMqB,UAA2C,GAAG,IAAIJ,KAAK,CAACD,UAAU,CAAC;IACzE,KAAK,IAAIpB,EAAC,GAAG,CAAC,EAAEA,EAAC,GAAGoB,UAAU,EAAE,EAAEpB,EAAC,EAAE;MACjC,IAAMuB,IAAG,GAAGzB,SAAS,CAACE,EAAC,CAAC;MACxByB,UAAU,CAACzB,EAAC,CAAC,GAAG,CACZI,kBAAkB,CAACmB,IAAU,CAAC,EAC9BA,IAAG,EACHD,MAAM,CAACtB,EAAC,CAAC,CACZ;IACL;;IAEA;IACAyB,UAAU,CAACC,IAAI,CAACrC,2BAA2B,CAAC;IAE5C,IAAIc,aAAa,CAACF,MAAM,KAAK,CAAC,EAAE;MAC5B;MACAC,OAAO,CAACC,aAAa,GAAGsB,UAAU;IACtC,CAAC,MAAM;MACH;MACAvB,OAAO,CAACC,aAAa,GAAGwB,iBAAiB,CAACxB,aAAa,EAAEsB,UAAU,EAAEpC,2BAA2B,CAAC;IACrG;EACJ;AACJ;;AAGA;AACA;AACA;AACA;AACA,SAASsC,iBAAiBA,CACtBrC,CAAM,EACNC,CAAM,EACNqC,UAAkC,EAC/B;EACH,IAAMC,IAAI,GAAGvC,CAAC,CAACW,MAAM;EACrB,IAAM6B,IAAI,GAAGvC,CAAC,CAACU,MAAM;EACrB,IAAM8B,MAAW,GAAG,IAAIV,KAAK,CAACQ,IAAI,GAAGC,IAAI,CAAC;EAC1C,IAAIE,EAAE,GAAG,CAAC;EACV,IAAIC,EAAE,GAAG,CAAC;EACV,IAAIC,EAAE,GAAG,CAAC;EAEV,OAAOF,EAAE,GAAGH,IAAI,IAAII,EAAE,GAAGH,IAAI,EAAE;IAC3B,IAAIF,UAAU,CAACtC,CAAC,CAAC0C,EAAE,CAAC,EAAEzC,CAAC,CAAC0C,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE;MAC/BF,MAAM,CAACG,EAAE,EAAE,CAAC,GAAG5C,CAAC,CAAC0C,EAAE,EAAE,CAAC;IAC1B,CAAC,MAAM;MACHD,MAAM,CAACG,EAAE,EAAE,CAAC,GAAG3C,CAAC,CAAC0C,EAAE,EAAE,CAAC;IAC1B;EACJ;EAEA,OAAOD,EAAE,GAAGH,IAAI,EAAE;IACdE,MAAM,CAACG,EAAE,EAAE,CAAC,GAAG5C,CAAC,CAAC0C,EAAE,EAAE,CAAC;EAC1B;EACA,OAAOC,EAAE,GAAGH,IAAI,EAAE;IACdC,MAAM,CAACG,EAAE,EAAE,CAAC,GAAG3C,CAAC,CAAC0C,EAAE,EAAE,CAAC;EAC1B;EAEA,OAAOF,MAAM;AACjB;AAEO,SAASI,kBAAkBA,CAC9BjB,WAAmB,EACnBlC,MAA+C,EAC/CU,KAAwC,EACxC6B,GAA8B,EAChC;EACE,IAAM9B,KAAa,GAAI8B,GAAG,CAASL,WAAW,CAAC;EAC/CxB,KAAK,CAACI,SAAS,CAACsC,MAAM,CAAC3C,KAAK,CAAC;EAE7B4C,MAAM,CAACC,MAAM,CAAC5C,KAAK,CAACQ,OAAO,CAAC,CAACqC,OAAO,CAACrC,OAAO,IAAI;IAC5C,IAAMC,aAAa,GAAGD,OAAO,CAACC,aAAa;IAC3C,IAAMqC,WAAW,GAAGtC,OAAO,CAACE,kBAAkB,CAACmB,GAAG,CAAC;IAEnD,IAAMkB,eAAe,GAAG,IAAA1B,2BAAO,EAC3BZ,aAAa,EACb,CACIqC,WAAW,CACd,EACDxB,oBACJ,CAAC;IACDb,aAAa,CAACO,MAAM,CAAC+B,eAAe,EAAE,CAAC,CAAC;EAC5C,CAAC,CAAC;AACN;AAGO,SAASzB,oBAAoBA,CAChC1B,CAAgC,EAChCC,CAAgC,EACtB;EACV,IAAMmD,YAAY,GAAGpD,CAAC,CAAC,CAAC,CAAC;EACzB,IAAMqD,YAAY,GAAGpD,CAAC,CAAC,CAAC,CAAC;EACzB,IAAImD,YAAY,GAAGC,YAAY,EAAE;IAC7B,OAAO,CAAC,CAAC;EACb,CAAC,MAAM,IAAID,YAAY,KAAKC,YAAY,EAAE;IACtC,OAAO,CAAC;EACZ,CAAC,MAAM;IACH,OAAO,CAAC;EACZ;AACJ","ignoreList":[]}

package/dist/cjs/plugins/storage-memory/memory-indexes.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addIndexesToInternalsState = addIndexesToInternalsState;
+exports.getMemoryIndexName = getMemoryIndexName;
+var _customIndex = require("../../custom-index.js");
+var _rxSchemaHelper = require("../../rx-schema-helper.js");
+var _index = require("../../plugins/utils/index.js");
+function addIndexesToInternalsState(state, schema) {
+  var primaryPath = (0, _rxSchemaHelper.getPrimaryFieldOfPrimaryKey)(schema.primaryKey);
+  var useIndexes = !schema.indexes ? [] : schema.indexes.map(row => (0, _index.toArray)(row));
+
+  // we need this index for running cleanup()
+  useIndexes.push(['_deleted', '_meta.lwt', primaryPath]);
+  useIndexes.forEach(indexAr => {
+    state.byIndex[getMemoryIndexName(indexAr)] = {
+      index: indexAr,
+      docsWithIndex: [],
+      getIndexableString: (0, _customIndex.getIndexableStringMonad)(schema, indexAr)
+    };
+  });
+}
+function getMemoryIndexName(index) {
+  return index.join(',');
+}
+//# sourceMappingURL=memory-indexes.js.map

package/dist/cjs/plugins/storage-memory/memory-indexes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-indexes.js","names":["_customIndex","require","_rxSchemaHelper","_index","addIndexesToInternalsState","state","schema","primaryPath","getPrimaryFieldOfPrimaryKey","primaryKey","useIndexes","indexes","map","row","toArray","push","forEach","indexAr","byIndex","getMemoryIndexName","index","docsWithIndex","getIndexableString","getIndexableStringMonad","join"],"sources":["../../../../src/plugins/storage-memory/memory-indexes.ts"],"sourcesContent":["import { getIndexableStringMonad } from '../../custom-index.ts';\r\nimport { getPrimaryFieldOfPrimaryKey } from '../../rx-schema-helper.ts';\r\nimport type { RxDocumentData, RxJsonSchema } from '../../types/index.d.ts';\r\nimport { toArray } from '../../plugins/utils/index.ts';\r\nimport type { MemoryStorageInternals } from './memory-types.ts';\r\n\r\nexport function addIndexesToInternalsState<RxDocType>(\r\n    state: MemoryStorageInternals<RxDocType>,\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>\r\n) {\r\n    const primaryPath = getPrimaryFieldOfPrimaryKey(schema.primaryKey);\r\n    const useIndexes: string[][] = !schema.indexes ? [] : schema.indexes.map(row => toArray(row)) as any;\r\n\r\n    // we need this index for running cleanup()\r\n    useIndexes.push([\r\n        '_deleted',\r\n        '_meta.lwt',\r\n        primaryPath\r\n    ]);\r\n\r\n\r\n    useIndexes.forEach(indexAr => {\r\n        state.byIndex[getMemoryIndexName(indexAr)] = {\r\n            index: indexAr,\r\n            docsWithIndex: [],\r\n            getIndexableString: getIndexableStringMonad(schema, indexAr)\r\n        };\r\n    });\r\n}\r\n\r\n\r\nexport function getMemoryIndexName(index: string[]): string {\r\n    return index.join(',');\r\n}\r\n"],"mappings":";;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,eAAA,GAAAD,OAAA;AAEA,IAAAE,MAAA,GAAAF,OAAA;AAGO,SAASG,0BAA0BA,CACtCC,KAAwC,EACxCC,MAA+C,EACjD;EACE,IAAMC,WAAW,GAAG,IAAAC,2CAA2B,EAACF,MAAM,CAACG,UAAU,CAAC;EAClE,IAAMC,UAAsB,GAAG,CAACJ,MAAM,CAACK,OAAO,GAAG,EAAE,GAAGL,MAAM,CAACK,OAAO,CAACC,GAAG,CAACC,GAAG,IAAI,IAAAC,cAAO,EAACD,GAAG,CAAC,CAAQ;;EAEpG;EACAH,UAAU,CAACK,IAAI,CAAC,CACZ,UAAU,EACV,WAAW,EACXR,WAAW,CACd,CAAC;EAGFG,UAAU,CAACM,OAAO,CAACC,OAAO,IAAI;IAC1BZ,KAAK,CAACa,OAAO,CAACC,kBAAkB,CAACF,OAAO,CAAC,CAAC,GAAG;MACzCG,KAAK,EAAEH,OAAO;MACdI,aAAa,EAAE,EAAE;MACjBC,kBAAkB,EAAE,IAAAC,oCAAuB,EAACjB,MAAM,EAAEW,OAAO;IAC/D,CAAC;EACL,CAAC,CAAC;AACN;AAGO,SAASE,kBAAkBA,CAACC,KAAe,EAAU;EACxD,OAAOA,KAAK,CAACI,IAAI,CAAC,GAAG,CAAC;AAC1B","ignoreList":[]}

package/dist/cjs/plugins/storage-memory/memory-types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=memory-types.js.map

package/dist/cjs/plugins/storage-memory/memory-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-types.js","names":[],"sources":["../../../../src/plugins/storage-memory/memory-types.ts"],"sourcesContent":["import { Subject } from 'rxjs';\r\nimport type {\r\n    CategorizeBulkWriteRowsOutput,\r\n    EventBulk,\r\n    RxAttachmentWriteData,\r\n    RxDocumentData,\r\n    RxJsonSchema,\r\n    RxStorage,\r\n    RxStorageChangeEvent,\r\n    RxStorageDefaultCheckpoint\r\n} from '../../types/index.d.ts';\r\n\r\nexport type RxStorageMemorySettings = {};\r\nexport type RxStorageMemoryInstanceCreationOptions = {};\r\nexport type RxStorageMemory = RxStorage<MemoryStorageInternals<any>, RxStorageMemoryInstanceCreationOptions> & {\r\n    /**\r\n     * State by collectionKey\r\n     */\r\n    collectionStates: Map<string, MemoryStorageInternals<any>>;\r\n};\r\n\r\nexport type MemoryStorageInternalsByIndex<RxDocType> = {\r\n    index: string[];\r\n    docsWithIndex: DocWithIndexString<RxDocType>[];\r\n    getIndexableString: (docData: RxDocumentData<RxDocType>) => string;\r\n};\r\n\r\n/**\r\n * The internals are shared between multiple storage instances\r\n * that have been created with the same [databaseName+collectionName] combination.\r\n */\r\nexport type MemoryStorageInternals<RxDocType> = {\r\n    // used to debug stuff and identify instances\r\n    id: string;\r\n\r\n    /**\r\n     * Schema of the first instance created with the given settings.\r\n     * Used to ensure that the same storage is not re-created with\r\n     * a different schema.\r\n     */\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>;\r\n\r\n    /**\r\n     * We reuse the memory state when multiple instances\r\n     * are created with the same params.\r\n     * If refCount becomes 0, we can delete the state.\r\n     */\r\n    refCount: number;\r\n    /**\r\n     * If this becomes true,\r\n     * it means that an instance has called remove()\r\n     * so all other instances should also not work anymore.\r\n     */\r\n    removed: boolean;\r\n    documents: Map<string, RxDocumentData<RxDocType>>;\r\n    /**\r\n     * Attachments data, indexed by a combined string\r\n     * consisting of [documentId + '||' + attachmentId]\r\n     */\r\n    attachments: Map<string, {\r\n        writeData: RxAttachmentWriteData;\r\n        digest: string;\r\n    }>;\r\n    byIndex: {\r\n        /**\r\n         * Because RxDB requires a deterministic sorting\r\n         * on all indexes, we can be sure that the composed index key\r\n         * of each document is unique, because it contains the primaryKey\r\n         * as last index part.\r\n         * So we do not have to store the index-position when we want to do fast\r\n         * writes. Instead we can do a binary search over the existing array\r\n         * because RxDB also knows the previous state of the document when we do a bulkWrite().\r\n         */\r\n        [indexName: string]: MemoryStorageInternalsByIndex<RxDocType>;\r\n    };\r\n\r\n    /**\r\n     * We need these to do lazy writes.\r\n     */\r\n    ensurePersistenceTask?: CategorizeBulkWriteRowsOutput<RxDocType>;\r\n    ensurePersistenceIdlePromise?: Promise<void>;\r\n\r\n    changes$: Subject<EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>>;\r\n};\r\n\r\nexport type DocWithIndexString<RxDocType> = [\r\n    string, // indexString, must be first because often we only need that one.\r\n    RxDocumentData<RxDocType>, // document\r\n    string, // id\r\n];\r\n"],"mappings":"","ignoreList":[]}