npm - @rocicorp/zero - Versions diffs - 1.5.0-canary.4 → 1.6.0-canary.1 - Mend

@rocicorp/zero 1.5.0-canary.4 → 1.6.0-canary.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (165) hide show

package/out/replicache/src/btree/node.d.ts CHANGED Viewed

@@ -90,6 +90,7 @@ declare abstract class NodeImpl<Value> {
     readonly isMutable: boolean;
     constructor(entries: Array<Entry<Value>>, hash: Hash, isMutable: boolean);
     abstract set(key: string, value: FrozenJSONValue, entrySize: number, tree: BTreeWrite): Promise<NodeImpl<Value>>;
+    abstract putMany(entries: ReadonlyArray<Entry<FrozenJSONValue>>, tree: BTreeWrite): Promise<NodeImpl<Value>>;
     abstract del(key: string, tree: BTreeWrite): Promise<NodeImpl<Value> | DataNodeImpl>;
     maxKey(): string;
     getChildNodeSize(tree: BTreeRead): number;
@@ -100,6 +101,7 @@ export declare class DataNodeImpl extends NodeImpl<FrozenJSONValue> {
     #private;
     readonly level = 0;
     set(key: string, value: FrozenJSONValue, entrySize: number, tree: BTreeWrite): Promise<DataNodeImpl>;
+    putMany(entries: ReadonlyArray<Entry<FrozenJSONValue>>, tree: BTreeWrite): Promise<DataNodeImpl>;
     del(key: string, tree: BTreeWrite): Promise<DataNodeImpl>;
     keys(_tree: BTreeRead): AsyncGenerator<string, void>;
     entriesIter(_tree: BTreeRead): AsyncGenerator<Entry<FrozenJSONValue>, void>;
@@ -109,6 +111,7 @@ export declare class InternalNodeImpl extends NodeImpl<Hash> {
     readonly level: number;
     constructor(entries: Array<Entry<Hash>>, hash: Hash, level: number, isMutable: boolean);
     set(key: string, value: FrozenJSONValue, entrySize: number, tree: BTreeWrite): Promise<InternalNodeImpl>;
+    putMany(entries: ReadonlyArray<Entry<FrozenJSONValue>>, tree: BTreeWrite): Promise<InternalNodeImpl>;
     del(key: string, tree: BTreeWrite): Promise<InternalNodeImpl | DataNodeImpl>;
     keys(tree: BTreeRead): AsyncGenerator<string, void>;
     entriesIter(tree: BTreeRead): AsyncGenerator<Entry<FrozenJSONValue>, void>;

package/out/replicache/src/btree/node.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/btree/node.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AAEtD,OAAO,EAEL,KAAK,iBAAiB,EAEvB,MAAM,6BAA6B,CAAC;AAErC,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,SAAS,EAGf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAC,KAAK,IAAI,EAA2B,MAAM,YAAY,CAAC;AAC/D,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,YAAY,CAAC;AAE3C,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAEhD,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;AAE7E,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B;;GAEG;AACH,KAAK,QAAQ,CAAC,CAAC,IAAI,SAAS,CAC1B,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAC3D,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;AAE1C,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC,eAAe,CAAC,CAAC;AAEjD,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAChC,aAAa,EAAE,aAAa,GAC3B,QAAQ,CAAC,CAAC,CAAC,CAOb;AAED,MAAM,MAAM,IAAI,GAAG,QAAQ,GAAG,YAAY,CAAC;AAE3C;;;;;GAKG;AACH,MAAM,MAAM,IAAI,GAAG,SAAS,GAAG,WAAW,CAAC;AAE3C;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,SAAS,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS,qBAAqB,EAAE,CAAC;AAE5D,MAAM,MAAM,gBAAgB,CAAC,GAAG,EAAE,KAAK,GAAG,iBAAiB,IAAI;IAC7D,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAAC,GAAG,EAAE,KAAK,GAAG,iBAAiB,IAAI;IAC7D,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,mBAAmB,CAAC,GAAG,EAAE,KAAK,GAAG,iBAAiB,IAAI;IAChE,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;CAC1B,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,CAAC,GAAG,IACzB,gBAAgB,CAAC,GAAG,CAAC,GACrB,gBAAgB,CAAC,GAAG,CAAC,GACrB,mBAAmB,CAAC,GAAG,CAAC,CAAC;AAG7B,MAAM,MAAM,qBAAqB,CAAC,GAAG,GAAG,MAAM,EAAE,KAAK,GAAG,eAAe,IACnE,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,GAC5B,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,GAC5B,mBAAmB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;AAEpC;;;GAGG;AACH,wBAAsB,QAAQ,CAC5B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,SAAS,EACjB,gBAAgB,EAAE,IAAI,GACrB,OAAO,CAAC,YAAY,CAAC,CAgBvB;AAED,KAAK,mBAAmB,GAAG,SAAS,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;AAErD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,mBAAmB,GAC3B,MAAM,~~CAIR~~;~~AAED~~,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,MAAM,EACT,OAAO,EAAE,mBAAmB,EAC5B,GAAG,EAAE,MAAM,GACV,OAAO,CAET;AAED,wBAAgB,cAAc,CAC5B,CAAC,EAAE,OAAO,EACV,aAAa,EAAE,aAAa,EAC5B,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,GACjD,YAAY,GAAG,QAAQ,CAyBzB;AAmCD,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,YAAY,CAE/D;AAED,uBAAe,QAAQ,CAAC,KAAK;;IAC3B,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7B,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;gBAIhB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO;IAMxE,QAAQ,CAAC,GAAG,CACV,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAE3B,QAAQ,CAAC,GAAG,CACV,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,YAAY,CAAC;IAE1C,MAAM,IAAI,MAAM;IAKhB,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM;IAYzC,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,UAAU;CAMvC;AAED,wBAAgB,WAAW,CAAC,CAAC,EAC3B,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EACjB,aAAa,EAAE,aAAa,GAC3B,QAAQ,CAAC,CAAC,CAAC,CAEb;AAED,qBAAa,YAAa,SAAQ,QAAQ,CAAC,eAAe,CAAC;;IACzD,QAAQ,CAAC,KAAK,KAAK;IAEnB,GAAG,CACD,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,YAAY,CAAC;~~IA+BxB~~,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IAWlD,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC;IAMpD,WAAW,CAChB,KAAK,EAAE,SAAS,GACf,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,EAAE,IAAI,CAAC;CAKhD;AAkBD,qBAAa,gBAAiB,SAAQ,QAAQ,CAAC,IAAI,CAAC;;IAClD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAGrB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAC3B,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO;IAMd,GAAG,CACP,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,gBAAgB,CAAC;~~IA0GtB~~,GAAG,CACP,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,gBAAgB,GAAG,YAAY,CAAC;IAwCpC,IAAI,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC;IAOnD,WAAW,CAChB,IAAI,EAAE,SAAS,GACd,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,EAAE,IAAI,CAAC;IAO/C,WAAW,CACT,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,KAAK,CAAC,gBAAgB,GAAG,YAAY,CAAC,CAAC;IAQ5C,oBAAoB,CACxB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,gBAAgB,GAAG,YAAY,CAAC;CAwB5C;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,EACtC,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO,GACjB,YAAY,CAAC;AAChB,wBAAgB,WAAW,CACzB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAC3B,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO,GACjB,gBAAgB,CAAC;AACpB,wBAAgB,WAAW,CACzB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAC3D,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO,GACjB,YAAY,GAAG,gBAAgB,CAAC;AAiBnC,wBAAgB,cAAc,CAC5B,IAAI,EAAE,YAAY,GAAG,gBAAgB,GACpC,IAAI,IAAI,YAAY,CAEtB;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAEnB,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,EAChC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,GAC1B,CAAC,EAAE,CAuDL;AAED,eAAO,MAAM,aAAa,6BAIzB,CAAC;AACF,eAAO,MAAM,iBAAiB,cAAyC,CAAC;AAExE,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,EACvB,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GAC3C,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAKxB"}
1	+ {"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/btree/node.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AAEtD,OAAO,EAEL,KAAK,iBAAiB,EAEvB,MAAM,6BAA6B,CAAC;AAErC,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,SAAS,EAGf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAC,KAAK,IAAI,EAA2B,MAAM,YAAY,CAAC;AAC/D,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,YAAY,CAAC;AAE3C,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAEhD,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;AAE7E,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B;;GAEG;AACH,KAAK,QAAQ,CAAC,CAAC,IAAI,SAAS,CAC1B,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAC3D,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;AAE1C,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC,eAAe,CAAC,CAAC;AAEjD,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAChC,aAAa,EAAE,aAAa,GAC3B,QAAQ,CAAC,CAAC,CAAC,CAOb;AAED,MAAM,MAAM,IAAI,GAAG,QAAQ,GAAG,YAAY,CAAC;AAE3C;;;;;GAKG;AACH,MAAM,MAAM,IAAI,GAAG,SAAS,GAAG,WAAW,CAAC;AAE3C;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,SAAS,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS,qBAAqB,EAAE,CAAC;AAE5D,MAAM,MAAM,gBAAgB,CAAC,GAAG,EAAE,KAAK,GAAG,iBAAiB,IAAI;IAC7D,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAAC,GAAG,EAAE,KAAK,GAAG,iBAAiB,IAAI;IAC7D,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,mBAAmB,CAAC,GAAG,EAAE,KAAK,GAAG,iBAAiB,IAAI;IAChE,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;CAC1B,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,CAAC,GAAG,IACzB,gBAAgB,CAAC,GAAG,CAAC,GACrB,gBAAgB,CAAC,GAAG,CAAC,GACrB,mBAAmB,CAAC,GAAG,CAAC,CAAC;AAG7B,MAAM,MAAM,qBAAqB,CAAC,GAAG,GAAG,MAAM,EAAE,KAAK,GAAG,eAAe,IACnE,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,GAC5B,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,GAC5B,mBAAmB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;AAEpC;;;GAGG;AACH,wBAAsB,QAAQ,CAC5B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,SAAS,EACjB,gBAAgB,EAAE,IAAI,GACrB,OAAO,CAAC,YAAY,CAAC,CAgBvB;AAED,KAAK,mBAAmB,GAAG,SAAS,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;AAErD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,mBAAmB,GAC3B,MAAM,CAER;AAgBD,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,MAAM,EACT,OAAO,EAAE,mBAAmB,EAC5B,GAAG,EAAE,MAAM,GACV,OAAO,CAET;AAED,wBAAgB,cAAc,CAC5B,CAAC,EAAE,OAAO,EACV,aAAa,EAAE,aAAa,EAC5B,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,GACjD,YAAY,GAAG,QAAQ,CAyBzB;AAmCD,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,YAAY,CAE/D;AAED,uBAAe,QAAQ,CAAC,KAAK;;IAC3B,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7B,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;gBAIhB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO;IAMxE,QAAQ,CAAC,GAAG,CACV,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAE3B,QAAQ,CAAC,OAAO,CACd,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,EAC9C,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAE3B,QAAQ,CAAC,GAAG,CACV,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,YAAY,CAAC;IAE1C,MAAM,IAAI,MAAM;IAKhB,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM;IAYzC,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,UAAU;CAMvC;AAED,wBAAgB,WAAW,CAAC,CAAC,EAC3B,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EACjB,aAAa,EAAE,aAAa,GAC3B,QAAQ,CAAC,CAAC,CAAC,CAEb;AAED,qBAAa,YAAa,SAAQ,QAAQ,CAAC,eAAe,CAAC;;IACzD,QAAQ,CAAC,KAAK,KAAK;IAEnB,GAAG,CACD,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,YAAY,CAAC;IAexB,OAAO,CACL,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,EAC9C,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,YAAY,CAAC;IAgExB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IAWlD,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC;IAMpD,WAAW,CAChB,KAAK,EAAE,SAAS,GACf,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,EAAE,IAAI,CAAC;CAKhD;AAkBD,qBAAa,gBAAiB,SAAQ,QAAQ,CAAC,IAAI,CAAC;;IAClD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAGrB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAC3B,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO;IAMd,GAAG,CACP,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,gBAAgB,CAAC;IAwBtB,OAAO,CACX,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,EAC9C,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,gBAAgB,CAAC;IA0NtB,GAAG,CACP,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,gBAAgB,GAAG,YAAY,CAAC;IAwCpC,IAAI,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC;IAOnD,WAAW,CAChB,IAAI,EAAE,SAAS,GACd,cAAc,CAAC,KAAK,CAAC,eAAe,CAAC,EAAE,IAAI,CAAC;IAO/C,WAAW,CACT,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,KAAK,CAAC,gBAAgB,GAAG,YAAY,CAAC,CAAC;IAQ5C,oBAAoB,CACxB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,gBAAgB,GAAG,YAAY,CAAC;CAwB5C;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,EACtC,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO,GACjB,YAAY,CAAC;AAChB,wBAAgB,WAAW,CACzB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAC3B,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO,GACjB,gBAAgB,CAAC;AACpB,wBAAgB,WAAW,CACzB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAC3D,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,OAAO,GACjB,YAAY,GAAG,gBAAgB,CAAC;AAiBnC,wBAAgB,cAAc,CAC5B,IAAI,EAAE,YAAY,GAAG,gBAAgB,GACpC,IAAI,IAAI,YAAY,CAEtB;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAEnB,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,EAChC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,GAC1B,CAAC,EAAE,CAuDL;AAED,eAAO,MAAM,aAAa,6BAIzB,CAAC;AACF,eAAO,MAAM,iBAAiB,cAAyC,CAAC;AAExE,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,EACvB,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,GAC3C,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAKxB"}

package/out/replicache/src/btree/node.js CHANGED Viewed

@@ -34,7 +34,13 @@ async function findLeaf(key, hash, source, expectedRootHash) {
 * be inserted at
 */
 function binarySearch(key, entries) {
-	return binarySearch$1(entries.length, (i) => compareUTF8(key, entries[i][0]));
+	return binarySearchFrom(key, entries, 0);
+}
+/**
+* Binary search starting from a given index.
+*/
+function binarySearchFrom(key, entries, start) {
+	return start + binarySearch$1(entries.length - start, (i) => compareUTF8(key, entries[start + i][0]));
 }
 function binarySearchFound(i, entries, key) {
 	return i !== entries.length && entries[i][0] === key;
@@ -117,6 +123,42 @@ var DataNodeImpl = class extends NodeImpl {
 			entrySize
 		]));
 	}
+	putMany(entries, tree) {
+		if (entries.length === 0) return Promise.resolve(this);
+		const merged = [];
+		let i = 0;
+		let j = 0;
+		while (i < this.entries.length && j < entries.length) {
+			const existingEntry = this.entries[i];
+			const newEntry = entries[j];
+			const cmp = compareUTF8(existingEntry[0], newEntry[0]);
+			if (cmp < 0) {
+				merged.push(existingEntry);
+				i++;
+			} else if (cmp > 0) {
+				merged.push(newEntry);
+				j++;
+			} else {
+				merged.push(newEntry);
+				i++;
+				j++;
+			}
+		}
+		while (i < this.entries.length) {
+			merged.push(this.entries[i]);
+			i++;
+		}
+		while (j < entries.length) {
+			merged.push(entries[j]);
+			j++;
+		}
+		if (this.isMutable) {
+			this.entries = merged;
+			this._updateNode(tree);
+			return Promise.resolve(this);
+		}
+		return Promise.resolve(tree.newDataNodeImpl(merged));
+	}
 	#splice(tree, start, deleteCount, ...items) {
 		if (this.isMutable) {
 			this.entries.splice(start, deleteCount, ...items);
@@ -160,6 +202,77 @@ var InternalNodeImpl = class InternalNodeImpl extends NodeImpl {
 		const newEntry = createNewInternalEntryForNode(childNode, tree.getEntrySize);
 		return this.#replaceChild(tree, i, newEntry);
 	}
+	async putMany(entries, tree) {
+		if (entries.length === 0) return this;
+		const childGroups = /* @__PURE__ */ new Map();
+		let searchStart = 0;
+		for (const entry of entries) {
+			const key = entry[0];
+			let i = binarySearchFrom(key, this.entries, searchStart);
+			if (i === this.entries.length) i--;
+			searchStart = i;
+			let group = childGroups.get(i);
+			if (!group) {
+				group = [];
+				childGroups.set(i, group);
+			}
+			group.push(entry);
+		}
+		const newEntries = [...this.entries];
+		const childrenToRebalance = [];
+		for (const [childIndex, childEntries] of childGroups) {
+			const childHash = this.entries[childIndex][1];
+			const childNode = await (await tree.getNode(childHash)).putMany(childEntries, tree);
+			const childNodeSize = childNode.getChildNodeSize(tree);
+			if (childNodeSize > tree.maxSize || childNodeSize < tree.minSize) childrenToRebalance.push({
+				index: childIndex,
+				node: childNode
+			});
+			else newEntries[childIndex] = createNewInternalEntryForNode(childNode, tree.getEntrySize);
+		}
+		if (childrenToRebalance.length > 0) {
+			childrenToRebalance.sort((a, b) => a.index - b.index);
+			const groups = [];
+			for (const { index, node } of childrenToRebalance) {
+				const lastGroup = groups.at(-1);
+				if (lastGroup && index <= lastGroup.maxIndex + 1) {
+					lastGroup.nodes.set(index, node);
+					lastGroup.maxIndex = index;
+				} else groups.push({
+					nodes: new Map([[index, node]]),
+					minIndex: index,
+					maxIndex: index
+				});
+			}
+			for (let g = groups.length - 1; g >= 0; g--) {
+				const group = groups[g];
+				const startIndex = Math.max(0, group.minIndex - 1);
+				const endIndex = Math.min(newEntries.length - 1, group.maxIndex + 1);
+				const removeCount = endIndex - startIndex + 1;
+				const allValues = [];
+				for (let idx = startIndex; idx <= endIndex; idx++) {
+					const rebalancedNode = group.nodes.get(idx);
+					if (rebalancedNode) allValues.push(rebalancedNode.entries);
+					else {
+						const hash = newEntries[idx][1];
+						const existingNode = await tree.getNode(hash);
+						allValues.push(existingNode.entries);
+					}
+				}
+				const level = this.level - 1;
+				const rebalanced = partition(joinIterables(...allValues), (e) => e[2], tree.minSize - tree.chunkHeaderSize, tree.maxSize - tree.chunkHeaderSize, (entries) => {
+					return createNewInternalEntryForNode(tree.newNodeImpl(entries, level), tree.getEntrySize);
+				});
+				newEntries.splice(startIndex, removeCount, ...rebalanced);
+			}
+		}
+		if (this.isMutable) {
+			this.entries = newEntries;
+			this._updateNode(tree);
+			return this;
+		}
+		return tree.newInternalNodeImpl(newEntries, this.level);
+	}
 	/**
 	* This merges the child node entries with previous or next sibling and then
 	* partitions the merged entries.

package/out/replicache/src/btree/node.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"node.js","names":["#childNodeSize","#splice","#mergeAndPartition","#replaceChild"],"sources":["../../../../../replicache/src/btree/node.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport {\n assert,\n assertArray,\n assertNumber,\n assertString,\n} from '../../../shared/src/asserts.ts';\nimport {binarySearch as binarySearchWithFunc} from '../../../shared/src/binary-search.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {joinIterables} from '../../../shared/src/iterables.ts';\nimport {\n type JSONValue,\n type ReadonlyJSONValue,\n assertJSONValue,\n} from '../../../shared/src/json.ts';\nimport {skipBTreeNodeAsserts} from '../config.ts';\nimport type {IndexKey} from '../db/index.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport {\n type FrozenJSONValue,\n type FrozenTag,\n assertDeepFrozen,\n deepFreeze,\n} from '../frozen-json.ts';\nimport {type Hash, emptyHash, newRandomHash} from '../hash.ts';\nimport type {BTreeRead} from './read.ts';\nimport type {BTreeWrite} from './write.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport type Entry<V> = readonly [key: string, value: V, sizeOfEntry: number];\n\nexport const NODE_LEVEL = 0;\nexport const NODE_ENTRIES = 1;\n\n/*\n The type of B+Tree node chunk data\n /\ntype BaseNode<V> = FrozenTag<\n readonly [level: number, entries: ReadonlyArray<Entry<V>>]\n>;\nexport type InternalNode = BaseNode<Hash>;\n\nexport type DataNode = BaseNode<FrozenJSONValue>;\n\nexport function makeNodeChunkData<V>(\n level: number,\n entries: ReadonlyArray<Entry<V>>,\n formatVersion: FormatVersion,\n): BaseNode<V> {\n return deepFreeze([\n level,\n (formatVersion >= FormatVersion.V7\n ? entries\n : entries.map(e => e.slice(0, 2))) as readonly ReadonlyJSONValue[],\n ]) as BaseNode<V>;\n}\n\nexport type Node = DataNode \| InternalNode;\n\n/\n Describes the changes that happened to Replicache after a\n * {@link WriteTransaction} was committed.\n \n @experimental This type is experimental and may change in the future.\n /\nexport type Diff = IndexDiff \| NoIndexDiff;\n\n/\n @experimental This type is experimental and may change in the future.\n /\nexport type IndexDiff = readonly DiffOperation<IndexKey>[];\n\n/\n @experimental This type is experimental and may change in the future.\n /\nexport type NoIndexDiff = readonly DiffOperation<string>[];\n\n/\n InternalDiff uses string keys even for the secondary index maps.\n /\nexport type InternalDiff = readonly InternalDiffOperation[];\n\nexport type DiffOperationAdd<Key, Value = ReadonlyJSONValue> = {\n readonly op: 'add';\n readonly key: Key;\n readonly newValue: Value;\n};\n\nexport type DiffOperationDel<Key, Value = ReadonlyJSONValue> = {\n readonly op: 'del';\n readonly key: Key;\n readonly oldValue: Value;\n};\n\nexport type DiffOperationChange<Key, Value = ReadonlyJSONValue> = {\n readonly op: 'change';\n readonly key: Key;\n readonly oldValue: Value;\n readonly newValue: Value;\n};\n\n/\n The individual parts describing the changes that happened to the Replicache\n * data. There are three different kinds of operations:\n * - `add`: A new entry was added.\n * - `del`: An entry was deleted.\n * - `change`: An entry was changed.\n \n @experimental This type is experimental and may change in the future.\n /\nexport type DiffOperation<Key> =\n \| DiffOperationAdd<Key>\n \| DiffOperationDel<Key>\n \| DiffOperationChange<Key>;\n\n// Duplicated with DiffOperation to make the docs less confusing.\nexport type InternalDiffOperation<Key = string, Value = FrozenJSONValue> =\n \| DiffOperationAdd<Key, Value>\n \| DiffOperationDel<Key, Value>\n \| DiffOperationChange<Key, Value>;\n\n/\n Finds the leaf where a key is (if present) or where it should go if not\n * present.\n /\nexport async function findLeaf(\n key: string,\n hash: Hash,\n source: BTreeRead,\n expectedRootHash: Hash,\n): Promise<DataNodeImpl> {\n const node = await source.getNode(hash);\n // The root changed. Try again\n if (expectedRootHash !== source.rootHash) {\n return findLeaf(key, source.rootHash, source, source.rootHash);\n }\n if (isDataNodeImpl(node)) {\n return node;\n }\n const {entries} = node;\n let i = binarySearch(key, entries);\n if (i === entries.length) {\n i--;\n }\n const entry = entries[i];\n return findLeaf(key, entry[1], source, expectedRootHash);\n}\n\ntype BinarySearchEntries = readonly Entry<unknown>[];\n\n/\n Does a binary search over entries\n \n If the key found then the return value is the index it was found at.\n \n If the key was not found then the return value is the index where it should\n * be inserted at\n /\nexport function binarySearch(\n key: string,\n entries: BinarySearchEntries,\n): number {\n return binarySearchWithFunc(entries.length, i =>\n compareUTF8(key, entries[i][0]),\n );\n}\n\nexport function binarySearchFound(\n i: number,\n entries: BinarySearchEntries,\n key: string,\n): boolean {\n return i !== entries.length && entries[i][0] === key;\n}\n\nexport function parseBTreeNode(\n v: unknown,\n formatVersion: FormatVersion,\n getSizeOfEntry: <K, V>(key: K, value: V) => number,\n): InternalNode \| DataNode {\n if (skipBTreeNodeAsserts && formatVersion >= FormatVersion.V7) {\n return v as InternalNode \| DataNode;\n }\n\n assertArray(v);\n assertDeepFrozen(v);\n // Be relaxed about what we accept.\n assert(v.length >= 2, 'Expected node array to have at least 2 elements');\n const [level, entries] = v;\n assertNumber(level);\n assertArray(entries);\n\n const f = level > 0 ? assertString : assertJSONValue;\n\n // For V7 we do not need to change the entries. Just assert that they are correct.\n if (formatVersion >= FormatVersion.V7) {\n for (const e of entries) {\n assertEntry(e, f);\n }\n return v as unknown as InternalNode \| DataNode;\n }\n\n const newEntries = entries.map(e => convertNonV7Entry(e, f, getSizeOfEntry));\n return [level, newEntries] as unknown as InternalNode \| DataNode;\n}\n\nfunction assertEntry(\n entry: unknown,\n f:\n \| ((v: unknown) => asserts v is Hash)\n \| ((v: unknown) => asserts v is JSONValue),\n): asserts entry is Entry<Hash \| JSONValue> {\n assertArray(entry);\n // Be relaxed about what we accept.\n assert(entry.length >= 3, 'Expected entry array to have at least 3 elements');\n assertString(entry[0]);\n f(entry[1]);\n assertNumber(entry[2]);\n}\n\n/\n Converts an entry that was from a format version before V7 to the format\n * wanted by V7.\n /\nfunction convertNonV7Entry(\n entry: unknown,\n f:\n \| ((v: unknown) => asserts v is Hash)\n \| ((v: unknown) => asserts v is JSONValue),\n getSizeOfEntry: <K, V>(key: K, value: V) => number,\n): Entry<Hash \| JSONValue> {\n assertArray(entry);\n assert(entry.length >= 2, 'Expected entry array to have at least 2 elements');\n assertString(entry[0]);\n f(entry[1]);\n const entrySize = getSizeOfEntry(entry[0], entry[1]);\n return [entry[0], entry[1], entrySize] as Entry<Hash \| JSONValue>;\n}\n\nexport function isInternalNode(node: Node): node is InternalNode {\n return node[NODE_LEVEL] > 0;\n}\n\nabstract class NodeImpl<Value> {\n entries: Array<Entry<Value>>;\n hash: Hash;\n abstract readonly level: number;\n readonly isMutable: boolean;\n\n #childNodeSize = -1;\n\n constructor(entries: Array<Entry<Value>>, hash: Hash, isMutable: boolean) {\n this.entries = entries;\n this.hash = hash;\n this.isMutable = isMutable;\n }\n\n abstract set(\n key: string,\n value: FrozenJSONValue,\n entrySize: number,\n tree: BTreeWrite,\n ): Promise<NodeImpl<Value>>;\n\n abstract del(\n key: string,\n tree: BTreeWrite,\n ): Promise<NodeImpl<Value> \| DataNodeImpl>;\n\n maxKey(): string {\n // oxlint-disable-next-line typescript/no-non-null-assertion\n return this.entries.at(-1)![0];\n }\n\n getChildNodeSize(tree: BTreeRead): number {\n if (this.#childNodeSize !== -1) {\n return this.#childNodeSize;\n }\n\n let sum = tree.chunkHeaderSize;\n for (const entry of this.entries) {\n sum += entry[2];\n }\n return (this.#childNodeSize = sum);\n }\n\n protected _updateNode(tree: BTreeWrite) {\n this.#childNodeSize = -1;\n tree.updateNode(\n this as NodeImpl<unknown> as DataNodeImpl \| InternalNodeImpl,\n );\n }\n}\n\nexport function toChunkData<V>(\n node: NodeImpl<V>,\n formatVersion: FormatVersion,\n): BaseNode<V> {\n return makeNodeChunkData(node.level, node.entries, formatVersion);\n}\n\nexport class DataNodeImpl extends NodeImpl<FrozenJSONValue> {\n readonly level = 0;\n\n set(\n key: string,\n value: FrozenJSONValue,\n entrySize: number,\n tree: BTreeWrite,\n ): Promise<DataNodeImpl> {\n let deleteCount: number;\n const i = binarySearch(key, this.entries);\n if (!binarySearchFound(i, this.entries, key)) {\n // Not found, insert.\n deleteCount = 0;\n } else {\n deleteCount = 1;\n }\n\n return Promise.resolve(\n this.#splice(tree, i, deleteCount, [key, value, entrySize]),\n );\n }\n\n #splice(\n tree: BTreeWrite,\n start: number,\n deleteCount: number,\n ...items: Entry<FrozenJSONValue>[]\n ): DataNodeImpl {\n if (this.isMutable) {\n this.entries.splice(start, deleteCount, ...items);\n this._updateNode(tree);\n return this;\n }\n\n const entries = readonlySplice(this.entries, start, deleteCount, ...items);\n return tree.newDataNodeImpl(entries);\n }\n\n del(key: string, tree: BTreeWrite): Promise<DataNodeImpl> {\n const i = binarySearch(key, this.entries);\n if (!binarySearchFound(i, this.entries, key)) {\n // Not found. Return this without changes.\n return Promise.resolve(this);\n }\n\n // Found. Create new node or mutate existing one.\n return Promise.resolve(this.#splice(tree, i, 1));\n }\n\n async keys(_tree: BTreeRead): AsyncGenerator<string, void> {\n for (const entry of this.entries) {\n yield entry[0];\n }\n }\n\n async entriesIter(\n _tree: BTreeRead,\n ): AsyncGenerator<Entry<FrozenJSONValue>, void> {\n for (const entry of this.entries) {\n yield entry;\n }\n }\n}\n\nfunction readonlySplice<T>(\n array: ReadonlyArray<T>,\n start: number,\n deleteCount: number,\n ...items: T[]\n): T[] {\n const arr = array.slice(0, start);\n for (let i = 0; i < items.length; i++) {\n arr.push(items[i]);\n }\n for (let i = start + deleteCount; i < array.length; i++) {\n arr.push(array[i]);\n }\n return arr;\n}\n\nexport class InternalNodeImpl extends NodeImpl<Hash> {\n readonly level: number;\n\n constructor(\n entries: Array<Entry<Hash>>,\n hash: Hash,\n level: number,\n isMutable: boolean,\n ) {\n super(entries, hash, isMutable);\n this.level = level;\n }\n\n async set(\n key: string,\n value: FrozenJSONValue,\n entrySize: number,\n tree: BTreeWrite,\n ): Promise<InternalNodeImpl> {\n let i = binarySearch(key, this.entries);\n if (i === this.entries.length) {\n // We are going to insert into last (right most) leaf.\n i--;\n }\n\n const childHash = this.entries[i][1];\n const oldChildNode = await tree.getNode(childHash);\n\n const childNode = await oldChildNode.set(key, value, entrySize, tree);\n\n const childNodeSize = childNode.getChildNodeSize(tree);\n if (childNodeSize > tree.maxSize \|\| childNodeSize < tree.minSize) {\n return this.#mergeAndPartition(tree, i, childNode);\n }\n\n const newEntry = createNewInternalEntryForNode(\n childNode,\n tree.getEntrySize,\n );\n return this.#replaceChild(tree, i, newEntry);\n }\n\n /\n This merges the child node entries with previous or next sibling and then\n * partitions the merged entries.\n /\n async #mergeAndPartition(\n tree: BTreeWrite,\n i: number,\n childNode: DataNodeImpl \| InternalNodeImpl,\n ): Promise<InternalNodeImpl> {\n const level = this.level - 1;\n const thisEntries = this.entries;\n\n type IterableHashEntries = Iterable<Entry<Hash>>;\n\n let values: IterableHashEntries;\n let startIndex: number;\n let removeCount: number;\n if (i > 0) {\n const hash = thisEntries[i - 1][1];\n const previousSibling = await tree.getNode(hash);\n values = joinIterables(\n previousSibling.entries as IterableHashEntries,\n childNode.entries as IterableHashEntries,\n );\n startIndex = i - 1;\n removeCount = 2;\n } else if (i < thisEntries.length - 1) {\n const hash = thisEntries[i + 1][1];\n const nextSibling = await tree.getNode(hash);\n values = joinIterables(\n childNode.entries as IterableHashEntries,\n nextSibling.entries as IterableHashEntries,\n );\n startIndex = i;\n removeCount = 2;\n } else {\n values = childNode.entries as IterableHashEntries;\n startIndex = i;\n removeCount = 1;\n }\n\n const newEntries = partition(\n values,\n value => value[2],\n tree.minSize - tree.chunkHeaderSize,\n tree.maxSize - tree.chunkHeaderSize,\n entries => {\n const node = tree.newNodeImpl(entries, level);\n return createNewInternalEntryForNode(node, tree.getEntrySize);\n },\n );\n\n if (this.isMutable) {\n this.entries.splice(startIndex, removeCount, ...newEntries);\n this._updateNode(tree);\n return this;\n }\n\n const entries = readonlySplice(\n thisEntries,\n startIndex,\n removeCount,\n ...newEntries,\n );\n\n return tree.newInternalNodeImpl(entries, this.level);\n }\n\n #replaceChild(\n tree: BTreeWrite,\n index: number,\n newEntry: Entry<Hash>,\n ): InternalNodeImpl {\n if (this.isMutable) {\n this.entries.splice(index, 1, newEntry);\n this._updateNode(tree);\n return this;\n }\n const entries = readonlySplice(this.entries, index, 1, newEntry);\n return tree.newInternalNodeImpl(entries, this.level);\n }\n\n async del(\n key: string,\n tree: BTreeWrite,\n ): Promise<InternalNodeImpl \| DataNodeImpl> {\n const i = binarySearch(key, this.entries);\n if (i === this.entries.length) {\n // Key is larger than maxKey of rightmost entry so it is not present.\n return this;\n }\n\n const childHash = this.entries[i][1];\n const oldChildNode = await tree.getNode(childHash);\n const oldHash = oldChildNode.hash;\n\n const childNode = await oldChildNode.del(key, tree);\n if (childNode.hash === oldHash) {\n // Not changed so not found.\n return this;\n }\n\n if (childNode.entries.length === 0) {\n // Subtree is now empty. Remove internal node.\n const entries = readonlySplice(this.entries, i, 1);\n return tree.newInternalNodeImpl(entries, this.level);\n }\n\n if (i === 0 && this.entries.length === 1) {\n // There was only one node at this level and it was removed. We can return\n // the modified subtree.\n return childNode;\n }\n\n // The child node is still a good size.\n if (childNode.getChildNodeSize(tree) > tree.minSize) {\n // No merging needed.\n const entry = createNewInternalEntryForNode(childNode, tree.getEntrySize);\n return this.#replaceChild(tree, i, entry);\n }\n\n // Child node size is too small.\n return this.#mergeAndPartition(tree, i, childNode);\n }\n\n async keys(tree: BTreeRead): AsyncGenerator<string, void> {\n for (const entry of this.entries) {\n const childNode = await tree.getNode(entry[1]);\n yield* childNode.keys(tree);\n }\n }\n\n async entriesIter(\n tree: BTreeRead,\n ): AsyncGenerator<Entry<FrozenJSONValue>, void> {\n for (const entry of this.entries) {\n const childNode = await tree.getNode(entry[1]);\n yield childNode.entriesIter(tree);\n }\n }\n\n getChildren(\n start: number,\n length: number,\n tree: BTreeRead,\n ): Promise<Array<InternalNodeImpl \| DataNodeImpl>> {\n const ps: Promise<DataNodeImpl \| InternalNodeImpl>[] = [];\n for (let i = start; i < length && i < this.entries.length; i++) {\n ps.push(tree.getNode(this.entries[i][1]));\n }\n return Promise.all(ps);\n }\n\n async getCompositeChildren(\n start: number,\n length: number,\n tree: BTreeRead,\n ): Promise<InternalNodeImpl \| DataNodeImpl> {\n const {level} = this;\n\n if (length === 0) {\n return new InternalNodeImpl([], newRandomHash(), level - 1, true);\n }\n\n const output = await this.getChildren(start, start + length, tree);\n\n if (level > 1) {\n const entries: Entry<Hash>[] = [];\n for (const child of output as InternalNodeImpl[]) {\n entries.push(...child.entries);\n }\n return new InternalNodeImpl(entries, newRandomHash(), level - 1, true);\n }\n\n assert(level === 1, 'Expected level to be 1');\n const entries: Entry<FrozenJSONValue>[] = [];\n for (const child of output as DataNodeImpl[]) {\n entries.push(...child.entries);\n }\n return new DataNodeImpl(entries, newRandomHash(), true);\n }\n}\n\nexport function newNodeImpl(\n entries: Array<Entry<FrozenJSONValue>>,\n hash: Hash,\n level: number,\n isMutable: boolean,\n): DataNodeImpl;\nexport function newNodeImpl(\n entries: Array<Entry<Hash>>,\n hash: Hash,\n level: number,\n isMutable: boolean,\n): InternalNodeImpl;\nexport function newNodeImpl(\n entries: Array<Entry<FrozenJSONValue>> \| Array<Entry<Hash>>,\n hash: Hash,\n level: number,\n isMutable: boolean,\n): DataNodeImpl \| InternalNodeImpl;\nexport function newNodeImpl(\n entries: Array<Entry<FrozenJSONValue>> \| Array<Entry<Hash>>,\n hash: Hash,\n level: number,\n isMutable: boolean,\n): DataNodeImpl \| InternalNodeImpl {\n if (level === 0) {\n return new DataNodeImpl(\n entries as Entry<FrozenJSONValue>[],\n hash,\n isMutable,\n );\n }\n return new InternalNodeImpl(entries as Entry<Hash>[], hash, level, isMutable);\n}\n\nexport function isDataNodeImpl(\n node: DataNodeImpl \| InternalNodeImpl,\n): node is DataNodeImpl {\n return node.level === 0;\n}\n\nexport function partition<T, R>(\n values: Iterable<T>,\n // This is the size of each Entry\n getSizeOfEntry: (v: T) => number,\n min: number,\n max: number,\n create: (entries: T[]) => R,\n): R[] {\n const results: R[] = [];\n let sum = 0;\n let accum: T[] = [];\n // The most recently finalized partition, held back until we know it won't be\n // merged with trailing entries.\n let lastPartition: T[] \| null = null;\n let lastSize = 0;\n\n function commitLast() {\n if (lastPartition !== null) {\n results.push(create(lastPartition));\n lastPartition = null;\n }\n }\n\n for (const value of values) {\n const size = getSizeOfEntry(value);\n if (size >= max) {\n if (accum.length > 0) {\n commitLast();\n lastPartition = accum;\n lastSize = sum;\n accum = [];\n sum = 0;\n }\n commitLast();\n lastPartition = [value];\n lastSize = size;\n } else if (sum + size >= min) {\n accum.push(value);\n commitLast();\n lastPartition = accum;\n lastSize = sum + size;\n accum = [];\n sum = 0;\n } else {\n sum += size;\n accum.push(value);\n }\n }\n\n if (sum > 0) {\n if (lastPartition !== null && sum + lastSize <= max) {\n lastPartition.push(...accum);\n commitLast();\n } else {\n commitLast();\n results.push(create(accum));\n }\n } else {\n commitLast();\n }\n\n return results;\n}\n\nexport const emptyDataNode = makeNodeChunkData<ReadonlyJSONValue>(\n 0,\n [],\n FormatVersion.Latest,\n);\nexport const emptyDataNodeImpl = new DataNodeImpl([], emptyHash, false);\n\nexport function createNewInternalEntryForNode(\n node: NodeImpl<unknown>,\n getSizeOfEntry: <K, V>(k: K, v: V) => number,\n): [string, Hash, number] {\n const key = node.maxKey();\n const value = node.hash;\n const size = getSizeOfEntry(key, value);\n return [key, value, size];\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"node.js","names":["#childNodeSize","#splice","#mergeAndPartition","#replaceChild"],"sources":["../../../../../replicache/src/btree/node.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport {\n assert,\n assertArray,\n assertNumber,\n assertString,\n} from '../../../shared/src/asserts.ts';\nimport {binarySearch as binarySearchWithFunc} from '../../../shared/src/binary-search.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {joinIterables} from '../../../shared/src/iterables.ts';\nimport {\n type JSONValue,\n type ReadonlyJSONValue,\n assertJSONValue,\n} from '../../../shared/src/json.ts';\nimport {skipBTreeNodeAsserts} from '../config.ts';\nimport type {IndexKey} from '../db/index.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport {\n type FrozenJSONValue,\n type FrozenTag,\n assertDeepFrozen,\n deepFreeze,\n} from '../frozen-json.ts';\nimport {type Hash, emptyHash, newRandomHash} from '../hash.ts';\nimport type {BTreeRead} from './read.ts';\nimport type {BTreeWrite} from './write.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport type Entry<V> = readonly [key: string, value: V, sizeOfEntry: number];\n\nexport const NODE_LEVEL = 0;\nexport const NODE_ENTRIES = 1;\n\n/*\n The type of B+Tree node chunk data\n /\ntype BaseNode<V> = FrozenTag<\n readonly [level: number, entries: ReadonlyArray<Entry<V>>]\n>;\nexport type InternalNode = BaseNode<Hash>;\n\nexport type DataNode = BaseNode<FrozenJSONValue>;\n\nexport function makeNodeChunkData<V>(\n level: number,\n entries: ReadonlyArray<Entry<V>>,\n formatVersion: FormatVersion,\n): BaseNode<V> {\n return deepFreeze([\n level,\n (formatVersion >= FormatVersion.V7\n ? entries\n : entries.map(e => e.slice(0, 2))) as readonly ReadonlyJSONValue[],\n ]) as BaseNode<V>;\n}\n\nexport type Node = DataNode \| InternalNode;\n\n/\n Describes the changes that happened to Replicache after a\n * {@link WriteTransaction} was committed.\n \n @experimental This type is experimental and may change in the future.\n /\nexport type Diff = IndexDiff \| NoIndexDiff;\n\n/\n @experimental This type is experimental and may change in the future.\n /\nexport type IndexDiff = readonly DiffOperation<IndexKey>[];\n\n/\n @experimental This type is experimental and may change in the future.\n /\nexport type NoIndexDiff = readonly DiffOperation<string>[];\n\n/\n InternalDiff uses string keys even for the secondary index maps.\n /\nexport type InternalDiff = readonly InternalDiffOperation[];\n\nexport type DiffOperationAdd<Key, Value = ReadonlyJSONValue> = {\n readonly op: 'add';\n readonly key: Key;\n readonly newValue: Value;\n};\n\nexport type DiffOperationDel<Key, Value = ReadonlyJSONValue> = {\n readonly op: 'del';\n readonly key: Key;\n readonly oldValue: Value;\n};\n\nexport type DiffOperationChange<Key, Value = ReadonlyJSONValue> = {\n readonly op: 'change';\n readonly key: Key;\n readonly oldValue: Value;\n readonly newValue: Value;\n};\n\n/\n The individual parts describing the changes that happened to the Replicache\n * data. There are three different kinds of operations:\n * - `add`: A new entry was added.\n * - `del`: An entry was deleted.\n * - `change`: An entry was changed.\n \n @experimental This type is experimental and may change in the future.\n /\nexport type DiffOperation<Key> =\n \| DiffOperationAdd<Key>\n \| DiffOperationDel<Key>\n \| DiffOperationChange<Key>;\n\n// Duplicated with DiffOperation to make the docs less confusing.\nexport type InternalDiffOperation<Key = string, Value = FrozenJSONValue> =\n \| DiffOperationAdd<Key, Value>\n \| DiffOperationDel<Key, Value>\n \| DiffOperationChange<Key, Value>;\n\n/\n Finds the leaf where a key is (if present) or where it should go if not\n * present.\n /\nexport async function findLeaf(\n key: string,\n hash: Hash,\n source: BTreeRead,\n expectedRootHash: Hash,\n): Promise<DataNodeImpl> {\n const node = await source.getNode(hash);\n // The root changed. Try again\n if (expectedRootHash !== source.rootHash) {\n return findLeaf(key, source.rootHash, source, source.rootHash);\n }\n if (isDataNodeImpl(node)) {\n return node;\n }\n const {entries} = node;\n let i = binarySearch(key, entries);\n if (i === entries.length) {\n i--;\n }\n const entry = entries[i];\n return findLeaf(key, entry[1], source, expectedRootHash);\n}\n\ntype BinarySearchEntries = readonly Entry<unknown>[];\n\n/\n Does a binary search over entries\n \n If the key found then the return value is the index it was found at.\n \n If the key was not found then the return value is the index where it should\n * be inserted at\n /\nexport function binarySearch(\n key: string,\n entries: BinarySearchEntries,\n): number {\n return binarySearchFrom(key, entries, 0);\n}\n\n/\n Binary search starting from a given index.\n /\nfunction binarySearchFrom(\n key: string,\n entries: BinarySearchEntries,\n start: number,\n): number {\n const result = binarySearchWithFunc(entries.length - start, i =>\n compareUTF8(key, entries[start + i][0]),\n );\n return start + result;\n}\n\nexport function binarySearchFound(\n i: number,\n entries: BinarySearchEntries,\n key: string,\n): boolean {\n return i !== entries.length && entries[i][0] === key;\n}\n\nexport function parseBTreeNode(\n v: unknown,\n formatVersion: FormatVersion,\n getSizeOfEntry: <K, V>(key: K, value: V) => number,\n): InternalNode \| DataNode {\n if (skipBTreeNodeAsserts && formatVersion >= FormatVersion.V7) {\n return v as InternalNode \| DataNode;\n }\n\n assertArray(v);\n assertDeepFrozen(v);\n // Be relaxed about what we accept.\n assert(v.length >= 2, 'Expected node array to have at least 2 elements');\n const [level, entries] = v;\n assertNumber(level);\n assertArray(entries);\n\n const f = level > 0 ? assertString : assertJSONValue;\n\n // For V7 we do not need to change the entries. Just assert that they are correct.\n if (formatVersion >= FormatVersion.V7) {\n for (const e of entries) {\n assertEntry(e, f);\n }\n return v as unknown as InternalNode \| DataNode;\n }\n\n const newEntries = entries.map(e => convertNonV7Entry(e, f, getSizeOfEntry));\n return [level, newEntries] as unknown as InternalNode \| DataNode;\n}\n\nfunction assertEntry(\n entry: unknown,\n f:\n \| ((v: unknown) => asserts v is Hash)\n \| ((v: unknown) => asserts v is JSONValue),\n): asserts entry is Entry<Hash \| JSONValue> {\n assertArray(entry);\n // Be relaxed about what we accept.\n assert(entry.length >= 3, 'Expected entry array to have at least 3 elements');\n assertString(entry[0]);\n f(entry[1]);\n assertNumber(entry[2]);\n}\n\n/\n Converts an entry that was from a format version before V7 to the format\n * wanted by V7.\n /\nfunction convertNonV7Entry(\n entry: unknown,\n f:\n \| ((v: unknown) => asserts v is Hash)\n \| ((v: unknown) => asserts v is JSONValue),\n getSizeOfEntry: <K, V>(key: K, value: V) => number,\n): Entry<Hash \| JSONValue> {\n assertArray(entry);\n assert(entry.length >= 2, 'Expected entry array to have at least 2 elements');\n assertString(entry[0]);\n f(entry[1]);\n const entrySize = getSizeOfEntry(entry[0], entry[1]);\n return [entry[0], entry[1], entrySize] as Entry<Hash \| JSONValue>;\n}\n\nexport function isInternalNode(node: Node): node is InternalNode {\n return node[NODE_LEVEL] > 0;\n}\n\nabstract class NodeImpl<Value> {\n entries: Array<Entry<Value>>;\n hash: Hash;\n abstract readonly level: number;\n readonly isMutable: boolean;\n\n #childNodeSize = -1;\n\n constructor(entries: Array<Entry<Value>>, hash: Hash, isMutable: boolean) {\n this.entries = entries;\n this.hash = hash;\n this.isMutable = isMutable;\n }\n\n abstract set(\n key: string,\n value: FrozenJSONValue,\n entrySize: number,\n tree: BTreeWrite,\n ): Promise<NodeImpl<Value>>;\n\n abstract putMany(\n entries: ReadonlyArray<Entry<FrozenJSONValue>>,\n tree: BTreeWrite,\n ): Promise<NodeImpl<Value>>;\n\n abstract del(\n key: string,\n tree: BTreeWrite,\n ): Promise<NodeImpl<Value> \| DataNodeImpl>;\n\n maxKey(): string {\n // oxlint-disable-next-line typescript/no-non-null-assertion\n return this.entries.at(-1)![0];\n }\n\n getChildNodeSize(tree: BTreeRead): number {\n if (this.#childNodeSize !== -1) {\n return this.#childNodeSize;\n }\n\n let sum = tree.chunkHeaderSize;\n for (const entry of this.entries) {\n sum += entry[2];\n }\n return (this.#childNodeSize = sum);\n }\n\n protected _updateNode(tree: BTreeWrite) {\n this.#childNodeSize = -1;\n tree.updateNode(\n this as NodeImpl<unknown> as DataNodeImpl \| InternalNodeImpl,\n );\n }\n}\n\nexport function toChunkData<V>(\n node: NodeImpl<V>,\n formatVersion: FormatVersion,\n): BaseNode<V> {\n return makeNodeChunkData(node.level, node.entries, formatVersion);\n}\n\nexport class DataNodeImpl extends NodeImpl<FrozenJSONValue> {\n readonly level = 0;\n\n set(\n key: string,\n value: FrozenJSONValue,\n entrySize: number,\n tree: BTreeWrite,\n ): Promise<DataNodeImpl> {\n let deleteCount: number;\n const i = binarySearch(key, this.entries);\n if (!binarySearchFound(i, this.entries, key)) {\n // Not found, insert.\n deleteCount = 0;\n } else {\n deleteCount = 1;\n }\n\n return Promise.resolve(\n this.#splice(tree, i, deleteCount, [key, value, entrySize]),\n );\n }\n\n putMany(\n entries: ReadonlyArray<Entry<FrozenJSONValue>>,\n tree: BTreeWrite,\n ): Promise<DataNodeImpl> {\n if (entries.length === 0) {\n return Promise.resolve(this);\n }\n\n // Merge sorted entries with existing entries\n const merged: Entry<FrozenJSONValue>[] = [];\n let i = 0; // index in this.entries\n let j = 0; // index in entries\n\n while (i < this.entries.length && j < entries.length) {\n const existingEntry = this.entries[i];\n const newEntry = entries[j];\n const cmp = compareUTF8(existingEntry[0], newEntry[0]);\n\n if (cmp < 0) {\n merged.push(existingEntry);\n i++;\n } else if (cmp > 0) {\n merged.push(newEntry);\n j++;\n } else {\n // Same key, new entry wins (update)\n merged.push(newEntry);\n i++;\n j++;\n }\n }\n\n // Add remaining entries\n while (i < this.entries.length) {\n merged.push(this.entries[i]);\n i++;\n }\n while (j < entries.length) {\n merged.push(entries[j]);\n j++;\n }\n\n if (this.isMutable) {\n this.entries = merged;\n this._updateNode(tree);\n return Promise.resolve(this);\n }\n\n return Promise.resolve(tree.newDataNodeImpl(merged));\n }\n\n #splice(\n tree: BTreeWrite,\n start: number,\n deleteCount: number,\n ...items: Entry<FrozenJSONValue>[]\n ): DataNodeImpl {\n if (this.isMutable) {\n this.entries.splice(start, deleteCount, ...items);\n this._updateNode(tree);\n return this;\n }\n\n const entries = readonlySplice(this.entries, start, deleteCount, ...items);\n return tree.newDataNodeImpl(entries);\n }\n\n del(key: string, tree: BTreeWrite): Promise<DataNodeImpl> {\n const i = binarySearch(key, this.entries);\n if (!binarySearchFound(i, this.entries, key)) {\n // Not found. Return this without changes.\n return Promise.resolve(this);\n }\n\n // Found. Create new node or mutate existing one.\n return Promise.resolve(this.#splice(tree, i, 1));\n }\n\n async keys(_tree: BTreeRead): AsyncGenerator<string, void> {\n for (const entry of this.entries) {\n yield entry[0];\n }\n }\n\n async entriesIter(\n _tree: BTreeRead,\n ): AsyncGenerator<Entry<FrozenJSONValue>, void> {\n for (const entry of this.entries) {\n yield entry;\n }\n }\n}\n\nfunction readonlySplice<T>(\n array: ReadonlyArray<T>,\n start: number,\n deleteCount: number,\n ...items: T[]\n): T[] {\n const arr = array.slice(0, start);\n for (let i = 0; i < items.length; i++) {\n arr.push(items[i]);\n }\n for (let i = start + deleteCount; i < array.length; i++) {\n arr.push(array[i]);\n }\n return arr;\n}\n\nexport class InternalNodeImpl extends NodeImpl<Hash> {\n readonly level: number;\n\n constructor(\n entries: Array<Entry<Hash>>,\n hash: Hash,\n level: number,\n isMutable: boolean,\n ) {\n super(entries, hash, isMutable);\n this.level = level;\n }\n\n async set(\n key: string,\n value: FrozenJSONValue,\n entrySize: number,\n tree: BTreeWrite,\n ): Promise<InternalNodeImpl> {\n let i = binarySearch(key, this.entries);\n if (i === this.entries.length) {\n // We are going to insert into last (right most) leaf.\n i--;\n }\n\n const childHash = this.entries[i][1];\n const oldChildNode = await tree.getNode(childHash);\n\n const childNode = await oldChildNode.set(key, value, entrySize, tree);\n\n const childNodeSize = childNode.getChildNodeSize(tree);\n if (childNodeSize > tree.maxSize \|\| childNodeSize < tree.minSize) {\n return this.#mergeAndPartition(tree, i, childNode);\n }\n\n const newEntry = createNewInternalEntryForNode(\n childNode,\n tree.getEntrySize,\n );\n return this.#replaceChild(tree, i, newEntry);\n }\n\n async putMany(\n entries: ReadonlyArray<Entry<FrozenJSONValue>>,\n tree: BTreeWrite,\n ): Promise<InternalNodeImpl> {\n if (entries.length === 0) {\n return this;\n }\n\n // Group entries by child index\n // Since entries are sorted, we can restrict the binary search range\n const childGroups: Map<number, Entry<FrozenJSONValue>[]> = new Map();\n\n let searchStart = 0;\n for (const entry of entries) {\n const key = entry[0];\n // Binary search from searchStart to end (entries are sorted)\n let i = binarySearchFrom(key, this.entries, searchStart);\n if (i === this.entries.length) {\n // Insert into last (right most) leaf.\n i--;\n }\n searchStart = i;\n\n let group = childGroups.get(i);\n if (!group) {\n group = [];\n childGroups.set(i, group);\n }\n group.push(entry);\n }\n\n // Process each affected child\n const newEntries = [...this.entries];\n const childrenToRebalance: Array<{\n index: number;\n node: DataNodeImpl \| InternalNodeImpl;\n }> = [];\n\n for (const [childIndex, childEntries] of childGroups) {\n const childHash = this.entries[childIndex][1];\n const oldChildNode = await tree.getNode(childHash);\n const childNode = await oldChildNode.putMany(childEntries, tree);\n\n const childNodeSize = childNode.getChildNodeSize(tree);\n if (childNodeSize > tree.maxSize \|\| childNodeSize < tree.minSize) {\n childrenToRebalance.push({index: childIndex, node: childNode});\n } else {\n const newEntry = createNewInternalEntryForNode(\n childNode,\n tree.getEntrySize,\n );\n newEntries[childIndex] = newEntry;\n }\n }\n\n // Handle rebalancing - merge adjacent children that need rebalancing\n // into contiguous groups and process each group as one unit.\n //\n // BUG FIX: Previously, each child was rebalanced independently R-to-L.\n // When adjacent children (e.g., indices 0 and 1) both needed rebalancing,\n // child[1] would merge with sibling[0] (the ORIGINAL), then child[0]\n // would merge with the rebalanced result at position 1, duplicating\n // child[0]'s data. The fix groups adjacent indices together.\n if (childrenToRebalance.length > 0) {\n childrenToRebalance.sort((a, b) => a.index - b.index);\n\n // Group adjacent indices into contiguous runs, each extended by one\n // sibling on either side for merge context.\n const groups: Array<{\n nodes: Map<number, DataNodeImpl \| InternalNodeImpl>;\n minIndex: number;\n maxIndex: number;\n }> = [];\n\n for (const {index, node} of childrenToRebalance) {\n const lastGroup = groups.at(-1);\n // Adjacent to previous group? (within 1 index of the last group's max)\n if (lastGroup && index <= lastGroup.maxIndex + 1) {\n lastGroup.nodes.set(index, node);\n lastGroup.maxIndex = index;\n } else {\n groups.push({\n nodes: new Map([[index, node]]),\n minIndex: index,\n maxIndex: index,\n });\n }\n }\n\n // Process groups from right to left to maintain indices during splices.\n for (let g = groups.length - 1; g >= 0; g--) {\n const group = groups[g];\n\n // Extend range by one sibling on each side for merge context.\n const startIndex = Math.max(0, group.minIndex - 1);\n const endIndex = Math.min(newEntries.length - 1, group.maxIndex + 1);\n const removeCount = endIndex - startIndex + 1;\n\n // Collect all entries from the range: use the putMany result for\n // indices that were rebalanced, the current newEntries node otherwise.\n type IterableHashEntries = Iterable<Entry<Hash>>;\n const allValues: IterableHashEntries[] = [];\n for (let idx = startIndex; idx <= endIndex; idx++) {\n const rebalancedNode = group.nodes.get(idx);\n if (rebalancedNode) {\n allValues.push(rebalancedNode.entries as IterableHashEntries);\n } else {\n const hash = newEntries[idx][1];\n const existingNode = await tree.getNode(hash);\n allValues.push(existingNode.entries as IterableHashEntries);\n }\n }\n\n const level = this.level - 1;\n const merged = joinIterables(...allValues);\n const rebalanced = partition(\n merged,\n e => e[2],\n tree.minSize - tree.chunkHeaderSize,\n tree.maxSize - tree.chunkHeaderSize,\n entries => {\n const node = tree.newNodeImpl(entries, level);\n return createNewInternalEntryForNode(node, tree.getEntrySize);\n },\n );\n\n newEntries.splice(startIndex, removeCount, ...rebalanced);\n }\n }\n\n if (this.isMutable) {\n this.entries = newEntries;\n this._updateNode(tree);\n return this;\n }\n\n return tree.newInternalNodeImpl(newEntries, this.level);\n }\n\n /\n This merges the child node entries with previous or next sibling and then\n * partitions the merged entries.\n /\n async #mergeAndPartition(\n tree: BTreeWrite,\n i: number,\n childNode: DataNodeImpl \| InternalNodeImpl,\n ): Promise<InternalNodeImpl> {\n const level = this.level - 1;\n const thisEntries = this.entries;\n\n type IterableHashEntries = Iterable<Entry<Hash>>;\n\n let values: IterableHashEntries;\n let startIndex: number;\n let removeCount: number;\n if (i > 0) {\n const hash = thisEntries[i - 1][1];\n const previousSibling = await tree.getNode(hash);\n values = joinIterables(\n previousSibling.entries as IterableHashEntries,\n childNode.entries as IterableHashEntries,\n );\n startIndex = i - 1;\n removeCount = 2;\n } else if (i < thisEntries.length - 1) {\n const hash = thisEntries[i + 1][1];\n const nextSibling = await tree.getNode(hash);\n values = joinIterables(\n childNode.entries as IterableHashEntries,\n nextSibling.entries as IterableHashEntries,\n );\n startIndex = i;\n removeCount = 2;\n } else {\n values = childNode.entries as IterableHashEntries;\n startIndex = i;\n removeCount = 1;\n }\n\n const newEntries = partition(\n values,\n value => value[2],\n tree.minSize - tree.chunkHeaderSize,\n tree.maxSize - tree.chunkHeaderSize,\n entries => {\n const node = tree.newNodeImpl(entries, level);\n return createNewInternalEntryForNode(node, tree.getEntrySize);\n },\n );\n\n if (this.isMutable) {\n this.entries.splice(startIndex, removeCount, ...newEntries);\n this._updateNode(tree);\n return this;\n }\n\n const entries = readonlySplice(\n thisEntries,\n startIndex,\n removeCount,\n ...newEntries,\n );\n\n return tree.newInternalNodeImpl(entries, this.level);\n }\n\n #replaceChild(\n tree: BTreeWrite,\n index: number,\n newEntry: Entry<Hash>,\n ): InternalNodeImpl {\n if (this.isMutable) {\n this.entries.splice(index, 1, newEntry);\n this._updateNode(tree);\n return this;\n }\n const entries = readonlySplice(this.entries, index, 1, newEntry);\n return tree.newInternalNodeImpl(entries, this.level);\n }\n\n async del(\n key: string,\n tree: BTreeWrite,\n ): Promise<InternalNodeImpl \| DataNodeImpl> {\n const i = binarySearch(key, this.entries);\n if (i === this.entries.length) {\n // Key is larger than maxKey of rightmost entry so it is not present.\n return this;\n }\n\n const childHash = this.entries[i][1];\n const oldChildNode = await tree.getNode(childHash);\n const oldHash = oldChildNode.hash;\n\n const childNode = await oldChildNode.del(key, tree);\n if (childNode.hash === oldHash) {\n // Not changed so not found.\n return this;\n }\n\n if (childNode.entries.length === 0) {\n // Subtree is now empty. Remove internal node.\n const entries = readonlySplice(this.entries, i, 1);\n return tree.newInternalNodeImpl(entries, this.level);\n }\n\n if (i === 0 && this.entries.length === 1) {\n // There was only one node at this level and it was removed. We can return\n // the modified subtree.\n return childNode;\n }\n\n // The child node is still a good size.\n if (childNode.getChildNodeSize(tree) > tree.minSize) {\n // No merging needed.\n const entry = createNewInternalEntryForNode(childNode, tree.getEntrySize);\n return this.#replaceChild(tree, i, entry);\n }\n\n // Child node size is too small.\n return this.#mergeAndPartition(tree, i, childNode);\n }\n\n async keys(tree: BTreeRead): AsyncGenerator<string, void> {\n for (const entry of this.entries) {\n const childNode = await tree.getNode(entry[1]);\n yield* childNode.keys(tree);\n }\n }\n\n async entriesIter(\n tree: BTreeRead,\n ): AsyncGenerator<Entry<FrozenJSONValue>, void> {\n for (const entry of this.entries) {\n const childNode = await tree.getNode(entry[1]);\n yield childNode.entriesIter(tree);\n }\n }\n\n getChildren(\n start: number,\n length: number,\n tree: BTreeRead,\n ): Promise<Array<InternalNodeImpl \| DataNodeImpl>> {\n const ps: Promise<DataNodeImpl \| InternalNodeImpl>[] = [];\n for (let i = start; i < length && i < this.entries.length; i++) {\n ps.push(tree.getNode(this.entries[i][1]));\n }\n return Promise.all(ps);\n }\n\n async getCompositeChildren(\n start: number,\n length: number,\n tree: BTreeRead,\n ): Promise<InternalNodeImpl \| DataNodeImpl> {\n const {level} = this;\n\n if (length === 0) {\n return new InternalNodeImpl([], newRandomHash(), level - 1, true);\n }\n\n const output = await this.getChildren(start, start + length, tree);\n\n if (level > 1) {\n const entries: Entry<Hash>[] = [];\n for (const child of output as InternalNodeImpl[]) {\n entries.push(...child.entries);\n }\n return new InternalNodeImpl(entries, newRandomHash(), level - 1, true);\n }\n\n assert(level === 1, 'Expected level to be 1');\n const entries: Entry<FrozenJSONValue>[] = [];\n for (const child of output as DataNodeImpl[]) {\n entries.push(...child.entries);\n }\n return new DataNodeImpl(entries, newRandomHash(), true);\n }\n}\n\nexport function newNodeImpl(\n entries: Array<Entry<FrozenJSONValue>>,\n hash: Hash,\n level: number,\n isMutable: boolean,\n): DataNodeImpl;\nexport function newNodeImpl(\n entries: Array<Entry<Hash>>,\n hash: Hash,\n level: number,\n isMutable: boolean,\n): InternalNodeImpl;\nexport function newNodeImpl(\n entries: Array<Entry<FrozenJSONValue>> \| Array<Entry<Hash>>,\n hash: Hash,\n level: number,\n isMutable: boolean,\n): DataNodeImpl \| InternalNodeImpl;\nexport function newNodeImpl(\n entries: Array<Entry<FrozenJSONValue>> \| Array<Entry<Hash>>,\n hash: Hash,\n level: number,\n isMutable: boolean,\n): DataNodeImpl \| InternalNodeImpl {\n if (level === 0) {\n return new DataNodeImpl(\n entries as Entry<FrozenJSONValue>[],\n hash,\n isMutable,\n );\n }\n return new InternalNodeImpl(entries as Entry<Hash>[], hash, level, isMutable);\n}\n\nexport function isDataNodeImpl(\n node: DataNodeImpl \| InternalNodeImpl,\n): node is DataNodeImpl {\n return node.level === 0;\n}\n\nexport function partition<T, R>(\n values: Iterable<T>,\n // This is the size of each Entry\n getSizeOfEntry: (v: T) => number,\n min: number,\n max: number,\n create: (entries: T[]) => R,\n): R[] {\n const results: R[] = [];\n let sum = 0;\n let accum: T[] = [];\n // The most recently finalized partition, held back until we know it won't be\n // merged with trailing entries.\n let lastPartition: T[] \| null = null;\n let lastSize = 0;\n\n function commitLast() {\n if (lastPartition !== null) {\n results.push(create(lastPartition));\n lastPartition = null;\n }\n }\n\n for (const value of values) {\n const size = getSizeOfEntry(value);\n if (size >= max) {\n if (accum.length > 0) {\n commitLast();\n lastPartition = accum;\n lastSize = sum;\n accum = [];\n sum = 0;\n }\n commitLast();\n lastPartition = [value];\n lastSize = size;\n } else if (sum + size >= min) {\n accum.push(value);\n commitLast();\n lastPartition = accum;\n lastSize = sum + size;\n accum = [];\n sum = 0;\n } else {\n sum += size;\n accum.push(value);\n }\n }\n\n if (sum > 0) {\n if (lastPartition !== null && sum + lastSize <= max) {\n lastPartition.push(...accum);\n commitLast();\n } else {\n commitLast();\n results.push(create(accum));\n }\n } else {\n commitLast();\n }\n\n return results;\n}\n\nexport const emptyDataNode = makeNodeChunkData<ReadonlyJSONValue>(\n 0,\n [],\n FormatVersion.Latest,\n);\nexport const emptyDataNodeImpl = new DataNodeImpl([], emptyHash, false);\n\nexport function createNewInternalEntryForNode(\n node: NodeImpl<unknown>,\n getSizeOfEntry: <K, V>(k: K, v: V) => number,\n): [string, Hash, number] {\n const key = node.maxKey();\n const value = node.hash;\n const size = getSizeOfEntry(key, value);\n return [key, value, size];\n}\n"],"mappings":"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"}

package/out/replicache/src/btree/write.d.ts CHANGED Viewed

@@ -19,6 +19,13 @@ export declare class BTreeWrite extends BTreeRead {
     newNodeImpl(entries: Entry<Hash>[], level: number): InternalNodeImpl;
     newNodeImpl(entries: Entry<Hash>[] | Entry<FrozenJSONValue>[], level: number): InternalNodeImpl | DataNodeImpl;
     put(key: string, value: FrozenJSONValue): Promise<void>;
+    /**
+     * Inserts multiple key-value pairs into the BTree efficiently.
+     * The entries array must be sorted by key.
+     * @param entries - Array of [key, value] tuples, must be sorted by key
+     * @returns Promise that resolves when all entries are inserted
+     */
+    putMany(entries: ReadonlyArray<readonly [string, FrozenJSONValue]>): Promise<void>;
     del(key: string): Promise<boolean>;
     clear(): Promise<void>;
     flush(): Promise<Hash>;

package/out/replicache/src/btree/write.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/btree/write.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AAItD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAC,KAAK,IAAI,EAA2B,MAAM,YAAY,CAAC;AAC/D,OAAO,EACL,YAAY,EACZ,KAAK,KAAK,EACV,gBAAgB,EAOjB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,SAAS,EAAC,MAAM,WAAW,CAAC;AAEpC,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAEhD,qBAAa,UAAW,SAAQ,SAAS;;IAoBvC,UAAkB,QAAQ,EAAE,KAAK,CAAC;IAElC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAGvB,QAAQ,EAAE,KAAK,EACf,aAAa,EAAE,aAAa,EAC5B,IAAI,GAAE,IAAgB,EACtB,OAAO,SAAW,EAClB,OAAO,SAAY,EACnB,YAAY,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAuB,EAC3D,eAAe,CAAC,EAAE,MAAM;IAc1B,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,gBAAgB,GAAG,IAAI;IAOvD,mBAAmB,CACjB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAC3B,KAAK,EAAE,MAAM,GACZ,gBAAgB;IAMnB,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE,GAAG,YAAY;IAMhE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY;IAC3E,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB;IACpE,WAAW,CACT,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,eAAe,CAAC,EAAE,EACjD,KAAK,EAAE,MAAM,GACZ,gBAAgB,GAAG,YAAY;IAUlC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BvD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBvB"}
1	+ {"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/btree/write.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AAItD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,KAAK,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAC,KAAK,IAAI,EAA2B,MAAM,YAAY,CAAC;AAC/D,OAAO,EACL,YAAY,EACZ,KAAK,KAAK,EACV,gBAAgB,EAOjB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,SAAS,EAAC,MAAM,WAAW,CAAC;AAEpC,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAEhD,qBAAa,UAAW,SAAQ,SAAS;;IAoBvC,UAAkB,QAAQ,EAAE,KAAK,CAAC;IAElC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAGvB,QAAQ,EAAE,KAAK,EACf,aAAa,EAAE,aAAa,EAC5B,IAAI,GAAE,IAAgB,EACtB,OAAO,SAAW,EAClB,OAAO,SAAY,EACnB,YAAY,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAuB,EAC3D,eAAe,CAAC,EAAE,MAAM;IAc1B,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,gBAAgB,GAAG,IAAI;IAOvD,mBAAmB,CACjB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAC3B,KAAK,EAAE,MAAM,GACZ,gBAAgB;IAMnB,eAAe,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE,GAAG,YAAY;IAMhE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY;IAC3E,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB;IACpE,WAAW,CACT,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC,eAAe,CAAC,EAAE,EACjD,KAAK,EAAE,MAAM,GACZ,gBAAgB,GAAG,YAAY;IAUlC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BvD;;;;;OAKG;IACH,OAAO,CACL,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,GACzD,OAAO,CAAC,IAAI,CAAC;IA6GhB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBvB"}

package/out/replicache/src/btree/write.js CHANGED Viewed

@@ -75,6 +75,56 @@ var BTreeWrite = class extends BTreeRead {
 			this.rootHash = rootNode.hash;
 		});
 	}
+	/**
+	* Inserts multiple key-value pairs into the BTree efficiently.
+	* The entries array must be sorted by key.
+	* @param entries - Array of [key, value] tuples, must be sorted by key
+	* @returns Promise that resolves when all entries are inserted
+	*/
+	putMany(entries) {
+		return this.#lock.withLock(async () => {
+			if (entries.length === 0) return;
+			const sizedEntries = entries.map(([k, v], i) => {
+				if (i > 0) assert(entries[i - 1][0] < k, `putMany entries must be sorted and unique`);
+				return [
+					k,
+					v,
+					this.getEntrySize(k, v)
+				];
+			});
+			const headerSize = this.chunkHeaderSize;
+			const contentMin = this.minSize - headerSize;
+			const contentMax = this.maxSize - headerSize;
+			if (this.rootHash === emptyHash) {
+				const leafPartitions = partition(sizedEntries, (e) => e[2], contentMin, contentMax, (entries) => entries);
+				if (leafPartitions.length === 0) return;
+				if (leafPartitions.length === 1) {
+					this.rootHash = this.newDataNodeImpl(leafPartitions[0]).hash;
+					return;
+				}
+				let currentLevel = leafPartitions.map((entries) => this.newDataNodeImpl(entries));
+				let level = 0;
+				while (currentLevel.length > 1) {
+					level++;
+					const parentEntriesLength = currentLevel.length;
+					for (let i = 0; i < parentEntriesLength; i++) currentLevel[i] = createNewInternalEntryForNode(currentLevel[i], this.getEntrySize);
+					currentLevel = partition(currentLevel, (e) => e[2], contentMin, contentMax, (entries) => entries).map((entries) => this.newInternalNodeImpl(entries, level));
+				}
+				this.rootHash = currentLevel[0].hash;
+				return;
+			}
+			const rootNode = await (await this.getNode(this.rootHash)).putMany(sizedEntries, this);
+			if (rootNode.getChildNodeSize(this) > this.maxSize) {
+				const { level } = rootNode;
+				const entries = partition(rootNode.entries, (e) => e[2], contentMin, contentMax, (partitionEntries) => {
+					return createNewInternalEntryForNode(this.newNodeImpl(partitionEntries, level), this.getEntrySize);
+				});
+				this.rootHash = this.newInternalNodeImpl(entries, level + 1).hash;
+				return;
+			}
+			this.rootHash = rootNode.hash;
+		});
+	}
 	del(key) {
 		return this.#lock.withLock(async () => {
 			const newRootNode = await (await this.getNode(this.rootHash)).del(key, this);

package/out/replicache/src/btree/write.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"write.js","names":["#lock","#modified","#addToModified"],"sources":["../../../../../replicache/src/btree/write.ts"],"sourcesContent":["import {Lock} from '@rocicorp/lock';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {getSizeOfEntry} from '../../../shared/src/size-of-value.ts';\nimport {type Chunk, type CreateChunk, toRefs} from '../dag/chunk.ts';\nimport type {Write} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash, newRandomHash} from '../hash.ts';\nimport {\n DataNodeImpl,\n type Entry,\n InternalNodeImpl,\n createNewInternalEntryForNode,\n emptyDataNode,\n isDataNodeImpl,\n newNodeImpl,\n partition,\n toChunkData,\n} from './node.ts';\nimport {BTreeRead} from './read.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class BTreeWrite extends BTreeRead {\n /*\n This rw lock is used to ensure we do not mutate the btree in parallel. It\n * would be a problem if we didn't have the lock in cases like this:\n \n ```ts\n * const p1 = tree.put('a', 0);\n * const p2 = tree.put('b', 1);\n * await p1;\n * await p2;\n * ```\n \n because both `p1` and `p2` would start from the old root hash but a put\n * changes the root hash so the two concurrent puts would lead to only one of\n * them actually working, and it is not deterministic which one would finish\n * last.\n /\n readonly #lock = new Lock();\n readonly #modified: Map<Hash, DataNodeImpl \| InternalNodeImpl> = new Map();\n\n declare protected _dagRead: Write;\n\n readonly minSize: number;\n readonly maxSize: number;\n\n constructor(\n dagWrite: Write,\n formatVersion: FormatVersion,\n root: Hash = emptyHash,\n minSize = 8 1024,\n maxSize = 16 * 1024,\n getEntrySize: <K, V>(k: K, v: V) => number = getSizeOfEntry,\n chunkHeaderSize?: number,\n ) {\n super(dagWrite, formatVersion, root, getEntrySize, chunkHeaderSize);\n\n this.minSize = minSize;\n this.maxSize = maxSize;\n }\n\n #addToModified(node: DataNodeImpl \| InternalNodeImpl): void {\n assert(node.isMutable, 'Expected node to be mutable');\n this.#modified.set(node.hash, node);\n this._cache.set(node.hash, node);\n }\n\n updateNode(node: DataNodeImpl \| InternalNodeImpl): void {\n assert(node.isMutable, 'Expected node to be mutable');\n this.#modified.delete(node.hash);\n node.hash = newRandomHash();\n this.#addToModified(node);\n }\n\n newInternalNodeImpl(\n entries: Array<Entry<Hash>>,\n level: number,\n ): InternalNodeImpl {\n const n = new InternalNodeImpl(entries, newRandomHash(), level, true);\n this.#addToModified(n);\n return n;\n }\n\n newDataNodeImpl(entries: Entry<FrozenJSONValue>[]): DataNodeImpl {\n const n = new DataNodeImpl(entries, newRandomHash(), true);\n this.#addToModified(n);\n return n;\n }\n\n newNodeImpl(entries: Entry<FrozenJSONValue>[], level: number): DataNodeImpl;\n newNodeImpl(entries: Entry<Hash>[], level: number): InternalNodeImpl;\n newNodeImpl(\n entries: Entry<Hash>[] \| Entry<FrozenJSONValue>[],\n level: number,\n ): InternalNodeImpl \| DataNodeImpl;\n newNodeImpl(\n entries: Entry<Hash>[] \| Entry<FrozenJSONValue>[],\n level: number,\n ): InternalNodeImpl \| DataNodeImpl {\n const n = newNodeImpl(entries, newRandomHash(), level, true);\n this.#addToModified(n);\n return n;\n }\n\n put(key: string, value: FrozenJSONValue): Promise<void> {\n return this.#lock.withLock(async () => {\n const oldRootNode = await this.getNode(this.rootHash);\n const entrySize = this.getEntrySize(key, value);\n const rootNode = await oldRootNode.set(key, value, entrySize, this);\n\n // We do the rebalancing in the parent so we need to do it here as well.\n if (rootNode.getChildNodeSize(this) > this.maxSize) {\n const headerSize = this.chunkHeaderSize;\n const {level} = rootNode;\n const entries = partition(\n rootNode.entries,\n value => value[2],\n this.minSize - headerSize,\n this.maxSize - headerSize,\n entries => {\n const node = this.newNodeImpl(entries, level);\n return createNewInternalEntryForNode(node, this.getEntrySize);\n },\n );\n const newRoot = this.newInternalNodeImpl(entries, level + 1);\n this.rootHash = newRoot.hash;\n return;\n }\n\n this.rootHash = rootNode.hash;\n });\n }\n\n del(key: string): Promise<boolean> {\n return this.#lock.withLock(async () => {\n const oldRootNode = await this.getNode(this.rootHash);\n const newRootNode = await oldRootNode.del(key, this);\n\n // No need to rebalance here since if root gets too small there is nothing\n // we can do about that.\n const found = this.rootHash !== newRootNode.hash;\n if (found) {\n // Flatten one layer.\n if (newRootNode.level > 0 && newRootNode.entries.length === 1) {\n this.rootHash = (newRootNode as InternalNodeImpl).entries[0][1];\n } else {\n this.rootHash = newRootNode.hash;\n }\n }\n\n return found;\n });\n }\n\n clear(): Promise<void> {\n return this.#lock.withLock(() => {\n this.#modified.clear();\n this.rootHash = emptyHash;\n });\n }\n\n flush(): Promise<Hash> {\n return this.#lock.withLock(async () => {\n const dagWrite = this._dagRead;\n\n if (this.rootHash === emptyHash) {\n // Write a chunk for the empty tree.\n const chunk = dagWrite.createChunk(emptyDataNode, []);\n await dagWrite.putChunk(chunk as Chunk<ReadonlyJSONValue>);\n return chunk.hash;\n }\n\n const newChunks: Chunk[] = [];\n const newRoot = gatherNewChunks(\n this.rootHash,\n newChunks,\n dagWrite.createChunk,\n this.#modified,\n this._formatVersion,\n );\n await Promise.all(newChunks.map(chunk => dagWrite.putChunk(chunk)));\n this.#modified.clear();\n this.rootHash = newRoot;\n return newRoot;\n });\n }\n}\n\nfunction gatherNewChunks(\n hash: Hash,\n newChunks: Chunk[],\n createChunk: CreateChunk,\n modified: Map<Hash, DataNodeImpl \| InternalNodeImpl>,\n formatVersion: FormatVersion,\n): Hash {\n const node = modified.get(hash);\n if (node === undefined) {\n // Not modified, use the original.\n return hash;\n }\n\n if (isDataNodeImpl(node)) {\n const chunk = createChunk(toChunkData(node, formatVersion), []);\n newChunks.push(chunk);\n return chunk.hash;\n }\n\n // The BTree cannot have duplicate keys so the child entry hashes are unique.\n // No need fot a set to dedupe here.\n const refs: Hash[] = [];\n const {entries} = node;\n for (let i = 0; i < entries.length; i++) {\n const entry = entries[i];\n const childHash = entry[1];\n const newChildHash = gatherNewChunks(\n childHash,\n newChunks,\n createChunk,\n modified,\n formatVersion,\n );\n if (newChildHash !== childHash) {\n // MUTATES the entries!\n // Hashes do not change the size of the entry because all hashes have the same length\n entries[i] = [entry[0], newChildHash, entry[2]];\n }\n refs.push(newChildHash);\n }\n const chunk = createChunk(toChunkData(node, formatVersion), toRefs(refs));\n newChunks.push(chunk);\n return chunk.hash;\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"write.js","names":["#lock","#modified","#addToModified"],"sources":["../../../../../replicache/src/btree/write.ts"],"sourcesContent":["import {Lock} from '@rocicorp/lock';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {ReadonlyJSONValue} from '../../../shared/src/json.ts';\nimport {getSizeOfEntry} from '../../../shared/src/size-of-value.ts';\nimport {type Chunk, type CreateChunk, toRefs} from '../dag/chunk.ts';\nimport type {Write} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash, newRandomHash} from '../hash.ts';\nimport {\n DataNodeImpl,\n type Entry,\n InternalNodeImpl,\n createNewInternalEntryForNode,\n emptyDataNode,\n isDataNodeImpl,\n newNodeImpl,\n partition,\n toChunkData,\n} from './node.ts';\nimport {BTreeRead} from './read.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class BTreeWrite extends BTreeRead {\n /*\n This rw lock is used to ensure we do not mutate the btree in parallel. It\n * would be a problem if we didn't have the lock in cases like this:\n \n ```ts\n * const p1 = tree.put('a', 0);\n * const p2 = tree.put('b', 1);\n * await p1;\n * await p2;\n * ```\n \n because both `p1` and `p2` would start from the old root hash but a put\n * changes the root hash so the two concurrent puts would lead to only one of\n * them actually working, and it is not deterministic which one would finish\n * last.\n /\n readonly #lock = new Lock();\n readonly #modified: Map<Hash, DataNodeImpl \| InternalNodeImpl> = new Map();\n\n declare protected _dagRead: Write;\n\n readonly minSize: number;\n readonly maxSize: number;\n\n constructor(\n dagWrite: Write,\n formatVersion: FormatVersion,\n root: Hash = emptyHash,\n minSize = 8 1024,\n maxSize = 16 * 1024,\n getEntrySize: <K, V>(k: K, v: V) => number = getSizeOfEntry,\n chunkHeaderSize?: number,\n ) {\n super(dagWrite, formatVersion, root, getEntrySize, chunkHeaderSize);\n\n this.minSize = minSize;\n this.maxSize = maxSize;\n }\n\n #addToModified(node: DataNodeImpl \| InternalNodeImpl): void {\n assert(node.isMutable, 'Expected node to be mutable');\n this.#modified.set(node.hash, node);\n this._cache.set(node.hash, node);\n }\n\n updateNode(node: DataNodeImpl \| InternalNodeImpl): void {\n assert(node.isMutable, 'Expected node to be mutable');\n this.#modified.delete(node.hash);\n node.hash = newRandomHash();\n this.#addToModified(node);\n }\n\n newInternalNodeImpl(\n entries: Array<Entry<Hash>>,\n level: number,\n ): InternalNodeImpl {\n const n = new InternalNodeImpl(entries, newRandomHash(), level, true);\n this.#addToModified(n);\n return n;\n }\n\n newDataNodeImpl(entries: Entry<FrozenJSONValue>[]): DataNodeImpl {\n const n = new DataNodeImpl(entries, newRandomHash(), true);\n this.#addToModified(n);\n return n;\n }\n\n newNodeImpl(entries: Entry<FrozenJSONValue>[], level: number): DataNodeImpl;\n newNodeImpl(entries: Entry<Hash>[], level: number): InternalNodeImpl;\n newNodeImpl(\n entries: Entry<Hash>[] \| Entry<FrozenJSONValue>[],\n level: number,\n ): InternalNodeImpl \| DataNodeImpl;\n newNodeImpl(\n entries: Entry<Hash>[] \| Entry<FrozenJSONValue>[],\n level: number,\n ): InternalNodeImpl \| DataNodeImpl {\n const n = newNodeImpl(entries, newRandomHash(), level, true);\n this.#addToModified(n);\n return n;\n }\n\n put(key: string, value: FrozenJSONValue): Promise<void> {\n return this.#lock.withLock(async () => {\n const oldRootNode = await this.getNode(this.rootHash);\n const entrySize = this.getEntrySize(key, value);\n const rootNode = await oldRootNode.set(key, value, entrySize, this);\n\n // We do the rebalancing in the parent so we need to do it here as well.\n if (rootNode.getChildNodeSize(this) > this.maxSize) {\n const headerSize = this.chunkHeaderSize;\n const {level} = rootNode;\n const entries = partition(\n rootNode.entries,\n value => value[2],\n this.minSize - headerSize,\n this.maxSize - headerSize,\n entries => {\n const node = this.newNodeImpl(entries, level);\n return createNewInternalEntryForNode(node, this.getEntrySize);\n },\n );\n const newRoot = this.newInternalNodeImpl(entries, level + 1);\n this.rootHash = newRoot.hash;\n return;\n }\n\n this.rootHash = rootNode.hash;\n });\n }\n\n /*\n Inserts multiple key-value pairs into the BTree efficiently.\n * The entries array must be sorted by key.\n * @param entries - Array of [key, value] tuples, must be sorted by key\n * @returns Promise that resolves when all entries are inserted\n */\n putMany(\n entries: ReadonlyArray<readonly [string, FrozenJSONValue]>,\n ): Promise<void> {\n return this.#lock.withLock(async () => {\n if (entries.length === 0) {\n return;\n }\n\n // Validate sortedness and convert to sized entries in one pass\n const sizedEntries: Entry<FrozenJSONValue>[] = entries.map(\n ([k, v], i) => {\n if (i > 0) {\n assert(\n entries[i - 1][0] < k,\n `putMany entries must be sorted and unique`,\n );\n }\n return [k, v, this.getEntrySize(k, v)];\n },\n );\n\n // Compute content size constraints\n const headerSize = this.chunkHeaderSize;\n const contentMin = this.minSize - headerSize;\n const contentMax = this.maxSize - headerSize;\n\n // Fast path: if tree is empty, use bulk loading algorithm\n if (this.rootHash === emptyHash) {\n // Build leaf nodes\n const leafPartitions = partition(\n sizedEntries,\n e => e[2],\n contentMin,\n contentMax,\n entries => entries,\n );\n\n if (leafPartitions.length === 0) {\n return;\n }\n\n if (leafPartitions.length === 1) {\n const leaf = this.newDataNodeImpl(leafPartitions[0]);\n this.rootHash = leaf.hash;\n return;\n }\n\n // Build tree bottom-up - reuse array to avoid allocations\n let currentLevel: Array<DataNodeImpl \| InternalNodeImpl \| Entry<Hash>> =\n leafPartitions.map(entries => this.newDataNodeImpl(entries));\n let level = 0;\n\n while (currentLevel.length > 1) {\n level++;\n\n // Create entries pointing to current level nodes - reuse array\n const parentEntriesLength = currentLevel.length;\n for (let i = 0; i < parentEntriesLength; i++) {\n currentLevel[i] = createNewInternalEntryForNode(\n currentLevel[i] as DataNodeImpl \| InternalNodeImpl,\n this.getEntrySize,\n );\n }\n\n // Partition parent entries\n const parentPartitions = partition(\n currentLevel as Entry<Hash>[],\n e => e[2],\n contentMin,\n contentMax,\n entries => entries,\n );\n\n // Create internal nodes\n currentLevel = parentPartitions.map(entries =>\n this.newInternalNodeImpl(entries, level),\n );\n }\n\n this.rootHash = (\n currentLevel[0] as DataNodeImpl \| InternalNodeImpl\n ).hash;\n return;\n }\n\n // Slow path: merge with existing tree\n const oldRootNode = await this.getNode(this.rootHash);\n const rootNode = await oldRootNode.putMany(sizedEntries, this);\n\n // We do the rebalancing in the parent so we need to do it here as well.\n if (rootNode.getChildNodeSize(this) > this.maxSize) {\n const {level} = rootNode;\n const entries: Entry<Hash>[] = partition(\n rootNode.entries,\n e => e[2],\n contentMin,\n contentMax,\n partitionEntries => {\n const node = this.newNodeImpl(partitionEntries, level);\n return createNewInternalEntryForNode(node, this.getEntrySize);\n },\n );\n const newRoot = this.newInternalNodeImpl(entries, level + 1);\n this.rootHash = newRoot.hash;\n return;\n }\n\n this.rootHash = rootNode.hash;\n });\n }\n\n del(key: string): Promise<boolean> {\n return this.#lock.withLock(async () => {\n const oldRootNode = await this.getNode(this.rootHash);\n const newRootNode = await oldRootNode.del(key, this);\n\n // No need to rebalance here since if root gets too small there is nothing\n // we can do about that.\n const found = this.rootHash !== newRootNode.hash;\n if (found) {\n // Flatten one layer.\n if (newRootNode.level > 0 && newRootNode.entries.length === 1) {\n this.rootHash = (newRootNode as InternalNodeImpl).entries[0][1];\n } else {\n this.rootHash = newRootNode.hash;\n }\n }\n\n return found;\n });\n }\n\n clear(): Promise<void> {\n return this.#lock.withLock(() => {\n this.#modified.clear();\n this.rootHash = emptyHash;\n });\n }\n\n flush(): Promise<Hash> {\n return this.#lock.withLock(async () => {\n const dagWrite = this._dagRead;\n\n if (this.rootHash === emptyHash) {\n // Write a chunk for the empty tree.\n const chunk = dagWrite.createChunk(emptyDataNode, []);\n await dagWrite.putChunk(chunk as Chunk<ReadonlyJSONValue>);\n return chunk.hash;\n }\n\n const newChunks: Chunk[] = [];\n const newRoot = gatherNewChunks(\n this.rootHash,\n newChunks,\n dagWrite.createChunk,\n this.#modified,\n this._formatVersion,\n );\n await Promise.all(newChunks.map(chunk => dagWrite.putChunk(chunk)));\n this.#modified.clear();\n this.rootHash = newRoot;\n return newRoot;\n });\n }\n}\n\nfunction gatherNewChunks(\n hash: Hash,\n newChunks: Chunk[],\n createChunk: CreateChunk,\n modified: Map<Hash, DataNodeImpl \| InternalNodeImpl>,\n formatVersion: FormatVersion,\n): Hash {\n const node = modified.get(hash);\n if (node === undefined) {\n // Not modified, use the original.\n return hash;\n }\n\n if (isDataNodeImpl(node)) {\n const chunk = createChunk(toChunkData(node, formatVersion), []);\n newChunks.push(chunk);\n return chunk.hash;\n }\n\n // The BTree cannot have duplicate keys so the child entry hashes are unique.\n // No need fot a set to dedupe here.\n const refs: Hash[] = [];\n const {entries} = node;\n for (let i = 0; i < entries.length; i++) {\n const entry = entries[i];\n const childHash = entry[1];\n const newChildHash = gatherNewChunks(\n childHash,\n newChunks,\n createChunk,\n modified,\n formatVersion,\n );\n if (newChildHash !== childHash) {\n // MUTATES the entries!\n // Hashes do not change the size of the entry because all hashes have the same length\n entries[i] = [entry[0], newChildHash, entry[2]];\n }\n refs.push(newChildHash);\n }\n const chunk = createChunk(toChunkData(node, formatVersion), toRefs(refs));\n newChunks.push(chunk);\n return chunk.hash;\n}\n"],"mappings":"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"}

package/out/replicache/src/db/write.d.ts CHANGED Viewed

@@ -25,6 +25,14 @@ export declare class Write extends Read {
      * comparison as well as returned in `get`.
      */
     put(lc: LogContext, key: string, value: FrozenJSONValue): Promise<void>;
+    /**
+     * Inserts or updates multiple entries in a single bulk operation. More
+     * efficient than calling {@link put} in a loop because it uses
+     * {@link BTreeWrite.putMany} to build or merge tree nodes in one pass.
+     *
+     * `entries` must be sorted in ascending key order.
+     */
+    putMany(lc: LogContext, entries: ReadonlyArray<readonly [string, FrozenJSONValue]>): Promise<void>;
     getMutationID(): Promise<number>;
     del(lc: LogContext, key: string): Promise<boolean>;
     clear(): Promise<void>;

package/out/replicache/src/db/write.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/db/write.ts"],"names":[],"mappings":"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"}
1	+ {"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/db/write.ts"],"names":[],"mappings":"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"}

package/out/replicache/src/db/write.js CHANGED Viewed

@@ -34,6 +34,21 @@ var Write = class extends Read {
 		await updateIndexes(lc, this.indexes, key, oldVal, value);
 		await this.map.put(key, value);
 	}
+	/**
+	* Inserts or updates multiple entries in a single bulk operation. More
+	* efficient than calling {@link put} in a loop because it uses
+	* {@link BTreeWrite.putMany} to build or merge tree nodes in one pass.
+	*
+	* `entries` must be sorted in ascending key order.
+	*/
+	async putMany(lc, entries) {
+		if (entries.length === 0) return;
+		if (this.indexes.size > 0) for (const [key, value] of entries) {
+			const oldVal = lazy(() => this.map.get(key));
+			await updateIndexes(lc, this.indexes, key, oldVal, value);
+		}
+		await this.map.putMany(entries);
+	}
 	getMutationID() {
 		return getMutationID(this.#clientID, this.#dagWrite, this.#meta);
 	}