@typecad/cuttlefish 0.1.0-alpha.1

package/dist/ir/extract-property-chain.d.ts

@@ -0,0 +1,10 @@
+import type { ExpressionIR } from "../api/index.js";
+/**
+ * Walk a nested `property-access` ExpressionIR and return the flat chain of
+ * identifiers, e.g. `Board.definition.memory.flash` →
+ * `['Board', 'definition', 'memory', 'flash']`.
+ *
+ * Returns `undefined` when the expression cannot be represented as a simple
+ * identifier chain (e.g. contains call expressions, computed indices, etc.).
+ */
+export declare function extractPropertyChain(expr: ExpressionIR): string[] | undefined;

package/dist/ir/extract-property-chain.js

@@ -0,0 +1,30 @@
+// ---------------------------------------------------------------------------
+// Extract Property Chain
+//
+// Pure IR utility — recursively walks an ExpressionIR tree to produce a flat
+// string array representing a left-to-right property chain.
+//
+// Example:  Board.definition.memory.flash
+//           → ['Board', 'definition', 'memory', 'flash']
+//
+// Moved from framework-arduino (CP5 decoupling). This function has zero
+// framework-specific logic; it only inspects the IR shape.
+// ---------------------------------------------------------------------------
+/**
+ * Walk a nested `property-access` ExpressionIR and return the flat chain of
+ * identifiers, e.g. `Board.definition.memory.flash` →
+ * `['Board', 'definition', 'memory', 'flash']`.
+ *
+ * Returns `undefined` when the expression cannot be represented as a simple
+ * identifier chain (e.g. contains call expressions, computed indices, etc.).
+ */
+export function extractPropertyChain(expr) {
+    if (expr.kind === "identifier")
+        return [expr.value];
+    if (expr.kind === "property-access") {
+        const base = extractPropertyChain(expr.object);
+        if (base)
+            return [...base, expr.property];
+    }
+    return undefined;
+}

package/dist/ir/feature-prescan.d.ts

@@ -0,0 +1,3 @@
+import ts from "typescript";
+import { Diagnostic } from "../types.js";
+export declare function prescanUnsupportedFeatures(source: ts.SourceFile, sourceText: string): Diagnostic[];

package/dist/ir/feature-prescan.js

@@ -0,0 +1,43 @@
+import ts from "typescript";
+import { makeDiagnostic } from "./ast-node-utils.js";
+import { getKindEntry, checkContextSensitive } from "./feature-registry.js";
+function extractSourceLine(sourceText, line1Indexed) {
+    const lines = sourceText.split("\n");
+    const idx = line1Indexed - 1;
+    if (idx >= 0 && idx < lines.length) {
+        return lines[idx];
+    }
+    return "";
+}
+export function prescanUnsupportedFeatures(source, sourceText) {
+    const diagnostics = [];
+    function severityFor(code, status) {
+        if (status === "approximation" || code === "TS2CPP_APPROXIMATE") {
+            return "warning";
+        }
+        return "error";
+    }
+    function addDiag(position, message, code, hint, status) {
+        const diag = makeDiagnostic(sourceText, position, message, severityFor(code, status), code);
+        if (hint) {
+            diag.hint = hint;
+        }
+        if (diag.line != null) {
+            diag.sourceLine = extractSourceLine(sourceText, diag.line);
+        }
+        diagnostics.push(diag);
+    }
+    function visit(node) {
+        const kindEntry = getKindEntry(node.kind);
+        if (kindEntry) {
+            addDiag(node.pos, kindEntry.message, kindEntry.code, kindEntry.hint, kindEntry.status);
+        }
+        const contextMatch = checkContextSensitive(node, sourceText);
+        if (contextMatch) {
+            addDiag(node.pos, contextMatch.message, contextMatch.code, contextMatch.hint, contextMatch.status);
+        }
+        ts.forEachChild(node, visit);
+    }
+    ts.forEachChild(source, visit);
+    return diagnostics;
+}

package/dist/ir/feature-registry.d.ts

@@ -0,0 +1,30 @@
+import ts from "typescript";
+export type FeatureStatus = "unsupported" | "approximation" | "unsupported-context";
+export interface FeatureEntry {
+    status: FeatureStatus;
+    message: string;
+    hint?: string;
+    code: string;
+    eslint?: {
+        selector: string;
+        message: string;
+    };
+}
+export interface LintRule {
+    selector: string;
+    message: string;
+    source: "kind" | "context";
+    filter?: string;
+}
+export interface DiagnosticMatch {
+    status?: FeatureStatus;
+    message: string;
+    hint?: string;
+    code: string;
+}
+export declare function getKindEntry(kind: ts.SyntaxKind): FeatureEntry | undefined;
+export declare function kindRegistryEntries(): ReadonlyArray<[ts.SyntaxKind, FeatureEntry]>;
+declare const ESLINT_OPT_OUT_KINDS: ReadonlySet<ts.SyntaxKind>;
+export declare const LINT_RULES: ReadonlyArray<LintRule>;
+export { ESLINT_OPT_OUT_KINDS };
+export declare function checkContextSensitive(node: ts.Node, sourceText: string): DiagnosticMatch | null;