articulated 0.1.0 → 0.3.0

package/src/index.ts

@@ -1,3 +1,3 @@
 export * from "./id";
-export * from "./id_list";
+export { IdList, KnownIdView } from "./id_list";
 export * from "./saved_id_list";

package/src/internal/leaf_map.ts

@@ -0,0 +1,59 @@
+import createRBTree, { Tree } from "functional-red-black-tree";
+import type { LeafNode } from "../id_list";
+
+/**
+ * A persistent sorted map from each LeafNode to its parent's seq.
+ *
+ * Leaves are sorted by their first ElementId.
+ * This lets you quickly look up the LeafNode containing an ElementId,
+ * even though the LeafNode might start at a lower counter.
+ */
+export class LeafMap {
+  private constructor(private readonly tree: Tree<LeafNode, number>) {}
+
+  static new() {
+    return new this(createRBTree(compareLeaves));
+  }
+
+  /**
+   * Returns the greatest leaf whose first id is <= the given id,
+   * or undefined if none exists. Also returns the associated seq (or -1 if not found).
+   *
+   * The returned leaf might not actually contain the given id.
+   */
+  getLeaf(
+    bunchId: string,
+    counter: number
+  ): [leaf: LeafNode | undefined, seq: number] {
+    const iter = this.tree.le({ bunchId, startCounter: counter } as LeafNode);
+    return [iter.key, iter.value ?? -1];
+  }
+
+  set(leaf: LeafNode, seq: number): LeafMap {
+    // TODO: Vendor functional-red-black-tree and add our own set method
+    // so we can avoid this 2x penalty.
+    return new LeafMap(this.tree.remove(leaf).insert(leaf, seq));
+  }
+
+  delete(leaf: LeafNode): LeafMap {
+    return new LeafMap(this.tree.remove(leaf));
+  }
+}
+
+/**
+ * Sort function for LeafNodes in LeafMap.
+ *
+ * Sorting by startCounters lets us quickly look up the LeafNode containing an ElementId,
+ * even though the LeafNode might start at a lower counter.
+ */
+function compareLeaves(a: LeafNode, b: LeafNode) {
+  if (a.bunchId === b.bunchId) {
+    return a.startCounter - b.startCounter;
+  } else {
+    return a.bunchId > b.bunchId ? 1 : -1;
+  }
+}
+
+export interface MutableLeafMap {
+  value: LeafMap;
+}

package/src/internal/seq_map.ts

@@ -0,0 +1,50 @@
+import createRBTree, { Tree } from "functional-red-black-tree";
+
+/**
+ * A persistent map from an InnerNode's seq to its parent's seq
+ * (or 0 for the root).
+ *
+ * Sequence numbers start at 1 and increment each time you call set(nextSeq, ...).
+ */
+export class SeqMap {
+  constructor(
+    private readonly tree: Tree<number, number>,
+    private readonly nextSeq: number
+  ) {}
+
+  static new(): SeqMap {
+    return new this(
+      createRBTree((a, b) => a - b),
+      1
+    );
+  }
+
+  bumpNextSeq(): SeqMap {
+    return new SeqMap(this.tree, this.nextSeq + 1);
+  }
+
+  get(seq: number): number {
+    return this.tree.get(seq)!;
+  }
+
+  set(seq: number, value: number): SeqMap {
+    // TODO: Vendor functional-red-black-tree and add our own set method
+    // so we can avoid this 2x penalty.
+    return new SeqMap(this.tree.remove(seq).insert(seq, value), this.nextSeq);
+  }
+
+  // delete(seq: number): SeqMap {
+  //   return new SeqMap(this.tree.remove(seq), this.nextSeq);
+  // }
+}
+
+export interface MutableSeqMap {
+  value: SeqMap;
+}
+
+export function getAndBumpNextSeq(seqsMut: MutableSeqMap): number {
+  // @ts-expect-error Ignore private
+  const nextSeq = seqsMut.value.nextSeq;
+  seqsMut.value = seqsMut.value.bumpNextSeq();
+  return nextSeq;
+}

package/src/saved_id_list.ts

@@ -1,13 +1,13 @@
 /**
- * Saved state for an IdList.
+ * JSON saved state for an IdList.
  *
  * It describes all of the list's known ElementIds in list order, with basic compression:
  * if sequential ElementIds have the same bunchId, the same isDeleted status,
  * and sequential counters, then they are combined into a single object.
  */
 export type SavedIdList = Array<{
-  bunchId: string;
-  startCounter: number;
-  count: number;
-  isDeleted: boolean;
+  readonly bunchId: string;
+  readonly startCounter: number;
+  readonly count: number;
+  readonly isDeleted: boolean;
 }>;