imxc 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { parseIgxFile, extractImports } from './parser.js';
+import { validate } from './validator.js';
+import { lowerComponent } from './lowering.js';
+import { emitComponent, emitComponentHeader, emitRoot } from './emitter.js';
+const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: { output: { type: 'string', short: 'o' } },
+});
+if (positionals.length === 0) {
+    console.error('Usage: imxc <input.tsx ...> -o <output-dir>');
+    process.exit(1);
+}
+const outputDir = values.output ?? '.';
+fs.mkdirSync(outputDir, { recursive: true });
+let hasErrors = false;
+const compiled = [];
+// Phase 1: Parse, validate, and lower all components
+for (const file of positionals) {
+    if (!fs.existsSync(file)) {
+        console.error(`${file}:1:1 - error: file not found`);
+        hasErrors = true;
+        continue;
+    }
+    const source = fs.readFileSync(file, 'utf-8');
+    const parsed = parseIgxFile(file, source);
+    if (parsed.errors.length > 0) {
+        parsed.errors.forEach(e => console.error(`${e.file}:${e.line}:${e.col} - error: ${e.message}`));
+        hasErrors = true;
+        continue;
+    }
+    const validation = validate(parsed);
+    if (validation.errors.length > 0) {
+        validation.errors.forEach(e => console.error(`${e.file}:${e.line}:${e.col} - error: ${e.message}`));
+        hasErrors = true;
+        continue;
+    }
+    const ir = lowerComponent(parsed, validation);
+    const imports = extractImports(parsed.sourceFile);
+    compiled.push({
+        name: ir.name,
+        stateCount: ir.stateSlots.length,
+        bufferCount: ir.bufferCount,
+        ir,
+        imports,
+        hasProps: ir.params.length > 0,
+    });
+}
+if (hasErrors)
+    process.exit(1);
+// Phase 2: Build lookup of compiled components for cross-file resolution
+const componentMap = new Map();
+for (const comp of compiled) {
+    componentMap.set(comp.name, comp);
+}
+// Phase 3: Resolve imported component stateCount/bufferCount in IR, then emit
+for (const comp of compiled) {
+    // Resolve cross-file custom component info
+    resolveCustomComponents(comp.ir.body, componentMap);
+    // Build import info for #include directives
+    const importInfos = [];
+    for (const [importedName] of comp.imports) {
+        const importedComp = componentMap.get(importedName);
+        if (importedComp && importedComp.hasProps) {
+            importInfos.push({
+                name: importedName,
+                headerFile: `${importedName}.gen.h`,
+            });
+        }
+    }
+    // Emit .gen.cpp
+    const cppOutput = emitComponent(comp.ir, importInfos);
+    const baseName = comp.name;
+    const outPath = path.join(outputDir, `${baseName}.gen.cpp`);
+    fs.writeFileSync(outPath, cppOutput);
+    console.log(`  ${baseName} -> ${outPath}`);
+    // Emit .gen.h for components with props
+    if (comp.hasProps) {
+        const headerOutput = emitComponentHeader(comp.ir);
+        const headerPath = path.join(outputDir, `${baseName}.gen.h`);
+        fs.writeFileSync(headerPath, headerOutput);
+        console.log(`  ${baseName} -> ${headerPath} (header)`);
+    }
+}
+// Phase 4: Emit root entry point
+if (compiled.length > 0) {
+    const root = compiled[0];
+    const rootOutput = emitRoot(root.name, root.stateCount, root.bufferCount);
+    const rootPath = path.join(outputDir, 'app_root.gen.cpp');
+    fs.writeFileSync(rootPath, rootOutput);
+    console.log(`  -> ${rootPath} (root entry point)`);
+}
+console.log(`imxc: ${compiled.length} component(s) compiled successfully.`);
+/**
+ * Walk IR nodes and update custom_component nodes with resolved stateCount/bufferCount
+ * from the compiled component map.
+ */
+function resolveCustomComponents(nodes, map) {
+    for (const node of nodes) {
+        if (node.kind === 'custom_component') {
+            const target = map.get(node.name);
+            if (target) {
+                node.stateCount = target.stateCount;
+                node.bufferCount = target.bufferCount;
+            }
+        }
+        else if (node.kind === 'conditional') {
+            resolveCustomComponents(node.body, map);
+            if (node.elseBody)
+                resolveCustomComponents(node.elseBody, map);
+        }
+        else if (node.kind === 'list_map') {
+            resolveCustomComponents(node.body, map);
+        }
+    }
+}

package/dist/ir.d.ts

@@ -0,0 +1,193 @@
+export type IRType = 'int' | 'float' | 'bool' | 'string' | 'color';
+export interface IRExpr {
+    code: string;
+    type: IRType;
+}
+export interface IRComponent {
+    name: string;
+    stateSlots: IRStateSlot[];
+    bufferCount: number;
+    params: IRPropParam[];
+    body: IRNode[];
+}
+export interface IRStateSlot {
+    name: string;
+    setter: string;
+    type: IRType;
+    initialValue: string;
+    index: number;
+}
+export interface IRPropParam {
+    name: string;
+    type: IRType | 'callback';
+}
+export type IRNode = IRBeginContainer | IREndContainer | IRText | IRButton | IRTextInput | IRCheckbox | IRSeparator | IRBeginPopup | IREndPopup | IROpenPopup | IRConditional | IRListMap | IRCustomComponent | IRMenuItem | IRSliderFloat | IRSliderInt | IRDragFloat | IRDragInt | IRCombo | IRInputInt | IRInputFloat | IRColorEdit | IRListBox | IRProgressBar | IRTooltip;
+export interface IRBeginContainer {
+    kind: 'begin_container';
+    tag: 'Window' | 'View' | 'Row' | 'Column' | 'DockSpace' | 'MenuBar' | 'Menu' | 'Table' | 'TableRow' | 'TabBar' | 'TabItem' | 'TreeNode' | 'CollapsingHeader';
+    props: Record<string, string>;
+    style?: string;
+}
+export interface IREndContainer {
+    kind: 'end_container';
+    tag: 'Window' | 'View' | 'Row' | 'Column' | 'DockSpace' | 'MenuBar' | 'Menu' | 'Table' | 'TableRow' | 'TabBar' | 'TabItem' | 'TreeNode' | 'CollapsingHeader';
+}
+export interface IRText {
+    kind: 'text';
+    format: string;
+    args: string[];
+}
+export interface IRButton {
+    kind: 'button';
+    title: string;
+    action: string[];
+    style?: string;
+}
+export interface IRTextInput {
+    kind: 'text_input';
+    label: string;
+    bufferIndex: number;
+    stateVar: string;
+    style?: string;
+}
+export interface IRCheckbox {
+    kind: 'checkbox';
+    label: string;
+    stateVar: string;
+    valueExpr?: string;
+    onChangeExpr?: string;
+    style?: string;
+}
+export interface IRSeparator {
+    kind: 'separator';
+}
+export interface IRBeginPopup {
+    kind: 'begin_popup';
+    id: string;
+    style?: string;
+}
+export interface IREndPopup {
+    kind: 'end_popup';
+}
+export interface IROpenPopup {
+    kind: 'open_popup';
+    id: string;
+}
+export interface IRConditional {
+    kind: 'conditional';
+    condition: string;
+    body: IRNode[];
+    elseBody?: IRNode[];
+}
+export interface IRListMap {
+    kind: 'list_map';
+    array: string;
+    itemVar: string;
+    key: string;
+    componentName: string;
+    stateCount: number;
+    bufferCount: number;
+    body: IRNode[];
+}
+export interface IRCustomComponent {
+    kind: 'custom_component';
+    name: string;
+    props: Record<string, string>;
+    key?: string;
+    stateCount: number;
+    bufferCount: number;
+}
+export interface IRMenuItem {
+    kind: 'menu_item';
+    label: string;
+    shortcut?: string;
+    action: string[];
+}
+export interface IRSliderFloat {
+    kind: 'slider_float';
+    label: string;
+    stateVar: string;
+    valueExpr?: string;
+    onChangeExpr?: string;
+    min: string;
+    max: string;
+    style?: string;
+}
+export interface IRSliderInt {
+    kind: 'slider_int';
+    label: string;
+    stateVar: string;
+    valueExpr?: string;
+    onChangeExpr?: string;
+    min: string;
+    max: string;
+    style?: string;
+}
+export interface IRDragFloat {
+    kind: 'drag_float';
+    label: string;
+    stateVar: string;
+    valueExpr?: string;
+    onChangeExpr?: string;
+    speed: string;
+    style?: string;
+}
+export interface IRDragInt {
+    kind: 'drag_int';
+    label: string;
+    stateVar: string;
+    valueExpr?: string;
+    onChangeExpr?: string;
+    speed: string;
+    style?: string;
+}
+export interface IRCombo {
+    kind: 'combo';
+    label: string;
+    stateVar: string;
+    valueExpr?: string;
+    onChangeExpr?: string;
+    items: string;
+    style?: string;
+}
+export interface IRInputInt {
+    kind: 'input_int';
+    label: string;
+    stateVar: string;
+    valueExpr?: string;
+    onChangeExpr?: string;
+    style?: string;
+}
+export interface IRInputFloat {
+    kind: 'input_float';
+    label: string;
+    stateVar: string;
+    valueExpr?: string;
+    onChangeExpr?: string;
+    style?: string;
+}
+export interface IRColorEdit {
+    kind: 'color_edit';
+    label: string;
+    stateVar: string;
+    style?: string;
+}
+export interface IRListBox {
+    kind: 'list_box';
+    label: string;
+    stateVar: string;
+    valueExpr?: string;
+    onChangeExpr?: string;
+    items: string;
+    style?: string;
+}
+export interface IRProgressBar {
+    kind: 'progress_bar';
+    value: string;
+    overlay?: string;
+    style?: string;
+}
+export interface IRTooltip {
+    kind: 'tooltip';
+    text: string;
+}

package/dist/ir.js

@@ -0,0 +1 @@
+export {};

package/dist/lowering.d.ts

@@ -0,0 +1,17 @@
+import ts from 'typescript';
+import type { ParsedFile } from './parser.js';
+import type { ValidationResult } from './validator.js';
+import type { IRComponent, IRStateSlot } from './ir.js';
+interface LoweringContext {
+    stateVars: Map<string, IRStateSlot>;
+    setterMap: Map<string, string>;
+    propsParam: string | null;
+    bufferIndex: number;
+    sourceFile: ts.SourceFile;
+}
+export declare function lowerComponent(parsed: ParsedFile, validation: ValidationResult): IRComponent;
+/**
+ * Convert a TypeScript expression to C++ code string.
+ */
+export declare function exprToCpp(node: ts.Expression, ctx: LoweringContext): string;
+export {};