@typecad/cuttlefish 0.1.0-alpha.1

package/dist/api/shared/hal-op-ir.d.ts

@@ -0,0 +1,393 @@
+import type { DisplayHALOp } from "./display-op-ir.js";
+export interface GpioWriteOp {
+    operation: "gpio.write";
+    /** MCU port name (e.g. "PB5") — canonical identity from datasheet */
+    port?: string;
+    /** Legacy framework pin number */
+    pin: number;
+    /** 0 = LOW, 1 = HIGH, or a runtime expression string (e.g. "state", "!state") */
+    value: 0 | 1 | string;
+}
+export interface GpioReadOp {
+    operation: "gpio.read";
+    port?: string;
+    pin: number;
+}
+export interface GpioToggleOp {
+    operation: "gpio.toggle";
+    port?: string;
+    pin: number;
+}
+export interface GpioSetModeOp {
+    operation: "gpio.set_mode";
+    port?: string;
+    pin: number;
+    /** "output" | "input" | "input_pullup" | "input_pulldown" */
+    mode: string;
+}
+export interface PwmWriteOp {
+    operation: "pwm.write";
+    port?: string;
+    pin: number;
+    /** Duty cycle — numeric value or runtime expression string */
+    duty: number | string;
+}
+export interface PwmGetFrequencyOp {
+    operation: "pwm.get_frequency";
+    port?: string;
+    pin: number;
+}
+export interface PwmGetResolutionOp {
+    operation: "pwm.get_resolution";
+    port?: string;
+    pin: number;
+}
+export interface AdcReadOp {
+    operation: "adc.read";
+    port?: string;
+    pin: number;
+}
+export interface AdcGetResolutionOp {
+    operation: "adc.get_resolution";
+}
+export interface AdcSetReferenceOp {
+    operation: "adc.set_reference";
+    /** Reference constant name or numeric value */
+    reference: string | number;
+}
+export interface AdcGetReferenceOp {
+    operation: "adc.get_reference";
+}
+export interface AdcReadVoltageOp {
+    operation: "adc.read_voltage";
+    port?: string;
+    pin: number;
+    vRef?: number;
+    maxValue?: number;
+}
+export interface DacWriteOp {
+    operation: "dac.write";
+    port?: string;
+    pin: number;
+    /** Output value — numeric or runtime expression string */
+    value: number | string;
+}
+export interface InterruptAttachOp {
+    operation: "interrupt.attach";
+    port?: string;
+    pin: number;
+    /** Resolved C++ callback function name */
+    handler: string;
+    /** "rising" | "falling" | "change" | "high" | "low" */
+    mode: string;
+}
+export interface InterruptDetachOp {
+    operation: "interrupt.detach";
+    port?: string;
+    pin: number;
+}
+export interface TonePlayOp {
+    operation: "tone.play";
+    port?: string;
+    pin: number;
+    /** Frequency in Hz — numeric or runtime expression string */
+    frequency: number | string;
+    /** Optional duration in milliseconds — numeric or runtime expression string */
+    duration?: number | string;
+}
+export interface ToneStopOp {
+    operation: "tone.stop";
+    port?: string;
+    pin: number;
+}
+export interface TimingDelayOp {
+    operation: "timing.delay";
+    ms: number;
+}
+export interface TimingDelayMicrosecondsOp {
+    operation: "timing.delay_microseconds";
+    us: number;
+}
+export interface TimingMillisOp {
+    operation: "timing.millis";
+}
+export interface TimingMicrosOp {
+    operation: "timing.micros";
+}
+export interface TimingFreeHeapOp {
+    operation: "timing.free_heap";
+}
+export interface TimingSetIntervalOp {
+    operation: "timing.set_interval";
+    /** Resolved C++ callback function name */
+    handler: string;
+    timeout: number;
+}
+export interface TimingSetTimeoutOp {
+    operation: "timing.set_timeout";
+    /** Resolved C++ callback function name */
+    handler: string;
+    timeout: number;
+}
+export interface TimingClearIntervalOp {
+    operation: "timing.clear_interval";
+    id: number;
+}
+export interface TimingClearTimeoutOp {
+    operation: "timing.clear_timeout";
+    id: number;
+}
+export interface PowerDeepSleepOp {
+    operation: "power.deep_sleep";
+    ms: number;
+}
+export interface PowerLightSleepOp {
+    operation: "power.light_sleep";
+}
+export interface PowerSetCpuFrequencyOp {
+    operation: "power.set_cpu_frequency";
+    mhz: number;
+}
+export interface I2cBeginOp {
+    operation: "i2c.begin";
+    bus: string;
+    /** Slave address (only for slave mode) — numeric or runtime expression string */
+    address?: number | string;
+}
+export interface I2cEndOp {
+    operation: "i2c.end";
+    bus: string;
+}
+export interface I2cSetClockOp {
+    operation: "i2c.set_clock";
+    bus: string;
+    /** Clock speed in Hz — numeric or runtime expression string */
+    hz: number | string;
+}
+export interface I2cBeginTransmissionOp {
+    operation: "i2c.begin_transmission";
+    bus: string;
+    /** Slave address — numeric or runtime expression string */
+    address: number | string;
+}
+export interface I2cWriteOp {
+    operation: "i2c.write";
+    bus: string;
+    /** Resolved C++ expression for the data to write */
+    data: string;
+}
+export interface I2cWriteBytesOp {
+    operation: "i2c.write_bytes";
+    bus: string;
+    /** Individual byte values — numeric literals or runtime expressions */
+    bytes: (number | string)[];
+}
+export interface I2cWriteBufferOp {
+    operation: "i2c.write_buffer";
+    bus: string;
+    /** C array / buffer variable name */
+    data: string;
+}
+export interface I2cReadBufferOp {
+    operation: "i2c.read_buffer";
+    bus: string;
+    count: number | string;
+    /** Buffer variable name, or "__DISCARD__" to read-and-drop */
+    buffer: string;
+}
+export interface I2cEndTransmissionOp {
+    operation: "i2c.end_transmission";
+    bus: string;
+    stop: boolean;
+}
+export interface I2cRequestFromOp {
+    operation: "i2c.request_from";
+    bus: string;
+    /** Slave address — numeric or runtime expression string */
+    address: number | string;
+    /** Number of bytes — numeric or runtime expression string */
+    quantity: number | string;
+    stop: boolean;
+}
+export interface I2cAvailableOp {
+    operation: "i2c.available";
+    bus: string;
+}
+export interface I2cReadOp {
+    operation: "i2c.read";
+    bus: string;
+}
+export interface I2cRecoverOp {
+    operation: "i2c.recover";
+    bus: string;
+}
+export interface SpiBeginOp {
+    operation: "spi.begin";
+    bus: string;
+}
+export interface SpiEndOp {
+    operation: "spi.end";
+    bus: string;
+}
+export interface SpiTransferOp {
+    operation: "spi.transfer";
+    bus: string;
+    /** Resolved C++ expression for data to transfer */
+    data: string;
+}
+export interface SpibeginTransactionOp {
+    operation: "spi.begin_transaction";
+    bus: string;
+    /** Resolved C++ SPISettings expression */
+    settings: string;
+}
+export interface SpiEndTransactionOp {
+    operation: "spi.end_transaction";
+    bus: string;
+}
+export interface SpiSetModeOp {
+    operation: "spi.set_mode";
+    bus: string;
+    /** SPI mode (0-3) — numeric or runtime expression string */
+    mode: number | string;
+}
+export interface SpiSetBitOrderOp {
+    operation: "spi.set_bit_order";
+    bus: string;
+    /** "lsb" | "msb" */
+    order: string;
+}
+export interface SpiCsLowOp {
+    operation: "spi.cs_low";
+    port?: string;
+    pin: number;
+}
+export interface SpiCsHighOp {
+    operation: "spi.cs_high";
+    port?: string;
+    pin: number;
+}
+export interface UartBeginOp {
+    operation: "uart.begin";
+    port: string;
+    /** Baud rate — numeric or runtime expression string */
+    baud: number | string;
+}
+export interface UartEndOp {
+    operation: "uart.end";
+    port: string;
+}
+export interface UartPrintOp {
+    operation: "uart.print";
+    port: string;
+    /** Resolved C++ expression to print */
+    value: string;
+}
+export interface UartPrintlnOp {
+    operation: "uart.println";
+    port: string;
+    /** Resolved C++ expression to print */
+    value: string;
+}
+export interface UartPrintfOp {
+    operation: "uart.printf";
+    port: string;
+    /** printf format string */
+    format: string;
+    /** Resolved C++ argument expressions */
+    args: string[];
+}
+export interface UartWriteOp {
+    operation: "uart.write";
+    port: string;
+    /** Resolved C++ expression for data */
+    data: string;
+}
+export interface UartReadOp {
+    operation: "uart.read";
+    port: string;
+}
+export interface UartPeekOp {
+    operation: "uart.peek";
+    port: string;
+}
+export interface UartAvailableOp {
+    operation: "uart.available";
+    port: string;
+}
+export interface UartFlushOp {
+    operation: "uart.flush";
+    port: string;
+}
+export interface PulseInOp {
+    operation: "pulse.in";
+    port?: string;
+    pin: number;
+    /** 0 = LOW, 1 = HIGH */
+    value: 0 | 1;
+    /** Optional timeout in microseconds */
+    timeout?: number;
+}
+export interface PulseInLongOp {
+    operation: "pulse.in_long";
+    port?: string;
+    pin: number;
+    /** 0 = LOW, 1 = HIGH */
+    value: 0 | 1;
+}
+export interface ShiftOutOp {
+    operation: "shift.out";
+    dataPin: number;
+    clockPin: number;
+    /** "lsb" | "msb" */
+    bitOrder: string;
+    value: number;
+}
+export interface ShiftInOp {
+    operation: "shift.in";
+    dataPin: number;
+    clockPin: number;
+    /** "lsb" | "msb" */
+    bitOrder: string;
+}
+export interface BoardResolveOp {
+    operation: "board.resolve";
+    /** Dot-separated path into the board definition (e.g. "peripherals.pwm.resolution") */
+    path: string;
+}
+export interface WdtEnableOp {
+    operation: "wdt.enable";
+    /** Timeout — a duration string ("250ms"), a WDTO_* constant name, or a number */
+    timeout: string | number;
+}
+export interface WdtResetOp {
+    operation: "wdt.reset";
+}
+export interface WdtDisableOp {
+    operation: "wdt.disable";
+}
+export interface SnprintfEmitOp {
+    operation: "snprintf.emit";
+    /** Temporary buffer variable name */
+    bufferName: string;
+    /** printf-style format string */
+    format: string;
+    /** Resolved C++ argument expressions */
+    args: string[];
+}
+export interface RawCppOp {
+    operation: "raw";
+    /** Raw C++ code string (framework-agnostic, use sparingly) */
+    code: string;
+}
+/**
+ * HAL Operation IR — a discriminated union of all supported hardware
+ * operations. Each node carries a semantic `operation` tag and typed
+ * arguments. Framework strategies translate these into concrete C++.
+ */
+export type HALOpIR = GpioWriteOp | GpioReadOp | GpioToggleOp | GpioSetModeOp | PwmWriteOp | PwmGetFrequencyOp | PwmGetResolutionOp | AdcReadOp | AdcGetResolutionOp | AdcSetReferenceOp | AdcGetReferenceOp | AdcReadVoltageOp | DacWriteOp | InterruptAttachOp | InterruptDetachOp | TonePlayOp | ToneStopOp | TimingDelayOp | TimingDelayMicrosecondsOp | TimingMillisOp | TimingMicrosOp | TimingFreeHeapOp | TimingSetIntervalOp | TimingSetTimeoutOp | TimingClearIntervalOp | TimingClearTimeoutOp | PowerDeepSleepOp | PowerLightSleepOp | PowerSetCpuFrequencyOp | I2cBeginOp | I2cEndOp | I2cSetClockOp | I2cBeginTransmissionOp | I2cWriteOp | I2cWriteBytesOp | I2cWriteBufferOp | I2cReadBufferOp | I2cEndTransmissionOp | I2cRequestFromOp | I2cAvailableOp | I2cReadOp | I2cRecoverOp | SpiBeginOp | SpiEndOp | SpiTransferOp | SpibeginTransactionOp | SpiEndTransactionOp | SpiSetModeOp | SpiSetBitOrderOp | SpiCsLowOp | SpiCsHighOp | UartBeginOp | UartEndOp | UartPrintOp | UartPrintlnOp | UartPrintfOp | UartWriteOp | UartReadOp | UartPeekOp | UartAvailableOp | UartFlushOp | PulseInOp | PulseInLongOp | ShiftOutOp | ShiftInOp | BoardResolveOp | WdtEnableOp | WdtResetOp | WdtDisableOp | SnprintfEmitOp | RawCppOp | DisplayHALOp;
+/**
+ * Helper type: extracts the operation string from a HALOpIR variant.
+ * Useful for type-safe switch statements in framework strategies.
+ */
+export type HALOperationKind = HALOpIR["operation"];

package/dist/api/shared/hal-op-ir.js

@@ -0,0 +1,18 @@
+// ---------------------------------------------------------------------------
+// HAL Operation IR — semantic hardware operations
+//
+// Each HALOpIR node represents a single hardware operation (GPIO write, I2C
+// transfer, timing delay, etc.) that the framework strategy translates into
+// framework-specific C++.
+//
+// The transpiler produces these nodes when resolving HAL method calls.
+// Framework strategies (ArduinoStrategy, NativeAVRStrategy, etc.) implement
+// resolveHALOperation() to map each operation to concrete C++ code.
+//
+// Pin-carrying operations include an optional `port` field for the MCU
+// datasheet port name (e.g. "PB5"). When present, framework strategies
+// should prefer the port name and look up the framework pin number via
+// the MCU package's pin mapping. The `pin` field provides backward
+// compatibility as a legacy framework pin number.
+// ---------------------------------------------------------------------------
+export {};

package/dist/api/shared/index.d.ts

@@ -0,0 +1,26 @@
+export type { Diagnostic, PlatformContext, SourceSpan, TargetProfile } from './types.js';
+export type { CppTypeIR, CppTypeKind, CppPrimitiveName, CppFormatKind, } from './cpp-type-ir.js';
+export { parseCppType, renderCppType, splitTemplateArgs, isPointer, isReference, isContainer, isVector, isMap, isSet, isTuple, isVariant, isStdFunction, isStaticArray, isCArray, isStringLike, isPrimitive, bareType, elementOf, formatKindOf, CppTypeIR as cppTypeIRBuilder, parsedIsPointer, parsedIsStringLike, parsedIsPrimitive, parsedIsContainer, parsedIsVector, parsedIsMap, parsedIsSet, parsedIsTuple, parsedIsVariant, parsedIsStaticArray, parsedIsStdString, parsedElementOf, parsedElementString, parsedBareString, parsedBareType, collectNamedTypes, parsedCollectNamedTypes, needsCStrForStringLike, parsedIsPlainStructType, } from './cpp-type-ir.js';
+export type { ExpressionIR, StatementIR, ProgramIR, ImportIR, ReExportIR, CallExpressionIR, SuperCallIR, VariableDeclarationIR, AssignmentIR, UpdateIR, ReturnIR, WhileIR, IfIR, ForIR, ForOfIR, ForInIR, BreakIR, ContinueIR, DoWhileIR, SwitchIR, CaseIR, TryIR, ThrowIR, LabeledIR, BlockIR, HALOpStatementIR, FunctionIR, StructDefIR, EnumIR, ClassFieldIR, ClassConstructorIR, ClassMethodIR, ClassGetterIR, ClassSetterIR, ClassIR, InterfaceIR, TypeAliasIR, NamespaceIR, PeripheralUsageIR, RegisterBitFieldIR, RegisterClassIR, ParameterIR, CppType, } from './ir.js';
+export type { HALOpIR, HALOperationKind, } from './hal-op-ir.js';
+export type { DisplayInitOp, DisplayFillRectOp, DisplayDrawTextOp, DisplayDrawRectOp, DisplayFlushOp, DisplayHALOp, } from './display-op-ir.js';
+export { DISPLAY_OPERATION_KINDS } from './display-op-ir.js';
+export type { PlatformGraphicsStrategy, GraphicsCapacity } from './graphics-strategy.js';
+export type { DisplayProfile, DisplayConfig, DisplaySize, TouchProfile, TouchLibrary, ResolvedDisplay } from './display-profile.js';
+export { effectiveDisplaySize, normalizeDisplayRotation, resolveDisplayProfile, resolveScrollConfig, DEFAULT_SCROLL_CANVAS_BUDGET_BYTES } from './display-profile.js';
+export type { DisplayCapabilities, DisplayFeatureFlags, NativeFormat, RefreshModel, PartialRefreshScope, } from './display-capabilities.js';
+export { defaultTftCapabilities, deriveCapabilities } from './display-capabilities.js';
+export type { BoardConstants } from './board-resolver.js';
+export type { RuntimePolyfillIR, StdLibSupport, } from './polyfill-types.js';
+export { getStdLibSupport, DEFAULT_STDLIB_SUPPORT } from './polyfill-types.js';
+export type { PlatformStrategy, PlatformProfileStrategy, PlatformPolyfillStrategy, PlatformTypeStrategy, PlatformExpressionStrategy, PlatformStatementStrategy, PlatformSafetyStrategy, PlatformBuildStrategy, PlatformDebugStrategy, PlatformAsyncStrategy, PlatformHALStrategy, } from './platform-strategy.js';
+export type { CompileError, CompileResult, UploadResult, ToolchainOptions } from './toolchain-types.js';
+export { parseCompileErrors, collectCppFiles } from './toolchain-types.js';
+export type { KnownVariableInfo, SnprintfArgRenderResult, SnprintfRenderResult, EmissionScopeState, SnprintfExpressionRenderer, } from './snprintf-types.js';
+export { POLYFILL_HELPER_MAP, filterPolyfillHelpers } from './polyfill-helper-registry.js';
+export { STRING_METHODS, STRING_METHOD_NAMES, applyStringMethodRewrites } from './string-method-registry.js';
+export type { StringMethodSpec, StringMethodArgForm } from './string-method-registry.js';
+export { isStringEnum } from './ir-declarations.js';
+export type { AsyncRuntimeConfig } from './async-types.js';
+export { generatePromiseRuntime } from './promise-runtime.js';
+export { generateStaticAsyncRuntime } from './async-runtime-static.js';

package/dist/api/shared/index.js

@@ -0,0 +1,21 @@
+// ---------------------------------------------------------------------------
+// Shared types barrel export
+//
+// Re-exports all shared types for use by CLI and framework packages.
+// ---------------------------------------------------------------------------
+export { parseCppType, renderCppType, splitTemplateArgs, isPointer, isReference, isContainer, isVector, isMap, isSet, isTuple, isVariant, isStdFunction, isStaticArray, isCArray, isStringLike, isPrimitive, bareType, elementOf, formatKindOf, CppTypeIR as cppTypeIRBuilder, parsedIsPointer, parsedIsStringLike, parsedIsPrimitive, parsedIsContainer, parsedIsVector, parsedIsMap, parsedIsSet, parsedIsTuple, parsedIsVariant, parsedIsStaticArray, parsedIsStdString, parsedElementOf, parsedElementString, parsedBareString, parsedBareType, collectNamedTypes, parsedCollectNamedTypes, needsCStrForStringLike, parsedIsPlainStructType, } from './cpp-type-ir.js';
+export { DISPLAY_OPERATION_KINDS } from './display-op-ir.js';
+export { effectiveDisplaySize, normalizeDisplayRotation, resolveDisplayProfile, resolveScrollConfig, DEFAULT_SCROLL_CANVAS_BUDGET_BYTES } from './display-profile.js';
+export { defaultTftCapabilities, deriveCapabilities } from './display-capabilities.js';
+export { getStdLibSupport, DEFAULT_STDLIB_SUPPORT } from './polyfill-types.js';
+export { parseCompileErrors, collectCppFiles } from './toolchain-types.js';
+// Polyfill helper registry
+export { POLYFILL_HELPER_MAP, filterPolyfillHelpers } from './polyfill-helper-registry.js';
+// Shared string-method lowering (used by all platform strategies)
+export { STRING_METHODS, STRING_METHOD_NAMES, applyStringMethodRewrites } from './string-method-registry.js';
+// Runtime helpers
+export { isStringEnum } from './ir-declarations.js';
+// Promise runtime generator (heap-based: ESP32/ESP8266/rp2040/samd/…)
+export { generatePromiseRuntime } from './promise-runtime.js';
+// Heap-free static async runtime generator (AVR / megaavr / no-<vector> targets)
+export { generateStaticAsyncRuntime } from './async-runtime-static.js';