@typecad/cuttlefish 0.1.0-alpha.1

package/dist/ir/transformers/ui-mount.d.ts

@@ -0,0 +1,20 @@
+import type { PlatformGraphicsStrategy, DisplayInitOp } from "../../api/shared/index.js";
+export interface MountRequest {
+    display: string;
+    bus: string;
+    cs: number;
+    dc: number;
+    rst: number;
+    rotation?: number;
+    backlight?: number;
+    spiFrequency?: number;
+    address?: number;
+    reset?: number;
+}
+export declare class MountValidationError extends Error {
+    constructor(driver: string, supported: ReadonlySet<string>);
+}
+export declare function resolveMount(req: MountRequest, strategy: PlatformGraphicsStrategy, viewport: {
+    width: number;
+    height: number;
+}): DisplayInitOp;

package/dist/ir/transformers/ui-mount.js

@@ -0,0 +1,35 @@
+// ---------------------------------------------------------------------------
+// ui.mount resolver — validates the requested driver against the active
+// framework's supportedDisplayDrivers() and returns a DisplayInitOp.
+//
+// Fail-fast: an unsupported driver errors at transpile time, not at runtime.
+// Mirrors the pin-conflict check philosophy.
+// ---------------------------------------------------------------------------
+export class MountValidationError extends Error {
+    constructor(driver, supported) {
+        super(`Unsupported display driver "${driver}". ` +
+            `Supported by this framework: ${[...supported].join(", ") || "(none)"}.`);
+        this.name = "MountValidationError";
+    }
+}
+export function resolveMount(req, strategy, viewport) {
+    const supported = strategy.supportedDisplayDrivers();
+    if (!supported.has(req.display)) {
+        throw new MountValidationError(req.display, supported);
+    }
+    return {
+        operation: "display.init",
+        bus: req.bus,
+        cs: req.cs,
+        dc: req.dc,
+        rst: req.rst,
+        width: viewport.width,
+        height: viewport.height,
+        driver: req.display,
+        rotation: req.rotation,
+        address: req.address,
+        reset: req.reset,
+        backlight: req.backlight,
+        spiFrequency: req.spiFrequency,
+    };
+}

package/dist/ir/transformers/ui-reactive.d.ts

@@ -0,0 +1,68 @@
+export interface BindingSpec {
+    nodeIndex: number;
+    property: string;
+    fnName: string;
+    /** The C++ expression for the color-binding compute function (v1: may be
+     *  empty if the arrow body couldn't be lowered; the emitter falls back to
+     *  returning the node's current value). */
+    cppExpr?: string;
+    /** The imperative C++ statement body for a text binding (e.g.
+     *  `snprintf(buf, size, "%d", count);`). Mutually exclusive with cppExpr:
+     *  text bindings use cppBody, color bindings use cppExpr. */
+    cppBody?: string;
+    /** The unrendered ExpressionIR for non-text (color/value/etc.) bindings.
+     *  When present, the emitter renders it through the strategy-aware
+     *  ExpressionRenderer (so division promotion, modulo→fmod, and string-concat
+     *  wrapping match top-level code) instead of inlining the prerendered
+     *  cppExpr. cppExpr is kept as a fallback. Color literals are pre-resolved
+     *  to raw hex nodes (resolveColorIR) so ExpressionRenderer emits the number. */
+    bodyIR?: import("../../api/shared/ir-core.js").ExpressionIR;
+}
+/** Emit a signal as a device variable declaration. */
+export declare function emitSignalDecl(name: string, cppType: string, initialValue: number | string | boolean): string;
+/** Emit a single binding-table entry line. */
+export declare function emitBindingEntry(spec: BindingSpec): string;
+/** Emit a full binding table from a list of specs. */
+export declare function emitBindingTable(specs: BindingSpec[]): string;
+export interface ListBindingSpec {
+    nodeIndex: number;
+    countFnName: string;
+    itemFnName: string;
+    tapFnName: string | null;
+    countFnBody: string;
+    itemFnBody: string;
+    tapFnBody: string | null;
+    /** Statement IR for the count function body (preferred over countFnBody). */
+    countStatements?: import("../../api/shared/ir-core.js").StatementIR[];
+    /** Statement IR for the item function body (preferred over itemFnBody). */
+    itemStatements?: import("../../api/shared/ir-core.js").StatementIR[];
+    /** Statement IR for the tap callback body (preferred over tapFnBody). */
+    tapStatements?: import("../../api/shared/ir-core.js").StatementIR[];
+    countSourceSpan?: import("../../types.js").SourceSpan;
+    itemSourceSpan?: import("../../types.js").SourceSpan;
+    tapSourceSpan?: import("../../types.js").SourceSpan;
+}
+export declare function recordListBinding(spec: ListBindingSpec): void;
+export declare function getListBindings(): ListBindingSpec[];
+export declare function getListBindingsCount(): number;
+export declare function resetListBindings(): void;
+export interface InputBindingSpec {
+    nodeIndex: number;
+    cbFnName: string;
+    cbFnBody: string;
+    /** Statement IR for the callback body (preferred over cbFnBody). */
+    bodyStatements?: import("../../api/shared/ir-core.js").StatementIR[];
+    sourceSpan?: import("../../types.js").SourceSpan;
+}
+export declare function recordInputBinding(spec: InputBindingSpec): void;
+export declare function getInputBindings(): InputBindingSpec[];
+export declare function getInputBindingsCount(): number;
+export declare function resetInputBindings(): void;
+/** Emit only the input-binding table (callback functions emitted separately). */
+export declare function emitInputBindingTable(specs: InputBindingSpec[]): string;
+/** @deprecated Prefer emit callback wrappers via emitCallbackWrapper + emitInputBindingTable. */
+export declare function emitInputBindings(specs: InputBindingSpec[]): string;
+/** Emit only the list-binding table (count/item/tap functions emitted separately). */
+export declare function emitListBindingTable(specs: ListBindingSpec[]): string;
+/** @deprecated Prefer emit callback wrappers via emitCallbackWrapper + emitListBindingTable. */
+export declare function emitListBindings(specs: ListBindingSpec[]): string;

package/dist/ir/transformers/ui-reactive.js

@@ -0,0 +1,129 @@
+// ---------------------------------------------------------------------------
+// Reactive lowering — ui.signal / ui.bind → C++ device variables + binding table.
+//
+// A signal lowers to a plain variable (with an initial value). A bind lowers
+// to a UIBinding entry: { nodeIndex, property, fn_ptr }. The runtime evaluates
+// each binding each tick; if the computed value differs from the node's current
+// value, the node is marked dirty (and the transition armed if applicable).
+//
+// The compute functions (fn_ptr) are emitted as free C++ functions that return
+// the property value, generated from the author's arrow-function bodies.
+// ---------------------------------------------------------------------------
+/** Emit a signal as a device variable declaration. */
+export function emitSignalDecl(name, cppType, initialValue) {
+    const val = typeof initialValue === "string" ? `"${initialValue}"` : `${initialValue}`;
+    return `${cppType} ${name} = ${val};`;
+}
+/** Map a bind property name to the runtime property enum. */
+function propEnum(property) {
+    switch (property) {
+        case "background": return "PROP_BG";
+        case "color": return "PROP_FG";
+        case "text": return "PROP_TEXT";
+        case "visible": return "PROP_VISIBLE";
+        case "borderColor": return "PROP_BORDER_COLOR";
+        case "value": return "PROP_VALUE";
+        default: return `PROP_${property.toUpperCase()}`;
+    }
+}
+/** Emit a single binding-table entry line. */
+export function emitBindingEntry(spec) {
+    // Text bindings wire to textFn (void fill-style); color bindings wire to fn.
+    if (spec.property === "text") {
+        return `  { .node=${spec.nodeIndex}, .prop=${propEnum(spec.property)}, .fn=nullptr, .textFn=${spec.fnName} },`;
+    }
+    return `  { .node=${spec.nodeIndex}, .prop=${propEnum(spec.property)}, .fn=${spec.fnName}, .textFn=nullptr },`;
+}
+/** Emit a full binding table from a list of specs. */
+export function emitBindingTable(specs) {
+    if (specs.length === 0)
+        return `UIBinding __ui_bindings[] = {};`;
+    return [
+        `UIBinding __ui_bindings[] = {`,
+        ...specs.map(emitBindingEntry),
+        `};`,
+    ].join("\n");
+}
+const listBindings = [];
+export function recordListBinding(spec) {
+    listBindings.push(spec);
+}
+export function getListBindings() {
+    return listBindings;
+}
+export function getListBindingsCount() {
+    return listBindings.length;
+}
+export function resetListBindings() {
+    listBindings.length = 0;
+}
+const inputBindings = [];
+export function recordInputBinding(spec) {
+    inputBindings.push(spec);
+}
+export function getInputBindings() {
+    return inputBindings;
+}
+export function getInputBindingsCount() {
+    return inputBindings.length;
+}
+export function resetInputBindings() {
+    inputBindings.length = 0;
+}
+/** Emit only the input-binding table (callback functions emitted separately). */
+export function emitInputBindingTable(specs) {
+    if (specs.length === 0) {
+        return `UIInputBinding __ui_input_bindings[] = {};\nconst uint16_t __ui_input_binding_count = 0;`;
+    }
+    const lines = [
+        `UIInputBinding __ui_input_bindings[] = {`,
+    ];
+    for (const spec of specs) {
+        lines.push(`  { .node=${spec.nodeIndex}, .cb=${spec.cbFnName} },`);
+    }
+    lines.push(`};`);
+    lines.push(`const uint16_t __ui_input_binding_count = ${specs.length};`);
+    return lines.join("\n");
+}
+/** @deprecated Prefer emit callback wrappers via emitCallbackWrapper + emitInputBindingTable. */
+export function emitInputBindings(specs) {
+    if (specs.length === 0)
+        return emitInputBindingTable(specs);
+    const lines = [];
+    for (const spec of specs) {
+        lines.push(`void ${spec.cbFnName}(const char* text) { ${spec.cbFnBody} }`);
+    }
+    lines.push(emitInputBindingTable(specs));
+    return lines.join("\n");
+}
+/** Emit only the list-binding table (count/item/tap functions emitted separately). */
+export function emitListBindingTable(specs) {
+    if (specs.length === 0) {
+        return `UIListBinding __ui_list_bindings[] = {};\nconst uint16_t __ui_list_binding_count = 0;`;
+    }
+    const lines = [
+        `UIListBinding __ui_list_bindings[] = {`,
+    ];
+    for (const spec of specs) {
+        const tap = spec.tapFnName && (spec.tapStatements || spec.tapFnBody) ? spec.tapFnName : "nullptr";
+        lines.push(`  { .node=${spec.nodeIndex}, .countFn=${spec.countFnName}, .itemFn=${spec.itemFnName}, .tapFn=${tap} },`);
+    }
+    lines.push(`};`);
+    lines.push(`const uint16_t __ui_list_binding_count = ${specs.length};`);
+    return lines.join("\n");
+}
+/** @deprecated Prefer emit callback wrappers via emitCallbackWrapper + emitListBindingTable. */
+export function emitListBindings(specs) {
+    if (specs.length === 0)
+        return emitListBindingTable(specs);
+    const lines = [];
+    for (const spec of specs) {
+        lines.push(`uint16_t ${spec.countFnName}() { ${spec.countFnBody} }`);
+        lines.push(`void ${spec.itemFnName}(uint16_t idx, char* buf, uint8_t size) { ${spec.itemFnBody} }`);
+        if (spec.tapFnName && spec.tapFnBody) {
+            lines.push(`void ${spec.tapFnName}(uint16_t idx) { ${spec.tapFnBody} }`);
+        }
+    }
+    lines.push(emitListBindingTable(specs));
+    return lines.join("\n");
+}

package/dist/ir/transformers/variables.d.ts

@@ -0,0 +1,14 @@
+import ts from "typescript";
+import { Diagnostic } from "../../types.js";
+import { StatementIR } from "../../api/index.js";
+import { CppTypeHint } from "../type-resolution.js";
+import { PointerTracker } from "../build-ir-state.js";
+export declare function assignmentOperatorToString(kind: ts.SyntaxKind): Extract<StatementIR, {
+    kind: "assign";
+}>['operator'] | undefined;
+export declare function updateLocalTypeFromAssignment(target: string, operator: Extract<StatementIR, {
+    kind: "assign";
+}>['operator'], valueType: CppTypeHint, localVariableTypes: Map<string, CppTypeHint>): void;
+export declare function extractForInKeys(expr: ts.Expression): string[] | undefined;
+export declare function variableStatementToIR(statement: ts.VariableStatement, fileName: string, sourceText: string, diagnostics: Diagnostic[], functionReturnTypes: Map<string, CppTypeHint>, localVariableTypes: Map<string, CppTypeHint>, typeAliases: Map<string, ts.TypeNode> | undefined, pointerVars: PointerTracker, functionNameForDiagnostics: string, lowerStatementListCallback: (statements: readonly ts.Statement[] | ts.NodeArray<ts.Statement>, fileName: string, sourceText: string, diagnostics: Diagnostic[], functionReturnTypes: Map<string, CppTypeHint>, localVariableTypes: Map<string, CppTypeHint>, functionNameForDiagnostics: string, typeAliases?: Map<string, ts.TypeNode>, pointerVars?: PointerTracker) => StatementIR[]): StatementIR[];
+export declare function collectPointerVars(statements: readonly ts.Statement[]): PointerTracker;