@tsonic/frontend 0.0.1 → 0.0.2

package/src/program/bindings.ts

@@ -1,253 +0,0 @@
-/**
- * Binding manifest loading - maps JS/TS names to CLR types/members
- * See spec/bindings.md for full manifest format
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-/**
- * Member binding (method/property level)
- */
-export type MemberBinding = {
-  readonly kind: "method" | "property";
-  readonly signature?: string; // Optional TS signature for diagnostics
-  readonly name: string; // CLR member name (e.g., "SelectMany")
-  readonly alias: string; // TS identifier (e.g., "selectMany")
-  readonly binding: {
-    readonly assembly: string;
-    readonly type: string; // Full CLR type (e.g., "System.Linq.Enumerable")
-    readonly member: string; // CLR member name
-  };
-};
-
-/**
- * Type binding (class/interface/struct/enum level)
- */
-export type TypeBinding = {
-  readonly name: string; // CLR type name (e.g., "Enumerable")
-  readonly alias: string; // TS identifier (e.g., "enumerable")
-  readonly kind: "class" | "interface" | "struct" | "enum";
-  readonly members: readonly MemberBinding[];
-};
-
-/**
- * Namespace binding
- */
-export type NamespaceBinding = {
-  readonly name: string; // CLR namespace (e.g., "System.Linq")
-  readonly alias: string; // TS identifier (e.g., "systemLinq")
-  readonly types: readonly TypeBinding[];
-};
-
-/**
- * Full binding manifest structure (new format from bindings.md)
- */
-export type FullBindingManifest = {
-  readonly assembly: string;
-  readonly namespaces: readonly NamespaceBinding[];
-};
-
-/**
- * Simple binding entry (legacy format for backwards compatibility)
- * Maps simple global/module identifiers to CLR types
- */
-export type SimpleBindingDescriptor = {
-  readonly kind: "global" | "module";
-  readonly assembly: string;
-  readonly type: string;
-  readonly csharpName?: string; // Optional: rename identifier in generated C#
-};
-
-/**
- * Legacy binding file structure (backwards compatible)
- */
-export type LegacyBindingFile = {
-  readonly bindings: Readonly<Record<string, SimpleBindingDescriptor>>;
-};
-
-/**
- * Union type for both binding formats
- */
-export type BindingFile = FullBindingManifest | LegacyBindingFile;
-
-/**
- * Type guard to check if a manifest is the full format
- */
-const isFullBindingManifest = (
-  manifest: BindingFile
-): manifest is FullBindingManifest => {
-  return "assembly" in manifest && "namespaces" in manifest;
-};
-
-/**
- * Registry of all loaded bindings
- * Supports both legacy (simple global/module) and new (hierarchical namespace/type/member) formats
- */
-export class BindingRegistry {
-  // Legacy format: simple global/module bindings
-  private readonly simpleBindings = new Map<string, SimpleBindingDescriptor>();
-
-  // New format: hierarchical bindings
-  private readonly namespaces = new Map<string, NamespaceBinding>();
-  private readonly types = new Map<string, TypeBinding>(); // Flat lookup by TS name
-  private readonly members = new Map<string, MemberBinding>(); // Flat lookup by "type.member"
-
-  /**
-   * Load a binding manifest file and add its bindings to the registry
-   * Supports both legacy and new formats
-   */
-  addBindings(_filePath: string, manifest: BindingFile): void {
-    if (isFullBindingManifest(manifest)) {
-      // New format: hierarchical namespace/type/member structure
-      // Index by alias (TS identifier) for quick lookup
-      for (const ns of manifest.namespaces) {
-        this.namespaces.set(ns.alias, ns);
-
-        // Index types for quick lookup by TS alias
-        for (const type of ns.types) {
-          this.types.set(type.alias, type);
-
-          // Index members for quick lookup (keyed by "typeAlias.memberAlias")
-          for (const member of type.members) {
-            const key = `${type.alias}.${member.alias}`;
-            this.members.set(key, member);
-          }
-        }
-      }
-    } else {
-      // Legacy format: simple global/module bindings
-      for (const [name, descriptor] of Object.entries(manifest.bindings)) {
-        this.simpleBindings.set(name, descriptor);
-      }
-    }
-  }
-
-  /**
-   * Look up a simple global/module binding (legacy format)
-   */
-  getBinding(name: string): SimpleBindingDescriptor | undefined {
-    return this.simpleBindings.get(name);
-  }
-
-  /**
-   * Look up a namespace binding by TS alias
-   */
-  getNamespace(tsAlias: string): NamespaceBinding | undefined {
-    return this.namespaces.get(tsAlias);
-  }
-
-  /**
-   * Look up a type binding by TS alias
-   */
-  getType(tsAlias: string): TypeBinding | undefined {
-    return this.types.get(tsAlias);
-  }
-
-  /**
-   * Look up a member binding by TS type alias and member alias
-   */
-  getMember(typeAlias: string, memberAlias: string): MemberBinding | undefined {
-    const key = `${typeAlias}.${memberAlias}`;
-    return this.members.get(key);
-  }
-
-  /**
-   * Get all loaded simple bindings (legacy)
-   */
-  getAllBindings(): readonly [string, SimpleBindingDescriptor][] {
-    return Array.from(this.simpleBindings.entries());
-  }
-
-  /**
-   * Get all loaded namespaces
-   */
-  getAllNamespaces(): readonly NamespaceBinding[] {
-    return Array.from(this.namespaces.values());
-  }
-
-  /**
-   * Clear all loaded bindings
-   */
-  clear(): void {
-    this.simpleBindings.clear();
-    this.namespaces.clear();
-    this.types.clear();
-    this.members.clear();
-  }
-}
-
-/**
- * Recursively scan a directory for .d.ts files
- * Reuses the same helper as metadata loading
- */
-const scanForDeclarationFiles = (dir: string): readonly string[] => {
-  if (!fs.existsSync(dir)) {
-    return [];
-  }
-
-  const results: string[] = [];
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...scanForDeclarationFiles(fullPath));
-    } else if (entry.name.endsWith(".d.ts")) {
-      results.push(fullPath);
-    }
-  }
-
-  return results;
-};
-
-/**
- * Load binding manifests from configured type roots
- * Looks for *.bindings.json files alongside .d.ts files OR directly in typeRoot
- */
-export const loadBindings = (typeRoots: readonly string[]): BindingRegistry => {
-  const registry = new BindingRegistry();
-
-  for (const typeRoot of typeRoots) {
-    const absoluteRoot = path.resolve(typeRoot);
-
-    // Skip if directory doesn't exist
-    if (!fs.existsSync(absoluteRoot)) {
-      continue;
-    }
-
-    // Strategy 1: Look for manifest in the typeRoot itself
-    const rootManifests = fs
-      .readdirSync(absoluteRoot)
-      .filter((f) => f.endsWith(".bindings.json"))
-      .map((f) => path.join(absoluteRoot, f));
-
-    for (const manifestPath of rootManifests) {
-      try {
-        const content = fs.readFileSync(manifestPath, "utf-8");
-        const manifest = JSON.parse(content) as BindingFile;
-        registry.addBindings(manifestPath, manifest);
-      } catch (err) {
-        console.warn(`Failed to load bindings from ${manifestPath}:`, err);
-      }
-    }
-
-    // Strategy 2: Look for *.bindings.json next to each .d.ts file
-    const declFiles = scanForDeclarationFiles(absoluteRoot);
-    for (const declPath of declFiles) {
-      const manifestPath = declPath.replace(/\.d\.ts$/, ".bindings.json");
-
-      try {
-        if (fs.existsSync(manifestPath)) {
-          const content = fs.readFileSync(manifestPath, "utf-8");
-          const manifest = JSON.parse(content) as BindingFile;
-          registry.addBindings(manifestPath, manifest);
-        }
-      } catch (err) {
-        console.warn(`Failed to load bindings from ${manifestPath}:`, err);
-      }
-    }
-  }
-
-  return registry;
-};

package/src/program/config.ts

@@ -1,30 +0,0 @@
-/**
- * TypeScript compiler configuration
- */
-
-import * as ts from "typescript";
-
-/**
- * Default TypeScript compiler options for Tsonic
- */
-export const defaultTsConfig: ts.CompilerOptions = {
-  target: ts.ScriptTarget.ES2022,
-  module: ts.ModuleKind.NodeNext,
-  moduleResolution: ts.ModuleResolutionKind.NodeNext,
-  // We use the globals from the BCL bindings directory instead of npm packages
-  // The BCL bindings include a globals.d.ts that provides minimal types
-  noLib: true,
-  types: [], // No npm packages - globals come from BCL bindings typeRoots
-  strict: false, // Disabled to allow .NET type usage
-  esModuleInterop: true,
-  skipLibCheck: true,
-  forceConsistentCasingInFileNames: true,
-  allowJs: false,
-  checkJs: false,
-  noEmit: true,
-  resolveJsonModule: false,
-  isolatedModules: true, // Re-enabled - safe now that DOM globals are gone
-  verbatimModuleSyntax: false, // Disabled to allow .NET type imports
-  noImplicitAny: false, // Allow any for .NET types
-  allowImportingTsExtensions: true, // ESM requires .ts/.js extensions
-};

package/src/program/creation.ts

@@ -1,249 +0,0 @@
-/**
- * Program creation
- */
-
-import * as ts from "typescript";
-import * as path from "node:path";
-import * as fs from "node:fs";
-import { Result, ok, error } from "../types/result.js";
-import { DiagnosticsCollector } from "../types/diagnostic.js";
-import { CompilerOptions, TsonicProgram } from "./types.js";
-import { defaultTsConfig } from "./config.js";
-import { loadDotnetMetadata } from "./metadata.js";
-import { loadBindings } from "./bindings.js";
-import { collectTsDiagnostics } from "./diagnostics.js";
-import { createDotNetImportResolver } from "../resolver/dotnet-import-resolver.js";
-
-/**
- * Recursively scan a directory for .d.ts files
- */
-const scanForDeclarationFiles = (dir: string): readonly string[] => {
-  if (!fs.existsSync(dir)) {
-    return [];
-  }
-
-  const results: string[] = [];
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...scanForDeclarationFiles(fullPath));
-    } else if (entry.name.endsWith(".d.ts")) {
-      results.push(fullPath);
-    }
-  }
-
-  return results;
-};
-
-/**
- * Create TypeScript compiler options from Tsonic options
- * Exported for use by dependency graph builder
- */
-export const createCompilerOptions = (
-  options: CompilerOptions
-): ts.CompilerOptions => {
-  const baseConfig = {
-    ...defaultTsConfig,
-    strict: options.strict ?? true,
-    rootDir: options.sourceRoot,
-  };
-
-  // When useStandardLib is true, disable noLib to use TypeScript's built-in types
-  // This is useful for tests that don't have access to BCL bindings
-  if (options.useStandardLib) {
-    return {
-      ...baseConfig,
-      noLib: false,
-      types: undefined, // Use default type resolution
-    };
-  }
-
-  return baseConfig;
-};
-
-/**
- * Create a Tsonic program from TypeScript source files
- */
-export const createProgram = (
-  filePaths: readonly string[],
-  options: CompilerOptions
-): Result<TsonicProgram, DiagnosticsCollector> => {
-  const absolutePaths = filePaths.map((fp) => path.resolve(fp));
-
-  // Get declaration files from type roots
-  const typeRoots = options.typeRoots ?? [
-    "node_modules/@tsonic/dotnet-types/types",
-  ];
-
-  // Debug log typeRoots
-  if (options.verbose && typeRoots.length > 0) {
-    console.log(`TypeRoots: ${typeRoots.join(", ")}`);
-  }
-
-  const declarationFiles: string[] = [];
-
-  for (const typeRoot of typeRoots) {
-    const absoluteRoot = path.resolve(typeRoot);
-    declarationFiles.push(...scanForDeclarationFiles(absoluteRoot));
-  }
-
-  // Add the main index.d.ts files for .NET namespaces directly to the file list
-  const namespaceIndexFiles: string[] = [];
-  for (const typeRoot of typeRoots) {
-    const absoluteRoot = path.resolve(typeRoot);
-    if (options.verbose) {
-      console.log(
-        `Checking typeRoot: ${absoluteRoot}, exists: ${fs.existsSync(absoluteRoot)}`
-      );
-    }
-    if (fs.existsSync(absoluteRoot)) {
-      const entries = fs.readdirSync(absoluteRoot, { withFileTypes: true });
-      for (const entry of entries) {
-        if (
-          entry.isDirectory() &&
-          !entry.name.startsWith("_") &&
-          !entry.name.startsWith("internal")
-        ) {
-          const indexPath = path.join(absoluteRoot, entry.name, "index.d.ts");
-          if (fs.existsSync(indexPath)) {
-            namespaceIndexFiles.push(indexPath);
-            if (options.verbose) {
-              console.log(`  Found namespace: ${entry.name} -> ${indexPath}`);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Combine source files, declaration files, and namespace index files
-  // Note: globals.d.ts should be in the BCL bindings directory (typeRoots)
-  const allFiles = [
-    ...absolutePaths,
-    ...declarationFiles,
-    ...namespaceIndexFiles,
-  ];
-
-  const tsOptions = createCompilerOptions(options);
-
-  // Create custom compiler host with virtual .NET module declarations
-  const host = ts.createCompilerHost(tsOptions);
-
-  // Map of .NET namespace names to their declaration file paths
-  const namespaceFiles = new Map<string, string>();
-  for (const indexFile of namespaceIndexFiles) {
-    // Extract namespace name from path (e.g., /path/to/System/index.d.ts -> System)
-    const dirName = path.basename(path.dirname(indexFile));
-    namespaceFiles.set(dirName, indexFile);
-  }
-
-  // Log namespace mappings when verbose
-  if (options.verbose && namespaceFiles.size > 0) {
-    console.log(`Found ${namespaceFiles.size} .NET namespace declarations`);
-    for (const [ns, file] of namespaceFiles) {
-      console.log(`  ${ns} -> ${file}`);
-    }
-  }
-
-  // Override getSourceFile to provide virtual module declarations
-  const originalGetSourceFile = host.getSourceFile;
-  host.getSourceFile = (
-    fileName: string,
-    languageVersion: ts.ScriptTarget,
-    onError?: (message: string) => void,
-    shouldCreateNewSourceFile?: boolean
-  ): ts.SourceFile | undefined => {
-    // Check if this is a .NET namespace being imported
-    const baseName = path.basename(fileName, path.extname(fileName));
-    if (namespaceFiles.has(baseName) && fileName.endsWith(".ts")) {
-      // Create a virtual source file that exports from the actual declaration
-      const declarationPath = namespaceFiles.get(baseName)!;
-      const virtualContent = `export * from '${declarationPath.replace(/\.d\.ts$/, "")}';`;
-      return ts.createSourceFile(
-        fileName,
-        virtualContent,
-        languageVersion,
-        true
-      );
-    }
-
-    return originalGetSourceFile.call(
-      host,
-      fileName,
-      languageVersion,
-      onError,
-      shouldCreateNewSourceFile
-    );
-  };
-
-  // Override resolveModuleNames to handle .NET imports
-  (host as any).resolveModuleNames = (
-    moduleNames: string[],
-    containingFile: string
-  ): (ts.ResolvedModule | undefined)[] => {
-    return moduleNames.map((moduleName) => {
-      // Debug log
-      if (options.verbose) {
-        console.log(`Resolving module: ${moduleName} from ${containingFile}`);
-      }
-
-      // Check if this is a .NET namespace
-      if (namespaceFiles.has(moduleName)) {
-        const resolvedFile = namespaceFiles.get(moduleName)!;
-        if (options.verbose) {
-          console.log(
-            `  Resolved .NET namespace ${moduleName} to ${resolvedFile}`
-          );
-        }
-        return {
-          resolvedFileName: resolvedFile,
-          isExternalLibraryImport: true,
-        };
-      }
-
-      // Use default resolution for other modules
-      const result = ts.resolveModuleName(
-        moduleName,
-        containingFile,
-        tsOptions,
-        host
-      );
-      return result.resolvedModule;
-    });
-  };
-
-  const program = ts.createProgram(allFiles, tsOptions, host);
-
-  const diagnostics = collectTsDiagnostics(program);
-
-  if (diagnostics.hasErrors) {
-    return error(diagnostics);
-  }
-
-  const sourceFiles = program
-    .getSourceFiles()
-    .filter(
-      (sf) => !sf.isDeclarationFile && absolutePaths.includes(sf.fileName)
-    );
-
-  // Load .NET metadata files
-  const metadata = loadDotnetMetadata(typeRoots);
-
-  // Load binding manifests (from typeRoots - for ambient globals)
-  const bindings = loadBindings(typeRoots);
-
-  // Create resolver for import-driven .NET namespace discovery
-  const dotnetResolver = createDotNetImportResolver(options.sourceRoot);
-
-  return ok({
-    program,
-    checker: program.getTypeChecker(),
-    options,
-    sourceFiles,
-    metadata,
-    bindings,
-    dotnetResolver,
-  });
-};