@barefootjs/test 0.1.2 → 0.1.3

package/dist/index.js

@@ -187670,6 +187670,7 @@ function createAnalyzerContext(sourceFile, filePath) {
     jsxConstants: new Map,
     inlineableJsxConsts: new Map,
     jsxFunctions: new Map,
+    jsxMultiReturnFunctions: new Map,
     reactiveFactories: new Map,
     signalTupleRefs: new Map,
     propsType: null,
@@ -187801,20 +187802,11 @@ init_path();
 var ErrorCodes = {
   MISSING_USE_CLIENT: "BF001",
   CLIENT_IMPORTING_SERVER: "BF003",
-  UNKNOWN_SIGNAL: "BF010",
   SIGNAL_OUTSIDE_COMPONENT: "BF011",
-  INVALID_SIGNAL_USAGE: "BF012",
-  INVALID_JSX_EXPRESSION: "BF020",
   UNSUPPORTED_JSX_PATTERN: "BF021",
-  INVALID_JSX_ATTRIBUTE: "BF022",
   MISSING_KEY_IN_LIST: "BF023",
   MISSING_KEY_IN_NESTED_LIST: "BF024",
   UNSUPPORTED_DESTRUCTURE_REST: "BF025",
-  TYPE_INFERENCE_FAILED: "BF030",
-  PROPS_TYPE_MISMATCH: "BF031",
-  COMPONENT_NOT_FOUND: "BF040",
-  CIRCULAR_DEPENDENCY: "BF041",
-  INVALID_COMPONENT_NAME: "BF042",
   PROPS_DESTRUCTURING: "BF043",
   SIGNAL_GETTER_NOT_CALLED: "BF044",
   JSX_IN_LOCAL_FUNCTION: "BF045",
@@ -187833,20 +187825,11 @@ var ErrorCodes = {
 var errorMessages = {
   [ErrorCodes.MISSING_USE_CLIENT]: "'use client' directive required for components with createSignal or event handlers",
   [ErrorCodes.CLIENT_IMPORTING_SERVER]: "Client component cannot import server component",
-  [ErrorCodes.UNKNOWN_SIGNAL]: "Unknown signal reference",
   [ErrorCodes.SIGNAL_OUTSIDE_COMPONENT]: "Module-level reactive declaration (createSignal / createMemo) is not allowed. " + "The downstream codegen drops the declaration silently and every reference becomes a ReferenceError at SSR and at hydrate. " + "Move the declaration inside a component function so each mount gets its own state.",
-  [ErrorCodes.INVALID_SIGNAL_USAGE]: "Invalid signal usage",
-  [ErrorCodes.INVALID_JSX_EXPRESSION]: "Invalid JSX expression",
   [ErrorCodes.UNSUPPORTED_JSX_PATTERN]: "Unsupported JSX pattern",
-  [ErrorCodes.INVALID_JSX_ATTRIBUTE]: "Invalid JSX attribute",
   [ErrorCodes.MISSING_KEY_IN_LIST]: "Missing key attribute in list rendering. Add a key prop for efficient updates",
   [ErrorCodes.MISSING_KEY_IN_NESTED_LIST]: "Nested .map() loop requires key attribute for event delegation. Add a key prop to elements in the inner loop",
   [ErrorCodes.UNSUPPORTED_DESTRUCTURE_REST]: "Computed property key in .map() callback destructure is not supported. Rewrite the callback to destructure explicit bindings (e.g., `({ a, b }) => ...`) so the compiler can rewrite references to per-item signal accessors.",
-  [ErrorCodes.TYPE_INFERENCE_FAILED]: "Failed to infer type",
-  [ErrorCodes.PROPS_TYPE_MISMATCH]: "Props type mismatch",
-  [ErrorCodes.COMPONENT_NOT_FOUND]: "Component not found",
-  [ErrorCodes.CIRCULAR_DEPENDENCY]: "Circular dependency detected",
-  [ErrorCodes.INVALID_COMPONENT_NAME]: "Component name must start with uppercase letter",
   [ErrorCodes.PROPS_DESTRUCTURING]: "Props destructuring in function parameters breaks reactivity. Use props object directly.",
   [ErrorCodes.SIGNAL_GETTER_NOT_CALLED]: "Signal/memo getter passed without calling it. Use getter() to read the value.",
   [ErrorCodes.JSX_IN_LOCAL_FUNCTION]: "Local function returns JSX but cannot be inlined. Extract it as a top-level PascalCase component or use a single return statement.",
@@ -187858,7 +187841,7 @@ var errorMessages = {
   [ErrorCodes.STRIPPED_CLIENT_IMPORT_REFERENCED]: "Import was stripped from the client bundle but its binding is still referenced. Client components ('use client' .tsx) are not callable as plain functions from imperative .ts modules — render them as JSX from a 'use client' parent instead. If the flagged name is a local shadow rather than the stripped import, please file an issue.",
   [ErrorCodes.STAGE_REACTIVE_IN_TEMPLATE]: "Reactive binding (signal getter or memo) referenced from template scope. The template lambda runs at module scope without the reactive context, so the value cannot be evaluated at SSR. Wrap the JSX expression in /* @client */ to defer it to hydrate, or restructure so the template uses a prop or static value.",
   [ErrorCodes.STAGE_INIT_LOCAL_IN_TEMPLATE]: "Init-scope local referenced from template scope. The template lambda runs at module scope (via render() / renderChild()) and cannot reach init-body locals. Wrap the JSX expression in /* @client */, or lift the value to a prop or module-scope const.",
-  [ErrorCodes.STAGE_AWAIT_IN_TEMPLATE]: "AwaitExpression in template scope. The hydrate-time template lambda is synchronous; awaiting here would hang first render. Move the await into a server-side handler and pass the resolved value as a prop.",
+  [ErrorCodes.STAGE_AWAIT_IN_TEMPLATE]: "AwaitExpression in template scope. The generated template and init functions are synchronous — a bare `await` produces a SyntaxError at parse time. Move the await into the component body (before the return) or into an onMount/effect callback, and pass the resolved value to JSX.",
   [ErrorCodes.INLINE_JSX_CALLBACK_CAPTURE]: "Inline JSX-returning arrow function captures a non-module identifier. Extract the callback into a top-level 'use client' component (e.g. `function MyNode(n) { return <div/> }` then `renderNode={MyNode}`) or pass captured values via component props.",
   [ErrorCodes.UNRECOGNIZED_REACTIVE_FACTORY]: "Tuple destructuring of a non-reactive factory call. The compiler only recognizes createSignal / createMemo calls and same-file helpers that wrap them with a single `return [a, b]` exit."
 };
@@ -188947,6 +188930,139 @@ function extractSingleJsxReturn(body) {
     return null;
   return jsxReturn;
 }
+function extractMultiReturnJsxBranches(body) {
+  const branches = [];
+  let fallback = null;
+  const stmts = body.statements;
+  for (let i2 = 0;i2 < stmts.length; i2++) {
+    const stmt = stmts[i2];
+    if (import_typescript6.default.isIfStatement(stmt)) {
+      let current = stmt;
+      while (import_typescript6.default.isIfStatement(current)) {
+        const ifStmt = current;
+        if (!isDirectReturnBlock(ifStmt.thenStatement))
+          return null;
+        const jsxReturn = findJsxReturnInBlock(ifStmt.thenStatement);
+        const nullReturn = findNullReturnInBlock(ifStmt.thenStatement);
+        if (!jsxReturn && !nullReturn)
+          return null;
+        branches.push({ condition: ifStmt.expression, jsxReturn: jsxReturn ?? null });
+        if (ifStmt.elseStatement) {
+          if (import_typescript6.default.isIfStatement(ifStmt.elseStatement)) {
+            current = ifStmt.elseStatement;
+            continue;
+          }
+          if (!isDirectReturnBlock(ifStmt.elseStatement))
+            return null;
+          const elseJsx = findJsxReturnInBlock(ifStmt.elseStatement);
+          if (elseJsx) {
+            fallback = elseJsx;
+          } else if (!findNullReturnInBlock(ifStmt.elseStatement)) {
+            return null;
+          }
+          if (branches.length === 0)
+            return null;
+          return { branches, fallback };
+        }
+        break;
+      }
+      continue;
+    }
+    if (import_typescript6.default.isSwitchStatement(stmt)) {
+      if (branches.length > 0)
+        return null;
+      if (!import_typescript6.default.isIdentifier(stmt.expression) && !import_typescript6.default.isPropertyAccessExpression(stmt.expression)) {
+        return null;
+      }
+      const hasDefault = stmt.caseBlock.clauses.some((c) => import_typescript6.default.isDefaultClause(c));
+      if (!hasDefault)
+        return null;
+      for (const clause of stmt.caseBlock.clauses) {
+        const jsxReturn = findJsxReturnInCaseClause(clause);
+        const nullReturn = findNullReturnInCaseClause(clause);
+        if (!jsxReturn && !nullReturn)
+          return null;
+        if (import_typescript6.default.isCaseClause(clause)) {
+          branches.push({
+            condition: clause.expression,
+            jsxReturn: jsxReturn ?? null
+          });
+        } else {
+          fallback = jsxReturn ?? null;
+        }
+      }
+      if (branches.length === 0)
+        return null;
+      return { branches, fallback, switchDiscriminant: stmt.expression };
+    }
+    if (import_typescript6.default.isReturnStatement(stmt) && stmt.expression) {
+      const expr = unwrapJsxTransparent(stmt.expression);
+      if (import_typescript6.default.isJsxElement(expr) || import_typescript6.default.isJsxSelfClosingElement(expr) || import_typescript6.default.isJsxFragment(expr)) {
+        fallback = expr;
+      } else if (expr.kind === import_typescript6.default.SyntaxKind.NullKeyword) {} else {
+        return null;
+      }
+      continue;
+    }
+    if (import_typescript6.default.isVariableStatement(stmt))
+      return null;
+    return null;
+  }
+  if (branches.length === 0)
+    return null;
+  return { branches, fallback };
+}
+function isDirectReturnBlock(node) {
+  if (import_typescript6.default.isReturnStatement(node))
+    return true;
+  if (import_typescript6.default.isBlock(node)) {
+    let returnCount = 0;
+    for (const stmt of node.statements) {
+      if (import_typescript6.default.isReturnStatement(stmt)) {
+        returnCount++;
+      } else if (import_typescript6.default.isIfStatement(stmt) || import_typescript6.default.isSwitchStatement(stmt) || import_typescript6.default.isForStatement(stmt) || import_typescript6.default.isForOfStatement(stmt) || import_typescript6.default.isForInStatement(stmt) || import_typescript6.default.isWhileStatement(stmt) || import_typescript6.default.isDoStatement(stmt) || import_typescript6.default.isTryStatement(stmt)) {
+        return false;
+      }
+    }
+    return returnCount === 1;
+  }
+  return false;
+}
+function findNullReturnInBlock(node) {
+  if (import_typescript6.default.isBlock(node)) {
+    for (const stmt of node.statements) {
+      if (import_typescript6.default.isReturnStatement(stmt) && stmt.expression) {
+        const expr = unwrapJsxTransparent(stmt.expression);
+        if (expr.kind === import_typescript6.default.SyntaxKind.NullKeyword)
+          return true;
+      }
+    }
+  }
+  if (import_typescript6.default.isReturnStatement(node) && node.expression) {
+    const expr = unwrapJsxTransparent(node.expression);
+    if (expr.kind === import_typescript6.default.SyntaxKind.NullKeyword)
+      return true;
+  }
+  return false;
+}
+function findJsxReturnInCaseClause(clause) {
+  for (const stmt of clause.statements) {
+    if (import_typescript6.default.isReturnStatement(stmt) && stmt.expression) {
+      return extractJsxFromExpression(stmt.expression);
+    }
+  }
+  return null;
+}
+function findNullReturnInCaseClause(clause) {
+  for (const stmt of clause.statements) {
+    if (import_typescript6.default.isReturnStatement(stmt) && stmt.expression) {
+      const expr = unwrapJsxTransparent(stmt.expression);
+      if (expr.kind === import_typescript6.default.SyntaxKind.NullKeyword)
+        return true;
+    }
+  }
+  return false;
+}
 function isMultiReturnJsxFunctionBody(body) {
   let returnCount = 0;
   let hasJsxReturn = false;
@@ -189030,6 +189146,15 @@ function collectFunction(node, ctx, _isModule, isExported = false) {
         jsxReturn,
         params: node.parameters.map((p) => p.name.getText(ctx.sourceFile))
       });
+    } else {
+      const multi = extractMultiReturnJsxBranches(node.body);
+      if (multi) {
+        isJsxFunction = true;
+        ctx.jsxMultiReturnFunctions.set(name, {
+          ...multi,
+          params: node.parameters.map((p) => p.name.getText(ctx.sourceFile))
+        });
+      }
     }
   }
   const isAsync = node.modifiers?.some((m) => m.kind === import_typescript6.default.SyntaxKind.AsyncKeyword) ?? false;
@@ -189282,6 +189407,15 @@ function collectConstant(node, ctx, _isModule, declarationKind = "const", isExpo
             jsxReturn,
             params: init.parameters.map((p) => p.name.getText(ctx.sourceFile))
           });
+        } else {
+          const multi = extractMultiReturnJsxBranches(arrowBody);
+          if (multi) {
+            isJsxFunction = true;
+            ctx.jsxMultiReturnFunctions.set(name, {
+              ...multi,
+              params: init.parameters.map((p) => p.name.getText(ctx.sourceFile))
+            });
+          }
         }
       } else {
         let body = arrowBody;
@@ -189541,7 +189675,7 @@ function inferTypeFromValue(value) {
   if (/\.(some|every|includes)\s*\([\s\S]*\)\s*$/.test(trimmed)) {
     return { kind: "primitive", raw: "boolean", primitive: "boolean" };
   }
-  if (/\.(indexOf|findIndex|lastIndexOf)\s*\([\s\S]*\)\s*$/.test(trimmed)) {
+  if (/\.(indexOf|findIndex|findLastIndex|lastIndexOf)\s*\([\s\S]*\)\s*$/.test(trimmed)) {
     return { kind: "primitive", raw: "number", primitive: "number" };
   }
   if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
@@ -190144,8 +190278,6 @@ var UNSUPPORTED_METHODS = new Set([
   "reduceRight",
   "every",
   "some",
-  "findLast",
-  "findLastIndex",
   "forEach",
   "flatMap",
   "flat"
@@ -190188,7 +190320,7 @@ function convertNode(node, raw) {
   if (import_typescript7.default.isCallExpression(node)) {
     const callee = convertNode(node.expression, raw);
     const args = node.arguments.map((arg) => convertNode(arg, raw));
-    if (callee.kind === "member" && ["filter", "every", "some", "find", "findIndex"].includes(callee.property)) {
+    if (callee.kind === "member" && ["filter", "every", "some", "find", "findIndex", "findLast", "findLastIndex"].includes(callee.property)) {
       if (args.length === 1 && args[0].kind === "arrow-fn") {
         const arrowFn = args[0];
         return {
@@ -192035,6 +192167,18 @@ function transformExpressionInner(expr, ctx, node, isClientOnly) {
     }
     return ir;
   }
+  if (containsAwaitExpression(expr)) {
+    ctx.analyzer.errors.push(createError(ErrorCodes.STAGE_AWAIT_IN_TEMPLATE, getSourceLocation(expr, ctx.sourceFile, ctx.filePath)));
+    return {
+      type: "expression",
+      expr: "undefined",
+      typeInfo: null,
+      reactive: false,
+      slotId: null,
+      loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath),
+      origin: { phase: "tick", scope: "template", effect: "pure", freeRefs: [] }
+    };
+  }
   const exprText = ctx.getJS(expr);
   const freeRefs = resolveFreeRefs(expr, makeBindingEnv(ctx));
   const origin = {
@@ -192106,6 +192250,97 @@ function transformJsxFunctionCall(callExpr, jsxFunc, ctx, _isClientOnly) {
     ctx.analyzer.getJS = originalAnalyzerGetJS;
   }
 }
+function transformMultiReturnJsxFunctionCall(callExpr, info, ctx) {
+  const substitutions = new Map;
+  for (let i2 = 0;i2 < info.params.length; i2++) {
+    const paramName = info.params[i2];
+    const arg = callExpr.arguments[i2];
+    if (arg) {
+      substitutions.set(paramName, ctx.getJS(arg));
+    }
+  }
+  const baseGetJS = ctx.analyzer.getJS.bind(ctx.analyzer);
+  const originalCtxGetJS = ctx.getJS;
+  const originalAnalyzerGetJS = ctx.analyzer.getJS;
+  const substitutedGetJS = (node) => {
+    let text = baseGetJS(node);
+    for (const [paramName, argExpr] of substitutions) {
+      text = text.replace(new RegExp(`\\b${paramName}\\b`, "g"), argExpr);
+    }
+    return text;
+  };
+  ctx.getJS = substitutedGetJS;
+  ctx.analyzer.getJS = substitutedGetJS;
+  try {
+    const loc = getSourceLocation(callExpr, ctx.sourceFile, ctx.filePath);
+    const nullExpr = {
+      type: "expression",
+      expr: "null",
+      typeInfo: { kind: "primitive", raw: "null", primitive: "null" },
+      reactive: false,
+      slotId: null,
+      loc,
+      origin: { phase: "tick", scope: "template", effect: "pure", freeRefs: [] }
+    };
+    let result = info.fallback ? transformNode(info.fallback, ctx) ?? nullExpr : nullExpr;
+    for (let i2 = info.branches.length - 1;i2 >= 0; i2--) {
+      const branch = info.branches[i2];
+      let conditionText;
+      if (info.switchDiscriminant) {
+        const discText = substitutedGetJS(info.switchDiscriminant);
+        const caseText = substitutedGetJS(branch.condition);
+        conditionText = `${discText} === ${caseText}`;
+      } else {
+        conditionText = substitutedGetJS(branch.condition);
+      }
+      const env = makeBindingEnv(ctx);
+      const caseFreeRefs = resolveFreeRefs(branch.condition, env);
+      const discFreeRefs = info.switchDiscriminant ? resolveFreeRefs(info.switchDiscriminant, env) : [];
+      const conditionOrigin = {
+        phase: "tick",
+        scope: "template",
+        effect: "pure",
+        freeRefs: [...discFreeRefs, ...caseFreeRefs]
+      };
+      const reactive = isReactiveExpression(conditionText, ctx, branch.condition) || isReactiveOrigin(conditionOrigin);
+      const loopParamReactive = !reactive && referencesLoopParam(conditionText, ctx);
+      const callsReactive = exprCallsReactiveGetters(branch.condition, ctx) || (info.switchDiscriminant ? exprCallsReactiveGetters(info.switchDiscriminant, ctx) : false);
+      const hasCalls = exprHasFunctionCalls(branch.condition) || (info.switchDiscriminant ? exprHasFunctionCalls(info.switchDiscriminant) : false);
+      const needsSlot = reactive || loopParamReactive || callsReactive || hasCalls;
+      const slotId = needsSlot ? generateSlotId(ctx) : null;
+      const whenTrue = branch.jsxReturn ? transformNode(branch.jsxReturn, ctx) ?? nullExpr : nullExpr;
+      let templateCondition;
+      if (info.switchDiscriminant) {
+        const discRewritten = rewriteBarePropRefs2(substitutedGetJS(info.switchDiscriminant), info.switchDiscriminant, ctx);
+        const caseRewritten = rewriteBarePropRefs2(substitutedGetJS(branch.condition), branch.condition, ctx);
+        const discPart = discRewritten ?? substitutedGetJS(info.switchDiscriminant);
+        const casePart = caseRewritten ?? substitutedGetJS(branch.condition);
+        templateCondition = `${discPart} === ${casePart}`;
+      } else {
+        templateCondition = rewriteBarePropRefs2(conditionText, branch.condition, ctx);
+      }
+      const conditional = {
+        type: "conditional",
+        condition: conditionText,
+        templateCondition,
+        conditionType: null,
+        reactive,
+        whenTrue,
+        whenFalse: result,
+        slotId,
+        callsReactiveGetters: callsReactive || undefined,
+        hasFunctionCalls: hasCalls || undefined,
+        loc,
+        origin: conditionOrigin
+      };
+      result = conditional;
+    }
+    return result;
+  } finally {
+    ctx.getJS = originalCtxGetJS;
+    ctx.analyzer.getJS = originalAnalyzerGetJS;
+  }
+}
 function transformConditional(node, ctx) {
   const condition = ctx.getJS(node.condition);
   const conditionOrigin = {
@@ -192187,6 +192422,13 @@ function containsJsxInExpression(node) {
   }
   return import_typescript10.default.forEachChild(node, containsJsxInExpression) ?? false;
 }
+function containsAwaitExpression(node) {
+  if (import_typescript10.default.isAwaitExpression(node))
+    return true;
+  if (import_typescript10.default.isFunctionDeclaration(node) || import_typescript10.default.isFunctionExpression(node) || import_typescript10.default.isArrowFunction(node))
+    return false;
+  return import_typescript10.default.forEachChild(node, containsAwaitExpression) ?? false;
+}
 function transformNullishCoalescing(node, ctx) {
   const leftText = ctx.getJS(node.left);
   const isNullish = node.operatorToken.kind === import_typescript10.default.SyntaxKind.QuestionQuestionToken;
@@ -192277,6 +192519,10 @@ function transformJsxExpression(expr, ctx, isClientOnly = false) {
         if (jsxFunc) {
           return transformJsxFunctionCall(node, jsxFunc, ctx, isClientOnly);
         }
+        const multiJsxFunc = ctx.analyzer.jsxMultiReturnFunctions.get(callee.text);
+        if (multiJsxFunc) {
+          return transformMultiReturnJsxFunctionCall(node, multiJsxFunc, ctx);
+        }
       }
       return null;
     }
@@ -192313,6 +192559,16 @@ function transformJsxExpression(expr, ctx, isClientOnly = false) {
     case import_typescript10.default.SyntaxKind.ArrayLiteralExpression:
       return null;
     case import_typescript10.default.SyntaxKind.AwaitExpression:
+      ctx.analyzer.errors.push(createError(ErrorCodes.STAGE_AWAIT_IN_TEMPLATE, getSourceLocation(node, ctx.sourceFile, ctx.filePath)));
+      return {
+        type: "expression",
+        expr: "undefined",
+        typeInfo: null,
+        reactive: false,
+        slotId: null,
+        loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath),
+        origin: { phase: "tick", scope: "template", effect: "pure", freeRefs: [] }
+      };
     case import_typescript10.default.SyntaxKind.YieldExpression:
       return null;
     case import_typescript10.default.SyntaxKind.SpreadElement:
@@ -192964,7 +193220,8 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   const bodyIsMultiRoot = loopBodyIsMultiRoot(children);
   const callsReactive = exprCallsReactiveGetters(arrayExpr, ctx);
   const hasCalls = exprHasFunctionCalls(arrayExpr);
-  const isStaticArray = !isSignalOrMemoArray(array, ctx) && !hasCalls;
+  const isDirectPropArray = method !== "flatMap" && isArrayExprDirectPropRef(arrayExpr, ctx);
+  const isStaticArray = !isSignalOrMemoArray(array, ctx) && !isDirectPropArray && !hasCalls;
   const nestedComponents = collectNestedComponents(children).filter((c) => c.name !== childComponent?.name);
   return {
     type: "loop",
@@ -192980,6 +193237,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     slotId: null,
     markerId: `l${ctx.loopMarkerCounter++}`,
     isStaticArray,
+    isPropDerivedArray: isDirectPropArray || undefined,
     callsReactiveGetters: callsReactive || undefined,
     hasFunctionCalls: hasCalls || undefined,
     bodyIsMultiRoot: bodyIsMultiRoot || undefined,
@@ -193239,6 +193497,10 @@ function getAttributeValue(attr, ctx) {
         expr = branchInit;
       }
     }
+    if (import_typescript10.default.isAwaitExpression(expr)) {
+      ctx.analyzer.errors.push(createError(ErrorCodes.STAGE_AWAIT_IN_TEMPLATE, getSourceLocation(expr, ctx.sourceFile, ctx.filePath)));
+      return AttrValueOf.expression("undefined");
+    }
     checkBareSignalOrMemoIdentifier(expr, ctx);
     if (attr.name.getText(ctx.sourceFile) === "style" && import_typescript10.default.isObjectLiteralExpression(expr)) {
       const cssString = tryStaticStyleObjectToCss(expr);
@@ -193560,6 +193822,20 @@ function checkBareSignalOrMemoIdentifier(expr, ctx) {
     }
   }
 }
+function isArrayExprDirectPropRef(arrayExpr, ctx) {
+  const propNames = new Set(ctx.patterns.props.map((p) => p.name));
+  const propsObjName = ctx.analyzer.propsObjectName;
+  if (import_typescript10.default.isIdentifier(arrayExpr)) {
+    return propNames.has(arrayExpr.text);
+  }
+  if (import_typescript10.default.isPropertyAccessExpression(arrayExpr) && propsObjName) {
+    const obj = arrayExpr.expression;
+    if (import_typescript10.default.isIdentifier(obj) && obj.text === propsObjName) {
+      return true;
+    }
+  }
+  return false;
+}
 function isSignalOrMemoArray(array, ctx) {
   for (const { pattern } of ctx.patterns.signals) {
     if (pattern.test(array))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/test",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Test utilities for BarefootJS - IR-based component testing without a browser",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "directory": "packages/test"
   },
   "dependencies": {
-    "@barefootjs/jsx": "0.1.2"
+    "@barefootjs/jsx": "0.1.3"
   },
   "devDependencies": {
     "typescript": "^5.0.0"