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

package/src/ir.test.ts

@@ -1,203 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  normalizeSpec,
-  normalizeUINode,
-  type NormalizedUIElement,
-  type NormalizedUINode,
-} from "./ir";
-
-/** Narrows a normalized node to its element form for property assertions. */
-const asElement = (node: NormalizedUINode): NormalizedUIElement => {
-  if (node === null || typeof node === "string" || typeof node === "number") {
-    throw new Error(`expected an element, got ${node as unknown as string}`);
-  }
-  if (Array.isArray(node)) {
-    throw new Error("expected an element, got an array");
-  }
-  return node as NormalizedUIElement;
-};
-
-describe("normalizeUINode", () => {
-  describe("text leaf", () => {
-    it("passes a string through", () => {
-      expect(normalizeUINode("hello")).toBe("hello");
-    });
-  });
-
-  describe("legacy component shape", () => {
-    it("maps component + nested props to the canonical element", () => {
-      const node = asElement(
-        normalizeUINode({
-          component: "Card",
-          props: { padding: 4 },
-          children: ["inside"],
-          key: "c1",
-        }),
-      );
-
-      expect(node).toEqual({
-        type: "Card",
-        props: { padding: 4 },
-        children: ["inside"],
-        key: "c1",
-        action: undefined,
-      });
-    });
-
-    it("defaults missing props to an empty bag and carries no action", () => {
-      const node = asElement(normalizeUINode({ component: "Divider" }));
-      expect(node.props).toEqual({});
-      expect(node.children).toBeUndefined();
-      expect(node.action).toBeUndefined();
-    });
-  });
-
-  describe("flat $type shape", () => {
-    it("keeps inline props and strips reserved keys", () => {
-      const node = asElement(
-        normalizeUINode({
-          $type: "Text",
-          value: "hi",
-          size: "md",
-          weight: "semibold",
-        }),
-      );
-
-      expect(node.type).toBe("Text");
-      expect(node.props).toEqual({
-        value: "hi",
-        size: "md",
-        weight: "semibold",
-      });
-      expect(node.children).toBeUndefined();
-    });
-
-    it("lets a component use `type` as an ordinary prop (no collision)", () => {
-      const node = asElement(
-        normalizeUINode({
-          $type: "Button",
-          type: "submit",
-          label: "Go",
-        }),
-      );
-
-      expect(node.type).toBe("Button");
-      expect(node.props).toEqual({ type: "submit", label: "Go" });
-    });
-
-    it("routes a flat `$type` node with a `component` prop to the flat branch, not the legacy one", () => {
-      const node = asElement(
-        normalizeUINode({
-          $type: "Schema",
-          component: "display-name",
-          label: "Go",
-        }),
-      );
-
-      expect(node.type).toBe("Schema");
-      expect(node.props).toEqual({ component: "display-name", label: "Go" });
-    });
-
-    it("threads $action and $key through as action/key", () => {
-      const node = asElement(
-        normalizeUINode({
-          $type: "Button",
-          $key: "buy",
-          label: "Purchase",
-          $action: { type: "purchase", itemId: "sku-1" },
-        }),
-      );
-
-      expect(node.key).toBe("buy");
-      expect(node.action).toEqual({ type: "purchase", itemId: "sku-1" });
-      expect(node.props).toEqual({ label: "Purchase" });
-    });
-
-    it("strips the whole $-prefixed namespace from props (not just the named keys)", () => {
-      const node = asElement(
-        normalizeUINode({
-          $type: "Card",
-          $status: "done",
-          $custom: 1,
-          title: "hi",
-        }),
-      );
-
-      expect(node.props).toEqual({ title: "hi" });
-      expect("$status" in node.props).toBe(false);
-      expect("$custom" in node.props).toBe(false);
-    });
-  });
-
-  describe("nesting", () => {
-    it("recurses through children of both shapes", () => {
-      const node = asElement(
-        normalizeUINode({
-          $type: "Col",
-          children: [
-            { component: "Text", props: { value: "a" } },
-            { $type: "Text", value: "b" },
-            "leaf",
-          ],
-        }),
-      );
-
-      expect(node.children).toEqual([
-        {
-          type: "Text",
-          props: { value: "a" },
-          children: undefined,
-          key: undefined,
-          action: undefined,
-        },
-        {
-          type: "Text",
-          props: { value: "b" },
-          children: undefined,
-          key: undefined,
-          action: undefined,
-        },
-        "leaf",
-      ]);
-    });
-  });
-
-  describe("malformed input", () => {
-    it("resolves a node without $type or component to null", () => {
-      expect(normalizeUINode({ foo: "bar" } as unknown as never)).toBeNull();
-    });
-
-    it("resolves non-record input: null and boolean to null, number to a text leaf", () => {
-      expect(normalizeUINode(null as unknown as never)).toBeNull();
-      expect(normalizeUINode(true as unknown as never)).toBeNull();
-      expect(normalizeUINode(42 as unknown as never)).toBe(42);
-    });
-  });
-});
-
-describe("normalizeSpec", () => {
-  it("normalizes a single root", () => {
-    expect(normalizeSpec({ $type: "Text", value: "x" }).root).toEqual({
-      type: "Text",
-      props: { value: "x" },
-      children: undefined,
-      key: undefined,
-      action: undefined,
-    });
-  });
-
-  it("normalizes a list root", () => {
-    const { root } = normalizeSpec([{ $type: "Text", value: "a" }, "b"]);
-    expect(Array.isArray(root)).toBe(true);
-    expect(root).toEqual([
-      {
-        type: "Text",
-        props: { value: "a" },
-        children: undefined,
-        key: undefined,
-        action: undefined,
-      },
-      "b",
-    ]);
-  });
-});

package/src/renderGenerativeUI.test.tsx

@@ -1,373 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { renderToStaticMarkup } from "react-dom/server";
-import { isValidElement, type ReactElement } from "react";
-import { parsePartialJsonObject } from "assistant-stream/utils";
-import { z } from "zod";
-import { renderGenerativeUI } from "./renderGenerativeUI";
-import { buildPresentParameters } from "./buildPresentParameters";
-import type { GenerativeUILibrary } from "./types";
-
-const library: GenerativeUILibrary = {
-  Card: {
-    description: "A card container.",
-    properties: z.object({ title: z.string() }),
-    render: ({ title, children }: any) => (
-      <section data-title={title}>{children}</section>
-    ),
-  },
-  Text: {
-    description: "A run of text.",
-    properties: z.object({ tone: z.enum(["muted", "normal"]).optional() }),
-    render: ({ tone, children }: any) => <p data-tone={tone}>{children}</p>,
-  },
-  Button: {
-    description: "A button with its own `type` prop.",
-    properties: z.object({ type: z.enum(["button", "submit"]) }),
-    render: ({ type, children }: any) => (
-      <button type={type}>{children}</button>
-    ),
-  },
-  Live: {
-    description: "Renders from partial props while streaming.",
-    properties: z.object({ label: z.string() }),
-    streamProperties: true,
-    render: (props) => (
-      <span data-status={props.$status}>{props.label ?? "…"}</span>
-    ),
-  },
-};
-
-describe("renderGenerativeUI", () => {
-  it("renders a component and passes its props", () => {
-    const html = renderToStaticMarkup(
-      <>{renderGenerativeUI({ $type: "Text", tone: "muted" }, library)}</>,
-    );
-    expect(html).toBe('<p data-tone="muted"></p>');
-  });
-
-  it("renders children recursively", () => {
-    const html = renderToStaticMarkup(
-      <>
-        {renderGenerativeUI(
-          {
-            $type: "Card",
-            title: "Hello",
-            children: [
-              { $type: "Text", children: "first" },
-              { $type: "Text", tone: "muted", children: "second" },
-            ],
-          },
-          library,
-        )}
-      </>,
-    );
-    expect(html).toBe(
-      '<section data-title="Hello"><p>first</p><p data-tone="muted">second</p></section>',
-    );
-  });
-
-  it("uses stable $key for array items and keeps the positional fallback", () => {
-    const out = renderGenerativeUI(
-      [
-        { $type: "Text", $key: "1:Text", children: "first" },
-        { $type: "Text", children: "second" },
-        "plain",
-        { $type: "Text", $key: { id: "bad" }, children: "bad key" },
-      ],
-      library,
-    );
-
-    expect(isValidElement(out)).toBe(true);
-    const elements = (out as ReactElement<{ children: ReactElement[] }>).props
-      .children;
-    expect(Array.isArray(elements)).toBe(true);
-    expect(elements.every(isValidElement)).toBe(true);
-    expect(elements.map((element) => element.key)).toEqual([
-      "model:1:Text",
-      "1:Text",
-      "2:#text",
-      "3:Text",
-    ]);
-  });
-
-  it("passes a component's own `type` prop through without collision", () => {
-    const html = renderToStaticMarkup(
-      <>
-        {renderGenerativeUI(
-          { $type: "Button", type: "submit", children: "Go" },
-          library,
-        )}
-      </>,
-    );
-    expect(html).toBe('<button type="submit">Go</button>');
-  });
-
-  it("renders a string child directly", () => {
-    const html = renderToStaticMarkup(
-      <>{renderGenerativeUI({ $type: "Card", children: "plain" }, library)}</>,
-    );
-    expect(html).toBe("<section><p></p></section>".replace("<p></p>", "plain"));
-  });
-
-  it("renders nothing for an unknown component", () => {
-    const rendered = renderGenerativeUI({ $type: "Missing" }, library);
-    expect(rendered).toBeNull();
-    const html = renderToStaticMarkup(<>{rendered}</>);
-    expect(html).toBe("");
-  });
-
-  it.each(["plain", 42, null])(
-    "preserves a primitive root result: %j",
-    (value) => {
-      expect(renderGenerativeUI(value, library)).toBe(value);
-    },
-  );
-
-  it.each(["toString", "constructor"])(
-    "treats inherited %s as an unknown component",
-    (type) => {
-      const html = renderToStaticMarkup(
-        <>{renderGenerativeUI({ $type: type }, library)}</>,
-      );
-      expect(html).toBe("");
-    },
-  );
-
-  it("renders an explicitly registered prototype-named component", () => {
-    const prototypeNamedLibrary: GenerativeUILibrary = {
-      ...library,
-      toString: {
-        description: "An explicitly registered component.",
-        properties: z.object({}),
-        render: () => <span>registered</span>,
-      },
-    };
-
-    const html = renderToStaticMarkup(
-      <>{renderGenerativeUI({ $type: "toString" }, prototypeNamedLibrary)}</>,
-    );
-    expect(html).toBe("<span>registered</span>");
-  });
-
-  it("holds back a node whose `$type` is still streaming", () => {
-    const error = vi.spyOn(console, "error").mockImplementation(() => {});
-    try {
-      for (const argsText of ['{"$type": "', '{"$type": "Tex']) {
-        const html = renderToStaticMarkup(
-          <>
-            {renderGenerativeUI(parsePartialJsonObject(argsText), library, {
-              status: "streaming",
-            })}
-          </>,
-        );
-        expect(html).toBe("");
-      }
-      expect(error).not.toHaveBeenCalled();
-    } finally {
-      error.mockRestore();
-    }
-  });
-
-  it("renders completed siblings while a nested `$type` streams", () => {
-    const error = vi.spyOn(console, "error").mockImplementation(() => {});
-    try {
-      const args = parsePartialJsonObject(
-        '{"$type": "Live", "label": "hi", "children": [{"$type": "Liv',
-      );
-      const html = renderToStaticMarkup(
-        <>{renderGenerativeUI(args, library, { status: "streaming" })}</>,
-      );
-      expect(html).toBe('<span data-status="streaming">hi</span>');
-      expect(error).not.toHaveBeenCalled();
-    } finally {
-      error.mockRestore();
-    }
-  });
-
-  it("renders nothing for a node without a resolved type", () => {
-    const html = renderToStaticMarkup(<>{renderGenerativeUI({}, library)}</>);
-    expect(html).toBe("");
-  });
-
-  it("bounds deeply nested trees instead of overflowing the stack", () => {
-    let node: any = { $type: "Text", children: "deep" };
-    for (let i = 0; i < 5000; i++) node = { $type: "Card", children: node };
-    expect(() =>
-      renderToStaticMarkup(<>{renderGenerativeUI(node, library)}</>),
-    ).not.toThrow();
-  });
-
-  it("passes the status to render and tolerates partial props while streaming", () => {
-    const html = renderToStaticMarkup(
-      <>
-        {renderGenerativeUI({ $type: "Live" }, library, {
-          status: "streaming",
-        })}
-      </>,
-    );
-    expect(html).toBe('<span data-status="streaming">…</span>');
-  });
-
-  it("gates opt-out components until their props are complete", () => {
-    const streaming = renderToStaticMarkup(
-      <>
-        {renderGenerativeUI({ $type: "Card", title: "x" }, library, {
-          status: "streaming",
-        })}
-      </>,
-    );
-    expect(streaming).toBe("");
-
-    const done = renderToStaticMarkup(
-      <>
-        {renderGenerativeUI({ $type: "Card", title: "x" }, library, {
-          status: "done",
-        })}
-      </>,
-    );
-    expect(done).toBe('<section data-title="x"></section>');
-  });
-});
-
-describe("buildPresentParameters", () => {
-  it("produces a flat object schema with no top-level oneOf/anyOf", () => {
-    const schema = buildPresentParameters(library) as any;
-
-    expect(schema.type).toBe("object");
-    expect(schema.required).toEqual(["$type"]);
-    // Tool/function-call schemas reject these at the top level.
-    expect(schema.oneOf).toBeUndefined();
-    expect(schema.anyOf).toBeUndefined();
-
-    expect(schema.properties.$type.enum).toEqual([
-      "Card",
-      "Text",
-      "Button",
-      "Live",
-    ]);
-    // each component's description rides along on the $type enum.
-    expect(schema.properties.$type.description).toContain("Card");
-    expect(schema.properties.$key).toEqual({
-      description:
-        "Stable identity for this UI node. Use it for list items that may reorder.",
-      anyOf: [{ type: "string" }, { type: "number" }],
-    });
-    expect(schema.properties.children.$ref).toBe("#/$defs/children");
-
-    // every component's props are merged into the one flat property bag.
-    expect(schema.properties.title).toBeDefined(); // Card
-    expect(schema.properties.tone).toBeDefined(); // Text
-    expect(schema.properties.type).toBeDefined(); // Button's own `type` prop
-    expect(schema.properties.label).toBeDefined(); // Live
-
-    // children recurses back into a node.
-    expect(schema.$defs.children.anyOf).toContainEqual({
-      $ref: "#/$defs/node",
-    });
-    expect(schema.$defs.node.type).toBe("object");
-    expect(schema.$defs.node.oneOf).toBeUndefined();
-  });
-
-  it("drops author-declared `$`-prefixed and `children` props, keeping framework fields", () => {
-    const schema = buildPresentParameters({
-      Reserved: {
-        description: "Declares reserved keys that must not leak through.",
-        properties: z.object({
-          $type: z.number(),
-          $key: z.boolean(),
-          $action: z.string(),
-          children: z.number(),
-          label: z.string(),
-        }),
-        render: () => null,
-      },
-    }) as any;
-
-    // The discriminator is the framework enum, not the author's `$type`; the
-    // author's `$`-prefixed props and `children` are dropped in favor of the
-    // framework fields.
-    expect(schema.properties.$type.enum).toEqual(["Reserved"]);
-    expect(schema.properties.$key).toEqual({
-      description:
-        "Stable identity for this UI node. Use it for list items that may reorder.",
-      anyOf: [{ type: "string" }, { type: "number" }],
-    });
-    expect(schema.properties.$action).toBeUndefined();
-    expect(schema.properties.children.$ref).toBe("#/$defs/children");
-    expect(schema.properties.label).toBeDefined();
-    expect(schema.required).toEqual(["$type"]);
-  });
-
-  it("keeps props whose names are inherited from Object.prototype", () => {
-    const schema = buildPresentParameters({
-      PrototypeProps: {
-        description: "Declares props that shadow Object.prototype members.",
-        properties: z.object({
-          toString: z.string(),
-          valueOf: z.number(),
-          constructor: z.boolean(),
-        }),
-        render: () => null,
-      },
-    }) as any;
-
-    expect(schema.properties.toString.type).toBe("string");
-    expect(schema.properties.valueOf.type).toBe("number");
-    expect(schema.properties.constructor.type).toBe("boolean");
-  });
-
-  it("omits __proto__, which the tool-argument decoder rejects", () => {
-    const schema = buildPresentParameters({
-      PrototypeProps: {
-        description: "Declares an undeliverable prop name.",
-        properties: z.object({ ["__proto__"]: z.number(), label: z.string() }),
-        render: () => null,
-      },
-    }) as any;
-
-    expect(Object.hasOwn(schema.properties, "__proto__")).toBe(false);
-    expect(schema.properties.label.type).toBe("string");
-  });
-
-  it("names every component that declares the same prop in the dev warning", () => {
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    try {
-      buildPresentParameters({
-        Select: {
-          description: "Selects an option.",
-          properties: z.object({ value: z.string() }),
-          render: () => null,
-        },
-        DatePicker: {
-          description: "Picks a date.",
-          properties: z.object({ value: z.string() }),
-          render: () => null,
-        },
-        Combobox: {
-          description: "Chooses from filtered options.",
-          properties: z.object({ value: z.string() }),
-          render: () => null,
-        },
-      });
-
-      expect(warn).toHaveBeenCalledTimes(1);
-      expect(warn).toHaveBeenCalledWith(
-        '[@assistant-ui/react-generative-ui] Prop "value" is declared by "Select", "DatePicker", and "Combobox"; keeping "Select"\'s schema. Rename or align the prop type to avoid an ambiguous schema.',
-      );
-    } finally {
-      warn.mockRestore();
-    }
-  });
-
-  it("throws when a component's properties is not an object schema", () => {
-    expect(() =>
-      buildPresentParameters({
-        Bad: {
-          description: "Non-object props.",
-          properties: z.string() as never,
-          render: () => null,
-        },
-      }),
-    ).toThrow(/must be an object schema/);
-  });
-});