@arcadeai/design-system 1.1.0 → 1.3.0

package/dist/components/ui/utils/memo.d.ts

@@ -0,0 +1,2 @@
+export declare function createPropsComparator<T extends object>(keys: Array<keyof T>): (prev: Readonly<T>, next: Readonly<T>) => boolean;
+export declare function areStringArraysEqual(a?: readonly string[] | null, b?: readonly string[] | null): boolean;

package/dist/components/ui/utils/memo.js

@@ -0,0 +1,25 @@
+function f(n) {
+  return function(e, t) {
+    for (const r of n) {
+      const o = e[r], u = t[r];
+      if (!Object.is(o, u))
+        return !1;
+    }
+    return !0;
+  };
+}
+function i(n, a) {
+  const e = n ?? [], t = a ?? [];
+  if (e === t)
+    return !0;
+  if (e.length !== t.length)
+    return !1;
+  for (let r = 0; r < e.length; r++)
+    if (e[r] !== t[r])
+      return !1;
+  return !0;
+}
+export {
+  i as areStringArraysEqual,
+  f as createPropsComparator
+};

package/dist/{index-CQhYMnjT.js → index-BDE30rcJ.js}

@@ -1,4 +1,4 @@
-import { a as O } from "./utils-CRiPKpXj.js";
+import { a as O } from "./utils-Db4QWi-E.js";
 const m = (e) => typeof e == "boolean" ? `${e}` : e === 0 ? "0" : e, y = O, j = (e, l) => (n) => {
   var u;
   if (l?.variants == null) return y(e, n?.class, n?.className);

package/dist/{index-PlrlSrPo.js → index-DEJd-dpa.js}

@@ -345,7 +345,7 @@ const We = (t) => ({
         const C = ((($ = r.flip) == null ? void 0 : $.index) || 0) + 1, F = P[C];
         if (F && (!(u === "alignment" ? x !== z(F) : !1) || // We leave the current main axis only if every placement on that axis
         // overflows the main axis.
-        L.every((b) => b.overflows[0] > 0 && z(b.placement) === x)))
+        L.every((b) => z(b.placement) === x ? b.overflows[0] > 0 : !0)))
           return {
             data: {
               index: C,

package/dist/{index-BSWzylXR.js → index-Ez2mlmzx.js}

@@ -232,12 +232,12 @@ For more information, see https://radix-ui.com/primitives/docs/components/${t.do
   }, [a, e, t]), null;
 }, he = x, Pe = T, Ee = M, ye = w, Ne = F, Oe = W, Ie = G, xe = $;
 export {
-  xe as C,
+  Ne as C,
   Ie as D,
   ye as O,
   Ee as P,
   he as R,
   Pe as T,
-  Ne as a,
+  xe as a,
   Oe as b
 };

package/dist/lib/arcade/arcade.d.ts

@@ -0,0 +1,100 @@
+import { Arcade } from '@arcadeai/arcadejs';
+import { ToolDefinition } from '@arcadeai/arcadejs/resources/index.mjs';
+export type Toolkit = ToolDefinition.Toolkit & {
+    tools: ToolDefinition[];
+    isByoc?: boolean;
+    isPro?: boolean;
+    requirements: {
+        met: boolean;
+        secrets?: Arcade.Tools.ToolDefinition.Requirements.Secret[];
+        authorization?: Arcade.Tools.ToolDefinition.Requirements.Authorization[];
+        scopes?: Record<string, string[]>;
+    };
+};
+export type ProcessedToolkit = Toolkit & {
+    searchableText: string;
+    requirementsSummary: {
+        secrets?: {
+            configured: string[];
+            pending: string[];
+        };
+        oauth?: {
+            providers: Array<{
+                id: string;
+                status: 'active' | 'inactive';
+                scopes: string[];
+            }>;
+        };
+    };
+};
+export type ProcessedTool = ToolDefinition & {
+    searchableText: string;
+};
+export type ToolkitCollection = {
+    toolkits: ProcessedToolkit[];
+    tools: ProcessedTool[];
+    toolkitMap: Map<string, ProcessedToolkit>;
+    toolToToolkitMap: Map<string, string>;
+    searchIndex: {
+        toolkitsByName: Map<string, ProcessedToolkit>;
+        toolsByName: Map<string, ProcessedTool>;
+    };
+};
+type ArcadeConfig = {
+    /**
+     * A unique identifier for your app or organization, used to authenticate and track requests.
+     */
+    arcadeClientId?: string;
+    /**
+     * The base URL for the Arcade API.
+     */
+    baseURL?: string;
+    /**
+     * The API key for the Arcade API.
+     */
+    apiKey?: string;
+    /**
+     * The access token for the Arcade API.
+     */
+    accessToken?: string;
+};
+export type GetToolsProps = {
+    limit?: number;
+    offset?: number;
+    toolkit?: string;
+};
+export declare class ArcadeClient {
+    #private;
+    constructor(config: ArcadeConfig);
+    static create(config: ArcadeConfig): Arcade;
+    getAllTools(props?: GetToolsProps): Promise<ToolDefinition[]>;
+    groupToolsBy(groupKey: keyof ToolDefinition): Promise<Map<string, ToolDefinition>>;
+    getToolkits(): Promise<Map<string, Toolkit>>;
+    getToolsForToolkit(toolkit: string): Promise<ToolDefinition[]>;
+    private applyToolRequirements;
+    private mergeSecrets;
+    private mergeAuthorizations;
+    private mergeScopes;
+    /**
+     * Pre-compute requirements summary for optimal UI performance.
+     * This eliminates the need for runtime transformation in UI components.
+     */
+    private computeRequirementsSummary;
+    /**
+     * Process raw toolkit data into an optimized collection with pre-computed search indices.
+     *
+     * @returns ToolkitCollection with:
+     *   - Pre-computed searchable text for fast filtering
+     *   - Pre-computed requirement badges (no runtime processing needed)
+     *   - Search indices for O(1) lookups
+     *   - Toolkit/tool mapping for quick relationships
+     */
+    getProcessedToolkitCollection(): Promise<ToolkitCollection>;
+    /**
+     * Helper function to create normalized searchable text from multiple strings.
+     * Separates compound terms (like Gmail.List_emails) into individual searchable components.
+     * Handles camelCase, snake_case, kebab-case, and dot.notation.
+     */
+    private normalizeText;
+}
+export {};

package/dist/lib/arcade/arcade.js

@@ -0,0 +1,5 @@
+import { A as t } from "../../arcade-49z5mR1G.js";
+import "../../utils-Db4QWi-E.js";
+export {
+  t as ArcadeClient
+};

package/dist/lib/arcade/arcade.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/arcade/arcade.test.js

@@ -0,0 +1,299 @@
+import { A as i, a as c } from "../../arcade-49z5mR1G.js";
+import { allTools as m } from "./mocks.js";
+import { v as l, d as u, b as p, i as s, g as e } from "../../vi.bdSIJ99Y-CZgZQPWH.js";
+const d = {
+  tools: {
+    list: l.fn().mockImplementation((o) => {
+      let t = m;
+      return o?.toolkit && (t = m.filter(
+        (a) => a.toolkit.name.toLowerCase() === o.toolkit.toLowerCase()
+      )), Promise.resolve({
+        items: t
+      });
+    })
+  }
+};
+l.mock("@arcadeai/arcadejs", () => ({
+  Arcade: l.fn().mockImplementation(() => d)
+}));
+l.mock("../utils", () => ({
+  // biome-ignore lint/suspicious/noEmptyBlockStatements: This is a mock
+  resolveEnv: l.fn(() => {
+  })
+}));
+u("Arcade Tests", () => {
+  p(() => {
+    l.clearAllMocks();
+  }), s("should create an arcade instance", () => {
+    const o = new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    });
+    e(o).toBeDefined();
+  }), s("should create an arcade instance with access token", () => {
+    const o = new i({
+      arcadeClientId: "test-client-id",
+      accessToken: "test-token"
+    });
+    e(o).toBeDefined(), e(c).toHaveBeenCalledWith(
+      e.objectContaining({
+        defaultHeaders: e.objectContaining({
+          "Arcade-Client-Id": "test-client-id",
+          Authorization: "Bearer test-token"
+        })
+      })
+    );
+  }), s("should create an arcade instance with API key", () => {
+    const o = new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    });
+    e(o).toBeDefined(), e(c).toHaveBeenCalledWith(
+      e.objectContaining({
+        apiKey: "test-api-key",
+        defaultHeaders: e.not.objectContaining({
+          Authorization: e.any(String)
+        })
+      })
+    );
+  }), s("should create an arcade instance with all config options", () => {
+    const o = new i({
+      arcadeClientId: "test-client-id",
+      accessToken: "test-token",
+      apiKey: "test-api-key"
+    });
+    e(o).toBeDefined(), e(c).toHaveBeenCalledWith(
+      e.objectContaining({
+        apiKey: "test-api-key",
+        defaultHeaders: e.not.objectContaining({
+          Authorization: e.any(String)
+        })
+      })
+    );
+  }), s("should use static create method", () => {
+    const o = i.create({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    });
+    e(o).toBeDefined();
+  }), s("should return all tools", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getAllTools();
+    e(t).toBeDefined(), e(t).toHaveLength(16);
+  }), s("should pass default limit/offset to list call", async () => {
+    await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getAllTools(), e(d.tools.list).toHaveBeenCalledWith(
+      e.objectContaining({ limit: 1e3, offset: 0 })
+    );
+  }), s("should filter tools by toolkit", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getAllTools({ toolkit: "E2b" });
+    e(t).toBeDefined(), e(t).toHaveLength(1), e(t[0].name).toBe("CreateStaticMatplotlibChart"), e(t[0].toolkit.name).toBe("E2b");
+  }), s("should pass provided limit/offset/toolkit to list call", async () => {
+    await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getAllTools({ toolkit: "Gmail", limit: 5, offset: 10 }), e(d.tools.list).toHaveBeenCalledWith(
+      e.objectContaining({ toolkit: "Gmail", limit: 5, offset: 10 })
+    );
+  }), s("should filter tools by toolkit case insensitive", async () => {
+    const o = new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }), t = await o.getAllTools({ toolkit: "e2b" });
+    e(t).toBeDefined(), e(t).toHaveLength(1), e(t[0].name).toBe("CreateStaticMatplotlibChart"), e(t[0].toolkit.name).toBe("E2b");
+    const a = await o.getAllTools({ toolkit: "E2B" });
+    e(a).toBeDefined(), e(a).toHaveLength(1), e(a[0].name).toBe("CreateStaticMatplotlibChart"), e(a[0].toolkit.name).toBe("E2b");
+    const n = await o.getAllTools({ toolkit: "E2B" });
+    e(n).toBeDefined(), e(n).toHaveLength(1), e(n[0].name).toBe("CreateStaticMatplotlibChart"), e(n[0].toolkit.name).toBe("E2b");
+  }), s("should process basic toolkit with no requirements", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolkits();
+    e(t.get("basic")).toBeDefined(), e(t.get("basic")?.tools).toHaveLength(1), e(t.get("basic")?.requirements.met).toBe(!0), e(t.get("basic")?.requirements.secrets).toHaveLength(0), e(t.get("basic")?.requirements.authorization).toHaveLength(0), e(t.get("basic")?.requirements.scopes).toEqual({});
+  }), s("should process API toolkit with secret requirements", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolkits();
+    e(t.get("api_toolkit")).toBeDefined(), e(t.get("api_toolkit")?.requirements.met).toBe(!1), e(t.get("api_toolkit")?.requirements.secrets).toHaveLength(3), e(
+      t.get("api_toolkit")?.requirements.secrets?.find((a) => a.key === "GROQ_API_KEY")
+    ).toBeDefined(), e(
+      t.get("api_toolkit")?.requirements.secrets?.find((a) => a.key === "OPENAI_API_KEY")
+    ).toBeDefined(), e(
+      t.get("api_toolkit")?.requirements.secrets?.find((a) => a.key === "ARCADE_API_KEY")
+    ).not.toBeDefined();
+  }), s("should process OAuth toolkit with authorization requirements", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolkits();
+    e(t.get("oauth_toolkit")).toBeDefined(), e(t.get("oauth_toolkit")?.requirements.met).toBe(!1), e(
+      t.get("oauth_toolkit")?.requirements.authorization
+    ).toHaveLength(1), e(t.get("oauth_toolkit")?.requirements.scopes).toEqual({
+      google: [
+        "https://www.googleapis.com/auth/calendar.readonly",
+        "https://www.googleapis.com/auth/drive",
+        "https://www.googleapis.com/auth/gmail.readonly"
+      ]
+    }), e(t.get("oauth_toolkit")?.requirements.secrets).toHaveLength(0);
+  }), s("should process GitHub toolkit with specific scopes", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolkits();
+    e(t.get("github_toolkit")).toBeDefined(), e(t.get("github_toolkit")?.requirements.met).toBe(!1), e(
+      t.get("github_toolkit")?.requirements.authorization?.find((a) => a.provider_id === "github")
+    ).toBeDefined(), e(t.get("github_toolkit")?.requirements.scopes).toEqual({
+      github: ["repo", "user", "issues"]
+    });
+  }), s("should process Google toolkit with met requirements", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolkits();
+    e(t.get("Google")).toBeDefined(), e(t.get("Google")?.requirements.met).toBe(!0), e(t.get("Google")?.requirements.authorization).toHaveLength(1), e(t.get("Google")?.requirements.scopes).toEqual({
+      google: ["https://www.googleapis.com/auth/drive.file"]
+    });
+  }), s("should process E2b toolkit with unmet secret requirements", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolkits();
+    e(t.get("E2b")).toBeDefined(), e(t.get("E2b")?.requirements.met).toBe(!1), e(t.get("E2b")?.requirements.secrets).toHaveLength(1), e(t.get("E2b")?.requirements.secrets?.[0]).toEqual({
+      key: "e2b_api_key",
+      met: !1,
+      status_reason: "Secret e2b_api_key not found"
+    });
+  }), s("should process Gmail toolkit with met authorization requirements", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolkits();
+    e(t.get("Gmail")).toBeDefined(), e(t.get("Gmail")?.requirements.met).toBe(!0), e(t.get("Gmail")?.requirements.authorization).toHaveLength(1), e(t.get("Gmail")?.requirements.scopes).toEqual({
+      google: [
+        "https://www.googleapis.com/auth/gmail.modify",
+        "https://www.googleapis.com/auth/gmail.labels"
+      ]
+    });
+  }), s("should merge OAuth scopes correctly", async () => {
+    const a = (await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolkits()).get("oauth_toolkit");
+    e(a?.requirements.scopes?.google).toContain(
+      "https://www.googleapis.com/auth/calendar.readonly"
+    ), e(a?.requirements.scopes?.google).toContain(
+      "https://www.googleapis.com/auth/drive"
+    ), e(a?.requirements.scopes?.google).toContain(
+      "https://www.googleapis.com/auth/gmail.readonly"
+    );
+    const n = new Set(a?.requirements.scopes?.google);
+    e(n.size).toBe(
+      a?.requirements.scopes?.google?.length
+    );
+  }), s("should handle tools with no requirements", async () => {
+    const a = (await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolkits()).get("basic");
+    e(a?.requirements.met).toBe(!0), e(a?.requirements.secrets).toHaveLength(0), e(a?.requirements.authorization).toHaveLength(0), e(a?.requirements.scopes).toEqual({});
+  }), s("should merge secrets correctly", async () => {
+    const a = (await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolkits()).get("api_toolkit");
+    e(a?.requirements.secrets).toHaveLength(3);
+    const n = a?.requirements.secrets?.filter(
+      (g) => g.key === "OPENAI_API_KEY"
+    ) || [], r = a?.requirements.secrets?.filter(
+      (g) => g.key === "GROQ_API_KEY"
+    ) || [];
+    e(n).toHaveLength(1), e(n[0].met).toBe(!0), e(r[0].met).toBe(!1), e(a?.requirements.met).toBe(!1), e(n[0].status_reason).toBe("API key configured"), e(r[0].status_reason).toBe("API key not configured");
+  }), s("should merge OAuth scopes from multiple Google services", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolkits();
+    e(t.get("Google")?.requirements.scopes?.google).toContain(
+      "https://www.googleapis.com/auth/drive.file"
+    ), e(t.get("Gmail")?.requirements.scopes?.google).toContain(
+      "https://www.googleapis.com/auth/gmail.modify"
+    ), e(t.get("Gmail")?.requirements.scopes?.google).toContain(
+      "https://www.googleapis.com/auth/gmail.labels"
+    ), e(
+      t.get("oauth_toolkit")?.requirements.scopes?.google
+    ).toContain("https://www.googleapis.com/auth/calendar.readonly"), e(
+      t.get("oauth_toolkit")?.requirements.scopes?.google
+    ).toContain("https://www.googleapis.com/auth/drive"), e(
+      t.get("oauth_toolkit")?.requirements.scopes?.google
+    ).toContain("https://www.googleapis.com/auth/gmail.readonly");
+    const a = t.get("Google")?.requirements.scopes?.google || [], n = t.get("Gmail")?.requirements.scopes?.google || [], r = t.get("oauth_toolkit")?.requirements.scopes?.google || [];
+    e(new Set(a).size).toBe(a.length), e(new Set(n).size).toBe(n.length), e(new Set(r).size).toBe(r.length);
+  }), s("should get tools for specific toolkit", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolsForToolkit("E2b");
+    e(t).toBeDefined(), e(t).toHaveLength(1), e(t[0].name).toBe("CreateStaticMatplotlibChart"), e(t[0].toolkit.name).toBe("E2b");
+  }), s("should call list with toolkit and default limit when getting tools for a toolkit", async () => {
+    await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getToolsForToolkit("Gmail"), e(d.tools.list).toHaveBeenCalledWith(
+      e.objectContaining({ toolkit: "Gmail", limit: 1e3 })
+    );
+  }), s("should group tools by a string key", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).groupToolsBy("fully_qualified_name");
+    e(t.get("gmail.gmail_get_inbox")?.name).toBe(
+      "gmail_get_inbox"
+    ), e(t.get("Gmail.CreateLabel@2.0.0")?.name).toBe(
+      "CreateLabel"
+    ), e(t.get("Google.CreateBlankDocument@1.2.4")?.name).toBe(
+      "CreateBlankDocument"
+    );
+  }), s("should ignore non-string grouping keys", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).groupToolsBy("input");
+    e(t.size).toBe(0);
+  }), s("should honor baseURL when provided", () => {
+    const o = new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key",
+      baseURL: "https://example.test"
+    });
+    e(o).toBeDefined(), e(c).toHaveBeenCalledWith(
+      e.objectContaining({ baseURL: "https://example.test" })
+    );
+  }), s("should build a processed toolkit collection with search indices", async () => {
+    const t = await new i({
+      arcadeClientId: "test-client-id",
+      apiKey: "test-api-key"
+    }).getProcessedToolkitCollection();
+    e(t.toolkits.length).toBeGreaterThan(0), e(t.tools.length).toBeGreaterThan(0), e(t.toolToToolkitMap.get("gmail.gmail_get_inbox")).toBe(
+      "Gmail"
+    ), e(t.searchIndex.toolkitsByName.get("gmail")?.name).toBe(
+      "Gmail"
+    ), e(
+      t.searchIndex.toolsByName.get("gmail.gmail_get_inbox")?.name
+    ).toBe("gmail_get_inbox");
+    const a = t.searchIndex.toolsByName.get(
+      "gmail.gmail_get_inbox"
+    );
+    e(a?.searchableText).toContain("gmail"), e(a?.searchableText).toContain("get"), e(a?.searchableText).toContain("inbox");
+    const n = t.searchIndex.toolkitsByName.get("google");
+    e(n?.searchableText).toContain("google"), e(n?.searchableText).toContain("arcade"), e(n?.searchableText).toContain("dev"), e(n?.searchableText).toContain("llm"), e(n?.searchableText).toContain("tools"), e(n?.searchableText).toContain("workspace");
+  });
+});

package/dist/lib/arcade/mocks.d.ts

@@ -0,0 +1,2 @@
+import { ToolDefinition } from '@arcadeai/arcadejs/resources/index.mjs';
+export declare const allTools: ToolDefinition[];