@iloveagents/foundry-web-ui 0.3.1 → 0.5.0

package/src/lib/__tests__/attachment-adapter.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { FileAttachmentAdapter } from "../attachment-adapter";
-
-const adapter = new FileAttachmentAdapter();
-
-describe("FileAttachmentAdapter.add", () => {
-  it("uses browser-supplied MIME type", async () => {
-    const file = new File(["x"], "photo.png", { type: "image/png" });
-    const result = await adapter.add({ file });
-    expect(result.contentType).toBe("image/png");
-    expect(result.type).toBe("image");
-  });
-
-  it("resolves MIME from extension when browser type is empty", async () => {
-    const file = new File(["x"], "report.docx", { type: "" });
-    const result = await adapter.add({ file });
-    expect(result.contentType).toBe(
-      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    );
-    expect(result.type).toBe("document");
-  });
-
-  it("falls back to application/octet-stream for unknown extensions", async () => {
-    const file = new File(["x"], "data.xyz", { type: "" });
-    const result = await adapter.add({ file });
-    expect(result.contentType).toBe("application/octet-stream");
-  });
-
-  it("throws for files exceeding 20 MB", async () => {
-    const big = new File(["x"], "big.png", { type: "image/png" });
-    Object.defineProperty(big, "size", { value: 20 * 1024 * 1024 + 1 });
-    await expect(adapter.add({ file: big })).rejects.toThrow("File too large");
-  });
-
-  it("accepts a file at exactly 20 MB", async () => {
-    const exact = new File(["x"], "ok.png", { type: "image/png" });
-    Object.defineProperty(exact, "size", { value: 20 * 1024 * 1024 });
-    await expect(adapter.add({ file: exact })).resolves.toBeDefined();
-  });
-
-  it("classifies images vs documents correctly", async () => {
-    const image = new File(["x"], "pic.jpg", { type: "image/jpeg" });
-    const pdf = new File(["x"], "doc.pdf", { type: "application/pdf" });
-
-    expect((await adapter.add({ file: image })).type).toBe("image");
-    expect((await adapter.add({ file: pdf })).type).toBe("document");
-  });
-});

package/src/lib/__tests__/chat-bubble-store.test.ts

@@ -1,67 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { useChatBubbleStore } from "../chat-bubble-store";
-
-const reset = () =>
-  useChatBubbleStore.setState({ isOpen: false, isExpanded: false, showPagePanel: true });
-const store = () => useChatBubbleStore.getState();
-
-describe("chat-bubble-store", () => {
-  beforeEach(reset);
-
-  it("starts closed", () => {
-    expect(store().isOpen).toBe(false);
-    expect(store().isExpanded).toBe(false);
-  });
-
-  it("open sets isOpen to true", () => {
-    store().open();
-    expect(store().isOpen).toBe(true);
-    expect(store().isExpanded).toBe(false);
-  });
-
-  it("close resets both states", () => {
-    store().expand();
-    store().close();
-    expect(store().isOpen).toBe(false);
-    expect(store().isExpanded).toBe(false);
-  });
-
-  it("toggle flips isOpen", () => {
-    store().toggle();
-    expect(store().isOpen).toBe(true);
-    store().toggle();
-    expect(store().isOpen).toBe(false);
-  });
-
-  it("expand hides bubble and shows expanded layout", () => {
-    store().open();
-    store().expand();
-    expect(store().isOpen).toBe(false);
-    expect(store().isExpanded).toBe(true);
-  });
-
-  it("collapse returns to bubble mode", () => {
-    store().expand();
-    store().collapse();
-    expect(store().isOpen).toBe(true);
-    expect(store().isExpanded).toBe(false);
-  });
-
-  it("expand defaults to showing page panel", () => {
-    store().expand();
-    expect(store().showPagePanel).toBe(true);
-    store().togglePagePanel();
-    expect(store().showPagePanel).toBe(false);
-    store().collapse();
-    store().expand();
-    expect(store().showPagePanel).toBe(true);
-  });
-
-  it("togglePagePanel flips showPagePanel", () => {
-    expect(store().showPagePanel).toBe(true);
-    store().togglePagePanel();
-    expect(store().showPagePanel).toBe(false);
-    store().togglePagePanel();
-    expect(store().showPagePanel).toBe(true);
-  });
-});

package/src/lib/__tests__/client-tools.test.ts

@@ -1,124 +0,0 @@
-// @vitest-environment jsdom
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-// Mock matchMedia before importing modules that use theme-store
-vi.stubGlobal(
-  "matchMedia",
-  vi.fn().mockReturnValue({
-    matches: false,
-    addEventListener: vi.fn(),
-    removeEventListener: vi.fn(),
-  }),
-);
-
-const { clientToolRegistry } = await import("@iloveagents/foundry-agent");
-await import("../client-tools"); // triggers registerGlobalTools()
-
-const registry = () => clientToolRegistry.getState();
-
-describe("Global tool registration", () => {
-  it("registers all global tools with ui_ prefix", () => {
-    const names = registry()
-      .getActiveSchemas()
-      .map((s) => s.name)
-      .sort();
-    expect(names).toEqual([
-      "ui_confirm",
-      "ui_get_context",
-      "ui_highlight",
-      "ui_navigate",
-      "ui_open_panel",
-      "ui_select_item",
-      "ui_set_theme",
-      "ui_update_content",
-    ]);
-  });
-
-  it("each schema has required fields", () => {
-    for (const schema of registry().getActiveSchemas()) {
-      expect(schema.name).toBeTruthy();
-      expect(schema.description).toBeTruthy();
-      expect(schema.parameters).toBeDefined();
-    }
-  });
-});
-
-describe("isRegistered", () => {
-  it("returns true for global tools", () => {
-    expect(registry().isRegistered("ui_navigate")).toBe(true);
-    expect(registry().isRegistered("ui_set_theme")).toBe(true);
-  });
-
-  it("returns false for unknown tools", () => {
-    expect(registry().isRegistered("unknown_tool")).toBe(false);
-  });
-});
-
-describe("executeTool", () => {
-  it("ui_set_theme returns success", async () => {
-    const result = await registry().executeTool("ui_set_theme", '{"mode":"dark"}');
-    expect(JSON.parse(result).status).toBe("success");
-  });
-
-  it("ui_confirm returns pending", async () => {
-    const result = await registry().executeTool("ui_confirm", '{"action":"Delete"}');
-    expect(JSON.parse(result).status).toBe("pending");
-  });
-
-  it("ui_update_content updates multiple fields", async () => {
-    const result = await registry().executeTool(
-      "ui_update_content",
-      '{"fields":{"title":"Test","priority":"High"}}',
-    );
-    const parsed = JSON.parse(result);
-    expect(parsed.status).toBe("success");
-    expect(parsed.fields).toEqual({ title: "Test", priority: "High" });
-  });
-
-  it("unknown tool returns error", async () => {
-    const result = await registry().executeTool("unknown", "{}");
-    expect(JSON.parse(result).error).toContain("Unknown client tool");
-  });
-});
-
-describe("Page tools", () => {
-  beforeEach(() => {
-    registry().clearPageTools();
-  });
-
-  it("registers and clears page tools", () => {
-    const before = registry().getActiveSchemas().length;
-
-    registry().registerPageTools([
-      {
-        name: "page_custom_tool",
-        description: "Page tool",
-        parameters: { type: "object", properties: {} },
-        execute: async () => JSON.stringify({ ok: true }),
-      },
-    ]);
-
-    expect(registry().getActiveSchemas().length).toBe(before + 1);
-    expect(registry().isRegistered("page_custom_tool")).toBe(true);
-
-    registry().clearPageTools();
-    expect(registry().isRegistered("page_custom_tool")).toBe(false);
-  });
-
-  it("page tools can be executed", async () => {
-    registry().registerPageTools([
-      {
-        name: "page_my_tool",
-        description: "Test",
-        parameters: { type: "object", properties: {} },
-        execute: async (argsJson) => {
-          const { value } = JSON.parse(argsJson);
-          return JSON.stringify({ received: value });
-        },
-      },
-    ]);
-
-    const result = await registry().executeTool("page_my_tool", '{"value":"hello"}');
-    expect(JSON.parse(result).received).toBe("hello");
-  });
-});

package/src/lib/__tests__/dev-store.test.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { useDevStore } from "../dev-store.ts";
-import type { DevToolCall } from "../dev-store.ts";
-
-function makeToolCall(id: string): DevToolCall {
-  return {
-    id,
-    name: `tool_${id}`,
-    args: "{}",
-    isClientSide: false,
-    timestamp: Date.now(),
-  };
-}
-
-describe("useDevStore", () => {
-  beforeEach(() => {
-    useDevStore.setState({
-      lastRequest: null,
-      lastRequestAt: null,
-      toolCalls: [],
-      events: [],
-    });
-  });
-
-  describe("captureRequest", () => {
-    it("stores request payload and timestamp", () => {
-      useDevStore.getState().captureRequest({ thread_id: "t1" });
-      expect(useDevStore.getState().lastRequest).toEqual({ thread_id: "t1" });
-      expect(useDevStore.getState().lastRequestAt).toBeTypeOf("number");
-    });
-
-    it("resets tool calls and events on fresh turn", () => {
-      useDevStore.getState().logEvent("TEXT_DELTA");
-      useDevStore.getState().captureRequest({ thread_id: "t1" });
-      expect(useDevStore.getState().toolCalls).toEqual([]);
-      expect(useDevStore.getState().events).toEqual([]);
-    });
-
-    it("preserves tool calls on follow-up (multi-turn)", () => {
-      useDevStore.getState().addToolCall(makeToolCall("tc1"));
-      useDevStore.getState().captureRequest({ thread_id: "t1" });
-      expect(useDevStore.getState().toolCalls.length).toBe(1);
-    });
-  });
-
-  describe("addToolCall", () => {
-    it("appends tool call", () => {
-      useDevStore.getState().addToolCall(makeToolCall("tc1"));
-      useDevStore.getState().addToolCall(makeToolCall("tc2"));
-      expect(useDevStore.getState().toolCalls.length).toBe(2);
-    });
-  });
-
-  describe("updateToolCall", () => {
-    it("updates args and result by id", () => {
-      useDevStore.getState().addToolCall(makeToolCall("tc1"));
-      useDevStore.getState().updateToolCall("tc1", { result: { temp: 22 } });
-      expect(useDevStore.getState().toolCalls[0].result).toEqual({ temp: 22 });
-    });
-  });
-
-  describe("logEvent", () => {
-    it("appends events", () => {
-      useDevStore.getState().logEvent("TEXT_DELTA", "hello");
-      expect(useDevStore.getState().events.length).toBe(1);
-      expect(useDevStore.getState().events[0].type).toBe("TEXT_DELTA");
-    });
-
-    it("caps at MAX_EVENTS (50)", () => {
-      for (let i = 0; i < 60; i++) {
-        useDevStore.getState().logEvent(`EVENT_${i}`);
-      }
-      expect(useDevStore.getState().events.length).toBe(50);
-      // Should keep the last 50 (events 10-59)
-      expect(useDevStore.getState().events[0].type).toBe("EVENT_10");
-    });
-  });
-});

package/src/lib/__tests__/nav-config.test.ts

@@ -1,135 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { findNavItem, DEFAULT_NAV_CONFIG, type NavGroup } from "../nav-config";
-
-describe("findNavItem", () => {
-  it("finds item in default config", () => {
-    const result = findNavItem(DEFAULT_NAV_CONFIG, "/");
-    expect(result).not.toBeNull();
-    expect(result!.group).toBe("Pages");
-    expect(result!.item.label).toBe("Chat");
-    expect(result!.item.description).toBeTruthy();
-  });
-
-  it("returns null for unknown path", () => {
-    expect(findNavItem(DEFAULT_NAV_CONFIG, "/unknown")).toBeNull();
-  });
-
-  it("finds item across multiple groups", () => {
-    const config: NavGroup[] = [
-      ...DEFAULT_NAV_CONFIG,
-      {
-        label: "Contracts",
-        items: [
-          {
-            to: "/contracts/123",
-            label: "Acme NDA",
-            icon: DEFAULT_NAV_CONFIG[0].items[0].icon,
-            description: "Review NDA",
-            meta: { contractId: "123" },
-          },
-        ],
-      },
-    ];
-
-    const result = findNavItem(config, "/contracts/123");
-    expect(result).not.toBeNull();
-    expect(result!.group).toBe("Contracts");
-    expect(result!.item.label).toBe("Acme NDA");
-    expect(result!.item.meta).toEqual({ contractId: "123" });
-  });
-
-  it("returns first match when paths duplicate across groups", () => {
-    const config: NavGroup[] = [
-      {
-        label: "A",
-        items: [{ to: "/x", label: "X-A", icon: DEFAULT_NAV_CONFIG[0].items[0].icon }],
-      },
-      {
-        label: "B",
-        items: [{ to: "/x", label: "X-B", icon: DEFAULT_NAV_CONFIG[0].items[0].icon }],
-      },
-    ];
-    const result = findNavItem(config, "/x");
-    expect(result!.group).toBe("A");
-  });
-
-  it("all default config items are findable", () => {
-    for (const group of DEFAULT_NAV_CONFIG) {
-      for (const item of group.items) {
-        const result = findNavItem(DEFAULT_NAV_CONFIG, item.to);
-        expect(result).not.toBeNull();
-        expect(result!.item.to).toBe(item.to);
-      }
-    }
-  });
-
-  it("finds deeply nested child items", () => {
-    const icon = DEFAULT_NAV_CONFIG[0].items[0].icon;
-    const config: NavGroup[] = [
-      {
-        label: "Workspaces",
-        items: [
-          {
-            to: "/spaces/root",
-            label: "Workspace",
-            icon,
-            children: [
-              {
-                to: "/spaces/folder",
-                label: "Folder",
-                icon,
-                children: [
-                  {
-                    to: "/spaces/entity",
-                    label: "Entity",
-                    icon,
-                    meta: { spacesEntityId: "entity" },
-                  },
-                ],
-              },
-            ],
-          },
-        ],
-      },
-    ];
-
-    const result = findNavItem(config, "/spaces/entity");
-    expect(result).not.toBeNull();
-    expect(result!.item.label).toBe("Entity");
-    expect(result!.item.meta).toEqual({ spacesEntityId: "entity" });
-  });
-
-  it("uses the deepest prefix match for nested routes", () => {
-    const icon = DEFAULT_NAV_CONFIG[0].items[0].icon;
-    const config: NavGroup[] = [
-      {
-        label: "Workspaces",
-        items: [
-          {
-            to: "/spaces/root",
-            label: "Workspace",
-            icon,
-            children: [
-              {
-                to: "/spaces/root/views",
-                label: "Views",
-                icon,
-                children: [
-                  {
-                    to: "/spaces/root/views/contradictions",
-                    label: "Contradictions",
-                    icon,
-                  },
-                ],
-              },
-            ],
-          },
-        ],
-      },
-    ];
-
-    const result = findNavItem(config, "/spaces/root/views/contradictions/details");
-    expect(result).not.toBeNull();
-    expect(result!.item.label).toBe("Contradictions");
-  });
-});

package/src/lib/__tests__/nav-dnd.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getContainerDropZoneLabel, hasAnyDropTarget, hasExternalFilesData } from "../nav-dnd";
-
-describe("nav-dnd helpers", () => {
-  it("detects external file drags from Files type alone", () => {
-    expect(
-      hasExternalFilesData({
-        types: ["Files"],
-        files: { length: 0 },
-      }),
-    ).toBe(true);
-  });
-
-  it("treats file-only targets as active drop targets", () => {
-    expect(hasAnyDropTarget(false, true)).toBe(true);
-    expect(hasAnyDropTarget(true, false)).toBe(true);
-    expect(hasAnyDropTarget(false, false)).toBe(false);
-  });
-
-  it("uses upload copy for external file container drops", () => {
-    expect(getContainerDropZoneLabel(true)).toBe("Upload to root");
-    expect(getContainerDropZoneLabel(false)).toBe("Move to root");
-  });
-});

package/src/lib/__tests__/nav-store.test.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { useNavStore } from "../nav-store.ts";
-import { DEFAULT_NAV_CONFIG } from "../nav-config.ts";
-import type { NavGroup } from "../nav-config.ts";
-
-const testGroup: NavGroup = {
-  label: "TestGroup",
-  items: [{ to: "/test", label: "Test", icon: {} as NavGroup["items"][0]["icon"] }],
-};
-
-describe("useNavStore", () => {
-  beforeEach(() => {
-    useNavStore.setState({ config: DEFAULT_NAV_CONFIG });
-  });
-
-  it("initializes with DEFAULT_NAV_CONFIG", () => {
-    expect(useNavStore.getState().config).toBe(DEFAULT_NAV_CONFIG);
-  });
-
-  describe("setConfig", () => {
-    it("replaces entire config", () => {
-      useNavStore.getState().setConfig([testGroup]);
-      expect(useNavStore.getState().config).toEqual([testGroup]);
-    });
-  });
-
-  describe("addGroup", () => {
-    it("appends new group", () => {
-      const before = useNavStore.getState().config.length;
-      useNavStore.getState().addGroup(testGroup);
-      expect(useNavStore.getState().config.length).toBe(before + 1);
-      expect(useNavStore.getState().config.at(-1)).toEqual(testGroup);
-    });
-
-    it("replaces existing group with same label (preserves order)", () => {
-      useNavStore.getState().addGroup(testGroup);
-      const updated: NavGroup = { ...testGroup, description: "updated" };
-      useNavStore.getState().addGroup(updated);
-
-      const matches = useNavStore.getState().config.filter((g) => g.label === "TestGroup");
-      expect(matches.length).toBe(1);
-      expect(matches[0].description).toBe("updated");
-    });
-  });
-
-  describe("removeGroup", () => {
-    it("removes group by label", () => {
-      useNavStore.getState().addGroup(testGroup);
-      useNavStore.getState().removeGroup("TestGroup");
-      expect(useNavStore.getState().config.find((g) => g.label === "TestGroup")).toBeUndefined();
-    });
-
-    it("no-op for non-existent label", () => {
-      const before = useNavStore.getState().config.length;
-      useNavStore.getState().removeGroup("NoSuchGroup");
-      expect(useNavStore.getState().config.length).toBe(before);
-    });
-  });
-});

package/src/lib/__tests__/selection-context.test.ts

@@ -1,114 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  registerSelectionContextResolver,
-  resolveSelectionContext,
-  type SelectionContextResolver,
-} from "../selection-context.ts";
-
-const unregisters: Array<() => void> = [];
-
-function register(resolver: SelectionContextResolver) {
-  const unregister = registerSelectionContextResolver(resolver);
-  unregisters.push(unregister);
-  return unregister;
-}
-
-function input(text = "selected text") {
-  const node = document.createElement("span");
-  const range = document.createRange();
-  range.selectNodeContents(node);
-  return {
-    text,
-    anchorNode: node,
-    focusNode: node,
-    range,
-    sourcePage: "Current page",
-  };
-}
-
-describe("selection-context", () => {
-  afterEach(() => {
-    for (const unregister of unregisters.splice(0)) unregister();
-    document.body.innerHTML = "";
-  });
-
-  it("falls back to a plain text selection context", () => {
-    const resolved = resolveSelectionContext(input("hello"));
-
-    expect(resolved.item).toMatchObject({
-      type: "selection",
-      label: "hello",
-      payload: { kind: "text", text: "hello" },
-      persistence: "ephemeral",
-    });
-    expect(resolved.supportsModify).toBeUndefined();
-  });
-
-  it("lets modules resolve richer selection context and opt into Modify", () => {
-    register({
-      id: "test-rich-selection",
-      resolve: (selection) => ({
-        item: {
-          type: "ref",
-          label: `Field · ${selection.text}`,
-          payload: {
-            kind: "ref",
-            refType: "block",
-            refId: "entity:block",
-            preview: selection.text,
-            meta: { selectionScope: "atom", targetPath: "$.blocks[0].field" },
-          },
-          sourcePage: "/spaces/entity#block-block",
-          persistence: "ephemeral",
-        },
-        supportsModify: true,
-      }),
-    });
-
-    const resolved = resolveSelectionContext(input("cell"));
-
-    expect(resolved.item).toMatchObject({
-      type: "ref",
-      label: "Field · cell",
-      payload: {
-        kind: "ref",
-        refType: "block",
-        refId: "entity:block",
-        meta: { targetPath: "$.blocks[0].field" },
-      },
-    });
-    expect(resolved.supportsModify).toBe(true);
-  });
-
-  it("uses resolver priority before falling through to lower priority resolvers", () => {
-    register({
-      id: "low",
-      priority: 1,
-      resolve: (selection) => ({
-        item: {
-          type: "selection",
-          label: `low ${selection.text}`,
-          payload: { kind: "text", text: selection.text },
-          sourcePage: selection.sourcePage,
-          persistence: "ephemeral",
-        },
-      }),
-    });
-    register({
-      id: "high",
-      priority: 100,
-      resolve: (selection) => ({
-        item: {
-          type: "selection",
-          label: `high ${selection.text}`,
-          payload: { kind: "text", text: selection.text },
-          sourcePage: selection.sourcePage,
-          persistence: "ephemeral",
-        },
-      }),
-    });
-
-    expect(resolveSelectionContext(input("x")).item.label).toBe("high x");
-  });
-});
-