@tsonic/frontend 0.0.1 → 0.0.4

package/src/types/explicit-views.test.ts

@@ -1,113 +0,0 @@
-/**
- * Tests for explicit interface views handling
- */
-
-import { describe, it } from "mocha";
-import { strict as assert } from "assert";
-import {
-  isExplicitViewProperty,
-  extractInterfaceNameFromView,
-  buildViewPropertyName,
-  generateInterfaceCast,
-  generateGenericInterfaceCast,
-} from "./explicit-views.js";
-
-describe("Explicit Interface Views", () => {
-  describe("isExplicitViewProperty", () => {
-    it("should detect As_IInterface pattern", () => {
-      assert.ok(isExplicitViewProperty("As_ICollection"));
-      assert.ok(isExplicitViewProperty("As_IEnumerable"));
-    });
-
-    it("should return false for non-view properties", () => {
-      assert.ok(!isExplicitViewProperty("Length"));
-      assert.ok(!isExplicitViewProperty("Count"));
-    });
-  });
-
-  describe("extractInterfaceNameFromView", () => {
-    it("should extract interface name from As_ prefix", () => {
-      const name = extractInterfaceNameFromView("As_ICollection");
-
-      assert.equal(name, "ICollection");
-    });
-
-    it("should handle generic interface names", () => {
-      const name = extractInterfaceNameFromView("As_IEnumerable_1");
-
-      assert.equal(name, "IEnumerable_1");
-    });
-
-    it("should return undefined for invalid pattern", () => {
-      const name = extractInterfaceNameFromView("InvalidProperty");
-
-      assert.equal(name, undefined);
-    });
-  });
-
-  describe("buildViewPropertyName", () => {
-    it("should build As_ property name from interface", () => {
-      const name = buildViewPropertyName("ICollection");
-
-      assert.equal(name, "As_ICollection");
-    });
-
-    it("should handle generic interfaces", () => {
-      const name = buildViewPropertyName("IEnumerable_1");
-
-      assert.equal(name, "As_IEnumerable_1");
-    });
-  });
-
-  describe("generateInterfaceCast", () => {
-    it("should generate C# cast expression", () => {
-      const cast = generateInterfaceCast(
-        "list",
-        "System.Collections.ICollection"
-      );
-
-      assert.equal(cast, "((ICollection)list)");
-    });
-
-    it("should extract short name from qualified name", () => {
-      const cast = generateInterfaceCast(
-        "obj",
-        "System.Collections.Generic.IEnumerable"
-      );
-
-      assert.equal(cast, "((IEnumerable)obj)");
-    });
-  });
-
-  describe("generateGenericInterfaceCast", () => {
-    it("should generate generic cast with type arguments", () => {
-      const cast = generateGenericInterfaceCast(
-        "list",
-        "System.Collections.Generic.ICollection`1",
-        ["string"]
-      );
-
-      assert.equal(cast, "((ICollection<string>)list)");
-    });
-
-    it("should handle multiple type arguments", () => {
-      const cast = generateGenericInterfaceCast(
-        "dict",
-        "System.Collections.Generic.IDictionary`2",
-        ["string", "int"]
-      );
-
-      assert.equal(cast, "((IDictionary<string, int>)dict)");
-    });
-
-    it("should handle empty type arguments", () => {
-      const cast = generateGenericInterfaceCast(
-        "obj",
-        "System.Collections.ICollection",
-        []
-      );
-
-      assert.equal(cast, "((ICollection)obj)");
-    });
-  });
-});

package/src/types/explicit-views.ts

@@ -1,218 +0,0 @@
-/**
- * Explicit Interface Views - Handle As_IInterface pattern for explicit implementations.
- *
- * C# supports explicit interface implementation (EII), where a class implements
- * an interface member explicitly. TypeScript doesn't support EII, so tsbindgen
- * generates special As_IInterface properties that return views of the object.
- *
- * Example:
- * TypeScript: list.As_ICollection.CopyTo(array, 0)
- * C#:         ((ICollection<T>)list).CopyTo(array, 0)
- *
- * @see spec/explicit-interface-views.md for complete documentation
- */
-
-import type { ExplicitView } from "./metadata.ts";
-
-/**
- * Pattern for explicit interface view property names.
- * Format: As_IInterfaceName
- */
-const VIEW_PROPERTY_PREFIX = "As_";
-const VIEW_PROPERTY_PATTERN = /^As_(.+)$/;
-
-/**
- * Check if a property name matches the explicit view pattern (As_IInterface).
- *
- * @param propertyName - Property name to check
- * @returns True if matches As_IInterface pattern
- */
-export const isExplicitViewProperty = (propertyName: string): boolean => {
-  return propertyName.startsWith(VIEW_PROPERTY_PREFIX);
-};
-
-/**
- * Extract interface name from an explicit view property name.
- *
- * @param viewPropertyName - Property name (e.g., "As_ICollection")
- * @returns Interface name (e.g., "ICollection"), or undefined if not a view property
- */
-export const extractInterfaceNameFromView = (
-  viewPropertyName: string
-): string | undefined => {
-  const match = viewPropertyName.match(VIEW_PROPERTY_PATTERN);
-  if (!match) {
-    return undefined;
-  }
-  return match[1];
-};
-
-/**
- * Build explicit view property name from interface name.
- *
- * @param interfaceName - Interface name (e.g., "ICollection")
- * @returns View property name (e.g., "As_ICollection")
- */
-export const buildViewPropertyName = (interfaceName: string): string => {
-  return `${VIEW_PROPERTY_PREFIX}${interfaceName}`;
-};
-
-/**
- * Find explicit view for a given interface in type metadata.
- *
- * @param explicitViews - Array of explicit views from metadata
- * @param interfaceName - CLR interface name to find (e.g., "System.Collections.ICollection")
- * @returns Explicit view if found, undefined otherwise
- */
-export const findExplicitView = (
-  explicitViews: readonly ExplicitView[] | undefined,
-  interfaceName: string
-): ExplicitView | undefined => {
-  if (!explicitViews) {
-    return undefined;
-  }
-
-  return explicitViews.find((view) => view.interfaceName === interfaceName);
-};
-
-/**
- * Check if a member is in an explicit view (view-only member).
- *
- * @param explicitViews - Array of explicit views from metadata
- * @param memberName - CLR member name to check
- * @returns True if member appears in any view
- */
-export const isMemberInExplicitView = (
-  explicitViews: readonly ExplicitView[] | undefined,
-  memberName: string
-): boolean => {
-  if (!explicitViews) {
-    return false;
-  }
-
-  for (const view of explicitViews) {
-    if (view.members.some((m) => m.clrName === memberName)) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
-/**
- * Get all interface names that have explicit views.
- *
- * @param explicitViews - Array of explicit views from metadata
- * @returns Array of interface CLR names
- */
-export const getExplicitViewInterfaces = (
-  explicitViews: readonly ExplicitView[] | undefined
-): readonly string[] => {
-  if (!explicitViews) {
-    return [];
-  }
-
-  return explicitViews.map((view) => view.interfaceName);
-};
-
-/**
- * Information about an explicit view member access.
- */
-export type ExplicitViewAccess = {
-  readonly interfaceName: string;
-  readonly interfaceTsName: string;
-  readonly memberName: string;
-  readonly memberKind: "Method" | "Property" | "Event";
-};
-
-/**
- * Parse an explicit view member access expression.
- *
- * Example: obj.As_ICollection.CopyTo
- * Returns: { interfaceName: "ICollection", memberName: "CopyTo", ... }
- *
- * @param viewPropertyName - View property name (e.g., "As_ICollection")
- * @param memberName - Member being accessed (e.g., "CopyTo")
- * @param explicitViews - Array of explicit views from metadata
- * @returns View access info if valid, undefined if invalid
- */
-export const parseExplicitViewAccess = (
-  viewPropertyName: string,
-  memberName: string,
-  explicitViews: readonly ExplicitView[] | undefined
-): ExplicitViewAccess | undefined => {
-  // Extract interface name from view property
-  const interfaceTsName = extractInterfaceNameFromView(viewPropertyName);
-  if (!interfaceTsName) {
-    return undefined;
-  }
-
-  // Find the explicit view in metadata
-  if (!explicitViews) {
-    return undefined;
-  }
-
-  // Look for view that matches the property name
-  const view = explicitViews.find((v) => v.tsPropertyName === viewPropertyName);
-  if (!view) {
-    return undefined;
-  }
-
-  // Find the member in the view
-  const member = view.members.find((m) => m.name === memberName);
-  if (!member) {
-    return undefined;
-  }
-
-  return {
-    interfaceName: view.interfaceName,
-    interfaceTsName,
-    memberName: member.name,
-    memberKind: member.kind,
-  };
-};
-
-/**
- * Generate C# interface cast expression for explicit view access.
- *
- * @param objectExpression - C# expression for the object
- * @param interfaceName - CLR interface name (e.g., "System.Collections.ICollection")
- * @returns C# cast expression (e.g., "((ICollection)obj)")
- */
-export const generateInterfaceCast = (
-  objectExpression: string,
-  interfaceName: string
-): string => {
-  // Extract short name from fully-qualified name
-  const shortName = interfaceName.split(".").pop() || interfaceName;
-
-  return `((${shortName})${objectExpression})`;
-};
-
-/**
- * Generate C# interface cast with generics.
- *
- * @param objectExpression - C# expression for the object
- * @param interfaceName - CLR interface name (e.g., "System.Collections.Generic.ICollection`1")
- * @param genericArguments - Generic type arguments in C# syntax (e.g., ["string"])
- * @returns C# cast expression (e.g., "((ICollection<string>)obj)")
- */
-export const generateGenericInterfaceCast = (
-  objectExpression: string,
-  interfaceName: string,
-  genericArguments: readonly string[]
-): string => {
-  // Extract short name from fully-qualified name
-  const shortName = interfaceName.split(".").pop() || interfaceName;
-
-  // Remove generic arity suffix (`1, `2, etc.)
-  const nameWithoutArity = shortName.replace(/`\d+$/, "");
-
-  // Build generic type
-  const genericType =
-    genericArguments.length > 0
-      ? `${nameWithoutArity}<${genericArguments.join(", ")}>`
-      : nameWithoutArity;
-
-  return `((${genericType})${objectExpression})`;
-};

package/src/types/metadata.ts

@@ -1,229 +0,0 @@
-/**
- * Type definitions for .NET metadata.json files generated by tsbindgen.
- *
- * These types represent the CLR type system metadata in a TypeScript-friendly format.
- * All property names use camelCase (JavaScript convention).
- *
- * @see spec/metadata.md for complete schema documentation
- */
-
-/**
- * Root metadata file structure.
- * Represents a single namespace with all its types.
- */
-export type MetadataFile = {
-  readonly namespace: string;
-  readonly contributingAssemblies: string[];
-  readonly types: TypeMetadata[];
-};
-
-/**
- * Type kind enumeration.
- * Represents the fundamental kind of CLR type.
- */
-export type TypeKind = "Class" | "Interface" | "Struct" | "Enum" | "Delegate";
-
-/**
- * Accessibility level enumeration.
- * Represents CLR accessibility modifiers.
- */
-export type Accessibility =
-  | "Public"
-  | "Internal"
-  | "Protected"
-  | "ProtectedInternal"
-  | "PrivateProtected"
-  | "Private";
-
-/**
- * Emit scope enumeration.
- * Determines where a member should be emitted in TypeScript declarations.
- */
-export type EmitScope =
-  | "ClassSurface" // Emit on main class
-  | "ViewOnly" // Emit only in explicit interface views
-  | "Omitted"; // Don't emit (not accessible from TypeScript)
-
-/**
- * Provenance enumeration.
- * Tracks the origin of a member in the type hierarchy.
- */
-export type Provenance =
-  | "Original" // Declared on this type
-  | "Declared" // Explicitly declared (alias of Original)
-  | "InlineFromInterface" // Implicit interface implementation
-  | "InlineFromBase" // Inherited from base class
-  | "SynthesizedViewOnly" // Generated for view-only access
-  | "ExplicitView"; // Explicit interface implementation
-
-/**
- * Complete metadata for a CLR type.
- */
-export type TypeMetadata = {
-  readonly clrName: string;
-  readonly tsEmitName: string;
-  readonly kind: TypeKind;
-  readonly accessibility: Accessibility;
-  readonly isAbstract: boolean;
-  readonly isSealed: boolean;
-  readonly isStatic: boolean;
-  readonly arity: number;
-  readonly baseType?: string | null;
-  readonly interfaces?: string[];
-  readonly isValueType?: boolean;
-  readonly methods: MethodMetadata[];
-  readonly properties: PropertyMetadata[];
-  readonly fields: FieldMetadata[];
-  readonly events: EventMetadata[];
-  readonly constructors: ConstructorMetadata[];
-  readonly intentionalOmissions?: IntentionalOmissions;
-  readonly explicitViews?: ExplicitView[];
-};
-
-/**
- * Method metadata.
- */
-export type MethodMetadata = {
-  readonly name: string;
-  readonly clrName: string;
-  readonly tsEmitName: string;
-  readonly accessibility: Accessibility;
-  readonly isStatic: boolean;
-  readonly isAbstract: boolean;
-  readonly isVirtual: boolean;
-  readonly isFinal: boolean;
-  readonly arity: number;
-  readonly parameters: ParameterMetadata[];
-  readonly returnType: string;
-  readonly emitScope: EmitScope;
-  readonly provenance: Provenance;
-};
-
-/**
- * Property metadata.
- */
-export type PropertyMetadata = {
-  readonly name: string;
-  readonly clrName: string;
-  readonly tsEmitName: string;
-  readonly accessibility: Accessibility;
-  readonly isStatic: boolean;
-  readonly type: string;
-  readonly hasGetter: boolean;
-  readonly hasSetter: boolean;
-  readonly emitScope: EmitScope;
-  readonly provenance: Provenance;
-};
-
-/**
- * Field metadata.
- */
-export type FieldMetadata = {
-  readonly name: string;
-  readonly clrName: string;
-  readonly tsEmitName: string;
-  readonly accessibility: Accessibility;
-  readonly isStatic: boolean;
-  readonly isReadonly: boolean;
-  readonly type: string;
-  readonly emitScope: EmitScope;
-  readonly provenance: Provenance;
-};
-
-/**
- * Event metadata.
- */
-export type EventMetadata = {
-  readonly name: string;
-  readonly clrName: string;
-  readonly tsEmitName: string;
-  readonly accessibility: Accessibility;
-  readonly isStatic: boolean;
-  readonly type: string;
-  readonly emitScope: EmitScope;
-  readonly provenance: Provenance;
-};
-
-/**
- * Constructor metadata.
- */
-export type ConstructorMetadata = {
-  readonly accessibility: Accessibility;
-  readonly parameters: ParameterMetadata[];
-  readonly emitScope: EmitScope;
-};
-
-/**
- * Parameter metadata.
- */
-export type ParameterMetadata = {
-  readonly name: string;
-  readonly type: string;
-  readonly isRef: boolean;
-  readonly isOut: boolean;
-  readonly isIn?: boolean;
-  readonly isParams: boolean;
-  readonly defaultValue?: any | null;
-};
-
-/**
- * Intentional omissions from TypeScript declarations.
- * Tracks members that are deliberately not emitted.
- */
-export type IntentionalOmissions = {
-  readonly methods?: OmittedMethod[];
-  readonly properties?: OmittedProperty[];
-  readonly fields?: OmittedField[];
-  readonly events?: OmittedEvent[];
-};
-
-/**
- * Omitted method information.
- */
-export type OmittedMethod = {
-  readonly name: string;
-  readonly reason: string;
-};
-
-/**
- * Omitted property information.
- */
-export type OmittedProperty = {
-  readonly name: string;
-  readonly reason: string;
-};
-
-/**
- * Omitted field information.
- */
-export type OmittedField = {
-  readonly name: string;
-  readonly reason: string;
-};
-
-/**
- * Omitted event information.
- */
-export type OmittedEvent = {
-  readonly name: string;
-  readonly reason: string;
-};
-
-/**
- * Explicit interface view metadata.
- * Represents an As_IInterface property for explicit interface implementations.
- */
-export type ExplicitView = {
-  readonly interfaceName: string;
-  readonly tsPropertyName: string;
-  readonly members: ExplicitViewMember[];
-};
-
-/**
- * Member within an explicit interface view.
- */
-export type ExplicitViewMember = {
-  readonly kind: "Method" | "Property" | "Event";
-  readonly name: string;
-  readonly clrName: string;
-};

package/src/types/module.ts

@@ -1,99 +0,0 @@
-/**
- * Module representation types for Tsonic compiler
- */
-
-export type ImportKind = "local" | "dotnet" | "node_module";
-
-export type Import = {
-  readonly kind: ImportKind;
-  readonly specifier: string; // Original import specifier
-  readonly resolvedPath?: string; // Resolved file path for local imports
-  readonly namespace?: string; // .NET namespace for dotnet imports
-  readonly importedNames: readonly ImportedName[];
-};
-
-export type ImportedName = {
-  readonly name: string;
-  readonly alias?: string;
-};
-
-export type Export =
-  | {
-      readonly kind: "named";
-      readonly name: string;
-      readonly localName: string;
-    }
-  | { readonly kind: "default"; readonly localName: string }
-  | {
-      readonly kind: "namespace";
-      readonly name: string;
-      readonly localName: string;
-    }
-  | {
-      readonly kind: "reexport";
-      readonly fromModule: string;
-      readonly exports: readonly ImportedName[];
-    };
-
-export type ModuleInfo = {
-  readonly filePath: string;
-  readonly sourceText: string;
-  readonly imports: readonly Import[];
-  readonly exports: readonly Export[];
-  readonly hasTopLevelCode: boolean;
-  readonly namespace?: string; // Will be computed from directory structure
-  readonly className?: string; // Will be computed from file name
-};
-
-export type ModuleGraph = {
-  readonly modules: ReadonlyMap<string, ModuleInfo>;
-  readonly dependencies: ReadonlyMap<string, readonly string[]>;
-  readonly dependents: ReadonlyMap<string, readonly string[]>;
-  readonly entryPoints: readonly string[];
-};
-
-export const createModuleInfo = (
-  filePath: string,
-  sourceText: string,
-  imports: readonly Import[] = [],
-  exports: readonly Export[] = [],
-  hasTopLevelCode: boolean = false,
-  namespace?: string,
-  className?: string
-): ModuleInfo => ({
-  filePath,
-  sourceText,
-  imports,
-  exports,
-  hasTopLevelCode,
-  namespace,
-  className,
-});
-
-export const createModuleGraph = (
-  modules: ReadonlyMap<string, ModuleInfo> = new Map(),
-  dependencies: ReadonlyMap<string, readonly string[]> = new Map(),
-  dependents: ReadonlyMap<string, readonly string[]> = new Map(),
-  entryPoints: readonly string[] = []
-): ModuleGraph => ({
-  modules,
-  dependencies,
-  dependents,
-  entryPoints,
-});
-
-export const addModule = (
-  graph: ModuleGraph,
-  module: ModuleInfo
-): ModuleGraph => {
-  const newModules = new Map(graph.modules);
-  newModules.set(module.filePath, module);
-
-  return {
-    ...graph,
-    modules: newModules,
-  };
-};
-
-export const isLocalImport = (importSpec: string): boolean =>
-  importSpec.startsWith(".") || importSpec.startsWith("/");