@tsonic/frontend 0.0.1 → 0.0.4

package/src/resolver/import-resolution.ts

@@ -1,177 +0,0 @@
-/**
- * Import resolution with ESM rules enforcement
- */
-
-import * as path from "node:path";
-import * as fs from "node:fs";
-import { Result, ok, error } from "../types/result.js";
-import { Diagnostic, createDiagnostic } from "../types/diagnostic.js";
-import { isLocalImport } from "../types/module.js";
-import { ResolvedModule } from "./types.js";
-import { getBindingRegistry } from "../ir/converters/statements/declarations/registry.js";
-import { DotNetImportResolver } from "./dotnet-import-resolver.js";
-
-/**
- * Resolve import specifier to module
- */
-export const resolveImport = (
-  importSpecifier: string,
-  containingFile: string,
-  sourceRoot: string,
-  dotnetResolver?: DotNetImportResolver
-): Result<ResolvedModule, Diagnostic> => {
-  if (isLocalImport(importSpecifier)) {
-    return resolveLocalImport(importSpecifier, containingFile, sourceRoot);
-  }
-
-  // Use import-driven resolution for .NET imports (if resolver provided)
-  if (dotnetResolver) {
-    const dotnetResolution = dotnetResolver.resolve(importSpecifier);
-    if (dotnetResolution.isDotNet) {
-      return ok({
-        resolvedPath: "", // No file path for .NET imports
-        isLocal: false,
-        isDotNet: true,
-        originalSpecifier: importSpecifier,
-        resolvedNamespace: dotnetResolution.resolvedNamespace,
-      });
-    }
-  }
-
-  // Check if this is a module binding (e.g., Node.js API)
-  const binding = getBindingRegistry().getBinding(importSpecifier);
-  if (binding && binding.kind === "module") {
-    return ok({
-      resolvedPath: "", // No file path for bound modules
-      isLocal: false,
-      isDotNet: false,
-      originalSpecifier: importSpecifier,
-      resolvedClrType: binding.type,
-      resolvedAssembly: binding.assembly,
-    });
-  }
-
-  // @tsonic/types is a type-only package (phantom types) - no runtime code
-  if (importSpecifier === "@tsonic/types") {
-    return ok({
-      resolvedPath: "", // No file path for type-only packages
-      isLocal: false,
-      isDotNet: false,
-      originalSpecifier: importSpecifier,
-      resolvedClrType: undefined,
-      resolvedAssembly: undefined,
-    });
-  }
-
-  return error(
-    createDiagnostic(
-      "TSN1004",
-      "error",
-      `Unsupported module import: "${importSpecifier}"`,
-      undefined,
-      "Tsonic only supports local imports (with .ts), .NET imports, and registered module bindings"
-    )
-  );
-};
-
-/**
- * Resolve local import with ESM rules
- */
-export const resolveLocalImport = (
-  importSpecifier: string,
-  containingFile: string,
-  sourceRoot: string
-): Result<ResolvedModule, Diagnostic> => {
-  // Check for .ts extension
-  if (!importSpecifier.endsWith(".ts")) {
-    return error(
-      createDiagnostic(
-        "TSN1001",
-        "error",
-        `Local import must have .ts extension: "${importSpecifier}"`,
-        undefined,
-        `Change to: "${importSpecifier}.ts"`
-      )
-    );
-  }
-
-  const containingDir = path.dirname(containingFile);
-  const resolvedPath = path.resolve(containingDir, importSpecifier);
-
-  // Check if file exists
-  if (!fs.existsSync(resolvedPath)) {
-    return error(
-      createDiagnostic(
-        "TSN1004",
-        "error",
-        `Cannot find module: "${importSpecifier}"`,
-        undefined,
-        `File not found: ${resolvedPath}`
-      )
-    );
-  }
-
-  // Check case sensitivity
-  const realPath = fs.realpathSync(resolvedPath);
-  if (realPath !== resolvedPath && process.platform !== "win32") {
-    return error(
-      createDiagnostic(
-        "TSN1003",
-        "error",
-        `Case mismatch in import path: "${importSpecifier}"`,
-        undefined,
-        `File exists as: ${realPath}`
-      )
-    );
-  }
-
-  // Ensure it's within the source root
-  if (!resolvedPath.startsWith(sourceRoot)) {
-    return error(
-      createDiagnostic(
-        "TSN1004",
-        "error",
-        `Import outside source root: "${importSpecifier}"`,
-        undefined,
-        `Source root: ${sourceRoot}`
-      )
-    );
-  }
-
-  return ok({
-    resolvedPath,
-    isLocal: true,
-    isDotNet: false,
-    originalSpecifier: importSpecifier,
-  });
-};
-
-/**
- * Resolve .NET import (namespace validation)
- */
-export const resolveDotNetImport = (
-  importSpecifier: string
-): Result<ResolvedModule, Diagnostic> => {
-  // For .NET imports, we don't resolve to a file
-  // We just validate the format and return the namespace
-
-  // Check for invalid characters
-  if (!/^[A-Za-z_][A-Za-z0-9_.]*$/.test(importSpecifier)) {
-    return error(
-      createDiagnostic(
-        "TSN4001",
-        "error",
-        `Invalid .NET namespace: "${importSpecifier}"`,
-        undefined,
-        "Must be a valid .NET namespace identifier"
-      )
-    );
-  }
-
-  return ok({
-    resolvedPath: "", // No file path for .NET imports
-    isLocal: false,
-    isDotNet: true,
-    originalSpecifier: importSpecifier,
-  });
-};

package/src/resolver/namespace.test.ts

@@ -1,86 +0,0 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { getNamespaceFromPath } from "./namespace.js";
-
-describe("getNamespaceFromPath", () => {
-  it("should return root namespace for files directly in source root", () => {
-    const result = getNamespaceFromPath(
-      "/project/src/index.ts",
-      "/project/src",
-      "MyApp"
-    );
-    expect(result).to.equal("MyApp");
-  });
-
-  it("should return root namespace for files in source root without src directory", () => {
-    const result = getNamespaceFromPath(
-      "/project/index.ts",
-      "/project",
-      "MyApp"
-    );
-    expect(result).to.equal("MyApp");
-  });
-
-  it("should compute namespace from single subdirectory", () => {
-    const result = getNamespaceFromPath(
-      "/project/src/models/user.ts",
-      "/project/src",
-      "MyApp"
-    );
-    expect(result).to.equal("MyApp.models");
-  });
-
-  it("should compute namespace from nested subdirectories", () => {
-    const result = getNamespaceFromPath(
-      "/project/src/models/entities/user.ts",
-      "/project/src",
-      "MyApp"
-    );
-    expect(result).to.equal("MyApp.models.entities");
-  });
-
-  it("should filter out 'src' from path components", () => {
-    const result = getNamespaceFromPath(
-      "/project/src/models/src/user.ts",
-      "/project/src",
-      "MyApp"
-    );
-    expect(result).to.equal("MyApp.models");
-  });
-
-  it("should handle case-preserved directory names", () => {
-    const result = getNamespaceFromPath(
-      "/project/src/MyModels/UserEntity.ts",
-      "/project/src",
-      "MyApp"
-    );
-    expect(result).to.equal("MyApp.MyModels");
-  });
-
-  it("should handle deep nesting", () => {
-    const result = getNamespaceFromPath(
-      "/project/src/a/b/c/d/e/file.ts",
-      "/project/src",
-      "MyApp"
-    );
-    expect(result).to.equal("MyApp.a.b.c.d.e");
-  });
-
-  it("should handle source root without trailing slash", () => {
-    const result = getNamespaceFromPath(
-      "/project/src/models/user.ts",
-      "/project/src",
-      "MyApp"
-    );
-    expect(result).to.equal("MyApp.models");
-  });
-
-  it("should handle source root with trailing slash", () => {
-    const result = getNamespaceFromPath(
-      "/project/src/models/user.ts",
-      "/project/src/",
-      "MyApp"
-    );
-    expect(result).to.equal("MyApp.models");
-  });
-});

package/src/resolver/namespace.ts

@@ -1,42 +0,0 @@
-import { dirname, relative } from "path";
-
-/**
- * Compute namespace from file path relative to source root.
- *
- * Rules:
- * - Namespace = rootNamespace + path components (excluding "src")
- * - Path normalized with "/" separators after relative() call
- * - Empty path maps to root namespace
- *
- * Examples:
- * - /project/src/models/user.ts → RootNamespace.models
- * - /project/src/index.ts → RootNamespace
- * - /project/models/user.ts → RootNamespace.models
- *
- * @param filePath - Absolute path to the TypeScript file
- * @param sourceRoot - Absolute path to source root directory
- * @param rootNamespace - Root namespace for the project
- * @returns Computed namespace string
- */
-export const getNamespaceFromPath = (
-  filePath: string,
-  sourceRoot: string,
-  rootNamespace: string
-): string => {
-  const fileDir = dirname(filePath);
-
-  // Make relative to source root, then normalize to forward slashes
-  // IMPORTANT: Normalize AFTER relative() call, not before (cross-platform)
-  let relativePath = relative(sourceRoot, fileDir).replace(/\\/g, "/");
-
-  // Split by "/" and filter out empty, ".", and "src" components
-  const parts = relativePath
-    .split("/")
-    .filter((p) => p !== "" && p !== "." && p !== "src");
-
-  // If no path components, return root namespace
-  // Otherwise, join with "."
-  return parts.length === 0
-    ? rootNamespace
-    : `${rootNamespace}.${parts.join(".")}`;
-};

package/src/resolver/naming.ts

@@ -1,38 +0,0 @@
-/**
- * Namespace and class name generation from file paths
- */
-
-import * as path from "node:path";
-import { resolveModulePath } from "./path-resolution.js";
-
-/**
- * Generate namespace from file path
- */
-export const getNamespaceFromPath = (
-  filePath: string,
-  sourceRoot: string,
-  rootNamespace: string
-): string => {
-  const relativePath = resolveModulePath(filePath, sourceRoot);
-  const dirPath = path.dirname(relativePath);
-
-  if (dirPath === ".") {
-    return rootNamespace;
-  }
-
-  // Strip hyphens from directory names (per spec: hyphens are ignored)
-  const parts = dirPath
-    .split(path.sep)
-    .filter((p) => p !== ".")
-    .map((p) => p.replace(/-/g, ""));
-  return [rootNamespace, ...parts].join(".");
-};
-
-/**
- * Generate class name from file path
- */
-export const getClassNameFromPath = (filePath: string): string => {
-  const basename = path.basename(filePath, ".ts");
-  // Strip hyphens from file names (per spec: hyphens are ignored)
-  return basename.replace(/-/g, "");
-};

package/src/resolver/path-resolution.ts

@@ -1,22 +0,0 @@
-/**
- * Path resolution utilities
- */
-
-import * as path from "node:path";
-
-/**
- * Resolve module path relative to source root
- */
-export const resolveModulePath = (
-  filePath: string,
-  sourceRoot: string
-): string => {
-  const absolutePath = path.resolve(filePath);
-  const absoluteRoot = path.resolve(sourceRoot);
-
-  if (!absolutePath.startsWith(absoluteRoot)) {
-    throw new Error(`File ${filePath} is outside source root ${sourceRoot}`);
-  }
-
-  return path.relative(absoluteRoot, absolutePath);
-};

package/src/resolver/types.ts

@@ -1,15 +0,0 @@
-/**
- * Resolver type definitions
- */
-
-export type ResolvedModule = {
-  readonly resolvedPath: string;
-  readonly isLocal: boolean;
-  readonly isDotNet: boolean;
-  readonly originalSpecifier: string;
-  // For .NET imports: the CLR namespace (e.g., "System" from "@tsonic/dotnet/System")
-  readonly resolvedNamespace?: string;
-  // For module bindings (Node.js APIs mapped to CLR types)
-  readonly resolvedClrType?: string; // e.g., "Tsonic.NodeApi.fs"
-  readonly resolvedAssembly?: string; // e.g., "Tsonic.NodeApi"
-};

package/src/resolver.test.ts

@@ -1,155 +0,0 @@
-/**
- * Tests for module resolver
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import * as path from "node:path";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import {
-  resolveImport,
-  getNamespaceFromPath,
-  getClassNameFromPath,
-} from "./resolver.js";
-
-describe("Module Resolver", () => {
-  describe("resolveImport", () => {
-    const tempDir = path.join(os.tmpdir(), "tsonic-test");
-    const sourceRoot = tempDir;
-
-    before(() => {
-      // Create temp directory structure
-      fs.mkdirSync(path.join(tempDir, "src", "models"), { recursive: true });
-      fs.writeFileSync(
-        path.join(tempDir, "src", "models", "User.ts"),
-        "export class User {}"
-      );
-      fs.writeFileSync(path.join(tempDir, "src", "index.ts"), "");
-    });
-
-    after(() => {
-      // Clean up
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    });
-
-    it("should resolve local imports with .ts extension", () => {
-      const result = resolveImport(
-        "./models/User.ts",
-        path.join(tempDir, "src", "index.ts"),
-        sourceRoot
-      );
-
-      expect(result.ok).to.equal(true);
-      if (result.ok) {
-        expect(result.value.isLocal).to.equal(true);
-        expect(result.value.isDotNet).to.equal(false);
-        expect(result.value.resolvedPath).to.equal(
-          path.join(tempDir, "src", "models", "User.ts")
-        );
-      }
-    });
-
-    it("should error on local imports without .ts extension", () => {
-      const result = resolveImport(
-        "./models/User",
-        path.join(tempDir, "src", "index.ts"),
-        sourceRoot
-      );
-
-      expect(result.ok).to.equal(false);
-      if (!result.ok) {
-        expect(result.error.code).to.equal("TSN1001");
-        expect(result.error.message).to.include("must have .ts extension");
-      }
-    });
-
-    it("should not detect bare imports as .NET without resolver with bindings", () => {
-      // Import-driven resolution: bare imports like "System.IO" are only detected as .NET
-      // if a resolver is provided and the import resolves to a package with bindings.json.
-      // Without a resolver or package, bare imports are treated as unsupported node_modules.
-      const result = resolveImport(
-        "System.IO",
-        path.join(tempDir, "src", "index.ts"),
-        sourceRoot
-        // No dotnetResolver passed
-      );
-
-      expect(result.ok).to.equal(false);
-      if (!result.ok) {
-        expect(result.error.code).to.equal("TSN1004");
-        expect(result.error.message).to.include("Unsupported module import");
-      }
-    });
-
-    it("should reject node_modules imports", () => {
-      const result = resolveImport(
-        "express",
-        path.join(tempDir, "src", "index.ts"),
-        sourceRoot
-      );
-
-      expect(result.ok).to.equal(false);
-      if (!result.ok) {
-        expect(result.error.code).to.equal("TSN1004");
-        expect(result.error.message).to.include("Unsupported module import");
-      }
-    });
-
-    it("should error on non-existent local files", () => {
-      const result = resolveImport(
-        "./nonexistent.ts",
-        path.join(tempDir, "src", "index.ts"),
-        sourceRoot
-      );
-
-      expect(result.ok).to.equal(false);
-      if (!result.ok) {
-        expect(result.error.code).to.equal("TSN1004");
-        expect(result.error.message).to.include("Cannot find module");
-      }
-    });
-  });
-
-  describe("getNamespaceFromPath", () => {
-    it("should generate namespace from directory structure", () => {
-      const namespace = getNamespaceFromPath(
-        "/project/src/models/auth/User.ts",
-        "/project/src",
-        "MyApp"
-      );
-
-      expect(namespace).to.equal("MyApp.models.auth");
-    });
-
-    it("should use root namespace for files in source root", () => {
-      const namespace = getNamespaceFromPath(
-        "/project/src/index.ts",
-        "/project/src",
-        "MyApp"
-      );
-
-      expect(namespace).to.equal("MyApp");
-    });
-
-    it("should preserve case in directory names", () => {
-      const namespace = getNamespaceFromPath(
-        "/project/src/Models/Auth/User.ts",
-        "/project/src",
-        "MyApp"
-      );
-
-      expect(namespace).to.equal("MyApp.Models.Auth");
-    });
-  });
-
-  describe("getClassNameFromPath", () => {
-    it("should extract class name from file name", () => {
-      expect(getClassNameFromPath("/src/User.ts")).to.equal("User");
-      expect(getClassNameFromPath("/src/models/UserProfile.ts")).to.equal(
-        "UserProfile"
-      );
-      expect(getClassNameFromPath("index.ts")).to.equal("index");
-    });
-  });
-});

package/src/resolver.ts

@@ -1,14 +0,0 @@
-/**
- * Module resolution with ESM rules enforcement
- * Main dispatcher - re-exports from resolver/ subdirectory
- */
-
-export type { ResolvedModule, ResolvedDotNetImport } from "./resolver/index.js";
-export {
-  resolveImport,
-  resolveModulePath,
-  getNamespaceFromPath,
-  getClassNameFromPath,
-  DotNetImportResolver,
-  createDotNetImportResolver,
-} from "./resolver/index.js";

package/src/symbol-table/builder.ts

@@ -1,114 +0,0 @@
-/**
- * Symbol table builder from TypeScript AST
- */
-
-import * as ts from "typescript";
-import { Symbol } from "./types.js";
-import { hasExportModifier } from "./helpers.js";
-
-/**
- * Build symbol table from a TypeScript source file
- */
-export const buildSymbolTable = (
-  sourceFile: ts.SourceFile,
-  checker: ts.TypeChecker
-): readonly Symbol[] => {
-  const symbols: Symbol[] = [];
-  const modulePath = sourceFile.fileName;
-
-  const visitor = (node: ts.Node): void => {
-    // Check for exported declarations
-    const isExported = hasExportModifier(node);
-
-    if (ts.isClassDeclaration(node) && node.name) {
-      symbols.push({
-        name: node.name.text,
-        kind: "class",
-        isExported,
-        module: modulePath,
-        tsSymbol: checker.getSymbolAtLocation(node.name),
-      });
-    } else if (ts.isInterfaceDeclaration(node)) {
-      symbols.push({
-        name: node.name.text,
-        kind: "interface",
-        isExported,
-        module: modulePath,
-        tsSymbol: checker.getSymbolAtLocation(node.name),
-      });
-    } else if (ts.isFunctionDeclaration(node) && node.name) {
-      symbols.push({
-        name: node.name.text,
-        kind: "function",
-        isExported,
-        module: modulePath,
-        tsSymbol: checker.getSymbolAtLocation(node.name),
-      });
-    } else if (ts.isVariableStatement(node)) {
-      node.declarationList.declarations.forEach((decl) => {
-        if (ts.isIdentifier(decl.name)) {
-          symbols.push({
-            name: decl.name.text,
-            kind: "variable",
-            isExported,
-            module: modulePath,
-            tsSymbol: checker.getSymbolAtLocation(decl.name),
-          });
-        }
-      });
-    } else if (ts.isTypeAliasDeclaration(node)) {
-      symbols.push({
-        name: node.name.text,
-        kind: "type",
-        isExported,
-        module: modulePath,
-        tsSymbol: checker.getSymbolAtLocation(node.name),
-      });
-    } else if (ts.isEnumDeclaration(node)) {
-      symbols.push({
-        name: node.name.text,
-        kind: "enum",
-        isExported,
-        module: modulePath,
-        tsSymbol: checker.getSymbolAtLocation(node.name),
-      });
-    } else if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name)) {
-      symbols.push({
-        name: node.name.text,
-        kind: "namespace",
-        isExported,
-        module: modulePath,
-        tsSymbol: checker.getSymbolAtLocation(node.name),
-      });
-    }
-
-    // Check for export declarations
-    if (
-      ts.isExportDeclaration(node) &&
-      node.exportClause &&
-      ts.isNamedExports(node.exportClause)
-    ) {
-      node.exportClause.elements.forEach((spec) => {
-        const originalName = spec.propertyName?.text ?? spec.name.text;
-        const exportedName = spec.name.text;
-
-        // Find the original symbol and mark it as exported
-        const originalSymbol = symbols.find(
-          (s) => s.name === originalName && !s.isExported
-        );
-        if (originalSymbol) {
-          symbols.push({
-            ...originalSymbol,
-            name: exportedName,
-            isExported: true,
-          });
-        }
-      });
-    }
-
-    ts.forEachChild(node, visitor);
-  };
-
-  visitor(sourceFile);
-  return symbols;
-};