@connecttomahdi/rxdb 17.0.0-beta.17 → 17.1.0

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

@@ -4,25 +4,31 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.boundEQ = boundEQ;
+exports.boundEQByIndexString = boundEQByIndexString;
 exports.boundGE = boundGE;
+exports.boundGEByIndexString = boundGEByIndexString;
 exports.boundGT = boundGT;
+exports.boundGTByIndexString = boundGTByIndexString;
 exports.boundLE = boundLE;
+exports.boundLEByIndexString = boundLEByIndexString;
 exports.boundLT = boundLT;
+exports.boundLTByIndexString = boundLTByIndexString;
 /**
- * Everything in this file was copied and adapted from
- * @link https://github.com/mikolalysenko/binary-search-bounds
- *
- * We should use the original npm module instead when this bug is fixed:
- * @link https://github.com/mikolalysenko/binary-search-bounds/pull/14
+ * Optimized binary search functions for the memory storage.
+ * Based on https://github.com/mikolalysenko/binary-search-bounds
+ * but with performance improvements:
+ * - Removed unnecessary undefined checks for comparator
+ * - Inlined the norm() wrapper to avoid extra function calls
+ * - Added string-specialized variants to avoid temporary array allocations
  */
 
-function ge(a, y, c, l, h) {
+function boundGE(a, y, c, lo, hi) {
+  var l = lo === undefined ? 0 : lo | 0;
+  var h = hi === undefined ? a.length - 1 : hi | 0;
   var i = h + 1;
   while (l <= h) {
     var m = l + h >>> 1;
-    var x = a[m];
-    var p = c !== undefined ? c(x, y) : x - y;
-    if (p >= 0) {
+    if (c(a[m], y) >= 0) {
       i = m;
       h = m - 1;
     } else {
@@ -31,13 +37,13 @@ function ge(a, y, c, l, h) {
   }
   return i;
 }
-function gt(a, y, c, l, h) {
+function boundGT(a, y, c, lo, hi) {
+  var l = lo === undefined ? 0 : lo | 0;
+  var h = hi === undefined ? a.length - 1 : hi | 0;
   var i = h + 1;
   while (l <= h) {
     var m = l + h >>> 1;
-    var x = a[m];
-    var p = c !== undefined ? c(x, y) : x - y;
-    if (p > 0) {
+    if (c(a[m], y) > 0) {
       i = m;
       h = m - 1;
     } else {
@@ -46,13 +52,13 @@ function gt(a, y, c, l, h) {
   }
   return i;
 }
-function lt(a, y, c, l, h) {
+function boundLT(a, y, c, lo, hi) {
+  var l = lo === undefined ? 0 : lo | 0;
+  var h = hi === undefined ? a.length - 1 : hi | 0;
   var i = l - 1;
   while (l <= h) {
-    var m = l + h >>> 1,
-      x = a[m];
-    var p = c !== undefined ? c(x, y) : x - y;
-    if (p < 0) {
+    var m = l + h >>> 1;
+    if (c(a[m], y) < 0) {
       i = m;
       l = m + 1;
     } else {
@@ -61,13 +67,13 @@ function lt(a, y, c, l, h) {
   }
   return i;
 }
-function le(a, y, c, l, h) {
+function boundLE(a, y, c, lo, hi) {
+  var l = lo === undefined ? 0 : lo | 0;
+  var h = hi === undefined ? a.length - 1 : hi | 0;
   var i = l - 1;
   while (l <= h) {
-    var m = l + h >>> 1,
-      x = a[m];
-    var p = c !== undefined ? c(x, y) : x - y;
-    if (p <= 0) {
+    var m = l + h >>> 1;
+    if (c(a[m], y) <= 0) {
       i = m;
       l = m + 1;
     } else {
@@ -76,11 +82,12 @@ function le(a, y, c, l, h) {
   }
   return i;
 }
-function eq(a, y, c, l, h) {
+function boundEQ(a, y, c, lo, hi) {
+  var l = lo === undefined ? 0 : lo | 0;
+  var h = hi === undefined ? a.length - 1 : hi | 0;
   while (l <= h) {
-    var m = l + h >>> 1,
-      x = a[m];
-    var p = c !== undefined ? c(x, y) : x - y;
+    var m = l + h >>> 1;
+    var p = c(a[m], y);
     if (p === 0) {
       return m;
     }
@@ -92,22 +99,87 @@ function eq(a, y, c, l, h) {
   }
   return -1;
 }
-function norm(a, y, c, l, h, f) {
-  return f(a, y, c, l === undefined ? 0 : l | 0, h === undefined ? a.length - 1 : h | 0);
-}
-function boundGE(a, y, c, l, h) {
-  return norm(a, y, c, l, h, ge);
+
+/**
+ * Specialized binary search functions that compare DocWithIndexString
+ * entries directly against an index string, avoiding temporary array allocations.
+ * Used in query() and count() hot paths.
+ */
+function boundGEByIndexString(a, indexString) {
+  var l = 0;
+  var h = a.length - 1;
+  var i = h + 1;
+  while (l <= h) {
+    var m = l + h >>> 1;
+    if (a[m][0] >= indexString) {
+      i = m;
+      h = m - 1;
+    } else {
+      l = m + 1;
+    }
+  }
+  return i;
 }
-function boundGT(a, y, c, l, h) {
-  return norm(a, y, c, l, h, gt);
+function boundGTByIndexString(a, indexString) {
+  var l = 0;
+  var h = a.length - 1;
+  var i = h + 1;
+  while (l <= h) {
+    var m = l + h >>> 1;
+    if (a[m][0] > indexString) {
+      i = m;
+      h = m - 1;
+    } else {
+      l = m + 1;
+    }
+  }
+  return i;
 }
-function boundLT(a, y, c, l, h) {
-  return norm(a, y, c, l, h, lt);
+function boundEQByIndexString(a, indexString) {
+  var l = 0;
+  var h = a.length - 1;
+  while (l <= h) {
+    var m = l + h >>> 1;
+    var s = a[m][0];
+    if (s === indexString) {
+      return m;
+    }
+    if (s < indexString) {
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return -1;
 }
-function boundLE(a, y, c, l, h) {
-  return norm(a, y, c, l, h, le);
+function boundLTByIndexString(a, indexString) {
+  var l = 0;
+  var h = a.length - 1;
+  var i = l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1;
+    if (a[m][0] < indexString) {
+      i = m;
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return i;
 }
-function boundEQ(a, y, c, l, h) {
-  return norm(a, y, c, l, h, eq);
+function boundLEByIndexString(a, indexString) {
+  var l = 0;
+  var h = a.length - 1;
+  var i = l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1;
+    if (a[m][0] <= indexString) {
+      i = m;
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return i;
 }
 //# sourceMappingURL=binary-search-bounds.js.map

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

@@ -1 +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":";;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMA,SAASA,EAAEA,CAAIC,CAAM,EAAEC,CAAI,EAAEC,CAAa,EAAEC,CAAO,EAAEC,CAAO,EAAU;EAClE,IAAIC,CAAS,GAAGD,CAAC,GAAG,CAAC;EACrB,OAAOD,CAAC,IAAIC,CAAC,EAAE;IACX,IAAME,CAAC,GAAIH,CAAC,GAAGC,CAAC,KAAM,CAAC;IACvB,IAAMG,CAAM,GAAGP,CAAC,CAACM,CAAC,CAAC;IACnB,IAAME,CAAM,GAAIN,CAAC,KAAKO,SAAS,GAAIP,CAAC,CAACK,CAAC,EAAEN,CAAC,CAAC,GAAIM,CAAC,GAAIN,CAAU;IAC7D,IAAIO,CAAC,IAAI,CAAC,EAAE;MACRH,CAAC,GAAGC,CAAC;MAAEF,CAAC,GAAGE,CAAC,GAAG,CAAC;IACpB,CAAC,MAAM;MACHH,CAAC,GAAGG,CAAC,GAAG,CAAC;IACb;EACJ;EACA,OAAOD,CAAC;AACZ;AAEA,SAASK,EAAEA,CAAIV,CAAM,EAAEC,CAAI,EAAEC,CAAa,EAAEC,CAAO,EAAEC,CAAO,EAAU;EAClE,IAAIC,CAAC,GAAGD,CAAC,GAAG,CAAC;EACb,OAAOD,CAAC,IAAIC,CAAC,EAAE;IACX,IAAME,CAAC,GAAIH,CAAC,GAAGC,CAAC,KAAM,CAAC;IACvB,IAAMG,CAAC,GAAGP,CAAC,CAACM,CAAC,CAAC;IACd,IAAME,CAAM,GAAIN,CAAC,KAAKO,SAAS,GAAIP,CAAC,CAACK,CAAC,EAAEN,CAAC,CAAC,GAAKM,CAAC,GAAYN,CAAU;IACtE,IAAIO,CAAC,GAAG,CAAC,EAAE;MACPH,CAAC,GAAGC,CAAC;MAAEF,CAAC,GAAGE,CAAC,GAAG,CAAC;IACpB,CAAC,MAAM;MACHH,CAAC,GAAGG,CAAC,GAAG,CAAC;IACb;EACJ;EACA,OAAOD,CAAC;AACZ;AAEA,SAASM,EAAEA,CAAIX,CAAM,EAAEC,CAAI,EAAEC,CAAa,EAAEC,CAAO,EAAEC,CAAO,EAAU;EAClE,IAAIC,CAAC,GAAGF,CAAC,GAAG,CAAC;EACb,OAAOA,CAAC,IAAIC,CAAC,EAAE;IACX,IAAME,CAAC,GAAIH,CAAC,GAAGC,CAAC,KAAM,CAAC;MAAEG,CAAC,GAAGP,CAAC,CAACM,CAAC,CAAC;IACjC,IAAME,CAAM,GAAIN,CAAC,KAAKO,SAAS,GAAIP,CAAC,CAACK,CAAC,EAAEN,CAAC,CAAC,GAAKM,CAAC,GAAYN,CAAU;IACtE,IAAIO,CAAC,GAAG,CAAC,EAAE;MACPH,CAAC,GAAGC,CAAC;MAAEH,CAAC,GAAGG,CAAC,GAAG,CAAC;IACpB,CAAC,MAAM;MACHF,CAAC,GAAGE,CAAC,GAAG,CAAC;IACb;EACJ;EACA,OAAOD,CAAC;AACZ;AAEA,SAASO,EAAEA,CAAIZ,CAAM,EAAEC,CAAI,EAAEC,CAAa,EAAEC,CAAO,EAAEC,CAAO,EAAU;EAClE,IAAIC,CAAC,GAAGF,CAAC,GAAG,CAAC;EACb,OAAOA,CAAC,IAAIC,CAAC,EAAE;IACX,IAAME,CAAC,GAAIH,CAAC,GAAGC,CAAC,KAAM,CAAC;MAAEG,CAAC,GAAGP,CAAC,CAACM,CAAC,CAAC;IACjC,IAAME,CAAM,GAAIN,CAAC,KAAKO,SAAS,GAAIP,CAAC,CAACK,CAAC,EAAEN,CAAC,CAAC,GAAKM,CAAC,GAAYN,CAAU;IACtE,IAAIO,CAAC,IAAI,CAAC,EAAE;MACRH,CAAC,GAAGC,CAAC;MAAEH,CAAC,GAAGG,CAAC,GAAG,CAAC;IACpB,CAAC,MAAM;MACHF,CAAC,GAAGE,CAAC,GAAG,CAAC;IACb;EACJ;EACA,OAAOD,CAAC;AACZ;AAEA,SAASQ,EAAEA,CAAIb,CAAM,EAAEC,CAAI,EAAEC,CAAa,EAAEC,CAAO,EAAEC,CAAO,EAAU;EAClE,OAAOD,CAAC,IAAIC,CAAC,EAAE;IACX,IAAME,CAAC,GAAIH,CAAC,GAAGC,CAAC,KAAM,CAAC;MAAEG,CAAC,GAAGP,CAAC,CAACM,CAAC,CAAC;IACjC,IAAME,CAAM,GAAIN,CAAC,KAAKO,SAAS,GAAIP,CAAC,CAACK,CAAC,EAAEN,CAAC,CAAC,GAAKM,CAAC,GAAYN,CAAU;IACtE,IAAIO,CAAC,KAAK,CAAC,EAAE;MACT,OAAOF,CAAC;IACZ;IACA,IAAIE,CAAC,IAAI,CAAC,EAAE;MACRL,CAAC,GAAGG,CAAC,GAAG,CAAC;IACb,CAAC,MAAM;MACHF,CAAC,GAAGE,CAAC,GAAG,CAAC;IACb;EACJ;EACA,OAAO,CAAC,CAAC;AACb;AAEA,SAASQ,IAAIA,CAAId,CAAM,EAAEC,CAAI,EAAEC,CAAa,EAAEC,CAAM,EAAEC,CAAM,EAAEW,CAAM,EAAE;EAClE,OAAOA,CAAC,CAACf,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAGC,CAAC,KAAKM,SAAS,GAAI,CAAC,GAAGN,CAAC,GAAG,CAAC,EAAGC,CAAC,KAAKK,SAAS,GAAIT,CAAC,CAACgB,MAAM,GAAG,CAAC,GAAGZ,CAAC,GAAG,CAAC,CAAC;AAC9F;AAGO,SAASa,OAAOA,CAAIjB,CAAM,EAAEC,CAAI,EAAEC,CAAa,EAAEC,CAAO,EAAEC,CAAO,EAAE;EACtE,OAAOU,IAAI,CAACd,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEL,EAAE,CAAC;AAClC;AACO,SAASmB,OAAOA,CAAIlB,CAAM,EAAEC,CAAI,EAAEC,CAAa,EAAEC,CAAO,EAAEC,CAAO,EAAE;EACtE,OAAOU,IAAI,CAACd,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEM,EAAE,CAAC;AAClC;AACO,SAASS,OAAOA,CAAInB,CAAM,EAAEC,CAAI,EAAEC,CAAa,EAAEC,CAAO,EAAEC,CAAO,EAAE;EACtE,OAAOU,IAAI,CAACd,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEO,EAAE,CAAC;AAClC;AACO,SAASS,OAAOA,CAAIpB,CAAM,EAAEC,CAAI,EAAEC,CAAa,EAAEC,CAAO,EAAEC,CAAO,EAAE;EACtE,OAAOU,IAAI,CAACd,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEQ,EAAE,CAAC;AAClC;AACO,SAASS,OAAOA,CAAIrB,CAAM,EAAEC,CAAI,EAAEC,CAAa,EAAEC,CAAO,EAAEC,CAAO,EAAE;EACtE,OAAOU,IAAI,CAACd,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAES,EAAE,CAAC;AAClC","ignoreList":[]}
+{"version":3,"file":"binary-search-bounds.js","names":["boundGE","a","y","c","lo","hi","l","undefined","h","length","i","m","boundGT","boundLT","boundLE","boundEQ","p","boundGEByIndexString","indexString","boundGTByIndexString","boundEQByIndexString","s","boundLTByIndexString","boundLEByIndexString"],"sources":["../../../../src/plugins/storage-memory/binary-search-bounds.ts"],"sourcesContent":["/**\r\n * Optimized binary search functions for the memory storage.\r\n * Based on https://github.com/mikolalysenko/binary-search-bounds\r\n * but with performance improvements:\r\n * - Removed unnecessary undefined checks for comparator\r\n * - Inlined the norm() wrapper to avoid extra function calls\r\n * - Added string-specialized variants to avoid temporary array allocations\r\n */\r\n\r\ntype Compare<T> = ((a: T, b: T) => number | null | undefined);\r\n\r\nexport function boundGE<T>(a: T[], y: T, c: Compare<T>, lo?: any, hi?: any): number {\r\n    let l: number = lo === undefined ? 0 : lo | 0;\r\n    let h: number = hi === undefined ? a.length - 1 : hi | 0;\r\n    let i: number = h + 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1;\r\n        if ((c(a[m], y) as number) >= 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\nexport function boundGT<T>(a: T[], y: T, c: Compare<T>, lo?: any, hi?: any): number {\r\n    let l: number = lo === undefined ? 0 : lo | 0;\r\n    let h: number = hi === undefined ? a.length - 1 : hi | 0;\r\n    let i = h + 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1;\r\n        if ((c(a[m], y) as number) > 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\nexport function boundLT<T>(a: T[], y: T, c: Compare<T>, lo?: any, hi?: any): number {\r\n    let l: number = lo === undefined ? 0 : lo | 0;\r\n    let h: number = hi === undefined ? a.length - 1 : hi | 0;\r\n    let i = l - 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1;\r\n        if ((c(a[m], y) as number) < 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\nexport function boundLE<T>(a: T[], y: T, c: Compare<T>, lo?: any, hi?: any): number {\r\n    let l: number = lo === undefined ? 0 : lo | 0;\r\n    let h: number = hi === undefined ? a.length - 1 : hi | 0;\r\n    let i = l - 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1;\r\n        if ((c(a[m], y) as number) <= 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\nexport function boundEQ<T>(a: T[], y: T, c: Compare<T>, lo?: any, hi?: any): number {\r\n    let l: number = lo === undefined ? 0 : lo | 0;\r\n    let h: number = hi === undefined ? a.length - 1 : hi | 0;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1;\r\n        const p = c(a[m], y) as number;\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\n/**\r\n * Specialized binary search functions that compare DocWithIndexString\r\n * entries directly against an index string, avoiding temporary array allocations.\r\n * Used in query() and count() hot paths.\r\n */\r\nexport function boundGEByIndexString<T extends [string, ...any[]]>(a: T[], indexString: string): number {\r\n    let l = 0;\r\n    let h = a.length - 1;\r\n    let i: number = h + 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1;\r\n        if (a[m][0] >= indexString) {\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\nexport function boundGTByIndexString<T extends [string, ...any[]]>(a: T[], indexString: string): number {\r\n    let l = 0;\r\n    let h = a.length - 1;\r\n    let i = h + 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1;\r\n        if (a[m][0] > indexString) {\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\nexport function boundEQByIndexString<T extends [string, ...any[]]>(a: T[], indexString: string): number {\r\n    let l = 0;\r\n    let h = a.length - 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1;\r\n        const s = a[m][0];\r\n        if (s === indexString) {\r\n            return m;\r\n        }\r\n        if (s < indexString) {\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\nexport function boundLTByIndexString<T extends [string, ...any[]]>(a: T[], indexString: string): number {\r\n    let l = 0;\r\n    let h = a.length - 1;\r\n    let i = l - 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1;\r\n        if (a[m][0] < indexString) {\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\nexport function boundLEByIndexString<T extends [string, ...any[]]>(a: T[], indexString: string): number {\r\n    let l = 0;\r\n    let h = a.length - 1;\r\n    let i = l - 1;\r\n    while (l <= h) {\r\n        const m = (l + h) >>> 1;\r\n        if (a[m][0] <= indexString) {\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"],"mappings":"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","ignoreList":[]}

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

@@ -24,6 +24,14 @@ function ensureNotRemoved(instance) {
 function attachmentMapKey(documentId, attachmentId) {
   return documentId + '||' + attachmentId;
 }
+
+/**
+ * @performance
+ * Threshold for using in-place splice vs. full merge-sort when inserting
+ * documents into indexes. Below this batch size, in-place binary search + splice
+ * is faster because it avoids allocating a new full-size array and copying all elements.
+ */
+var IN_PLACE_INSERT_THRESHOLD = 64;
 function sortByIndexStringComparator(a, b) {
   if (a[0] < b[0]) {
     return -1;
@@ -37,29 +45,57 @@ function sortByIndexStringComparator(a, b) {
  */
 function putWriteRowToState(docId, state, stateByIndex, document, docInState) {
   state.documents.set(docId, document);
-  for (var i = 0; i < stateByIndex.length; ++i) {
+  var stateByIndexLength = stateByIndex.length;
+  for (var i = 0; i < stateByIndexLength; ++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
+     * @performance
+     * When updating a document, first compute whether the index changed.
+     * If it did not change, we only need to update the document reference
+     * in-place without any splice operations.
      */
     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.
+         * Index did not change, so the old entry is at the same position.
+         * We can find it by string-specialized binary search and update in-place.
          */
-        var prev = docsWithIndex[insertPosition - 1];
-        if (prev && prev[2] === docId) {
+        var eqPos = (0, _binarySearchBounds.boundEQByIndexString)(docsWithIndex, previousIndexString);
+        if (eqPos !== -1) {
+          /**
+           * There might be multiple entries with the same index string
+           * (e.g. different documents). Search around eqPos for ours.
+           */
+          if (docsWithIndex[eqPos][2] === docId) {
+            docsWithIndex[eqPos][1] = document;
+            continue;
+          }
+          // Check neighbors
+          var prev = docsWithIndex[eqPos - 1];
+          if (prev && prev[0] === previousIndexString && prev[2] === docId) {
+            docsWithIndex[eqPos - 1][1] = document;
+            continue;
+          }
+          var next = docsWithIndex[eqPos + 1];
+          if (next && next[0] === previousIndexString && next[2] === docId) {
+            docsWithIndex[eqPos + 1][1] = document;
+            continue;
+          }
+        }
+        // Fallback: use the old insert+remove approach
+        var insertPosition = (0, _arrayPushAtSortPosition.pushAtSortPosition)(docsWithIndex, [newIndexString, document, docId], sortByIndexStringComparator, 0);
+        var prevEntry = docsWithIndex[insertPosition - 1];
+        if (prevEntry && prevEntry[2] === docId) {
           docsWithIndex.splice(insertPosition - 1, 1);
         } else {
-          var next = docsWithIndex[insertPosition + 1];
-          if (next[2] === docId) {
+          var nextEntry = docsWithIndex[insertPosition + 1];
+          if (nextEntry[2] === docId) {
             docsWithIndex.splice(insertPosition + 1, 1);
           } else {
             throw (0, _rxError.newRxError)('SNH', {
@@ -70,26 +106,35 @@ function putWriteRowToState(docId, state, stateByIndex, document, docInState) {
             });
           }
         }
+        continue;
       } else {
         /**
-         * Index changed, we must search for the old one and remove it.
+         * Index changed, we must remove the old entry and insert the new one.
          */
-        var indexBefore = (0, _binarySearchBounds.boundEQ)(docsWithIndex, [previousIndexString], compareDocsWithIndex);
-        docsWithIndex.splice(indexBefore, 1);
+        var indexBefore = (0, _binarySearchBounds.boundEQByIndexString)(docsWithIndex, previousIndexString);
+        if (indexBefore !== -1) {
+          docsWithIndex.splice(indexBefore, 1);
+        }
       }
     }
+    (0, _arrayPushAtSortPosition.pushAtSortPosition)(docsWithIndex, [newIndexString, document, docId], sortByIndexStringComparator, 0);
   }
 }
 
 /**
  * @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)).
+ *
+ * Uses two strategies based on batch size:
+ * - For small batches (relative to existing index size), uses in-place
+ *   binary search + splice per document. This avoids allocating a new
+ *   full-size array and copying all elements, reducing GC pressure.
+ * - For large batches (or empty indexes), pre-computes all index entries,
+ *   sorts them, and merges into the existing sorted arrays in a single pass.
  */
 function bulkInsertToState(primaryPath, state, stateByIndex, docs) {
   var docsLength = docs.length;
+  var stateByIndexLength = stateByIndex.length;
 
   // Extract documents and docIds once, store in Map
   var documents = new Array(docsLength);
@@ -102,36 +147,74 @@ function bulkInsertToState(primaryPath, state, stateByIndex, docs) {
     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]];
+  /**
+   * @performance
+   * For small batch sizes, use in-place binary search + splice
+   * instead of creating a full merged array copy. This is faster
+   * for serial inserts and small bulk inserts because it avoids:
+   * - Allocating a new array of size n+m
+   * - Copying all n existing elements
+   * - GC pressure from discarding the old array
+   *
+   * The threshold is based on when the merge approach becomes more
+   * efficient than individual splices.
+   */
+  var useInPlaceInsert = docsLength < IN_PLACE_INSERT_THRESHOLD;
+  if (useInPlaceInsert) {
+    for (var indexI = 0; indexI < stateByIndexLength; ++indexI) {
+      var byIndex = stateByIndex[indexI];
+      var docsWithIndex = byIndex.docsWithIndex;
+      var getIndexableString = byIndex.getIndexableString;
+      if (docsWithIndex.length === 0) {
+        for (var _i = 0; _i < docsLength; ++_i) {
+          var _doc = documents[_i];
+          var indexString = getIndexableString(_doc);
+          docsWithIndex.push([indexString, _doc, docIds[_i]]);
+        }
+        docsWithIndex.sort(sortByIndexStringComparator);
+      } else {
+        for (var _i2 = 0; _i2 < docsLength; ++_i2) {
+          var _doc2 = documents[_i2];
+          var _indexString = getIndexableString(_doc2);
+          var newEntry = [_indexString, _doc2, docIds[_i2]];
+          (0, _arrayPushAtSortPosition.pushAtSortPosition)(docsWithIndex, newEntry, sortByIndexStringComparator, 0);
+        }
+      }
     }
+  } else {
+    // For each index, batch-compute entries, sort, and merge
+    for (var _indexI = 0; _indexI < stateByIndexLength; ++_indexI) {
+      var _byIndex = stateByIndex[_indexI];
+      var _docsWithIndex = _byIndex.docsWithIndex;
+      var _getIndexableString = _byIndex.getIndexableString;
 
-    // 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);
+      // Build new entries
+      var newEntries = new Array(docsLength);
+      for (var _i3 = 0; _i3 < docsLength; ++_i3) {
+        var _doc3 = documents[_i3];
+        newEntries[_i3] = [_getIndexableString(_doc3), _doc3, docIds[_i3]];
+      }
+
+      // 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);
+      }
     }
   }
 }
 
 /**
- * Merges two sorted arrays into a single sorted array.
+ * Merges two sorted DocWithIndexString arrays into a single sorted array.
  * Runs in O(n + m) where n and m are the lengths of the input arrays.
+ * @performance Comparator is inlined to avoid function call overhead
+ * per comparison, which is significant for large arrays.
  */
-function mergeSortedArrays(a, b, comparator) {
+function mergeSortedArrays(a, b) {
   var aLen = a.length;
   var bLen = b.length;
   var result = new Array(aLen + bLen);
@@ -139,7 +222,7 @@ function mergeSortedArrays(a, b, comparator) {
   var bi = 0;
   var ri = 0;
   while (ai < aLen && bi < bLen) {
-    if (comparator(a[ai], b[bi]) <= 0) {
+    if (a[ai][0] <= b[bi][0]) {
       result[ri++] = a[ai++];
     } else {
       result[ri++] = b[bi++];
@@ -156,12 +239,16 @@ function mergeSortedArrays(a, b, comparator) {
 function removeDocFromState(primaryPath, schema, state, doc) {
   var docId = doc[primaryPath];
   state.documents.delete(docId);
-  Object.values(state.byIndex).forEach(byIndex => {
+  var stateByIndex = state.byIndexArray;
+  for (var i = 0; i < stateByIndex.length; ++i) {
+    var byIndex = stateByIndex[i];
     var docsWithIndex = byIndex.docsWithIndex;
     var indexString = byIndex.getIndexableString(doc);
-    var positionInIndex = (0, _binarySearchBounds.boundEQ)(docsWithIndex, [indexString], compareDocsWithIndex);
-    docsWithIndex.splice(positionInIndex, 1);
-  });
+    var positionInIndex = (0, _binarySearchBounds.boundEQByIndexString)(docsWithIndex, indexString);
+    if (positionInIndex !== -1) {
+      docsWithIndex.splice(positionInIndex, 1);
+    }
+  }
 }
 function compareDocsWithIndex(a, b) {
   var indexStringA = a[0];

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

@@ -1 +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":[]}
+{"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","IN_PLACE_INSERT_THRESHOLD","sortByIndexStringComparator","a","b","putWriteRowToState","docId","state","stateByIndex","document","docInState","documents","set","stateByIndexLength","length","i","byIndex","docsWithIndex","getIndexableString","newIndexString","previousIndexString","eqPos","boundEQByIndexString","prev","next","insertPosition","pushAtSortPosition","prevEntry","splice","nextEntry","newRxError","args","indexBefore","bulkInsertToState","primaryPath","docs","docsLength","Array","docIds","doc","useInPlaceInsert","indexI","indexString","push","sort","newEntry","newEntries","mergeSortedArrays","aLen","bLen","result","ai","bi","ri","removeDocFromState","delete","byIndexArray","positionInIndex","compareDocsWithIndex","indexStringA","indexStringB"],"sources":["../../../../src/plugins/storage-memory/memory-helper.ts"],"sourcesContent":["import type {\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 { boundEQByIndexString } 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\n/**\r\n * @performance\r\n * Threshold for using in-place splice vs. full merge-sort when inserting\r\n * documents into indexes. Below this batch size, in-place binary search + splice\r\n * is faster because it avoids allocating a new full-size array and copying all elements.\r\n */\r\nconst IN_PLACE_INSERT_THRESHOLD = 64;\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    const stateByIndexLength = stateByIndex.length;\r\n    for (let i = 0; i < stateByIndexLength; ++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\r\n        /**\r\n         * @performance\r\n         * When updating a document, first compute whether the index changed.\r\n         * If it did not change, we only need to update the document reference\r\n         * in-place without any splice operations.\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                 * Index did not change, so the old entry is at the same position.\r\n                 * We can find it by string-specialized binary search and update in-place.\r\n                 */\r\n                const eqPos = boundEQByIndexString(\r\n                    docsWithIndex,\r\n                    previousIndexString\r\n                );\r\n                if (eqPos !== -1) {\r\n                    /**\r\n                     * There might be multiple entries with the same index string\r\n                     * (e.g. different documents). Search around eqPos for ours.\r\n                     */\r\n                    if (docsWithIndex[eqPos][2] === docId) {\r\n                        docsWithIndex[eqPos][1] = document;\r\n                        continue;\r\n                    }\r\n                    // Check neighbors\r\n                    const prev = docsWithIndex[eqPos - 1];\r\n                    if (prev && prev[0] === previousIndexString && prev[2] === docId) {\r\n                        docsWithIndex[eqPos - 1][1] = document;\r\n                        continue;\r\n                    }\r\n                    const next = docsWithIndex[eqPos + 1];\r\n                    if (next && next[0] === previousIndexString && next[2] === docId) {\r\n                        docsWithIndex[eqPos + 1][1] = document;\r\n                        continue;\r\n                    }\r\n                }\r\n                // Fallback: use the old insert+remove approach\r\n                const insertPosition = pushAtSortPosition(\r\n                    docsWithIndex,\r\n                    [newIndexString, document, docId],\r\n                    sortByIndexStringComparator,\r\n                    0\r\n                );\r\n                const prevEntry = docsWithIndex[insertPosition - 1];\r\n                if (prevEntry && prevEntry[2] === docId) {\r\n                    docsWithIndex.splice(insertPosition - 1, 1);\r\n                } else {\r\n                    const nextEntry = docsWithIndex[insertPosition + 1];\r\n                    if (nextEntry[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                continue;\r\n            } else {\r\n                /**\r\n                 * Index changed, we must remove the old entry and insert the new one.\r\n                 */\r\n                const indexBefore = boundEQByIndexString(\r\n                    docsWithIndex,\r\n                    previousIndexString\r\n                );\r\n                if (indexBefore !== -1) {\r\n                    docsWithIndex.splice(indexBefore, 1);\r\n                }\r\n            }\r\n        }\r\n\r\n        pushAtSortPosition(\r\n            docsWithIndex,\r\n            [newIndexString, document, docId],\r\n            sortByIndexStringComparator,\r\n            0\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 *\r\n * Uses two strategies based on batch size:\r\n * - For small batches (relative to existing index size), uses in-place\r\n *   binary search + splice per document. This avoids allocating a new\r\n *   full-size array and copying all elements, reducing GC pressure.\r\n * - For large batches (or empty indexes), pre-computes all index entries,\r\n *   sorts them, and merges into the existing sorted arrays in a single pass.\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    const stateByIndexLength = stateByIndex.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    /**\r\n     * @performance\r\n     * For small batch sizes, use in-place binary search + splice\r\n     * instead of creating a full merged array copy. This is faster\r\n     * for serial inserts and small bulk inserts because it avoids:\r\n     * - Allocating a new array of size n+m\r\n     * - Copying all n existing elements\r\n     * - GC pressure from discarding the old array\r\n     *\r\n     * The threshold is based on when the merge approach becomes more\r\n     * efficient than individual splices.\r\n     */\r\n    const useInPlaceInsert = docsLength < IN_PLACE_INSERT_THRESHOLD;\r\n\r\n    if (useInPlaceInsert) {\r\n        for (let indexI = 0; indexI < stateByIndexLength; ++indexI) {\r\n            const byIndex = stateByIndex[indexI];\r\n            const docsWithIndex = byIndex.docsWithIndex;\r\n            const getIndexableString = byIndex.getIndexableString;\r\n\r\n            if (docsWithIndex.length === 0) {\r\n                for (let i = 0; i < docsLength; ++i) {\r\n                    const doc = documents[i];\r\n                    const indexString = getIndexableString(doc as any);\r\n                    docsWithIndex.push([indexString, doc, docIds[i]]);\r\n                }\r\n                docsWithIndex.sort(sortByIndexStringComparator);\r\n            } else {\r\n                for (let i = 0; i < docsLength; ++i) {\r\n                    const doc = documents[i];\r\n                    const indexString = getIndexableString(doc as any);\r\n                    const newEntry: DocWithIndexString<RxDocType> = [indexString, doc, docIds[i]];\r\n                    pushAtSortPosition(\r\n                        docsWithIndex,\r\n                        newEntry,\r\n                        sortByIndexStringComparator,\r\n                        0\r\n                    );\r\n                }\r\n            }\r\n        }\r\n    } else {\r\n        // For each index, batch-compute entries, sort, and merge\r\n        for (let indexI = 0; indexI < stateByIndexLength; ++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);\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * Merges two sorted DocWithIndexString 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 * @performance Comparator is inlined to avoid function call overhead\r\n * per comparison, which is significant for large arrays.\r\n */\r\nfunction mergeSortedArrays<RxDocType>(\r\n    a: DocWithIndexString<RxDocType>[],\r\n    b: DocWithIndexString<RxDocType>[]\r\n): DocWithIndexString<RxDocType>[] {\r\n    const aLen = a.length;\r\n    const bLen = b.length;\r\n    const result: DocWithIndexString<RxDocType>[] = 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 (a[ai][0] <= 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    const stateByIndex = state.byIndexArray;\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 indexString = byIndex.getIndexableString(doc);\r\n\r\n        const positionInIndex = boundEQByIndexString(\r\n            docsWithIndex,\r\n            indexString\r\n        );\r\n        if (positionInIndex !== -1) {\r\n            docsWithIndex.splice(positionInIndex, 1);\r\n        }\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":"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","ignoreList":[]}

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

@@ -21,6 +21,7 @@ function addIndexesToInternalsState(state, schema) {
       getIndexableString: (0, _customIndex.getIndexableStringMonad)(schema, indexAr)
     };
   });
+  state.byIndexArray = Object.values(state.byIndex);
 }
 function getMemoryIndexName(index) {
   return index.join(',');

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

@@ -1 +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":[]}
+{"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","byIndexArray","Object","values","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    state.byIndexArray = Object.values(state.byIndex);\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;EACFZ,KAAK,CAACmB,YAAY,GAAGC,MAAM,CAACC,MAAM,CAACrB,KAAK,CAACa,OAAO,CAAC;AACrD;AAGO,SAASC,kBAAkBA,CAACC,KAAe,EAAU;EACxD,OAAOA,KAAK,CAACO,IAAI,CAAC,GAAG,CAAC;AAC1B","ignoreList":[]}

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

@@ -1 +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":[]}
+{"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     * Cached array of all MemoryStorageInternalsByIndex values.\r\n     * Avoids calling Object.values(byIndex) on every write operation.\r\n     */\r\n    byIndexArray: MemoryStorageInternalsByIndex<RxDocType>[];\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":[]}