@player-lang/functional-dsl-generator 0.0.2-next.0

package/src/__tests__/import-generator.test.ts

@@ -0,0 +1,444 @@
+import { describe, test, expect, beforeEach } from "vitest";
+import { ImportGenerator } from "../import-generator";
+
+describe("ImportGenerator", () => {
+  let generator: ImportGenerator;
+
+  describe("Basic Configuration", () => {
+    beforeEach(() => {
+      generator = new ImportGenerator();
+    });
+
+    test("generates default import paths", () => {
+      const imports = generator.generateImports("TextAsset");
+
+      // Default path uses kebab-case conversion
+      expect(imports).toContain('from "../types/');
+      expect(imports).toContain('from "@player-lang/functional-dsl"');
+    });
+
+    test("uses custom functional import path", () => {
+      generator = new ImportGenerator({
+        functionalImportPath: "../../../gen/common.js",
+      });
+
+      const imports = generator.generateImports("TextAsset");
+
+      expect(imports).toContain('from "../../../gen/common.js"');
+      expect(imports).not.toContain('from "@player-lang/functional-dsl"');
+    });
+
+    test("uses custom types import path", () => {
+      generator = new ImportGenerator({
+        typesImportPath: "../custom-types.js",
+      });
+
+      generator.setNeedsAssetImport(true);
+      const imports = generator.generateImports("TextAsset");
+
+      expect(imports).toContain('from "../custom-types.js"');
+    });
+
+    test("uses custom type import path generator", () => {
+      generator = new ImportGenerator({
+        typeImportPathGenerator: (typeName) =>
+          `../types/${typeName.toLowerCase()}.js`,
+      });
+
+      const imports = generator.generateImports("TextAsset");
+
+      expect(imports).toContain('from "../types/textasset.js"');
+    });
+  });
+
+  describe("Type Tracking", () => {
+    beforeEach(() => {
+      generator = new ImportGenerator();
+    });
+
+    test("tracks referenced types for same file", () => {
+      generator = new ImportGenerator({
+        sameFileTypes: new Set(["TypeA", "TypeB"]),
+      });
+
+      generator.trackReferencedType("TypeA");
+      generator.trackReferencedType("TypeB");
+
+      const imports = generator.generateImports("MainType");
+
+      expect(imports).toMatch(/import type \{[^}]*MainType[^}]*\}/);
+      expect(imports).toMatch(/import type \{[^}]*TypeA[^}]*\}/);
+      expect(imports).toMatch(/import type \{[^}]*TypeB[^}]*\}/);
+    });
+
+    test("tracks external types", () => {
+      const externalTypes = new Map<string, string>();
+      externalTypes.set("ExternalType", "@external/types");
+
+      generator = new ImportGenerator({ externalTypes });
+
+      generator.trackReferencedType("ExternalType");
+
+      const imports = generator.generateImports("MainType");
+
+      expect(imports).toContain(
+        'import type { ExternalType } from "@external/types"',
+      );
+    });
+
+    test("groups multiple types from same external package", () => {
+      const externalTypes = new Map<string, string>();
+      externalTypes.set("TypeA", "@external/types");
+      externalTypes.set("TypeB", "@external/types");
+
+      generator = new ImportGenerator({ externalTypes });
+
+      generator.trackReferencedType("TypeA");
+      generator.trackReferencedType("TypeB");
+
+      const imports = generator.generateImports("MainType");
+
+      // Both types should be in one import statement
+      expect(imports).toMatch(
+        /import type \{[^}]*TypeA[^}]*TypeB[^}]*\} from "@external\/types"/,
+      );
+    });
+
+    test("external types take precedence over sameFileTypes", () => {
+      const sameFileTypes = new Set(["SharedType"]);
+      const externalTypes = new Map<string, string>();
+      externalTypes.set("SharedType", "@external/shared");
+
+      generator = new ImportGenerator({ sameFileTypes, externalTypes });
+
+      generator.trackReferencedType("SharedType");
+
+      const imports = generator.generateImports("MainType");
+
+      expect(imports).toContain(
+        'import type { SharedType } from "@external/shared"',
+      );
+    });
+  });
+
+  describe("Namespace Tracking", () => {
+    test("tracks namespace imports", () => {
+      const externalTypes = new Map<string, string>();
+      externalTypes.set("Validation", "@player-ui/types");
+
+      generator = new ImportGenerator({ externalTypes });
+
+      generator.trackNamespaceImport("Validation");
+
+      const imports = generator.generateImports("MainType");
+
+      expect(imports).toContain(
+        'import type { Validation } from "@player-ui/types"',
+      );
+    });
+  });
+
+  describe("Asset Import", () => {
+    beforeEach(() => {
+      generator = new ImportGenerator();
+    });
+
+    test("includes Asset import when needed", () => {
+      generator.setNeedsAssetImport(true);
+
+      const imports = generator.generateImports("TextAsset");
+
+      expect(imports).toContain(
+        'import type { Asset } from "@player-ui/types"',
+      );
+    });
+
+    test("does not include Asset import when not needed", () => {
+      generator.setNeedsAssetImport(false);
+
+      const imports = generator.generateImports("TextAsset");
+
+      expect(imports).not.toContain("import type { Asset }");
+    });
+
+    test("trackReferencedType for PLAYER_BUILTINS is a no-op", () => {
+      // Calling trackReferencedType with PLAYER_BUILTINS should not add them to any imports
+      generator.trackReferencedType("Asset");
+      generator.trackReferencedType("AssetWrapper");
+      generator.trackReferencedType("Binding");
+      generator.trackReferencedType("Expression");
+
+      const imports = generator.generateImports("MainType");
+
+      // None of these should be imported (they have special handling)
+      expect(imports).not.toContain("import type { Asset }");
+      expect(imports).not.toMatch(/import type \{[^}]*\bAsset\b[^}]*\} from/);
+      expect(imports).not.toMatch(
+        /import type \{[^}]*\bAssetWrapper\b[^}]*\} from/,
+      );
+      expect(imports).not.toMatch(/import type \{[^}]*\bBinding\b[^}]*\} from/);
+      expect(imports).not.toMatch(
+        /import type \{[^}]*\bExpression\b[^}]*\} from/,
+      );
+    });
+
+    test("Asset only appears via needsAssetImport flag, not trackReferencedType", () => {
+      // Track Asset but don't set needsAssetImport
+      generator.trackReferencedType("Asset");
+
+      let imports = generator.generateImports("MainType");
+      expect(imports).not.toContain("import type { Asset }");
+
+      // Now set needsAssetImport - Asset should appear
+      generator.setNeedsAssetImport(true);
+      imports = generator.generateImports("MainType");
+      expect(imports).toContain(
+        'import type { Asset } from "@player-ui/types"',
+      );
+    });
+
+    test("Asset is not duplicated when both trackReferencedType and needsAssetImport are used", () => {
+      generator.trackReferencedType("Asset");
+      generator.setNeedsAssetImport(true);
+
+      const imports = generator.generateImports("MainType");
+
+      // Count Asset occurrences - should only appear once
+      const assetMatches = imports.match(/\bAsset\b/g);
+      expect(assetMatches?.length).toBe(1);
+    });
+  });
+
+  describe("Import Statement Structure", () => {
+    test("generates functional utilities import", () => {
+      generator = new ImportGenerator();
+
+      const imports = generator.generateImports("TextAsset");
+
+      expect(imports).toContain("FunctionalBuilder");
+      expect(imports).toContain("BaseBuildContext");
+      expect(imports).toContain("FunctionalBuilderBase");
+      expect(imports).toContain("createInspectMethod");
+      expect(imports).toContain("TaggedTemplateValue");
+    });
+
+    test("generates type import for main type", () => {
+      generator = new ImportGenerator();
+
+      const imports = generator.generateImports("TextAsset");
+
+      expect(imports).toMatch(/import type \{[^}]*TextAsset[^}]*\}/);
+    });
+  });
+
+  describe("Type Import Path Generator with sameFileTypes", () => {
+    test("uses typeImportPathGenerator for non-same-file types", () => {
+      generator = new ImportGenerator({
+        sameFileTypes: new Set(["LocalType"]),
+        typeImportPathGenerator: (typeName) =>
+          `../other/${typeName.toLowerCase()}.js`,
+      });
+
+      generator.trackReferencedType("LocalType");
+      generator.trackReferencedType("ExternalType");
+
+      const imports = generator.generateImports("MainType");
+
+      // LocalType should be with MainType
+      expect(imports).toMatch(/import type \{[^}]*LocalType[^}]*\}/);
+
+      // ExternalType should use the generator
+      expect(imports).toContain(
+        'import type { ExternalType } from "../other/externaltype.js"',
+      );
+    });
+  });
+
+  describe("Strip Generic Arguments", () => {
+    test("strips generic arguments from type names for imports", () => {
+      generator = new ImportGenerator({
+        sameFileTypes: new Set(["ListItem"]),
+      });
+
+      generator.trackReferencedType("ListItem<AnyAsset>");
+
+      const imports = generator.generateImports("MainType");
+
+      // Should import "ListItem", not "ListItem<AnyAsset>"
+      expect(imports).toMatch(/import type \{[^}]*ListItem[^}]*\}/);
+      expect(imports).not.toContain("ListItem<AnyAsset>");
+    });
+  });
+
+  describe("Namespaced Type Handling", () => {
+    test("handles namespaced types from external packages", () => {
+      const externalTypes = new Map<string, string>();
+      externalTypes.set("Validation", "@player-ui/types");
+
+      generator = new ImportGenerator({ externalTypes });
+
+      generator.trackReferencedType("Validation.CrossfieldReference");
+
+      const imports = generator.generateImports("MainType");
+
+      // Should import the namespace, not the full path
+      expect(imports).toContain(
+        'import type { Validation } from "@player-ui/types"',
+      );
+    });
+
+    test("defaults namespaced types to @player-ui/types", () => {
+      generator = new ImportGenerator();
+
+      generator.trackReferencedType("Validation.CrossfieldReference");
+
+      const imports = generator.generateImports("MainType");
+
+      expect(imports).toContain(
+        'import type { Validation } from "@player-ui/types"',
+      );
+    });
+  });
+
+  describe("TypeTransformContext Interface", () => {
+    test("implements getGenericParamSymbols", () => {
+      generator = new ImportGenerator();
+      const symbols = generator.getGenericParamSymbols();
+
+      expect(symbols).toBeInstanceOf(Set);
+    });
+
+    test("implements getNamespaceMemberMap", () => {
+      generator = new ImportGenerator();
+      const map = generator.getNamespaceMemberMap();
+
+      expect(map).toBeInstanceOf(Map);
+    });
+
+    test("implements setNeedsAssetImport and getNeedsAssetImport", () => {
+      generator = new ImportGenerator();
+
+      expect(generator.getNeedsAssetImport()).toBe(false);
+
+      generator.setNeedsAssetImport(true);
+      expect(generator.getNeedsAssetImport()).toBe(true);
+
+      generator.setNeedsAssetImport(false);
+      expect(generator.getNeedsAssetImport()).toBe(false);
+    });
+  });
+
+  describe("Scoped Packages", () => {
+    test("handles scoped packages (@org/package)", () => {
+      const externalTypes = new Map<string, string>();
+      externalTypes.set("ScopedType", "@org/package");
+
+      generator = new ImportGenerator({ externalTypes });
+
+      generator.trackReferencedType("ScopedType");
+
+      const imports = generator.generateImports("MainType");
+
+      expect(imports).toContain(
+        'import type { ScopedType } from "@org/package"',
+      );
+    });
+
+    test("groups multiple types from same scoped package", () => {
+      const externalTypes = new Map<string, string>();
+      externalTypes.set("TypeA", "@my-org/shared-types");
+      externalTypes.set("TypeB", "@my-org/shared-types");
+      externalTypes.set("TypeC", "@my-org/shared-types");
+
+      generator = new ImportGenerator({ externalTypes });
+
+      generator.trackReferencedType("TypeA");
+      generator.trackReferencedType("TypeB");
+      generator.trackReferencedType("TypeC");
+
+      const imports = generator.generateImports("MainType");
+
+      // All types should be in one import statement
+      expect(imports).toMatch(
+        /import type \{[^}]*TypeA[^}]*\} from "@my-org\/shared-types"/,
+      );
+      expect(imports).toMatch(
+        /import type \{[^}]*TypeB[^}]*\} from "@my-org\/shared-types"/,
+      );
+    });
+
+    test("handles deeply scoped packages (@org/category/package)", () => {
+      const externalTypes = new Map<string, string>();
+      externalTypes.set("DeepType", "@org/category/package");
+
+      generator = new ImportGenerator({ externalTypes });
+
+      generator.trackReferencedType("DeepType");
+
+      const imports = generator.generateImports("MainType");
+
+      expect(imports).toContain(
+        'import type { DeepType } from "@org/category/package"',
+      );
+    });
+  });
+
+  describe("Deduplication", () => {
+    test("deduplicates imports from same source", () => {
+      generator = new ImportGenerator({
+        sameFileTypes: new Set(["TypeA"]),
+      });
+
+      // Track the same type multiple times
+      generator.trackReferencedType("TypeA");
+      generator.trackReferencedType("TypeA");
+      generator.trackReferencedType("TypeA");
+
+      const imports = generator.generateImports("MainType");
+
+      // TypeA should only appear once in the import
+      const typeAMatches = imports.match(/TypeA/g);
+      expect(typeAMatches?.length).toBe(1);
+    });
+
+    test("deduplicates external type imports", () => {
+      const externalTypes = new Map<string, string>();
+      externalTypes.set("ExternalType", "@external/types");
+
+      generator = new ImportGenerator({ externalTypes });
+
+      generator.trackReferencedType("ExternalType");
+      generator.trackReferencedType("ExternalType");
+
+      const imports = generator.generateImports("MainType");
+
+      // Should only have one import statement for ExternalType
+      const importStatements = imports
+        .split("\n")
+        .filter((line) => line.includes("ExternalType"));
+      expect(importStatements.length).toBe(1);
+    });
+  });
+
+  describe("Import Ordering", () => {
+    test("orders imports consistently", () => {
+      const externalTypes = new Map<string, string>();
+      externalTypes.set("ZType", "@z-package/types");
+      externalTypes.set("AType", "@a-package/types");
+      externalTypes.set("MType", "@m-package/types");
+
+      generator = new ImportGenerator({ externalTypes });
+
+      generator.trackReferencedType("ZType");
+      generator.trackReferencedType("AType");
+      generator.trackReferencedType("MType");
+
+      const imports = generator.generateImports("MainType");
+
+      // All imports should be present
+      expect(imports).toContain("@a-package/types");
+      expect(imports).toContain("@m-package/types");
+      expect(imports).toContain("@z-package/types");
+    });
+  });
+});

package/src/__tests__/path-utils.test.ts

@@ -0,0 +1,174 @@
+import { describe, test, expect } from "vitest";
+import {
+  isNodeModulesPath,
+  extractPackageNameFromPath,
+  createRelativeImportPath,
+  resolveRelativeImportPath,
+} from "../path-utils";
+
+describe("path-utils", () => {
+  describe("isNodeModulesPath", () => {
+    test("returns true for standard node_modules path", () => {
+      expect(isNodeModulesPath("/project/node_modules/lodash/index.d.ts")).toBe(
+        true,
+      );
+    });
+
+    test("returns true for scoped package in node_modules", () => {
+      expect(
+        isNodeModulesPath(
+          "/project/node_modules/@player-lang/types/index.d.ts",
+        ),
+      ).toBe(true);
+    });
+
+    test("returns true for pnpm store path", () => {
+      expect(
+        isNodeModulesPath(
+          "/project/node_modules/.pnpm/@player-lang+types@1.0.0/node_modules/@player-lang/types/index.d.ts",
+        ),
+      ).toBe(true);
+    });
+
+    test("returns false for local source file", () => {
+      expect(isNodeModulesPath("/project/src/types/foo.ts")).toBe(false);
+    });
+
+    test("returns false for local file with 'modules' in path", () => {
+      expect(isNodeModulesPath("/project/src/modules/auth.ts")).toBe(false);
+    });
+  });
+
+  describe("extractPackageNameFromPath", () => {
+    test("extracts simple package name", () => {
+      expect(
+        extractPackageNameFromPath("/project/node_modules/lodash/index.d.ts"),
+      ).toBe("lodash");
+    });
+
+    test("extracts scoped package name", () => {
+      expect(
+        extractPackageNameFromPath(
+          "/project/node_modules/@player-lang/types/index.d.ts",
+        ),
+      ).toBe("@player-lang/types");
+    });
+
+    test("extracts package from pnpm store structure", () => {
+      expect(
+        extractPackageNameFromPath(
+          "/project/node_modules/.pnpm/@player-lang+types@1.0.0/node_modules/@player-lang/types/index.d.ts",
+        ),
+      ).toBe("@player-lang/types");
+    });
+
+    test("extracts package from nested pnpm path", () => {
+      expect(
+        extractPackageNameFromPath(
+          "/project/node_modules/.pnpm/react@18.2.0/node_modules/react/index.d.ts",
+        ),
+      ).toBe("react");
+    });
+
+    test("handles deeply nested scoped package", () => {
+      expect(
+        extractPackageNameFromPath(
+          "/project/node_modules/@babel/core/lib/index.d.ts",
+        ),
+      ).toBe("@babel/core");
+    });
+
+    test("returns null for local path without node_modules", () => {
+      expect(extractPackageNameFromPath("/project/src/types/foo.ts")).toBe(
+        null,
+      );
+    });
+
+    test("returns null for path ending at node_modules", () => {
+      expect(extractPackageNameFromPath("/project/node_modules")).toBe(null);
+    });
+  });
+
+  describe("createRelativeImportPath", () => {
+    test("creates relative path for same directory", () => {
+      const result = createRelativeImportPath(
+        "/project/src/types/foo.ts",
+        "/project/src/types/bar.ts",
+      );
+      expect(result).toBe("./bar.js");
+    });
+
+    test("creates relative path for parent directory", () => {
+      const result = createRelativeImportPath(
+        "/project/src/builders/foo.ts",
+        "/project/src/types/bar.ts",
+      );
+      expect(result).toBe("../types/bar.js");
+    });
+
+    test("creates relative path for deeply nested file", () => {
+      const result = createRelativeImportPath(
+        "/project/src/a/b/c/foo.ts",
+        "/project/src/x/y/bar.ts",
+      );
+      expect(result).toBe("../../../x/y/bar.js");
+    });
+
+    test("converts .ts extension to .js", () => {
+      const result = createRelativeImportPath(
+        "/project/src/foo.ts",
+        "/project/src/bar.ts",
+      );
+      expect(result).toContain(".js");
+      expect(result).not.toContain(".ts");
+    });
+
+    test("converts .d.ts extension to .js", () => {
+      const result = createRelativeImportPath(
+        "/project/src/foo.ts",
+        "/project/src/bar.d.ts",
+      );
+      expect(result).toContain(".js");
+      expect(result).not.toContain(".d.ts");
+    });
+  });
+
+  describe("resolveRelativeImportPath", () => {
+    test("resolves relative import to absolute path", () => {
+      const result = resolveRelativeImportPath(
+        "/project/src/types/foo.ts",
+        "./bar",
+      );
+      expect(result).toBe("/project/src/types/bar.ts");
+    });
+
+    test("resolves parent directory import", () => {
+      const result = resolveRelativeImportPath(
+        "/project/src/builders/foo.ts",
+        "../types/bar",
+      );
+      expect(result).toBe("/project/src/types/bar.ts");
+    });
+
+    test("converts .js extension to .ts", () => {
+      const result = resolveRelativeImportPath(
+        "/project/src/foo.ts",
+        "./bar.js",
+      );
+      expect(result).toBe("/project/src/bar.ts");
+    });
+
+    test("preserves .ts extension", () => {
+      const result = resolveRelativeImportPath(
+        "/project/src/foo.ts",
+        "./bar.ts",
+      );
+      expect(result).toBe("/project/src/bar.ts");
+    });
+
+    test("adds .ts extension if no extension provided", () => {
+      const result = resolveRelativeImportPath("/project/src/foo.ts", "./bar");
+      expect(result).toMatch(/\.ts$/);
+    });
+  });
+});