@tsonic/frontend 0.0.1

package/src/resolver.test.ts

@@ -0,0 +1,155 @@
+/**
+ * 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

@@ -0,0 +1,14 @@
+/**
+ * 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

@@ -0,0 +1,114 @@
+/**
+ * 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;
+};

package/src/symbol-table/creation.ts

@@ -0,0 +1,42 @@
+/**
+ * Symbol table creation and modification
+ */
+
+import { Symbol, SymbolTable } from "./types.js";
+
+/**
+ * Create an empty symbol table
+ */
+export const createSymbolTable = (): SymbolTable => ({
+  symbols: new Map(),
+  moduleSymbols: new Map(),
+  exportedSymbols: new Map(),
+});
+
+/**
+ * Add a symbol to the table (immutable)
+ */
+export const addSymbol = (table: SymbolTable, symbol: Symbol): SymbolTable => {
+  // Add to symbols map (by name)
+  const symbolsByName = table.symbols.get(symbol.name) ?? [];
+  const newSymbolsByName = new Map(table.symbols);
+  newSymbolsByName.set(symbol.name, [...symbolsByName, symbol]);
+
+  // Add to module symbols map
+  const moduleSymbols = table.moduleSymbols.get(symbol.module) ?? [];
+  const newModuleSymbols = new Map(table.moduleSymbols);
+  newModuleSymbols.set(symbol.module, [...moduleSymbols, symbol]);
+
+  // Add to exported symbols if exported
+  let newExportedSymbols = new Map(table.exportedSymbols);
+  if (symbol.isExported) {
+    const exportedSymbols = table.exportedSymbols.get(symbol.module) ?? [];
+    newExportedSymbols.set(symbol.module, [...exportedSymbols, symbol]);
+  }
+
+  return {
+    symbols: newSymbolsByName,
+    moduleSymbols: newModuleSymbols,
+    exportedSymbols: newExportedSymbols,
+  };
+};

package/src/symbol-table/helpers.ts

@@ -0,0 +1,18 @@
+/**
+ * Symbol table helper functions
+ */
+
+import * as ts from "typescript";
+
+/**
+ * Check if a node has an export modifier
+ */
+export const hasExportModifier = (node: ts.Node): boolean => {
+  if (!ts.canHaveModifiers(node)) {
+    return false;
+  }
+  const modifiers = ts.getModifiers(node);
+  return (
+    modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false
+  );
+};

package/src/symbol-table/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Symbol table - Public API
+ */
+
+export type { SymbolKind, Symbol, SymbolTable } from "./types.js";
+export { createSymbolTable, addSymbol } from "./creation.js";
+export { buildSymbolTable } from "./builder.js";
+export {
+  findSymbol,
+  getExportedSymbols,
+  hasExportedSymbol,
+} from "./queries.js";
+export { hasExportModifier } from "./helpers.js";

package/src/symbol-table/queries.ts

@@ -0,0 +1,42 @@
+/**
+ * Symbol table query functions
+ */
+
+import { Symbol, SymbolTable } from "./types.js";
+
+/**
+ * Find symbols by name, optionally filtered by module
+ */
+export const findSymbol = (
+  table: SymbolTable,
+  name: string,
+  module?: string
+): readonly Symbol[] => {
+  if (module) {
+    const moduleSymbols = table.moduleSymbols.get(module) ?? [];
+    return moduleSymbols.filter((s) => s.name === name);
+  }
+  return table.symbols.get(name) ?? [];
+};
+
+/**
+ * Get all exported symbols from a module
+ */
+export const getExportedSymbols = (
+  table: SymbolTable,
+  module: string
+): readonly Symbol[] => {
+  return table.exportedSymbols.get(module) ?? [];
+};
+
+/**
+ * Check if a module exports a symbol with the given name
+ */
+export const hasExportedSymbol = (
+  table: SymbolTable,
+  module: string,
+  name: string
+): boolean => {
+  const exported = getExportedSymbols(table, module);
+  return exported.some((s) => s.name === name);
+};

package/src/symbol-table/types.ts

@@ -0,0 +1,28 @@
+/**
+ * Symbol table type definitions
+ */
+
+import * as ts from "typescript";
+
+export type SymbolKind =
+  | "class"
+  | "interface"
+  | "function"
+  | "variable"
+  | "type"
+  | "enum"
+  | "namespace";
+
+export type Symbol = {
+  readonly name: string;
+  readonly kind: SymbolKind;
+  readonly isExported: boolean;
+  readonly module: string; // File path
+  readonly tsSymbol?: ts.Symbol; // Optional reference to TypeScript symbol
+};
+
+export type SymbolTable = {
+  readonly symbols: ReadonlyMap<string, readonly Symbol[]>; // Name to symbols
+  readonly moduleSymbols: ReadonlyMap<string, readonly Symbol[]>; // Module path to symbols
+  readonly exportedSymbols: ReadonlyMap<string, readonly Symbol[]>; // Module path to exported symbols
+};

package/src/symbol-table.ts

@@ -0,0 +1,14 @@
+/**
+ * Symbol table for tracking cross-module references
+ * Main dispatcher - re-exports from symbol-table/ subdirectory
+ */
+
+export type { SymbolKind, Symbol, SymbolTable } from "./symbol-table/index.js";
+export {
+  createSymbolTable,
+  addSymbol,
+  buildSymbolTable,
+  findSymbol,
+  getExportedSymbols,
+  hasExportedSymbol,
+} from "./symbol-table/index.js";

package/src/types/bindings.ts

@@ -0,0 +1,172 @@
+/**
+ * Type definitions for .NET bindings.json files generated by tsbindgen.
+ *
+ * These types represent runtime binding information used for reflection-based dispatch.
+ * All property names use camelCase (JavaScript convention).
+ *
+ * The bindings format uses a dual-version structure:
+ * - V1 Definitions: Full method signatures for reference
+ * - V2 Exposures: Lightweight binding info for runtime dispatch
+ *
+ * @see spec/bindings.md for complete schema documentation
+ */
+
+/**
+ * Root bindings file structure.
+ * Represents a single namespace with all its type bindings.
+ */
+export type BindingsFile = {
+  readonly namespace: string;
+  readonly types: TypeBinding[];
+};
+
+/**
+ * Complete binding information for a CLR type.
+ * Includes both V1 definitions and V2 exposures.
+ */
+export type TypeBinding = {
+  readonly clrName: string;
+  readonly tsEmitName: string;
+  readonly assemblyName: string;
+  readonly metadataToken: number;
+  readonly methods?: MethodBinding[]; // V1: Full signatures
+  readonly properties?: PropertyBinding[]; // V1: Property info
+  readonly fields?: FieldBinding[]; // V1: Field info
+  readonly events?: EventBinding[]; // V1: Event info
+  readonly exposedMethods?: ExposedMethodBinding[]; // V2: Runtime dispatch
+  readonly exposedProperties?: ExposedPropertyBinding[]; // V2: Runtime access
+  readonly exposedFields?: ExposedFieldBinding[]; // V2: Runtime access
+  readonly exposedEvents?: ExposedEventBinding[]; // V2: Runtime access
+};
+
+/**
+ * V1 Definition: Complete method signature.
+ * Used for type checking and reference.
+ */
+export type MethodBinding = {
+  readonly name: string;
+  readonly clrName: string;
+  readonly tsEmitName: string;
+  readonly isStatic: boolean;
+  readonly arity: number;
+  readonly parameters: ParameterBinding[];
+  readonly returnType: string;
+  readonly metadataToken: number;
+};
+
+/**
+ * V1 Definition: Property information.
+ */
+export type PropertyBinding = {
+  readonly name: string;
+  readonly clrName: string;
+  readonly tsEmitName: string;
+  readonly isStatic: boolean;
+  readonly type: string;
+  readonly hasGetter: boolean;
+  readonly hasSetter: boolean;
+  readonly getterToken?: number;
+  readonly setterToken?: number;
+};
+
+/**
+ * V1 Definition: Field information.
+ */
+export type FieldBinding = {
+  readonly name: string;
+  readonly clrName: string;
+  readonly tsEmitName: string;
+  readonly isStatic: boolean;
+  readonly type: string;
+  readonly metadataToken: number;
+};
+
+/**
+ * V1 Definition: Event information.
+ */
+export type EventBinding = {
+  readonly name: string;
+  readonly clrName: string;
+  readonly tsEmitName: string;
+  readonly isStatic: boolean;
+  readonly type: string;
+  readonly adderToken: number;
+  readonly removerToken: number;
+};
+
+/**
+ * Parameter binding information.
+ */
+export type ParameterBinding = {
+  readonly name: string;
+  readonly type: string;
+  readonly isRef: boolean;
+  readonly isOut: boolean;
+  readonly isIn?: boolean;
+  readonly isParams: boolean;
+};
+
+/**
+ * V2 Exposure: Lightweight method binding for runtime dispatch.
+ * Optimized format with minimal data for fast lookups.
+ */
+export type ExposedMethodBinding = {
+  readonly tsEmitName: string;
+  readonly isStatic: boolean;
+  readonly arity: number;
+  readonly overloads: MethodOverloadBinding[];
+};
+
+/**
+ * Method overload binding.
+ * One entry per unique parameter count.
+ */
+export type MethodOverloadBinding = {
+  readonly parameterCount: number;
+  readonly metadataToken: number;
+};
+
+/**
+ * V2 Exposure: Lightweight property binding for runtime access.
+ */
+export type ExposedPropertyBinding = {
+  readonly tsEmitName: string;
+  readonly isStatic: boolean;
+  readonly getterToken?: number;
+  readonly setterToken?: number;
+};
+
+/**
+ * V2 Exposure: Lightweight field binding for runtime access.
+ */
+export type ExposedFieldBinding = {
+  readonly tsEmitName: string;
+  readonly isStatic: boolean;
+  readonly metadataToken: number;
+};
+
+/**
+ * V2 Exposure: Lightweight event binding for runtime access.
+ */
+export type ExposedEventBinding = {
+  readonly tsEmitName: string;
+  readonly isStatic: boolean;
+  readonly adderToken: number;
+  readonly removerToken: number;
+};
+
+/**
+ * Helper type: Extract V1 definitions from a type binding.
+ */
+export type V1Definitions = Pick<
+  TypeBinding,
+  "methods" | "properties" | "fields" | "events"
+>;
+
+/**
+ * Helper type: Extract V2 exposures from a type binding.
+ */
+export type V2Exposures = Pick<
+  TypeBinding,
+  "exposedMethods" | "exposedProperties" | "exposedFields" | "exposedEvents"
+>;