@assistant-ui/react 0.14.27 → 0.14.29

package/src/tests/DataRenderers.test.ts

@@ -1,355 +0,0 @@
-import { describe, it, expect } from "vitest";
-import type {
-  DataMessagePartComponent,
-  DataRenderersState,
-} from "@assistant-ui/core/react";
-
-// The resource in DataRenderers.ts requires fiber infrastructure, so these
-// tests replicate the reducer directly and exercise it in isolation.
-
-type StateHarness = {
-  state: DataRenderersState;
-  setDataUI: (name: string, render: DataMessagePartComponent) => () => void;
-  setFallbackDataUI: (render: DataMessagePartComponent) => () => void;
-};
-
-const createState = (): StateHarness => {
-  let state: DataRenderersState = { renderers: {}, fallbacks: [] };
-
-  const setDataUI = (name: string, render: DataMessagePartComponent) => {
-    state = {
-      ...state,
-      renderers: {
-        ...state.renderers,
-        [name]: [...(state.renderers[name] ?? []), render],
-      },
-    };
-    return () => {
-      state = {
-        ...state,
-        renderers: {
-          ...state.renderers,
-          [name]: state.renderers[name]?.filter((r) => r !== render) ?? [],
-        },
-      };
-    };
-  };
-
-  const setFallbackDataUI = (render: DataMessagePartComponent) => {
-    state = { ...state, fallbacks: [...state.fallbacks, render] };
-    return () => {
-      state = {
-        ...state,
-        fallbacks: state.fallbacks.filter((r) => r !== render),
-      };
-    };
-  };
-
-  return {
-    get state() {
-      return state;
-    },
-    setDataUI,
-    setFallbackDataUI,
-  };
-};
-
-describe("DataRenderers state logic", () => {
-  describe("initial state", () => {
-    it("should start with empty renderers and fallbacks", () => {
-      const { state } = createState();
-      expect(state.renderers).toEqual({});
-      expect(state.fallbacks).toEqual([]);
-    });
-  });
-
-  describe("setDataUI", () => {
-    it("should register a data renderer", () => {
-      const s = createState();
-      const Component = (() => null) as unknown as DataMessagePartComponent;
-
-      s.setDataUI("my-event", Component);
-
-      expect(s.state.renderers["my-event"]).toHaveLength(1);
-      expect(s.state.renderers["my-event"]![0]).toBe(Component);
-    });
-
-    it("should register multiple renderers for the same name", () => {
-      const s = createState();
-      const Component1 = (() => null) as unknown as DataMessagePartComponent;
-      const Component2 = (() => null) as unknown as DataMessagePartComponent;
-
-      s.setDataUI("my-event", Component1);
-      s.setDataUI("my-event", Component2);
-
-      expect(s.state.renderers["my-event"]).toHaveLength(2);
-      expect(s.state.renderers["my-event"]![0]).toBe(Component1);
-      expect(s.state.renderers["my-event"]![1]).toBe(Component2);
-    });
-
-    it("should register renderers for different names independently", () => {
-      const s = createState();
-      const Component1 = (() => null) as unknown as DataMessagePartComponent;
-      const Component2 = (() => null) as unknown as DataMessagePartComponent;
-
-      s.setDataUI("event-a", Component1);
-      s.setDataUI("event-b", Component2);
-
-      expect(s.state.renderers["event-a"]).toHaveLength(1);
-      expect(s.state.renderers["event-b"]).toHaveLength(1);
-      expect(s.state.renderers["event-a"]![0]).toBe(Component1);
-      expect(s.state.renderers["event-b"]![0]).toBe(Component2);
-    });
-
-    it("should unregister a renderer when cleanup is called", () => {
-      const s = createState();
-      const Component = (() => null) as unknown as DataMessagePartComponent;
-
-      const unsubscribe = s.setDataUI("my-event", Component);
-      expect(s.state.renderers["my-event"]).toHaveLength(1);
-
-      unsubscribe();
-      expect(s.state.renderers["my-event"]).toHaveLength(0);
-    });
-
-    it("should only unregister the specific renderer on cleanup", () => {
-      const s = createState();
-      const Component1 = (() => null) as unknown as DataMessagePartComponent;
-      const Component2 = (() => null) as unknown as DataMessagePartComponent;
-
-      const unsub1 = s.setDataUI("my-event", Component1);
-      s.setDataUI("my-event", Component2);
-
-      unsub1();
-
-      expect(s.state.renderers["my-event"]).toHaveLength(1);
-      expect(s.state.renderers["my-event"]![0]).toBe(Component2);
-    });
-
-    it("should not affect other names when unregistering", () => {
-      const s = createState();
-      const Component1 = (() => null) as unknown as DataMessagePartComponent;
-      const Component2 = (() => null) as unknown as DataMessagePartComponent;
-
-      const unsub1 = s.setDataUI("event-a", Component1);
-      s.setDataUI("event-b", Component2);
-
-      unsub1();
-
-      expect(s.state.renderers["event-a"]).toHaveLength(0);
-      expect(s.state.renderers["event-b"]).toHaveLength(1);
-    });
-  });
-});
-
-describe("DataRenderers fallback state logic", () => {
-  it("should register a fallback renderer", () => {
-    const s = createState();
-    const Fallback = (() => null) as unknown as DataMessagePartComponent;
-
-    s.setFallbackDataUI(Fallback);
-
-    expect(s.state.fallbacks).toHaveLength(1);
-    expect(s.state.fallbacks[0]).toBe(Fallback);
-  });
-
-  it("should unregister the fallback renderer on cleanup", () => {
-    const s = createState();
-    const Fallback = (() => null) as unknown as DataMessagePartComponent;
-
-    const unsub = s.setFallbackDataUI(Fallback);
-    expect(s.state.fallbacks).toHaveLength(1);
-
-    unsub();
-    expect(s.state.fallbacks).toHaveLength(0);
-  });
-
-  it("should stack fallbacks; the first registered takes priority", () => {
-    const s = createState();
-    const Fallback1 = (() => null) as unknown as DataMessagePartComponent;
-    const Fallback2 = (() => null) as unknown as DataMessagePartComponent;
-
-    s.setFallbackDataUI(Fallback1);
-    s.setFallbackDataUI(Fallback2);
-
-    expect(s.state.fallbacks).toEqual([Fallback1, Fallback2]);
-  });
-
-  it("should only unregister the specific fallback on cleanup", () => {
-    const s = createState();
-    const Fallback1 = (() => null) as unknown as DataMessagePartComponent;
-    const Fallback2 = (() => null) as unknown as DataMessagePartComponent;
-
-    const unsub1 = s.setFallbackDataUI(Fallback1);
-    s.setFallbackDataUI(Fallback2);
-
-    unsub1();
-    expect(s.state.fallbacks).toEqual([Fallback2]);
-  });
-
-  it("should restore the previous fallback when the active one unmounts", () => {
-    const s = createState();
-    const Fallback1 = (() => null) as unknown as DataMessagePartComponent;
-    const Fallback2 = (() => null) as unknown as DataMessagePartComponent;
-
-    s.setFallbackDataUI(Fallback1);
-    const unsub2 = s.setFallbackDataUI(Fallback2);
-
-    unsub2();
-    expect(s.state.fallbacks).toEqual([Fallback1]);
-  });
-
-  it("should not affect named renderers when setting fallback", () => {
-    const s = createState();
-    const Named = (() => null) as unknown as DataMessagePartComponent;
-    const Fallback = (() => null) as unknown as DataMessagePartComponent;
-
-    s.setDataUI("chart", Named);
-    s.setFallbackDataUI(Fallback);
-
-    expect(s.state.renderers["chart"]).toHaveLength(1);
-    expect(s.state.renderers["chart"]![0]).toBe(Named);
-    expect(s.state.fallbacks[0]).toBe(Fallback);
-  });
-});
-
-describe("Data part component resolution", () => {
-  const resolveDataComponent = (
-    partName: string,
-    inlineConfig?: {
-      by_name?: Record<string, DataMessagePartComponent | undefined>;
-      Fallback?: DataMessagePartComponent;
-    },
-    globalRenderers?: Record<string, DataMessagePartComponent[]>,
-    globalFallbacks?: DataMessagePartComponent[],
-  ): DataMessagePartComponent | undefined => {
-    const named = globalRenderers?.[partName]?.[0];
-    if (named) return named;
-    const inlineFallback =
-      inlineConfig?.by_name?.[partName] ?? inlineConfig?.Fallback;
-    return globalFallbacks?.[0] ?? inlineFallback;
-  };
-
-  it("should return undefined when no config provided", () => {
-    expect(resolveDataComponent("my-event")).toBeUndefined();
-  });
-
-  it("should return undefined when config has no matching name and no fallback", () => {
-    expect(resolveDataComponent("my-event", { by_name: {} })).toBeUndefined();
-  });
-
-  it("should resolve by_name component", () => {
-    const Component = (() => null) as unknown as DataMessagePartComponent;
-    const result = resolveDataComponent("my-event", {
-      by_name: { "my-event": Component },
-    });
-    expect(result).toBe(Component);
-  });
-
-  it("should fall back to Fallback when name not in by_name", () => {
-    const Fallback = (() => null) as unknown as DataMessagePartComponent;
-    const result = resolveDataComponent("unknown-event", {
-      by_name: {},
-      Fallback,
-    });
-    expect(result).toBe(Fallback);
-  });
-
-  it("should prefer by_name over Fallback", () => {
-    const SpecificComponent = (() =>
-      null) as unknown as DataMessagePartComponent;
-    const Fallback = (() => null) as unknown as DataMessagePartComponent;
-    const result = resolveDataComponent("my-event", {
-      by_name: { "my-event": SpecificComponent },
-      Fallback,
-    });
-    expect(result).toBe(SpecificComponent);
-  });
-
-  it("should prefer global registration over inline config", () => {
-    const InlineComponent = (() => null) as unknown as DataMessagePartComponent;
-    const GlobalComponent = (() => null) as unknown as DataMessagePartComponent;
-
-    const result = resolveDataComponent(
-      "my-event",
-      { by_name: { "my-event": InlineComponent } },
-      { "my-event": [GlobalComponent] },
-    );
-    expect(result).toBe(GlobalComponent);
-  });
-
-  it("should fall back to inline when global has no match", () => {
-    const InlineComponent = (() => null) as unknown as DataMessagePartComponent;
-
-    const result = resolveDataComponent(
-      "my-event",
-      { by_name: { "my-event": InlineComponent } },
-      {},
-    );
-    expect(result).toBe(InlineComponent);
-  });
-
-  it("should fall back to inline Fallback when global has empty array", () => {
-    const Fallback = (() => null) as unknown as DataMessagePartComponent;
-
-    const result = resolveDataComponent(
-      "my-event",
-      { Fallback },
-      { "my-event": [] },
-    );
-    expect(result).toBe(Fallback);
-  });
-
-  // --- Global fallback stack resolution ---
-
-  it("should use global fallback when no name-specific renderer exists", () => {
-    const GlobalFallback = (() => null) as unknown as DataMessagePartComponent;
-
-    const result = resolveDataComponent("unknown-widget", undefined, {}, [
-      GlobalFallback,
-    ]);
-    expect(result).toBe(GlobalFallback);
-  });
-
-  it("should prefer global name-match over global fallback", () => {
-    const NamedComponent = (() => null) as unknown as DataMessagePartComponent;
-    const GlobalFallback = (() => null) as unknown as DataMessagePartComponent;
-
-    const result = resolveDataComponent(
-      "chart",
-      undefined,
-      { chart: [NamedComponent] },
-      [GlobalFallback],
-    );
-    expect(result).toBe(NamedComponent);
-  });
-
-  it("should prefer the first global fallback over inline Fallback", () => {
-    const InlineFallback = (() => null) as unknown as DataMessagePartComponent;
-    const GlobalFallback = (() => null) as unknown as DataMessagePartComponent;
-
-    const result = resolveDataComponent(
-      "unknown",
-      { Fallback: InlineFallback },
-      {},
-      [GlobalFallback],
-    );
-    expect(result).toBe(GlobalFallback);
-  });
-
-  it("should pick the first registered when multiple fallbacks are stacked", () => {
-    const First = (() => null) as unknown as DataMessagePartComponent;
-    const Second = (() => null) as unknown as DataMessagePartComponent;
-
-    const result = resolveDataComponent("anything", undefined, {}, [
-      First,
-      Second,
-    ]);
-    expect(result).toBe(First);
-  });
-
-  it("should return undefined when no fallbacks of any kind exist", () => {
-    const result = resolveDataComponent("unknown", undefined, {}, []);
-    expect(result).toBeUndefined();
-  });
-});