assistant-stream 0.2.0 → 0.2.2

package/src/utils/json/parse-partial-json-object.test.ts

@@ -0,0 +1,225 @@
+import { describe, it, expect } from "vitest";
+import {
+  parsePartialJsonObject,
+  getPartialJsonObjectFieldState,
+} from "./parse-partial-json-object";
+
+type PartialJsonTest = {
+  input: string;
+  query: (string | number)[];
+  result: "partial" | "complete" | "undefined";
+};
+
+const tests: PartialJsonTest[] = [
+  // empty query
+  {
+    input: ``,
+    query: [],
+    result: "partial",
+  },
+  {
+    input: `{`,
+    query: [],
+    result: "partial",
+  },
+  {
+    input: `{}`,
+    query: [],
+    result: "complete",
+  },
+  // field query (missing)
+  {
+    input: ``,
+    query: ["test"],
+    result: "partial",
+  },
+  {
+    input: `{`,
+    query: ["test"],
+    result: "partial",
+  },
+  {
+    input: `{}`,
+    query: ["test"],
+    result: "complete",
+  },
+  // field query (partial)
+  {
+    input: `{"foo": `,
+    query: ["foo"],
+    result: "partial",
+  },
+  {
+    input: `{"foo": "b`,
+    query: ["foo"],
+    result: "partial",
+  },
+  {
+    input: `{"foo": 123`,
+    query: ["foo"],
+    result: "partial",
+  },
+  {
+    input: `{"foo": {`,
+    query: ["foo"],
+    result: "partial",
+  },
+  {
+    input: `{"foo": [`,
+    query: ["foo"],
+    result: "partial",
+  },
+  // field query (complete)
+  {
+    input: `{"foo": 123,`,
+    query: ["foo"],
+    result: "complete",
+  },
+  {
+    input: `{"foo": "b"`,
+    query: ["foo"],
+    result: "complete",
+  },
+  {
+    input: `{"foo": nu`,
+    query: ["foo"],
+    result: "complete",
+  },
+  {
+    input: `{"foo": fa`,
+    query: ["foo"],
+    result: "complete",
+  },
+  {
+    input: `{"foo": tr`,
+    query: ["foo"],
+    result: "complete",
+  },
+  {
+    input: `{"foo": {}`,
+    query: ["foo"],
+    result: "complete",
+  },
+  {
+    input: `{"foo": []`,
+    query: ["foo"],
+    result: "complete",
+  },
+  // field query (nested)
+  {
+    input: `{"foo": [{ "bar": "abc`,
+    query: ["foo", "0", "bar"],
+    result: "partial",
+  },
+  {
+    input: `{"foo": [{ "bar": "abc"`,
+    query: ["foo", "0", "bar"],
+    result: "complete",
+  },
+  {
+    input: `{"foo": [{ "bar": 123`,
+    query: ["foo", "0", "bar"],
+    result: "partial",
+  },
+  {
+    input: `{"foo": [{ "bar": nu`,
+    query: ["foo", 0, "bar"],
+    result: "complete",
+  },
+  // field non-existent
+  {
+    input: `{"bar": "hello"`,
+    query: ["foo"],
+    result: "partial",
+  },
+  {
+    input: `{"bar": "hello"}`,
+    query: ["foo"],
+    result: "complete",
+  },
+  // mismatch type
+  {
+    input: `{"foo": 123`,
+    query: ["foo", "bar", "baz"],
+    result: "partial",
+  },
+  {
+    input: `{"foo": fa`,
+    query: ["foo", "bar", "baz"],
+    result: "complete",
+  },
+  // numeric keys
+  {
+    input: `{"1": "value","0":"`,
+    query: ["0"],
+    result: "partial",
+  },
+  {
+    input: `{"1": "value","0":"`,
+    query: ["1"],
+    result: "complete",
+  },
+  {
+    input: `{"foo": "value", "0": "`,
+    query: ["0"],
+    result: "partial",
+  },
+  {
+    input: `{"foo": "value", "0": "`,
+    query: ["foo"],
+    result: "complete",
+  },
+  // duplicate keys
+  {
+    input: `{"foo": "foo","bar":"bar","foo": "`,
+    query: ["foo"],
+    result: "partial",
+  },
+  {
+    input: `{"foo": "foo","bar":"bar","foo": "`,
+    query: ["bar"],
+    result: "complete",
+  },
+  {
+    input: `{"foo": [1,"a",{"b":1},[],{},[1,[[2]]],{"1":1,"t":1`,
+    query: ["foo", 6, 1],
+    result: "complete",
+  },
+  {
+    input: `{"foo": [1,"\",{"b":1},[],{},[1,[[2]]],{"1":1,"t":1`,
+    query: ["foo", 6, "t"],
+    result: "partial",
+  },
+  {
+    input: `{"\\"": "t`,
+    query: ['"'],
+    result: "partial",
+  },
+  {
+    input: `{"\\"": "t"`,
+    query: ['"'],
+    result: "complete",
+  },
+  {
+    input: `{"\\u25CF": "t`,
+    query: ["\u25CF"],
+    result: "partial",
+  },
+];
+
+describe("parsePartialJsonObject and getPartialJsonObjectFieldState", () => {
+  // Test each case in the tests array
+  tests.forEach((testCase, index) => {
+    it(`Test case #${index + 1}: ${testCase.input || `""`} with query ${JSON.stringify(testCase.query)} should return "${testCase.result}"`, () => {
+      const args = parsePartialJsonObject(testCase.input);
+      if (args === undefined) throw new Error("unable to parse args");
+
+      const fieldState = getPartialJsonObjectFieldState(
+        args as Record<string, unknown>,
+        testCase.query,
+      );
+
+      expect(fieldState).toBe(testCase.result);
+    });
+  });
+});

package/src/utils/json/parse-partial-json-object.ts

@@ -0,0 +1,103 @@
+import sjson from "secure-json-parse";
+import { fixJson } from "./fix-json";
+import { ReadonlyJSONObject } from "./json-value";
+
+const PARTIAL_JSON_OBJECT_META_SYMBOL = Symbol(
+  "aui.parse-partial-json-object.meta",
+);
+
+type FieldState = "complete" | "partial";
+
+type PartialJsonObjectMeta = {
+  state: "complete" | "partial";
+  partialPath: string[];
+};
+
+export const getPartialJsonObjectMeta = (
+  obj: Record<symbol, unknown>,
+): PartialJsonObjectMeta | undefined => {
+  return obj?.[PARTIAL_JSON_OBJECT_META_SYMBOL] as PartialJsonObjectMeta;
+};
+
+export const parsePartialJsonObject = (
+  json: string,
+):
+  | (ReadonlyJSONObject & {
+      [PARTIAL_JSON_OBJECT_META_SYMBOL]: PartialJsonObjectMeta;
+    })
+  | undefined => {
+  if (json.length === 0)
+    return {
+      [PARTIAL_JSON_OBJECT_META_SYMBOL]: { state: "partial", partialPath: [] },
+    };
+
+  try {
+    const res = sjson.parse(json);
+    if (typeof res !== "object" || res === null)
+      throw new Error("argsText is expected to be an object");
+
+    res[PARTIAL_JSON_OBJECT_META_SYMBOL] = {
+      state: "complete",
+      partialPath: [],
+    };
+    return res;
+  } catch {
+    try {
+      const [fixedJson, partialPath] = fixJson(json);
+      const res = sjson.parse(fixedJson);
+      if (typeof res !== "object" || res === null)
+        throw new Error("argsText is expected to be an object");
+
+      res[PARTIAL_JSON_OBJECT_META_SYMBOL] = {
+        state: "partial",
+        partialPath,
+      };
+      return res;
+    } catch {
+      return undefined;
+    }
+  }
+};
+
+const getFieldState = (
+  parent: unknown,
+  parentMeta: PartialJsonObjectMeta,
+  fieldPath: string[],
+): FieldState => {
+  if (typeof parent !== "object" || parent === null) return parentMeta.state;
+
+  // 1) parent is complete: return "complete"
+  if (parentMeta.state === "complete") return "complete";
+
+  // 2) we finished traversing: return parent state
+  if (fieldPath.length === 0) return parentMeta.state;
+
+  const [field, ...restPath] = fieldPath as [string, ...string[]];
+
+  // 3) field doesn't yet exist in parent: return "partial"
+  if (!Object.prototype.hasOwnProperty.call(parent, field)) return "partial";
+
+  const [partialField, ...restPartialPath] = parentMeta.partialPath;
+
+  // 4) field exists but is not partial: return "complete"
+  if (field !== partialField) return "complete";
+
+  // 5) field exists and is partial: return child state
+  const child = (parent as Record<string, unknown>)[field];
+  const childMeta: PartialJsonObjectMeta = {
+    state: "partial",
+    partialPath: restPartialPath,
+  };
+
+  return getFieldState(child, childMeta, restPath);
+};
+
+export const getPartialJsonObjectFieldState = (
+  obj: Record<string, unknown>,
+  fieldPath: (string | number)[],
+): FieldState => {
+  const meta = getPartialJsonObjectMeta(obj);
+  if (!meta) throw new Error("unable to determine object state");
+
+  return getFieldState(obj, meta, fieldPath.map(String));
+};

package/src/utils/promiseWithResolvers.ts

@@ -0,0 +1,10 @@
+export const promiseWithResolvers = function <T>() {
+  let resolve: ((value: T | PromiseLike<T>) => void) | undefined;
+  let reject: ((reason?: unknown) => void) | undefined;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  if (!resolve || !reject) throw new Error("Failed to create promise");
+  return { promise, resolve, reject };
+};

package/src/utils.ts

@@ -0,0 +1,13 @@
+export {
+  parsePartialJsonObject,
+  getPartialJsonObjectFieldState,
+} from "./utils/json/parse-partial-json-object";
+export {
+  type AsyncIterableStream,
+  asAsyncIterableStream,
+} from "./utils/AsyncIterableStream";
+export type {
+  ReadonlyJSONValue,
+  ReadonlyJSONArray,
+  ReadonlyJSONObject,
+} from "./utils/json/json-value";

package/utils/README.md

@@ -1 +0,0 @@
-This directory exists to support subpath imports for TypeScript projects using --moduleResolution node.

package/utils/package.json

@@ -1,5 +0,0 @@
-{
-  "type": "module",
-  "main": "../dist/utils.js",
-  "types": "../dist/utils.d.ts"
-}