imxc 0.1.0

package/dist/parser.d.ts

@@ -0,0 +1,15 @@
+import ts from 'typescript';
+export interface ParsedFile {
+    sourceFile: ts.SourceFile;
+    filePath: string;
+    component: ts.FunctionDeclaration | null;
+    errors: ParseError[];
+}
+export interface ParseError {
+    file: string;
+    line: number;
+    col: number;
+    message: string;
+}
+export declare function parseIgxFile(filePath: string, source: string): ParsedFile;
+export declare function extractImports(sourceFile: ts.SourceFile): Map<string, string>;

package/dist/parser.js

@@ -0,0 +1,47 @@
+import ts from 'typescript';
+import * as path from 'node:path';
+function formatError(sourceFile, node, message) {
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    return { file: sourceFile.fileName, line: line + 1, col: character + 1, message };
+}
+export function parseIgxFile(filePath, source) {
+    const fileName = path.basename(filePath);
+    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const errors = [];
+    let component = null;
+    for (const stmt of sourceFile.statements) {
+        if (ts.isFunctionDeclaration(stmt) && stmt.name) {
+            if (component !== null) {
+                errors.push(formatError(sourceFile, stmt, 'Only one component function per .igx file is supported'));
+            }
+            else {
+                component = stmt;
+            }
+        }
+        else if (ts.isImportDeclaration(stmt)) {
+            // allowed
+        }
+        else {
+            errors.push(formatError(sourceFile, stmt, `Unsupported top-level statement: ${ts.SyntaxKind[stmt.kind]}`));
+        }
+    }
+    if (!component && errors.length === 0) {
+        errors.push({ file: fileName, line: 1, col: 1, message: 'No component function found in file' });
+    }
+    return { sourceFile, filePath, component, errors };
+}
+export function extractImports(sourceFile) {
+    const imports = new Map();
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt) && stmt.importClause) {
+            const moduleSpecifier = stmt.moduleSpecifier.text;
+            const bindings = stmt.importClause.namedBindings;
+            if (bindings && ts.isNamedImports(bindings)) {
+                for (const spec of bindings.elements) {
+                    imports.set(spec.name.text, moduleSpecifier);
+                }
+            }
+        }
+    }
+    return imports;
+}

package/dist/validator.d.ts

@@ -0,0 +1,14 @@
+import ts from 'typescript';
+import type { ParsedFile, ParseError } from './parser.js';
+export interface ValidationResult {
+    errors: ParseError[];
+    customComponents: Map<string, string>;
+    useStateCalls: UseStateInfo[];
+}
+export interface UseStateInfo {
+    name: string;
+    setter: string;
+    initializer: ts.Expression;
+    index: number;
+}
+export declare function validate(parsed: ParsedFile): ValidationResult;

package/dist/validator.js

@@ -0,0 +1,138 @@
+import ts from 'typescript';
+import { HOST_COMPONENTS, isHostComponent } from './components.js';
+import { extractImports } from './parser.js';
+function err(sf, node, msg) {
+    const { line, character } = sf.getLineAndCharacterOfPosition(node.getStart());
+    return { file: sf.fileName, line: line + 1, col: character + 1, message: msg };
+}
+export function validate(parsed) {
+    const errors = [];
+    const sf = parsed.sourceFile;
+    const func = parsed.component;
+    const customComponents = extractImports(sf);
+    const useStateCalls = [];
+    if (!func || !func.body)
+        return { errors, customComponents, useStateCalls };
+    let slotIndex = 0;
+    for (const stmt of func.body.statements) {
+        if (ts.isVariableStatement(stmt)) {
+            for (const decl of stmt.declarationList.declarations) {
+                if (isUseStateCall(decl)) {
+                    const info = extractUseState(decl, slotIndex, sf, errors);
+                    if (info) {
+                        useStateCalls.push(info);
+                        slotIndex++;
+                    }
+                }
+            }
+        }
+    }
+    const returnStmt = func.body.statements.find(ts.isReturnStatement);
+    if (returnStmt && returnStmt.expression) {
+        validateExpression(returnStmt.expression, sf, customComponents, errors);
+    }
+    return { errors, customComponents, useStateCalls };
+}
+function isUseStateCall(decl) {
+    if (!decl.initializer || !ts.isCallExpression(decl.initializer))
+        return false;
+    const callee = decl.initializer.expression;
+    return ts.isIdentifier(callee) && callee.text === 'useState';
+}
+function extractUseState(decl, index, sf, errors) {
+    const call = decl.initializer;
+    if (!ts.isArrayBindingPattern(decl.name)) {
+        errors.push(err(sf, decl, 'useState must use array destructuring'));
+        return null;
+    }
+    const elements = decl.name.elements;
+    if (elements.length !== 2) {
+        errors.push(err(sf, decl, 'useState destructuring must have exactly 2 elements'));
+        return null;
+    }
+    const nameEl = elements[0], setterEl = elements[1];
+    if (!ts.isBindingElement(nameEl) || !ts.isIdentifier(nameEl.name)) {
+        errors.push(err(sf, nameEl, 'First useState element must be an identifier'));
+        return null;
+    }
+    if (!ts.isBindingElement(setterEl) || !ts.isIdentifier(setterEl.name)) {
+        errors.push(err(sf, setterEl, 'Second useState element must be an identifier'));
+        return null;
+    }
+    if (call.arguments.length !== 1) {
+        errors.push(err(sf, call, 'useState requires exactly 1 argument'));
+        return null;
+    }
+    return { name: nameEl.name.text, setter: setterEl.name.text, initializer: call.arguments[0], index };
+}
+function validateExpression(node, sf, customComponents, errors) {
+    if (ts.isJsxElement(node)) {
+        validateJsxElement(node, sf, customComponents, errors);
+    }
+    else if (ts.isJsxSelfClosingElement(node)) {
+        validateJsxTag(node.tagName, node, sf, customComponents, errors);
+        validateJsxAttributes(node.attributes, node.tagName, sf, errors);
+    }
+    else if (ts.isJsxFragment(node)) {
+        for (const child of node.children)
+            validateExpression(child, sf, customComponents, errors);
+    }
+    else if (ts.isParenthesizedExpression(node)) {
+        validateExpression(node.expression, sf, customComponents, errors);
+    }
+    else if (ts.isConditionalExpression(node)) {
+        validateExpression(node.whenTrue, sf, customComponents, errors);
+        validateExpression(node.whenFalse, sf, customComponents, errors);
+    }
+    else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        validateExpression(node.right, sf, customComponents, errors);
+    }
+    else if (ts.isJsxExpression(node) && node.expression) {
+        validateExpression(node.expression, sf, customComponents, errors);
+    }
+    else if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'map') {
+        const callback = node.arguments[0];
+        if (callback && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))) {
+            if (ts.isBlock(callback.body)) {
+                const ret = callback.body.statements.find(ts.isReturnStatement);
+                if (ret?.expression)
+                    validateExpression(ret.expression, sf, customComponents, errors);
+            }
+            else if (callback.body) {
+                validateExpression(callback.body, sf, customComponents, errors);
+            }
+        }
+    }
+}
+function validateJsxElement(node, sf, customComponents, errors) {
+    validateJsxTag(node.openingElement.tagName, node, sf, customComponents, errors);
+    validateJsxAttributes(node.openingElement.attributes, node.openingElement.tagName, sf, errors);
+    for (const child of node.children)
+        validateExpression(child, sf, customComponents, errors);
+}
+function validateJsxTag(tagName, node, sf, customComponents, errors) {
+    if (!ts.isIdentifier(tagName))
+        return;
+    const name = tagName.text;
+    if (!isHostComponent(name) && !customComponents.has(name)) {
+        errors.push(err(sf, node, `Unknown component: <${name}>`));
+    }
+}
+function validateJsxAttributes(attrs, tagName, sf, errors) {
+    if (!ts.isIdentifier(tagName))
+        return;
+    const name = tagName.text;
+    const def = HOST_COMPONENTS[name];
+    if (!def)
+        return;
+    const presentProps = new Set();
+    for (const attr of attrs.properties) {
+        if (ts.isJsxAttribute(attr) && attr.name && ts.isIdentifier(attr.name))
+            presentProps.add(attr.name.text);
+    }
+    for (const [propName, propDef] of Object.entries(def.props)) {
+        if (propDef.required && !presentProps.has(propName)) {
+            errors.push(err(sf, attrs, `<${name}> requires prop '${propName}'`));
+        }
+    }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "imxc",
+  "version": "0.1.0",
+  "description": "Compiler for ReImGui — compiles React-like .tsx to native Dear ImGui C++",
+  "type": "module",
+  "bin": {
+    "imxc": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["imgui", "react", "tsx", "native", "gui", "compiler", "codegen"],
+  "license": "MIT",
+  "dependencies": {
+    "typescript": "^5.8.0"
+  },
+  "devDependencies": {
+    "vitest": "^3.1.0",
+    "@types/node": "^22.0.0"
+  }
+}