@typra/emitter 0.2.0

package/dist/src/languages/rust/visitor.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Rust expression visitor — Expr IR → Rust source fragments.
+ */
+import { Expr, TypeRegistry } from "../../ir/expansion.js";
+import { ExprVisitor } from "../../ir/visitor.js";
+export declare class RustExprVisitor implements ExprVisitor {
+    registry?: TypeRegistry;
+    constructor(registry?: TypeRegistry);
+    visitExpr(expr: Expr): string;
+    private visitConstruct;
+    /**
+     * Handle Construct on a polymorphic type — the discriminator field becomes an enum variant.
+     * E.g., Property { kind: "boolean", example: v } → Property { kind: PropertyKind::Custom { kind_name: "boolean".to_string() }, example: Some(v.into()), ..Default::default() }
+     */
+    private visitPolymorphicConstruct;
+    private visitVariant;
+    private visitArray;
+    /**
+     * Wrap field values appropriately for Rust — Option<T> fields need Some(),
+     * string fields need .into(), etc.
+     */
+    private wrapFieldValue;
+    private escapeString;
+    private visitFieldRead;
+}

package/dist/src/languages/rust/visitor.js

@@ -0,0 +1,153 @@
+/**
+ * Rust expression visitor — Expr IR → Rust source fragments.
+ */
+import { assertNever } from "../../ir/visitor.js";
+import { toSnakeCase } from "../../ir/utilities.js";
+const RUST_KEYWORDS = new Set([
+    "as", "break", "const", "continue", "crate", "else", "enum", "extern",
+    "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod",
+    "move", "mut", "pub", "ref", "return", "self", "Self", "static", "struct",
+    "super", "trait", "true", "type", "unsafe", "use", "where", "while",
+    "async", "await", "dyn",
+]);
+function rustFieldName(name) {
+    const snake = toSnakeCase(name);
+    return RUST_KEYWORDS.has(snake) ? `r#${snake}` : snake;
+}
+export class RustExprVisitor {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    visitExpr(expr) {
+        switch (expr.kind) {
+            case "string":
+                return `"${this.escapeString(expr.value)}".to_string()`;
+            case "number":
+                return String(expr.value);
+            case "boolean":
+                return expr.value ? "true" : "false";
+            case "null":
+                return "None";
+            case "param":
+                // Always use .into() in Rust — handles String→String, bool→Value, i64→Value, etc.
+                return `${toSnakeCase(expr.name)}.into()`;
+            case "construct":
+                return this.visitConstruct(expr);
+            case "variant":
+                return this.visitVariant(expr);
+            case "array":
+                return this.visitArray(expr);
+            case "dict":
+                return `serde_json::json!({${expr.entries.map(e => `"${e.key}": ${this.visitExpr(e.value)}`).join(", ")}})`;
+            case "field_read":
+                return this.visitFieldRead(expr);
+            default:
+                return assertNever(expr);
+        }
+    }
+    visitConstruct(expr) {
+        const typeName = expr.typeName.name;
+        // Check if this is a polymorphic type — discriminator fields need enum variant wrapping
+        const typeNode = this.registry?.get(typeName);
+        if (typeNode?.discriminator && typeNode.childTypes.length > 0) {
+            return this.visitPolymorphicConstruct(expr, typeNode);
+        }
+        if (expr.fields.length === 0) {
+            return `${typeName} { ..Default::default() }`;
+        }
+        const fields = expr.fields.map(f => {
+            let val = this.wrapFieldValue(f);
+            // For enum fields, convert string literals to EnumName::VariantName
+            if (f.value.kind === "string" && typeNode) {
+                const prop = typeNode.properties.find(p => p.name === f.propertyName);
+                if (prop?.enumName) {
+                    const variantName = f.value.value.charAt(0).toUpperCase() + f.value.value.slice(1);
+                    const enumVal = `${prop.enumName}::${variantName}`;
+                    val = f.isOptional ? `Some(${enumVal})` : enumVal;
+                }
+            }
+            return `${toSnakeCase(f.propertyName)}: ${val}`;
+        }).join(", ");
+        return `${typeName} { ${fields}, ..Default::default() }`;
+    }
+    /**
+     * Handle Construct on a polymorphic type — the discriminator field becomes an enum variant.
+     * E.g., Property { kind: "boolean", example: v } → Property { kind: PropertyKind::Custom { kind_name: "boolean".to_string() }, example: Some(v.into()), ..Default::default() }
+     */
+    visitPolymorphicConstruct(expr, typeNode) {
+        const typeName = expr.typeName.name;
+        const enumName = `${typeName}Kind`;
+        const discFieldName = typeNode.discriminator;
+        // Find the discriminator field assignment
+        const discField = expr.fields.find(f => f.propertyName === discFieldName);
+        const discValue = discField?.value;
+        // If no discriminator field or not a string literal, fall back to normal construction
+        if (!discField || discValue?.kind !== "string") {
+            const fields = expr.fields.map(f => `${toSnakeCase(f.propertyName)}: ${this.wrapFieldValue(f)}`).join(", ");
+            return fields.length > 0
+                ? `${typeName} { ${fields}, ..Default::default() }`
+                : `${typeName} { ..Default::default() }`;
+        }
+        const discValueStr = discValue.value;
+        // Find matching named child type
+        const childType = typeNode.childTypes.find(child => {
+            const dp = child.properties.find((p) => p.name === discFieldName);
+            return dp?.defaultValue === discValueStr;
+        });
+        let kindValue;
+        if (childType) {
+            // Named variant (e.g., PropertyKind::Array)
+            const variantName = childType.typeName.name.replace(typeName, '') || childType.typeName.name;
+            kindValue = `${enumName}::${variantName}`;
+        }
+        else {
+            // Wildcard/Custom variant — carries kind_name field
+            kindValue = `${enumName}::Custom { kind_name: "${discValueStr}".to_string() }`;
+        }
+        // Non-discriminator fields
+        const baseFields = expr.fields
+            .filter(f => f.propertyName !== discFieldName)
+            .map(f => `${toSnakeCase(f.propertyName)}: ${this.wrapFieldValue(f)}`);
+        const allFields = [
+            `${toSnakeCase(discFieldName)}: ${kindValue}`,
+            ...baseFields,
+        ];
+        return `${typeName} { ${allFields.join(", ")}, ..Default::default() }`;
+    }
+    visitVariant(expr) {
+        const baseName = expr.baseTypeName.name;
+        const variantName = expr.variantTypeName.name;
+        const enumName = `${baseName}Kind`;
+        const fields = expr.fields.map(f => `${toSnakeCase(f.propertyName)}: ${this.wrapFieldValue(f)}`).join(", ");
+        const kindValue = fields.length > 0
+            ? `${enumName}::${variantName} { ${fields} }`
+            : `${enumName}::${variantName}`;
+        return `${baseName} { ${toSnakeCase(expr.discriminator)}: ${kindValue}, ..Default::default() }`;
+    }
+    visitArray(expr) {
+        if (expr.items.length === 0) {
+            return "vec![]";
+        }
+        const items = expr.items.map(i => this.visitExpr(i)).join(", ");
+        return `vec![${items}]`;
+    }
+    /**
+     * Wrap field values appropriately for Rust — Option<T> fields need Some(),
+     * string fields need .into(), etc.
+     */
+    wrapFieldValue(field) {
+        const inner = this.visitExpr(field.value);
+        if (field.isOptional) {
+            return `Some(${inner})`;
+        }
+        return inner;
+    }
+    escapeString(s) {
+        return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    }
+    visitFieldRead(expr) {
+        return `${toSnakeCase(expr.objectName)}.${rustFieldName(expr.fieldName)}`;
+    }
+}
+//# sourceMappingURL=visitor.js.map

package/dist/src/languages/typescript/driver.d.ts

@@ -0,0 +1,8 @@
+import { EmitContext } from "@typespec/compiler";
+import { EmitTarget, TypraEmitterOptions } from "../../lib.js";
+import { TypeNode } from "../../ir/ast.js";
+import { GeneratorOptions } from "../../emitter.js";
+/**
+ * Generate TypeScript code from TypeSpec models.
+ */
+export declare const generateTypeScript: (context: EmitContext<TypraEmitterOptions>, node: TypeNode, emitTarget: EmitTarget, options?: GeneratorOptions) => Promise<void>;

package/dist/src/languages/typescript/driver.js

@@ -0,0 +1,209 @@
+import { resolvePath } from "@typespec/compiler";
+import { enumerateTypes } from "../../ir/ast.js";
+import { filterNodes } from "../../emitter.js";
+import { TypeRegistry } from "../../ir/expansion.js";
+import { TypeScriptExprVisitor } from "./visitor.js";
+import { emitTypeScriptFile as emitTypeScriptFileDecl } from "./emitter.js";
+import { emitTypeScriptContext, emitTypeScriptIndex, emitTypeScriptGroupIndex, emitEslintConfig } from "./scaffolding.js";
+import { emitTypeScriptTest } from "./test-emitter.js";
+import { lowerFile, collectPolymorphicTypeNames } from "../../ir/lower.js";
+import { buildBaseTestContext, typescriptTestOptions } from "../../testing/test-context.js";
+import { toKebabCase } from "../../ir/utilities.js";
+import { resolve, dirname } from "path";
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { emitGeneratedFile } from "../../cleanup/generated-file.js";
+/**
+ * Stale-file deletion is intentionally disabled until manifest cleanup is enabled.
+ */
+function cleanupFlatTypeFiles(relDir, isTypeFile) {
+    void relDir;
+    void isTypeFile;
+    return;
+}
+/**
+ * Generate TypeScript code from TypeSpec models.
+ */
+export const generateTypeScript = async (context, node, emitTarget, options) => {
+    const allTypes = Array.from(enumerateTypes(node));
+    const nodes = filterNodes(allTypes, options);
+    // Build the expression IR infrastructure
+    const registry = TypeRegistry.fromTypeGraph(allTypes);
+    const visitor = new TypeScriptExprVisitor(registry);
+    // Determine namespace: use override or default
+    const originalNamespace = node.typeName.namespace;
+    const tsNamespace = emitTarget.namespace ?? originalNamespace.replace(/\.Core$/, "");
+    // Stale flat-file cleanup is disabled in this slice.
+    cleanupFlatTypeFiles(emitTarget["output-dir"], name => name.endsWith(".ts") && name !== "context.ts" && name !== "index.ts" && name !== "eslint.config.js");
+    cleanupFlatTypeFiles(emitTarget["test-dir"], name => name.endsWith(".ts") && name !== "context.test.ts");
+    // Emit context classes (LoadContext, SaveContext)
+    const contextCode = emitTypeScriptContext();
+    await emitTypeScriptFile(context, "context.ts", contextCode, emitTarget["output-dir"]);
+    // Collect polymorphic type names once for the full type graph
+    const polymorphicTypeNames = new Set();
+    for (const n of allTypes) {
+        for (const name of collectPolymorphicTypeNames(n, registry)) {
+            polymorphicTypeNames.add(name);
+        }
+    }
+    // Group root nodes by their semantic group folder
+    const groupMap = new Map();
+    for (const n of nodes) {
+        if (!n.base) {
+            const g = n.group || "";
+            if (!groupMap.has(g))
+                groupMap.set(g, []);
+            groupMap.get(g).push(n);
+        }
+    }
+    // Emit each base type file (includes children in the same file)
+    for (const n of nodes) {
+        // Skip child types - they're rendered with their parent
+        if (n.base) {
+            continue;
+        }
+        const group = n.group || "";
+        const fileDecl = lowerFile(n, registry, polymorphicTypeNames);
+        const code = emitTypeScriptFileDecl(fileDecl, visitor, tsNamespace, group);
+        const outDir = group ? `${emitTarget["output-dir"]}/${group}` : emitTarget["output-dir"];
+        await emitTypeScriptFile(context, `${toKebabCase(n.typeName.name)}.ts`, code, outDir);
+    }
+    // Emit group index.ts files
+    for (const [group, groupNodes] of groupMap) {
+        if (!group)
+            continue;
+        const groupIndexCode = emitTypeScriptGroupIndex(group, groupNodes);
+        await emitTypeScriptFile(context, "index.ts", groupIndexCode, `${emitTarget["output-dir"]}/${group}`);
+    }
+    // Emit test files for all types (skip protocols — they have no data to test)
+    if (emitTarget["test-dir"]) {
+        const importPath = emitTarget["import-path"] || "../src/index";
+        for (const n of nodes) {
+            if (n.isProtocol)
+                continue;
+            const group = n.group || "";
+            const testDir = group ? `${emitTarget["test-dir"]}/${group}` : emitTarget["test-dir"];
+            const groupDepth = group ? group.split("/").filter(Boolean).length : 0;
+            const testImportPath = groupDepth > 0 ? `${"../".repeat(groupDepth)}${importPath}` : importPath;
+            const testContext = buildTestContext(n);
+            const testCode = emitTypeScriptTest({
+                ...testContext,
+                importPath: testImportPath,
+                namespace: tsNamespace,
+            });
+            await emitTypeScriptFile(context, `${toKebabCase(n.typeName.name)}.test.ts`, testCode, testDir);
+        }
+    }
+    // Emit root index.ts file — re-exports from group sub-indexes
+    const indexContext = buildIndexContext(nodes);
+    const indexCode = emitTypeScriptIndex(indexContext.baseTypes, indexContext.types);
+    await emitTypeScriptFile(context, "index.ts", indexCode, emitTarget["output-dir"]);
+    // Emit eslint.config.js to project root (parent of output-dir)
+    if (emitTarget["output-dir"]) {
+        const projectRoot = resolve(process.cwd(), emitTarget["output-dir"], "..");
+        const eslintConfigCode = emitEslintConfig();
+        await emitTypeScriptFile(context, "eslint.config.js", eslintConfigCode, projectRoot);
+    }
+    // Format emitted files if format option is enabled (default: true)
+    if (emitTarget.format !== false) {
+        const outputDir = emitTarget["output-dir"]
+            ? resolve(process.cwd(), emitTarget["output-dir"])
+            : context.emitterOutputDir;
+        const testDir = emitTarget["test-dir"]
+            ? resolve(process.cwd(), emitTarget["test-dir"])
+            : undefined;
+        formatTypeScriptFiles(outputDir, testDir);
+    }
+};
+/**
+ * Format TypeScript files using prettier.
+ */
+function formatTypeScriptFiles(outputDir, testDir) {
+    const projectRoot = findTypeScriptProjectRoot(outputDir);
+    if (!projectRoot) {
+        console.warn(`Warning: Could not find package.json. Skipping formatting.`);
+        return;
+    }
+    const dirs = [outputDir, ...(testDir ? [testDir] : [])];
+    const prettierBin = findNodeModuleFile(projectRoot, ["prettier", "bin", "prettier.cjs"]);
+    for (const dir of dirs) {
+        const globPattern = `${dir}/**/*.ts`;
+        if (prettierBin) {
+            try {
+                execFileSync(process.execPath, [prettierBin, "--write", globPattern], {
+                    cwd: projectRoot,
+                    stdio: "pipe",
+                    encoding: "utf-8",
+                });
+            }
+            catch (error) {
+                console.warn(`Warning: prettier formatting failed for ${dir}.`);
+            }
+        }
+        else {
+            console.warn(`Warning: prettier not found for ${dir}. Run npm install in the TypeScript workspace.`);
+        }
+        // Run eslint fix
+        try {
+            execFileSync("npx", ["eslint", "--fix", globPattern], {
+                cwd: projectRoot,
+                stdio: "pipe",
+                encoding: "utf-8",
+            });
+        }
+        catch (error) {
+            // ESLint errors are common, don't warn about them
+        }
+    }
+}
+function findNodeModuleFile(startDir, segments) {
+    let currentDir = resolve(startDir);
+    const root = resolve("/");
+    while (currentDir !== root && currentDir !== dirname(currentDir)) {
+        const candidate = resolve(currentDir, "node_modules", ...segments);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+        currentDir = dirname(currentDir);
+    }
+    return undefined;
+}
+/**
+ * Find the TypeScript project root by looking for package.json.
+ */
+function findTypeScriptProjectRoot(startDir) {
+    let currentDir = resolve(startDir);
+    const root = resolve("/");
+    while (currentDir !== root && currentDir !== dirname(currentDir)) {
+        const packageJsonPath = resolve(currentDir, "package.json");
+        if (existsSync(packageJsonPath)) {
+            return currentDir;
+        }
+        currentDir = dirname(currentDir);
+    }
+    return undefined;
+}
+/**
+ * Build context for rendering the index.ts file.
+ */
+function buildIndexContext(nodes) {
+    return {
+        baseTypes: nodes.filter((n) => !n.base),
+        types: nodes,
+    };
+}
+/**
+ * Build context for rendering a test file.
+ */
+function buildTestContext(node) {
+    return buildBaseTestContext(node, undefined, typescriptTestOptions);
+}
+/**
+ * Write generated TypeScript content to file.
+ */
+async function emitTypeScriptFile(context, filename, content, outputDir) {
+    outputDir = outputDir || `${context.emitterOutputDir}/typescript`;
+    const filePath = resolvePath(outputDir, filename);
+    await emitGeneratedFile(context, filePath, content);
+}
+//# sourceMappingURL=driver.js.map

package/dist/src/languages/typescript/emitter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * TypeScript code emitter — Declaration IR → TypeScript source code.
+ *
+ * Replaces `file.ts.njk` (~414 lines of Nunjucks templates)
+ * with a typed TypeScript function that walks the FileDecl tree.
+ *
+ * The emitter produces correctly-formatted TypeScript code using modern
+ * class patterns with `Partial<T>` constructors. Output is post-processed
+ * by prettier + eslint, so exact whitespace is not critical.
+ *
+ * Structural blocks emitted (in order):
+ *   1. Header comment (auto-generated warning)
+ *   2. Imports (LoadContext/SaveContext, referenced types)
+ *   3. For each type in the file:
+ *      a. [abstract] class definition with extends
+ *      b. shorthandProperty static ClassVar
+ *      c. Field declarations with type annotations + defaults
+ *      d. Constructor with Partial<T>
+ *      e. //#region Load Methods
+ *         - load() static method
+ *         - loadKind() for polymorphic dispatch (private static)
+ *         - Collection helpers (loadX / saveX)
+ *      f. //#endregion
+ *      g. //#region Save Methods
+ *         - save() instance method
+ *         - toYaml() / toJson()
+ *         - fromJson() / fromYaml() static methods
+ *      h. //#endregion
+ *      i. Factory static methods
+ *      j. Method stubs (as comments)
+ */
+import { FileDecl } from "../../ir/declarations.js";
+import { ExprVisitor } from "../../ir/visitor.js";
+/**
+ * Emit a complete TypeScript file from a FileDecl.
+ *
+ * @param decl - The file declaration to emit
+ * @param visitor - Expression visitor for rendering expressions
+ * @param namespace - Optional namespace override
+ * @param group - Semantic group folder this file lives in (e.g. "connection"). Empty string = root.
+ */
+export declare function emitTypeScriptFile(decl: FileDecl, visitor: ExprVisitor, namespace?: string, group?: string): string;