@actuarial-ts/data 0.6.0 → 0.7.0

package/src/compactDiagnosticJson.ts

@@ -0,0 +1,216 @@
+import {
+  createDiagnosticIdentityArray,
+  createDiagnosticIdentityObject,
+  createDiagnosticIdentityValue,
+  DiagnosticValidationError,
+  type DiagnosticIdentityDocument,
+} from "@actuarial-ts/core";
+
+/** Private column-backed snapshots for SDK-constructed finding records. No I/O. */
+const CHUNK = 4096;
+
+/** Internal capacity guard, exported only from this private module for tests. */
+export function assertCompactFindingCapacity(
+  count: number,
+  addition = 1,
+): void {
+  if (
+    !Number.isSafeInteger(count) ||
+    !Number.isSafeInteger(addition) ||
+    count < 0 ||
+    addition < 0 ||
+    count + addition > 0xffff_ffff
+  )
+    throw new DiagnosticValidationError([
+      {
+        domain: "input",
+        code: "expression-limit",
+        path: "$",
+        message: "Compact finding index capacity exceeded",
+      },
+    ]);
+}
+
+interface Nodes {
+  kind: Uint8Array;
+  start: Uint32Array;
+  length: Uint32Array;
+  number: Float64Array;
+}
+export class CompactDiagnosticJson {
+  private nodes: Nodes[] = [];
+  private edges: Uint32Array[] = [];
+  private strings: string[] = [];
+  private stringIds = new Map<string, number>();
+  private primitiveIds = new Map<string | number, number>();
+  private smallNodes = new Map<string, number>();
+  private nodeCount = 0;
+  private edgeCount = 0;
+  private sealed = false;
+  private stringId(value: string): number {
+    let id = this.stringIds.get(value);
+    if (id === undefined) {
+      assertCompactFindingCapacity(this.strings.length);
+      id = this.strings.length;
+      this.strings.push(value);
+      this.stringIds.set(value, id);
+    }
+    return id;
+  }
+  add(value: unknown): number {
+    if (this.sealed) throw new Error("Finding snapshot table is sealed");
+    let kind: number;
+    let numeric = 0;
+    let primitive: string | number | undefined;
+    const edges: number[] = [];
+    if (value === null) {
+      kind = 0;
+      primitive = "null";
+    } else if (typeof value === "boolean") {
+      kind = 1;
+      numeric = value ? 1 : 0;
+      primitive = `bool/${numeric}`;
+    } else if (typeof value === "number") {
+      kind = 2;
+      numeric = value;
+      primitive = Object.is(value, -0) ? "-0" : value;
+    } else if (typeof value === "string") {
+      kind = 3;
+      numeric = this.stringId(value);
+      primitive = `string/${numeric}`;
+    } else if (value === undefined) {
+      kind = 7;
+      primitive = "undefined";
+    } else if (Array.isArray(value)) {
+      kind = 4;
+      for (const child of value) edges.push(this.add(child));
+    } else if (typeof value === "object") {
+      kind = Object.getPrototypeOf(value) === null ? 6 : 5;
+      for (const key of Object.keys(value))
+        edges.push(
+          this.stringId(key),
+          this.add((value as Record<string, unknown>)[key]),
+        );
+    } else throw new Error("Unsupported SDK finding snapshot value");
+    const signature =
+      primitive === undefined && edges.length <= 32
+        ? `${kind}/${edges.join(",")}`
+        : undefined;
+    const previous =
+      primitive === undefined
+        ? signature === undefined
+          ? undefined
+          : this.smallNodes.get(signature)
+        : this.primitiveIds.get(primitive);
+    if (previous !== undefined) return previous;
+    assertCompactFindingCapacity(this.nodeCount);
+    assertCompactFindingCapacity(this.edgeCount, edges.length);
+    const id = this.nodeCount++;
+    const row = id % CHUNK;
+    if (row === 0)
+      this.nodes.push({
+        kind: new Uint8Array(CHUNK),
+        start: new Uint32Array(CHUNK),
+        length: new Uint32Array(CHUNK),
+        number: new Float64Array(CHUNK),
+      });
+    const block = this.nodes[Math.floor(id / CHUNK)]!;
+    block.kind[row] = kind;
+    block.start[row] = this.edgeCount;
+    block.length[row] = edges.length;
+    block.number[row] = numeric;
+    for (const child of edges) {
+      if (this.edgeCount % CHUNK === 0) this.edges.push(new Uint32Array(CHUNK));
+      this.edges[Math.floor(this.edgeCount / CHUNK)]![this.edgeCount % CHUNK] =
+        child;
+      this.edgeCount++;
+    }
+    if (primitive !== undefined) this.primitiveIds.set(primitive, id);
+    else if (signature !== undefined && this.smallNodes.size < 100_000)
+      this.smallNodes.set(signature, id);
+    return id;
+  }
+  seal(): void {
+    this.sealed = true;
+    this.stringIds.clear();
+    this.primitiveIds.clear();
+    this.smallNodes.clear();
+  }
+  private edge(index: number): number {
+    return this.edges[Math.floor(index / CHUNK)]![index % CHUNK]!;
+  }
+  length(id: number): number {
+    return this.nodes[Math.floor(id / CHUNK)]!.length[id % CHUNK]!;
+  }
+  property(id: number | undefined, key: string): number | undefined {
+    if (id === undefined) return undefined;
+    const block = this.nodes[Math.floor(id / CHUNK)]!;
+    const row = id % CHUNK;
+    for (let offset = 0; offset < block.length[row]!; offset += 2) {
+      const edge = block.start[row]! + offset;
+      if (this.strings[this.edge(edge)] === key) return this.edge(edge + 1);
+    }
+    return undefined;
+  }
+  arrayItem(id: number, index: number): number {
+    const block = this.nodes[Math.floor(id / CHUNK)]!;
+    return this.edge(block.start[id % CHUNK]! + index);
+  }
+  identityDocument(id: number): DiagnosticIdentityDocument {
+    if (!this.sealed) throw new Error("Finding snapshot table is not sealed");
+    const block = this.nodes[Math.floor(id / CHUNK)]!;
+    const row = id % CHUNK;
+    const kind = block.kind[row]!;
+    const start = block.start[row]!;
+    const length = block.length[row]!;
+    if (kind === 4)
+      return createDiagnosticIdentityArray(length, (index) =>
+        this.identityDocument(this.edge(start + index)),
+      );
+    if (kind === 5 || kind === 6) {
+      const fields: Record<string, DiagnosticIdentityDocument> =
+        Object.create(null);
+      for (let offset = 0; offset < length; offset += 2)
+        fields[this.strings[this.edge(start + offset)]!] =
+          this.identityDocument(this.edge(start + offset + 1));
+      return createDiagnosticIdentityObject(fields);
+    }
+    return createDiagnosticIdentityValue(this.read(id));
+  }
+  read(id: number, sourceCountsOnly = false): unknown {
+    const block = this.nodes[Math.floor(id / CHUNK)]!;
+    const row = id % CHUNK;
+    const kind = block.kind[row]!;
+    const start = block.start[row]!;
+    const length = block.length[row]!;
+    if (kind === 0) return null;
+    if (kind === 1) return block.number[row] === 1;
+    if (kind === 2) return block.number[row];
+    if (kind === 3) return this.strings[block.number[row]!];
+    if (kind === 7) return undefined;
+    if (kind === 4)
+      return Object.freeze(
+        Array.from({ length }, (_, index) =>
+          this.read(this.edge(start + index), sourceCountsOnly),
+        ),
+      );
+    const result: Record<string, unknown> =
+      kind === 6 ? Object.create(null) : {};
+    for (let offset = 0; offset < length; offset += 2) {
+      const key = this.strings[this.edge(start + offset)]!;
+      const child = this.edge(start + offset + 1);
+      Object.defineProperty(
+        result,
+        sourceCountsOnly && key === "sources" ? "sourceCount" : key,
+        {
+          value:
+            sourceCountsOnly && key === "sources"
+              ? this.length(child)
+              : this.read(child, sourceCountsOnly),
+          enumerable: true,
+        },
+      );
+    }
+    return Object.freeze(result);
+  }
+}