@typecad/expect 1.0.0-alpha.11 → 1.0.0-alpha.13

package/dist/host/compiler.js

@@ -377,8 +377,6 @@ function writeBuildConfig(buildDir, projectRoot, entryFileName, buildTarget, con
         lines.push('  output: {');
         if (baseValues.output?.framework)
             lines.push(`    framework: '${baseValues.output?.framework}',`);
-        if (baseValues.output?.optimize)
-            lines.push(`    optimize: '${baseValues.output?.optimize}',`);
         lines.push(`    outDir: './out',`);
         lines.push('  },');
         if (baseValues.console?.baudRate) {

package/dist/host/config.d.ts

@@ -24,7 +24,6 @@ export interface RawConfig {
     test?: Partial<TestConfig>;
     output?: {
         framework?: string;
-        optimize?: string;
         outDir?: string;
     };
     console?: {

package/dist/host/config.js

@@ -79,6 +79,60 @@ function findConfigFile(projectRoot) {
     ];
     return candidates.find(c => fs.existsSync(c));
 }
+/** Unwrap `as const` / `satisfies T` / parenthesized wrappers so initializers
+ *  like `const config = {...} satisfies CuttlefishConfig` still parse. */
+function unwrapExpr(node) {
+    let curr = node;
+    for (;;) {
+        if (ts.isAsExpression(curr) || ts.isTypeAssertionExpression(curr) || ts.isParenthesizedExpression(curr)) {
+            curr = curr.expression;
+            continue;
+        }
+        // satisfies is TS ≥4.9 — guard for older typings, then cast for .expression.
+        const isSatisfies = ts.isSatisfiesExpression;
+        if (typeof isSatisfies === 'function' && isSatisfies(curr)) {
+            curr = curr.expression;
+            continue;
+        }
+        return curr;
+    }
+}
+/** Property key as plain text — accepts both `target:` and `'target':` forms. */
+function propName(prop) {
+    const name = prop.name;
+    if (name && (ts.isIdentifier(name) || ts.isStringLiteral(name)))
+        return name.text;
+    return undefined;
+}
+/** String-literal (or plain template-literal) text, through as-cast wrappers. */
+function stringLikeText(node) {
+    const curr = unwrapExpr(node);
+    return (ts.isStringLiteral(curr) || ts.isNoSubstitutionTemplateLiteral(curr))
+        ? curr.text
+        : undefined;
+}
+/** Numeric literal via Number() so hex (0x38), decimals, and separators parse
+ *  correctly — parseInt(text, 10) silently corrupted hex values to 0. */
+function numericValue(node) {
+    const curr = unwrapExpr(node);
+    if (ts.isNumericLiteral(curr))
+        return Number(curr.text);
+    if (ts.isPrefixUnaryExpression(curr)
+        && (curr.operator === ts.SyntaxKind.MinusToken || curr.operator === ts.SyntaxKind.PlusToken)
+        && ts.isNumericLiteral(curr.operand)) {
+        const magnitude = Number(curr.operand.text);
+        return curr.operator === ts.SyntaxKind.MinusToken ? -magnitude : magnitude;
+    }
+    return undefined;
+}
+function boolValue(node) {
+    const curr = unwrapExpr(node);
+    if (curr.kind === ts.SyntaxKind.TrueKeyword)
+        return true;
+    if (curr.kind === ts.SyntaxKind.FalseKeyword)
+        return false;
+    return undefined;
+}
 export function parseConfigAST(configPath) {
     const text = fs.readFileSync(configPath, 'utf8');
     const sf = ts.createSourceFile(configPath, text, ts.ScriptTarget.Latest, true);
@@ -87,155 +141,212 @@ export function parseConfigAST(configPath) {
         // `const config: CuttlefishConfig = { ... };`
         if (ts.isVariableStatement(stmt)) {
             for (const decl of stmt.declarationList.declarations) {
-                if (decl.initializer && ts.isObjectLiteralExpression(decl.initializer)) {
-                    extractConfigProperties(decl.initializer, result);
+                const init = decl.initializer ? unwrapExpr(decl.initializer) : undefined;
+                if (init && ts.isObjectLiteralExpression(init)) {
+                    extractConfigProperties(init, result);
                 }
             }
         }
         // `export default { ... };`
-        if (ts.isExportAssignment(stmt) && ts.isObjectLiteralExpression(stmt.expression)) {
-            extractConfigProperties(stmt.expression, result);
+        if (ts.isExportAssignment(stmt)) {
+            const expr = unwrapExpr(stmt.expression);
+            if (ts.isObjectLiteralExpression(expr)) {
+                extractConfigProperties(expr, result);
+            }
         }
     }
     return result;
 }
 function extractConfigProperties(obj, out) {
     for (const prop of obj.properties) {
-        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const name = propName(prop);
+        if (!name)
             continue;
-        const name = prop.name.text;
         switch (name) {
-            case 'target':
-                if (ts.isStringLiteral(prop.initializer))
-                    out.target = prop.initializer.text;
+            case 'target': {
+                const v = stringLikeText(prop.initializer);
+                if (v !== undefined)
+                    out.target = v;
                 break;
-            case 'board':
-                if (ts.isStringLiteral(prop.initializer))
-                    out.board = prop.initializer.text;
+            }
+            case 'board': {
+                const v = stringLikeText(prop.initializer);
+                if (v !== undefined)
+                    out.board = v;
                 break;
-            case 'mcu':
-                if (ts.isStringLiteral(prop.initializer))
-                    out.mcu = prop.initializer.text;
+            }
+            case 'mcu': {
+                const v = stringLikeText(prop.initializer);
+                if (v !== undefined)
+                    out.mcu = v;
                 break;
-            case 'frameworkData':
-                if (ts.isObjectLiteralExpression(prop.initializer)) {
+            }
+            case 'frameworkData': {
+                const init = unwrapExpr(prop.initializer);
+                if (ts.isObjectLiteralExpression(init)) {
                     out.frameworkData = {};
-                    for (const fProp of prop.initializer.properties) {
-                        if (ts.isPropertyAssignment(fProp) && ts.isIdentifier(fProp.name) && fProp.name.text === 'buildTarget') {
-                            if (ts.isStringLiteral(fProp.initializer))
-                                out.frameworkData.buildTarget = fProp.initializer.text;
+                    for (const fProp of init.properties) {
+                        if (ts.isPropertyAssignment(fProp) && propName(fProp) === 'buildTarget') {
+                            const v = stringLikeText(fProp.initializer);
+                            if (v !== undefined)
+                                out.frameworkData.buildTarget = v;
                         }
                     }
                 }
                 break;
-            case 'framework':
-                if (ts.isStringLiteral(prop.initializer))
-                    out.framework = prop.initializer.text;
+            }
+            case 'framework': {
+                const v = stringLikeText(prop.initializer);
+                if (v !== undefined)
+                    out.framework = v;
                 break;
-            case 'toolchain':
-                if (ts.isObjectLiteralExpression(prop.initializer)) {
+            }
+            case 'toolchain': {
+                const init = unwrapExpr(prop.initializer);
+                if (ts.isObjectLiteralExpression(init)) {
                     out.toolchain = {};
-                    for (const tProp of prop.initializer.properties) {
-                        if (ts.isPropertyAssignment(tProp) && tProp.name.getText() === 'type' && ts.isStringLiteral(tProp.initializer)) {
-                            out.toolchain.type = tProp.initializer.text;
+                    for (const tProp of init.properties) {
+                        if (ts.isPropertyAssignment(tProp) && propName(tProp) === 'type') {
+                            const v = stringLikeText(tProp.initializer);
+                            if (v !== undefined)
+                                out.toolchain.type = v;
                         }
                     }
                 }
                 break;
-            case 'zephyr':
+            }
+            case 'zephyr': {
                 // Parse the zephyr section (kconfig, runner, cmakeArgs) as a generic
                 // object so it can be passed through to the Zephyr toolchain.
-                if (ts.isObjectLiteralExpression(prop.initializer)) {
+                const init = unwrapExpr(prop.initializer);
+                if (ts.isObjectLiteralExpression(init)) {
                     out.zephyr = {};
-                    for (const zProp of prop.initializer.properties) {
-                        if (ts.isPropertyAssignment(zProp)) {
-                            const key = zProp.name.getText();
-                            if (ts.isObjectLiteralExpression(zProp.initializer)) {
-                                // kconfig: { 'CONFIG_X': 'y' }
-                                const sub = {};
-                                for (const subProp of zProp.initializer.properties) {
-                                    if (ts.isPropertyAssignment(subProp) && ts.isStringLiteral(subProp.initializer)) {
-                                        sub[subProp.name.getText().replace(/['"]/g, '')] = subProp.initializer.text;
-                                    }
-                                }
-                                out.zephyr[key] = sub;
-                            }
-                            else if (ts.isStringLiteral(zProp.initializer)) {
-                                out.zephyr[key] = zProp.initializer.text;
+                    for (const zProp of init.properties) {
+                        if (!ts.isPropertyAssignment(zProp))
+                            continue;
+                        const key = propName(zProp);
+                        if (!key)
+                            continue;
+                        const zInit = unwrapExpr(zProp.initializer);
+                        if (ts.isObjectLiteralExpression(zInit)) {
+                            // kconfig: { 'CONFIG_X': 'y' }
+                            const sub = {};
+                            for (const subProp of zInit.properties) {
+                                if (!ts.isPropertyAssignment(subProp))
+                                    continue;
+                                const subKey = propName(subProp);
+                                const v = stringLikeText(subProp.initializer);
+                                if (subKey !== undefined && v !== undefined)
+                                    sub[subKey] = v;
                             }
+                            out.zephyr[key] = sub;
+                        }
+                        else {
+                            const v = stringLikeText(zInit);
+                            if (v !== undefined)
+                                out.zephyr[key] = v;
                         }
                     }
                 }
                 break;
-            case 'test':
-                if (ts.isObjectLiteralExpression(prop.initializer)) {
-                    out.test = extractTestConfig(prop.initializer);
+            }
+            case 'test': {
+                const init = unwrapExpr(prop.initializer);
+                if (ts.isObjectLiteralExpression(init)) {
+                    out.test = extractTestConfig(init);
                 }
                 break;
-            case 'output':
-                if (ts.isObjectLiteralExpression(prop.initializer)) {
-                    out.output = extractOutputConfig(prop.initializer);
+            }
+            case 'output': {
+                const init = unwrapExpr(prop.initializer);
+                if (ts.isObjectLiteralExpression(init)) {
+                    out.output = extractOutputConfig(init);
                 }
                 break;
-            case 'console':
-                if (ts.isObjectLiteralExpression(prop.initializer)) {
-                    out.console = extractConsoleConfig(prop.initializer);
+            }
+            case 'console': {
+                const init = unwrapExpr(prop.initializer);
+                if (ts.isObjectLiteralExpression(init)) {
+                    out.console = extractConsoleConfig(init);
                 }
                 break;
+            }
         }
     }
 }
 function extractTestConfig(obj) {
     const result = {};
     for (const prop of obj.properties) {
-        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const name = propName(prop);
+        if (!name)
             continue;
-        const name = prop.name.text;
         switch (name) {
-            case 'port':
-                if (ts.isStringLiteral(prop.initializer))
-                    result.port = prop.initializer.text;
+            case 'port': {
+                const v = stringLikeText(prop.initializer);
+                if (v !== undefined)
+                    result.port = v;
                 break;
-            case 'baudRate':
-                if (ts.isNumericLiteral(prop.initializer))
-                    result.baudRate = parseInt(prop.initializer.text, 10);
+            }
+            case 'baudRate': {
+                const v = numericValue(prop.initializer);
+                if (v !== undefined)
+                    result.baudRate = v;
                 break;
-            case 'timeout':
-                if (ts.isNumericLiteral(prop.initializer))
-                    result.timeout = parseInt(prop.initializer.text, 10);
+            }
+            case 'timeout': {
+                const v = numericValue(prop.initializer);
+                if (v !== undefined)
+                    result.timeout = v;
+                break;
+            }
+            case 'serialOpenDelay': {
+                const v = numericValue(prop.initializer);
+                if (v !== undefined)
+                    result.serialOpenDelay = v;
                 break;
-            case 'serialOpenDelay':
-                if (ts.isNumericLiteral(prop.initializer))
-                    result.serialOpenDelay = parseInt(prop.initializer.text, 10);
+            }
+            case 'buildTarget': {
+                const v = stringLikeText(prop.initializer);
+                if (v !== undefined)
+                    result.buildTarget = v;
                 break;
-            case 'buildTarget':
-                if (ts.isStringLiteral(prop.initializer))
-                    result.buildTarget = prop.initializer.text;
+            }
+            case 'resetAfterOpen': {
+                const v = boolValue(prop.initializer);
+                if (v !== undefined)
+                    result.resetAfterOpen = v;
                 break;
-            case 'resetAfterOpen':
-                if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword)
-                    result.resetAfterOpen = true;
-                if (prop.initializer.kind === ts.SyntaxKind.FalseKeyword)
-                    result.resetAfterOpen = false;
+            }
+            case 'verbose': {
+                const v = boolValue(prop.initializer);
+                if (v !== undefined)
+                    result.verbose = v;
                 break;
-            case 'board':
-                if (ts.isStringLiteral(prop.initializer))
-                    result.board = prop.initializer.text;
+            }
+            case 'board': {
+                const v = stringLikeText(prop.initializer);
+                if (v !== undefined)
+                    result.board = v;
                 break;
+            }
             case 'include':
-                if (ts.isArrayLiteralExpression(prop.initializer)) {
-                    result.include = prop.initializer.elements
-                        .filter(ts.isStringLiteral)
-                        .map(el => el.text);
-                }
-                break;
-            case 'exclude':
-                if (ts.isArrayLiteralExpression(prop.initializer)) {
-                    result.exclude = prop.initializer.elements
-                        .filter(ts.isStringLiteral)
-                        .map(el => el.text);
+            case 'exclude': {
+                const init = unwrapExpr(prop.initializer);
+                if (ts.isArrayLiteralExpression(init)) {
+                    const values = init.elements
+                        .map(el => stringLikeText(el))
+                        .filter((v) => v !== undefined);
+                    if (name === 'include')
+                        result.include = values;
+                    else
+                        result.exclude = values;
                 }
                 break;
+            }
         }
     }
     return result;
@@ -243,25 +354,30 @@ function extractTestConfig(obj) {
 function extractOutputConfig(obj) {
     const result = {};
     for (const prop of obj.properties) {
-        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const name = propName(prop);
+        if (!name)
+            continue;
+        const v = stringLikeText(prop.initializer);
+        if (v === undefined)
             continue;
-        const name = prop.name.text;
-        if (name === 'framework' && ts.isStringLiteral(prop.initializer))
-            result.framework = prop.initializer.text;
-        if (name === 'optimize' && ts.isStringLiteral(prop.initializer))
-            result.optimize = prop.initializer.text;
-        if (name === 'outDir' && ts.isStringLiteral(prop.initializer))
-            result.outDir = prop.initializer.text;
+        if (name === 'framework')
+            result.framework = v;
+        if (name === 'outDir')
+            result.outDir = v;
     }
     return result;
 }
 function extractConsoleConfig(obj) {
     const result = {};
     for (const prop of obj.properties) {
-        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+        if (!ts.isPropertyAssignment(prop))
             continue;
-        if (prop.name.text === 'baudRate' && ts.isNumericLiteral(prop.initializer)) {
-            result.baudRate = parseInt(prop.initializer.text, 10);
+        if (propName(prop) === 'baudRate') {
+            const v = numericValue(prop.initializer);
+            if (v !== undefined)
+                result.baudRate = v;
         }
     }
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typecad/expect",
-  "version": "1.0.0-alpha.11",
+  "version": "1.0.0-alpha.13",
   "description": "Hardware test framework for TypeCAD — vitest-style assertions over serial",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,10 +40,13 @@
   "dependencies": {
     "typescript": "^5.7.3",
     "serialport": "^12.0.0",
-    "@typecad/arduino-cli": "1.0.0-alpha.11"
+    "@typecad/arduino-cli": "1.0.0-alpha.13",
+    "@typecad/hal": "1.0.0-alpha.13"
+  },
+  "optionalDependencies": {
+    "@typecad/framework-zephyr": "1.0.0-alpha.13"
   },
   "devDependencies": {
-    "@typecad/cuttlefish": "1.0.0-alpha.11",
     "@types/node": "^22.10.7"
   },
   "license": "MIT",