assistant-ui 0.0.116 → 0.0.118

package/src/codemods/utils/resolveBinding.ts

@@ -0,0 +1,130 @@
+import type { JSCodeshift } from "jscodeshift";
+
+const patternBinding = (node: any, name: string): any => {
+  switch (node?.type) {
+    case "Identifier":
+      return node.name === name ? node : undefined;
+    case "TSParameterProperty":
+      return patternBinding(node.parameter, name);
+    case "AssignmentPattern":
+      return patternBinding(node.left, name);
+    case "RestElement":
+      return patternBinding(node.argument, name);
+    case "ObjectPattern":
+      return node.properties
+        .map((p: any) => patternBinding(p.value ?? p.argument, name))
+        .find(Boolean);
+    case "ArrayPattern":
+      return node.elements
+        .map((p: any) => patternBinding(p, name))
+        .find(Boolean);
+  }
+};
+
+const declarationBinding = (node: any, name: string): any => {
+  switch (node?.type) {
+    case "ExportNamedDeclaration":
+    case "ExportDefaultDeclaration":
+      return declarationBinding(node.declaration, name);
+    case "VariableDeclaration":
+      return node.declarations
+        .map((d: any) => patternBinding(d.id, name))
+        .find(Boolean);
+    case "ImportDeclaration":
+      if (node.importKind === "type") return;
+      return node.specifiers
+        ?.filter((s: any) => s.importKind !== "type")
+        .map((s: any) => patternBinding(s.local, name))
+        .find(Boolean);
+    case "TSTypeAliasDeclaration":
+    case "TSInterfaceDeclaration":
+    case "TSDeclareFunction":
+      return;
+    default:
+      return patternBinding(node?.id, name);
+  }
+};
+
+const hoistedBinding = (j: JSCodeshift, body: any, name: string): any => {
+  let binding: any;
+  j.types.visit(body, {
+    visitFunction() {
+      return false;
+    },
+    visitClassDeclaration() {
+      return false;
+    },
+    visitClassExpression() {
+      return false;
+    },
+    visitTSModuleBlock(path) {
+      if (path.node !== body) return false;
+      this.traverse(path);
+      return undefined;
+    },
+    visitVariableDeclaration(path) {
+      if (path.node.kind === "var")
+        binding ??= declarationBinding(path.node, name);
+      this.traverse(path);
+    },
+  });
+  return binding;
+};
+
+// ast-types scopes do not distinguish block-scoped declarations.
+export const resolveBinding = (
+  j: JSCodeshift,
+  path: any,
+  name: string,
+): any => {
+  let child = path;
+  for (
+    let current = path.parent;
+    current;
+    child = current, current = current.parent
+  ) {
+    const node = current.value;
+    let binding: any;
+    if (Array.isArray(node.params)) {
+      binding =
+        node.params.map((p: any) => patternBinding(p, name)).find(Boolean) ??
+        patternBinding(node.id, name) ??
+        (child.value === node.body
+          ? hoistedBinding(j, node.body, name)
+          : undefined);
+    } else if (node.type === "CatchClause") {
+      binding = patternBinding(node.param, name);
+    } else if (node.type === "ClassExpression") {
+      binding = patternBinding(node.id, name);
+    } else if (node.type === "ForStatement") {
+      binding = declarationBinding(node.init, name);
+    } else if (
+      node.type === "ForInStatement" ||
+      node.type === "ForOfStatement"
+    ) {
+      binding = declarationBinding(node.left, name);
+    } else {
+      const statements =
+        node.type === "SwitchStatement" && child.value !== node.discriminant
+          ? node.cases.flatMap((c: any) => c.consequent)
+          : [
+                "BlockStatement",
+                "Program",
+                "StaticBlock",
+                "TSModuleBlock",
+              ].includes(node.type)
+            ? node.body
+            : [];
+      binding = statements
+        .map((s: any) => declarationBinding(s, name))
+        .find(Boolean);
+      if (
+        !binding &&
+        ["Program", "StaticBlock", "TSModuleBlock"].includes(node.type)
+      ) {
+        binding = hoistedBinding(j, node, name);
+      }
+    }
+    if (binding) return binding;
+  }
+};

package/src/codemods/v0-12/__tests__/assistant-api-to-aui.test.ts

@@ -21,6 +21,262 @@ function applyTransform(source: string): string | null {
 }
 
 describe("assistant-api-to-aui", () => {
+  it.each([
+    "const aui = props.aui; const api = useAui(); api.thread();",
+    "const api = useAui(); const aui = props.aui; api.thread();",
+    "const api = useAui(); function read(aui) { return api.thread(); }",
+    "const api = useAui(); { const aui = props.aui; api.thread(); }",
+    "function read(aui) { const api = useAui(); return api.thread(); }",
+  ])("preserves api when renaming would collide or capture: %s", (source) => {
+    const input = `import { useAui } from "@assistant-ui/react";\n${source}`;
+    expect(applyTransform(input)).toBeNull();
+  });
+
+  it("still migrates the hook when the api local name must be preserved", () => {
+    const output =
+      applyTransform(`import { useAssistantApi } from "@assistant-ui/react";
+const aui = props.aui;
+const api = useAssistantApi();
+api.thread();`);
+    expect(output).toContain('import { useAui } from "@assistant-ui/react";');
+    expect(output).toContain("const api = useAui();");
+    expect(output).toContain("api.thread();");
+    expect(applyTransform(output!)).toBeNull();
+  });
+
+  it("does not let one colliding api binding prevent independent renames", () => {
+    const blocked =
+      "function blocked(aui) { const api = useAui(); return api.thread(); }";
+    const output = applyTransform(`import { useAui } from "@assistant-ui/react";
+${blocked}
+function safe() { const api = useAui(); return api.thread(); }`);
+    expect(output).toContain(blocked);
+    expect(output).toContain(
+      "function safe() { const aui = useAui(); return aui.thread(); }",
+    );
+    expect(applyTransform(output!)).toBeNull();
+  });
+
+  it.each([
+    ["AssistantProvider", "AuiProvider"],
+    ["useAssistantState", "useAuiState"],
+  ])("preserves qualified type members named %s", (oldName, newName) => {
+    const output =
+      applyTransform(`import { ${oldName} } from "@assistant-ui/react";
+import type { Components } from "./types";
+type Foreign = Components.${oldName};
+type Nested = Components.Nested.${oldName};
+type ForeignValue = typeof Components.${oldName};
+type LocalValue = typeof ${oldName};
+type LocalMember = typeof ${oldName}.displayName;
+const value = ${oldName};`);
+    expect(output).toContain(`type Foreign = Components.${oldName};`);
+    expect(output).toContain(`type Nested = Components.Nested.${oldName};`);
+    expect(output).toContain(
+      `type ForeignValue = typeof Components.${oldName};`,
+    );
+    expect(output).toContain(`type LocalValue = typeof ${newName};`);
+    expect(output).toContain(
+      `type LocalMember = typeof ${newName}.displayName;`,
+    );
+    expect(output).toContain(`const value = ${newName};`);
+    expect(applyTransform(output!)).toBeNull();
+  });
+
+  it.each([
+    ["const", "of"],
+    ["let", "of"],
+    ["const", "in"],
+    ["let", "in"],
+  ])(
+    "preserves %s for-%s bindings in their right-hand side",
+    (kind, operator) => {
+      const loop = `for (${kind} api ${operator} api.thread()) { api.thread(); }`;
+      const output =
+        applyTransform(`import { useAssistantApi } from "@assistant-ui/react";
+const api = useAssistantApi();
+${loop}
+api.thread();`);
+      expect(output).toContain(loop);
+      expect(output).toContain("const aui = useAui();");
+      expect(output).toContain("\naui.thread();");
+    },
+  );
+
+  it.each(["useAssistantApi", "useAui"])(
+    "preserves api initialized from a foreign %s import",
+    (hook) => {
+      const input = `import { ${hook} } from "./local-hooks";
+const api = ${hook}();
+api.thread();`;
+      expect(applyTransform(input)).toBeNull();
+    },
+  );
+
+  it.each(["useAssistantApi", "useAui"])(
+    "preserves api initialized from a shadowed %s import",
+    (hook) => {
+      const shadowed = `function local(${hook}) { const api = ${hook}(); return api.thread(); }
+{ const ${hook} = other; const api = ${hook}(); api.thread(); }
+function hoisted() { const api = ${hook}(); if (ready) { var ${hook} = other; } return api.thread(); }`;
+      const output =
+        applyTransform(`import { ${hook} } from "@assistant-ui/react";
+${shadowed}
+const api = ${hook}();
+api.thread();`);
+      expect(output).toContain(shadowed);
+      expect(output).toContain("const aui = useAui();");
+      expect(output).toContain("\naui.thread();");
+      expect(applyTransform(output!)).toBeNull();
+    },
+  );
+
+  it.each(["useAssistantApi", "useAui"])(
+    "renames api initialized from an aliased %s import",
+    (hook) => {
+      const output =
+        applyTransform(`import { ${hook} as useClient } from "@assistant-ui/react";
+const api = useClient();
+api.thread();`);
+      expect(output).toContain("useAui as useClient");
+      expect(output).toContain("const aui = useClient();");
+      expect(output).toContain("aui.thread();");
+      expect(applyTransform(output!)).toBeNull();
+    },
+  );
+
+  it.each([
+    'import type { useAssistantApi } from "@assistant-ui/react";',
+    'import { type useAssistantApi } from "@assistant-ui/react";',
+  ])(
+    "does not infer an api value from type-only imports: %s",
+    (declaration) => {
+      const output = applyTransform(`${declaration}
+const api = useAssistantApi();
+api.thread();`);
+      expect(output).toContain("const api = useAssistantApi();");
+      expect(output).toContain("api.thread();");
+    },
+  );
+
+  it.each(["useAssistantApi", "useAui"])(
+    "leaves unresolved %s calls alone",
+    (hook) => {
+      expect(applyTransform(`const api = ${hook}(); api.thread();`)).toBeNull();
+    },
+  );
+
+  it("preserves hooks and components imported from another package", () => {
+    const input = `import { useAssistantState, AssistantIf } from "./local-hooks";
+import { useAui } from "@assistant-ui/react";
+const read = () => useAssistantState();
+const view = <AssistantIf />;`;
+    expect(applyTransform(input)).toBeNull();
+  });
+
+  it.each([
+    "function local(useAssistantState) { return useAssistantState(); }",
+    "{ const useAssistantState = other; useAssistantState(); }",
+    "{ const { useAssistantState } = other; useAssistantState(); }",
+    "function local() { if (ready) { var useAssistantState = other; } return useAssistantState(); }",
+  ])("preserves a shadowed hook: %s", (unrelated) => {
+    const output = applyTransform(
+      `import { useAssistantState } from "@assistant-ui/react";\n${unrelated}\nuseAssistantState();`,
+    );
+    expect(output).toContain(unrelated);
+    expect(output).toContain("\nuseAuiState();");
+  });
+
+  it("preserves hook import aliases", () => {
+    const output =
+      applyTransform(`import { useAssistantState as useLocalState } from "@assistant-ui/react";
+useLocalState();`);
+    expect(output).toContain("useAuiState as useLocalState");
+    expect(output).toContain("useLocalState();");
+    expect(applyTransform(output!)).toBeNull();
+  });
+
+  it("avoids duplicating an existing import of the new local name", () => {
+    const output =
+      applyTransform(`import { useAssistantState } from "@assistant-ui/react";
+import { useAuiState } from "./other";
+useAssistantState();
+useAuiState();`);
+    expect(output).toContain("useAuiState as useAssistantState");
+    expect(output).toContain('import { useAuiState } from "./other";');
+    expect(output).toContain("\nuseAssistantState();");
+  });
+
+  it("preserves public property and export names", () => {
+    const output =
+      applyTransform(`import { useAssistantState } from "@assistant-ui/react";
+const value = { useAssistantState };
+obj.useAssistantState();
+const config = { useAssistantState: "unchanged" };
+export { useAssistantState };
+export { useAssistantState as remote } from "./other";`);
+    expect(output).toMatch(/useAssistantState: useAuiState/);
+    expect(output).toContain("obj.useAssistantState();");
+    expect(output).toContain('useAssistantState: "unchanged"');
+    expect(output).toContain("useAuiState as useAssistantState");
+    expect(output).toContain(
+      'export { useAssistantState as remote } from "./other";',
+    );
+  });
+
+  it("does not capture references with an existing new-name binding", () => {
+    const output =
+      applyTransform(`import { useAssistantState } from "@assistant-ui/react";
+function local(useAuiState) { return useAssistantState(); }`);
+    expect(output).toContain("useAuiState as useAssistantState");
+    expect(output).toContain(
+      "function local(useAuiState) { return useAssistantState(); }",
+    );
+  });
+
+  it("preserves a shadowed JSX component and JSX property names", () => {
+    const output =
+      applyTransform(`import { AssistantIf } from "@assistant-ui/react";
+const view = <AssistantIf AssistantIf="attribute" />;
+function local(AssistantIf) { return <AssistantIf />; }
+const other = <components.AssistantIf />;`);
+    expect(output).toContain('<AuiIf AssistantIf="attribute" />');
+    expect(output).toContain(
+      "function local(AssistantIf) { return <AssistantIf />; }",
+    );
+    expect(output).toContain("<components.AssistantIf />");
+  });
+
+  it("preserves local names for type-only imports", () => {
+    const output =
+      applyTransform(`import type { AssistantProvider } from "@assistant-ui/react";
+type Provider = typeof AssistantProvider;`);
+    expect(output).toContain("AuiProvider as AssistantProvider");
+    expect(output).toContain("typeof AssistantProvider");
+  });
+  it("does not rename references to a hoisted body variable", () => {
+    const input = `import { useAssistantApi } from "@assistant-ui/react";
+const api = useAssistantApi();
+function worker() { if (ready) { var api = other(); } return api.value; }
+api.thread();`;
+    const output = applyTransform(input);
+    expect(output).toContain(
+      "if (ready) { var api = other(); } return api.value;",
+    );
+    expect(output).toContain("aui.thread();");
+  });
+
+  it("resolves switch discriminants and parameter defaults outside body bindings", () => {
+    const output =
+      applyTransform(`import { useAssistantApi } from "@assistant-ui/react";
+const api = useAssistantApi();
+function worker(value = api.thread()) { var api = other(); return api.value; }
+switch (api.kind) { case 1: const api = other(); api.thread(); }`);
+    expect(output).toContain("value = aui.thread()");
+    expect(output).toContain("switch (aui.kind)");
+    expect(output).toContain("var api = other(); return api.value;");
+    expect(output).toContain("const api = other(); api.thread();");
+  });
   it("should rename useAssistantApi to useAui", () => {
     const input = `
 import { useAssistantApi } from "@assistant-ui/react";