@tsonic/frontend 0.0.1

package/src/types/metadata.ts

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

@@ -0,0 +1,99 @@
+/**
+ * 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("/");

package/src/types/nested-types.test.ts

@@ -0,0 +1,194 @@
+/**
+ * Tests for nested types handling
+ */
+
+import { describe, it } from "mocha";
+import { strict as assert } from "assert";
+import {
+  parseNestedTypeName,
+  isNestedType,
+  tsCSharpNestedTypeName,
+  clrToTsNestedTypeName,
+  tsToCLRNestedTypeName,
+  getNestedTypeLevels,
+  getOutermostType,
+  getInnermostType,
+  isNestedInside,
+  getParentType,
+} from "./nested-types.js";
+
+describe("Nested Types", () => {
+  describe("isNestedType", () => {
+    it("should detect nested type with $ separator", () => {
+      assert.ok(isNestedType("List_1$Enumerator"));
+    });
+
+    it("should return false for non-nested type", () => {
+      assert.ok(!isNestedType("List_1"));
+    });
+  });
+
+  describe("parseNestedTypeName", () => {
+    it("should parse simple nested type", () => {
+      const info = parseNestedTypeName("List_1$Enumerator");
+
+      assert.ok(info);
+      assert.equal(info?.outerType, "List_1");
+      assert.equal(info?.nestedType, "Enumerator");
+      assert.equal(info?.depth, 1);
+      assert.deepEqual(info?.fullPath, ["List_1", "Enumerator"]);
+    });
+
+    it("should parse multiple nesting levels", () => {
+      const info = parseNestedTypeName("A$B$C");
+
+      assert.ok(info);
+      assert.equal(info?.outerType, "A");
+      assert.equal(info?.nestedType, "C");
+      assert.equal(info?.depth, 2);
+      assert.deepEqual(info?.fullPath, ["A", "B", "C"]);
+    });
+
+    it("should return undefined for non-nested type", () => {
+      const info = parseNestedTypeName("SimpleType");
+
+      assert.equal(info, undefined);
+    });
+  });
+
+  describe("tsCSharpNestedTypeName", () => {
+    it("should convert $ to . separator", () => {
+      const result = tsCSharpNestedTypeName("List_1$Enumerator");
+
+      assert.equal(result, "List_1.Enumerator");
+    });
+
+    it("should handle multiple levels", () => {
+      const result = tsCSharpNestedTypeName("A$B$C");
+
+      assert.equal(result, "A.B.C");
+    });
+
+    it("should leave non-nested types unchanged", () => {
+      const result = tsCSharpNestedTypeName("SimpleType");
+
+      assert.equal(result, "SimpleType");
+    });
+  });
+
+  describe("clrToTsNestedTypeName", () => {
+    it("should convert CLR name to TypeScript", () => {
+      const result = clrToTsNestedTypeName("List`1+Enumerator");
+
+      assert.equal(result, "List_1$Enumerator");
+    });
+
+    it("should handle multiple levels", () => {
+      const result = clrToTsNestedTypeName("A+B+C");
+
+      assert.equal(result, "A$B$C");
+    });
+
+    it("should handle generic nested types", () => {
+      const result = clrToTsNestedTypeName("Dictionary`2+KeyCollection`1");
+
+      assert.equal(result, "Dictionary_2$KeyCollection_1");
+    });
+  });
+
+  describe("tsToCLRNestedTypeName", () => {
+    it("should convert TypeScript name to CLR", () => {
+      const result = tsToCLRNestedTypeName("List_1$Enumerator");
+
+      assert.equal(result, "List`1+Enumerator");
+    });
+
+    it("should handle multiple levels", () => {
+      const result = tsToCLRNestedTypeName("A$B$C");
+
+      assert.equal(result, "A+B+C");
+    });
+  });
+
+  describe("getNestedTypeLevels", () => {
+    it("should return all nesting levels", () => {
+      const levels = getNestedTypeLevels("A$B$C");
+
+      assert.deepEqual(levels, ["A", "A$B", "A$B$C"]);
+    });
+
+    it("should return single level for non-nested type", () => {
+      const levels = getNestedTypeLevels("SimpleType");
+
+      assert.deepEqual(levels, ["SimpleType"]);
+    });
+  });
+
+  describe("getOutermostType", () => {
+    it("should return outermost type", () => {
+      const outermost = getOutermostType("List_1$Enumerator");
+
+      assert.equal(outermost, "List_1");
+    });
+
+    it("should return same type for non-nested", () => {
+      const outermost = getOutermostType("SimpleType");
+
+      assert.equal(outermost, "SimpleType");
+    });
+  });
+
+  describe("getInnermostType", () => {
+    it("should return innermost type", () => {
+      const innermost = getInnermostType("A$B$C");
+
+      assert.equal(innermost, "C");
+    });
+
+    it("should return same type for non-nested", () => {
+      const innermost = getInnermostType("SimpleType");
+
+      assert.equal(innermost, "SimpleType");
+    });
+  });
+
+  describe("isNestedInside", () => {
+    it("should detect type nested inside another", () => {
+      const result = isNestedInside("List_1$Enumerator", "List_1");
+
+      assert.ok(result);
+    });
+
+    it("should return false for unrelated types", () => {
+      const result = isNestedInside("Dictionary_2$KeyCollection", "List_1");
+
+      assert.ok(!result);
+    });
+
+    it("should return false for non-nested type", () => {
+      const result = isNestedInside("SimpleType", "List_1");
+
+      assert.ok(!result);
+    });
+  });
+
+  describe("getParentType", () => {
+    it("should return parent type", () => {
+      const parent = getParentType("A$B$C");
+
+      assert.equal(parent, "A$B");
+    });
+
+    it("should return parent for single nesting", () => {
+      const parent = getParentType("List_1$Enumerator");
+
+      assert.equal(parent, "List_1");
+    });
+
+    it("should return undefined for non-nested type", () => {
+      const parent = getParentType("SimpleType");
+
+      assert.equal(parent, undefined);
+    });
+  });
+});