@assistant-ui/react-generative-ui 0.0.23 → 0.1.0

package/src/a2ui/dataModel.ts

@@ -1,69 +0,0 @@
-import { setAtPointer } from "./reducer";
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value);
-
-export const equalData = (left: unknown, right: unknown): boolean => {
-  if (Object.is(left, right)) return true;
-  if (Array.isArray(left) && Array.isArray(right)) {
-    return (
-      left.length === right.length &&
-      left.every((value, index) => equalData(value, right[index]))
-    );
-  }
-  if (!isRecord(left) || !isRecord(right)) return false;
-  const keys = Object.keys(left);
-  return (
-    keys.length === Object.keys(right).length &&
-    keys.every(
-      (key) => Object.hasOwn(right, key) && equalData(left[key], right[key]),
-    )
-  );
-};
-
-export const decodePointer = (path: string): string[] => {
-  if (path === "" || path === "/") return [];
-  return (path.startsWith("/") ? path.slice(1) : path)
-    .split("/")
-    .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
-};
-
-export const resolvePointer = (source: unknown, path: string): unknown => {
-  let current = source;
-  for (const segment of decodePointer(path)) {
-    if (Array.isArray(current)) {
-      if (!/^(0|[1-9]\d*)$/.test(segment)) return undefined;
-      current = current[Number(segment)];
-      continue;
-    }
-    if (!isRecord(current) || !Object.hasOwn(current, segment)) {
-      return undefined;
-    }
-    current = current[segment];
-  }
-  return current;
-};
-
-export const reconcileDataModel = (
-  previous: unknown,
-  incoming: unknown,
-  local: unknown,
-  editedPaths: ReadonlySet<string>,
-) => {
-  let value = incoming;
-  const retained = new Set<string>();
-  for (const path of editedPaths) {
-    if (
-      equalData(resolvePointer(previous, path), resolvePointer(incoming, path))
-    ) {
-      value = setAtPointer(
-        value,
-        path,
-        resolvePointer(local, path),
-        false,
-      ).value;
-      retained.add(path);
-    }
-  }
-  return { incoming, value, editedPaths: retained };
-};

package/src/a2ui/reducer.test.ts

@@ -1,422 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { applyA2uiOperations } from "./reducer";
-import type { A2uiState, A2uiSurfaceState } from "./types";
-
-describe("applyA2uiOperations", () => {
-  it("applies create, component upsert, data model update, and delete operations without mutating prior state", () => {
-    const initial: A2uiState = new Map();
-    const created = applyA2uiOperations(initial, [
-      {
-        version: "v0.9",
-        createSurface: { surfaceId: "main", catalogId: "default" },
-      },
-      {
-        version: "v0.9",
-        updateComponents: {
-          surfaceId: "main",
-          components: [
-            { id: "root", component: "Text", text: "first" },
-            { id: "root", component: "Text", text: "second" },
-          ],
-        },
-      },
-      {
-        version: "v0.9",
-        updateDataModel: {
-          surfaceId: "main",
-          path: "/profile/name",
-          contents: "Ada",
-          value: "ignored",
-          data: "ignored",
-        },
-      },
-    ]);
-
-    expect(initial.size).toBe(0);
-    expect(created.warnings).toEqual([]);
-    expect(created.state.get("main")).toMatchObject({
-      catalogId: "default",
-      dataModel: { profile: { name: "Ada" } },
-    });
-    expect(created.state.get("main")?.components.get("root")).toEqual({
-      id: "root",
-      component: "Text",
-      text: "second",
-    });
-
-    const removed = applyA2uiOperations(created.state, [
-      {
-        version: "v1.0",
-        deleteSurface: { surfaceId: "main" },
-      },
-    ]);
-
-    expect(removed.warnings).toEqual([]);
-    expect(removed.state.has("main")).toBe(false);
-    expect(created.state.has("main")).toBe(true);
-  });
-
-  it("accepts v1.0 inline components and data model as initial state", () => {
-    const result = applyA2uiOperations(new Map(), [
-      {
-        version: "v1.0",
-        createSurface: {
-          surfaceId: "inline",
-          catalogId: "basic",
-          surfaceProperties: { ignored: true },
-          sendDataModel: true,
-          components: [
-            { id: "root", component: "Text", text: { path: "/message" } },
-          ],
-          dataModel: { message: "hello" },
-        },
-      },
-    ]);
-
-    expect(result.warnings).toEqual([]);
-    expect(result.state.get("inline")).toMatchObject({
-      catalogId: "basic",
-      dataModel: { message: "hello" },
-    });
-    expect(result.state.get("inline")?.components.get("root")).toEqual({
-      id: "root",
-      component: "Text",
-      text: { path: "/message" },
-    });
-  });
-
-  it("keeps a v1.0 catalog id from surface properties", () => {
-    const result = applyA2uiOperations(new Map(), [
-      {
-        version: "v1.0",
-        createSurface: {
-          surfaceId: "properties",
-          surfaceProperties: { catalogId: "basic" },
-        },
-      },
-    ]);
-
-    expect(result.warnings).toEqual([]);
-    expect(result.state.get("properties")?.catalogId).toBe("basic");
-  });
-
-  it("applies v0.9.1 operations the way v0.9 does", () => {
-    const result = applyA2uiOperations(new Map(), [
-      {
-        version: "v0.9.1",
-        createSurface: { surfaceId: "main", catalogId: "basic" },
-      },
-      {
-        version: "v0.9.1",
-        updateComponents: {
-          surfaceId: "main",
-          components: [{ id: "root", component: "Text", text: "hello" }],
-        },
-      },
-      {
-        version: "v0.9.1",
-        updateDataModel: {
-          surfaceId: "main",
-          path: "/profile/name",
-          value: "Ada",
-        },
-      },
-    ]);
-
-    expect(result.warnings).toEqual([]);
-    expect(result.state.get("main")).toMatchObject({
-      catalogId: "basic",
-      dataModel: { profile: { name: "Ada" } },
-    });
-    expect(result.state.get("main")?.components.get("root")).toEqual({
-      id: "root",
-      component: "Text",
-      text: "hello",
-    });
-  });
-
-  it.each(["10001", "4294967294"])(
-    "rejects array pointer index %s beyond the auto-vivification limit",
-    (index) => {
-      const dataModel = { items: [] };
-      const state: A2uiState = new Map([
-        ["main", { components: new Map(), dataModel }],
-      ]);
-
-      const result = applyA2uiOperations(state, [
-        {
-          version: "v1.0",
-          updateDataModel: {
-            surfaceId: "main",
-            path: `/items/${index}`,
-            value: "unsafe",
-          },
-        },
-      ]);
-
-      expect(result.warnings).toEqual([
-        "Operation at index 0 has an invalid JSON Pointer path.",
-      ]);
-      expect(result.state.get("main")?.dataModel).toBe(dataModel);
-      expect(dataModel.items).toHaveLength(0);
-    },
-  );
-
-  it("allows bounded expansion, existing large indices, and appends", () => {
-    const items = new Array<string | undefined>(10_002);
-    items[10_001] = "existing";
-    const state: A2uiState = new Map([
-      ["main", { components: new Map(), dataModel: { bounded: [], items } }],
-    ]);
-
-    const result = applyA2uiOperations(state, [
-      {
-        version: "v1.0",
-        updateDataModel: {
-          surfaceId: "main",
-          path: "/bounded/10000",
-          value: "limit",
-        },
-      },
-      {
-        version: "v1.0",
-        updateDataModel: {
-          surfaceId: "main",
-          path: "/items/10001",
-          value: "updated",
-        },
-      },
-      {
-        version: "v1.0",
-        updateDataModel: {
-          surfaceId: "main",
-          path: "/items/-",
-          value: "appended",
-        },
-      },
-    ]);
-
-    const resultModel = result.state.get("main")!.dataModel as {
-      bounded: string[];
-      items: string[];
-    };
-    expect(result.warnings).toEqual([]);
-    expect(resultModel.bounded).toHaveLength(10_001);
-    expect(resultModel.bounded[10_000]).toBe("limit");
-    expect(resultModel.items).toHaveLength(10_003);
-    expect(resultModel.items[10_001]).toBe("updated");
-    expect(resultModel.items[10_002]).toBe("appended");
-  });
-
-  it("stores prototype-named JSON Pointer segments as own properties", () => {
-    const state: A2uiState = new Map([
-      ["main", { components: new Map(), dataModel: {} }],
-    ]);
-
-    const result = applyA2uiOperations(state, [
-      {
-        version: "v1.0",
-        updateDataModel: {
-          surfaceId: "main",
-          path: "/__proto__/admin",
-          value: true,
-        },
-      },
-    ]);
-
-    const resultModel = result.state.get("main")?.dataModel as Record<
-      string,
-      unknown
-    >;
-    expect(result.warnings).toEqual([]);
-    expect(Object.getPrototypeOf(resultModel)).toBe(Object.prototype);
-    expect(Object.hasOwn(resultModel, "__proto__")).toBe(true);
-    expect(resultModel["__proto__"]).toEqual({ admin: true });
-    expect(JSON.stringify(resultModel)).toBe('{"__proto__":{"admin":true}}');
-  });
-
-  it("deletes object properties updated to null", () => {
-    const dataModel = {
-      profile: { name: "Ada", role: "admin" },
-      tags: ["first", "second"],
-    };
-    const state: A2uiState = new Map([
-      ["main", { components: new Map(), dataModel }],
-    ]);
-
-    const result = applyA2uiOperations(state, [
-      {
-        version: "v1.0",
-        updateDataModel: {
-          surfaceId: "main",
-          path: "/profile/name",
-          value: null,
-        },
-      },
-      {
-        version: "v1.0",
-        updateDataModel: {
-          surfaceId: "main",
-          path: "/tags/1",
-          value: null,
-        },
-      },
-    ]);
-
-    expect(result.warnings).toEqual([]);
-    const resultModel = result.state.get("main")?.dataModel as typeof dataModel;
-    expect(resultModel.profile).toEqual({ role: "admin" });
-    expect(resultModel.tags).toHaveLength(2);
-    expect(resultModel.tags[0]).toBe("first");
-    expect(Object.prototype.hasOwnProperty.call(resultModel.tags, 1)).toBe(
-      false,
-    );
-    expect(dataModel).toEqual({
-      profile: { name: "Ada", role: "admin" },
-      tags: ["first", "second"],
-    });
-  });
-
-  it("preserves null values in v0.9 data model updates", () => {
-    const state: A2uiState = new Map([
-      [
-        "main",
-        { components: new Map(), dataModel: { profile: { name: "Ada" } } },
-      ],
-    ]);
-
-    const result = applyA2uiOperations(state, [
-      {
-        version: "v0.9",
-        updateDataModel: {
-          surfaceId: "main",
-          path: "/profile/name",
-          value: null,
-        },
-      },
-    ]);
-
-    expect(result.warnings).toEqual([]);
-    expect(result.state.get("main")?.dataModel).toEqual({
-      profile: { name: null },
-    });
-  });
-
-  it("does not create missing paths for null updates", () => {
-    const dataModel = { profile: { name: "Ada" }, tags: ["first", "second"] };
-    const state: A2uiState = new Map([
-      ["main", { components: new Map(), dataModel }],
-    ]);
-
-    const result = applyA2uiOperations(state, [
-      {
-        version: "v1.0",
-        updateDataModel: {
-          surfaceId: "main",
-          path: "/missing/value",
-          value: null,
-        },
-      },
-      {
-        version: "v1.0",
-        updateDataModel: {
-          surfaceId: "main",
-          path: "/tags/-",
-          value: null,
-        },
-      },
-      {
-        version: "v1.0",
-        updateDataModel: {
-          surfaceId: "main",
-          path: "/tags/7",
-          value: null,
-        },
-      },
-    ]);
-
-    expect(result.warnings).toEqual([]);
-    expect(result.state.get("main")?.dataModel).toBe(dataModel);
-  });
-
-  it("allows null to replace the data model root", () => {
-    const state: A2uiState = new Map([
-      [
-        "main",
-        { components: new Map(), dataModel: { profile: { name: "Ada" } } },
-      ],
-    ]);
-
-    const result = applyA2uiOperations(state, [
-      {
-        version: "v1.0",
-        updateDataModel: { surfaceId: "main", value: null },
-      },
-    ]);
-
-    expect(result.warnings).toEqual([]);
-    expect(result.state.get("main")?.dataModel).toBeNull();
-  });
-
-  it("clones the touched surface and component map", () => {
-    const components = new Map<string, Record<string, unknown>>([
-      ["root", { id: "root", component: "Divider" }],
-    ]);
-    const surface: A2uiSurfaceState = {
-      components,
-      dataModel: { value: 1 },
-    };
-    const state: A2uiState = new Map([["main", surface]]);
-
-    const result = applyA2uiOperations(state, [
-      {
-        version: "v1.0",
-        updateComponents: {
-          surfaceId: "main",
-          components: [{ id: "next", component: "Divider" }],
-        },
-      },
-    ]);
-
-    expect(result.state.get("main")).not.toBe(surface);
-    expect(result.state.get("main")?.components).not.toBe(components);
-    expect(components.has("next")).toBe(false);
-    expect(result.state.get("main")?.components.has("next")).toBe(true);
-  });
-
-  it("skips unknown operations with a warning naming the key", () => {
-    const result = applyA2uiOperations(new Map(), [
-      {
-        version: "v1.0",
-        animateSurface: { surfaceId: "main" },
-      },
-    ]);
-
-    expect(result.state.size).toBe(0);
-    expect(result.warnings).toHaveLength(1);
-    expect(result.warnings[0]).toContain("animateSurface");
-  });
-
-  it("tolerates non-array input and malformed entries", () => {
-    const nonArray = applyA2uiOperations(new Map(), { version: "v1.0" });
-    expect(nonArray.state.size).toBe(0);
-    expect(nonArray.warnings).toHaveLength(1);
-
-    const malformed = applyA2uiOperations(new Map(), [
-      null,
-      42,
-      {},
-      { version: "v2.0", deleteSurface: { surfaceId: "main" } },
-      {
-        version: "v1.0",
-        createSurface: { surfaceId: "main" },
-        deleteSurface: { surfaceId: "main" },
-      },
-      { version: "v1.0", updateComponents: null },
-      { version: "v1.0", deleteSurface: {} },
-    ]);
-
-    expect(malformed.state.size).toBe(0);
-    expect(malformed.warnings).toHaveLength(7);
-  });
-});