@barefootjs/test 0.18.5 → 0.19.0

package/dist/index.js

@@ -189250,6 +189250,32 @@ var VOID_ELEMENTS = new Set([
   "track",
   "wbr"
 ]);
+var SKELETON_PATH_HAZARD_TAGS = new Set([
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "caption",
+  "colgroup",
+  "col",
+  "select",
+  "optgroup",
+  "p",
+  "pre",
+  "textarea",
+  "listing",
+  "template",
+  "math"
+]);
+var SKELETON_PATH_FORCE_CLOSE_GROUPS = [
+  new Set(["a"]),
+  new Set(["button"]),
+  new Set(["form"]),
+  new Set(["option"]),
+  new Set(["h1", "h2", "h3", "h4", "h5", "h6"]),
+  new Set(["dd", "dt"]),
+  new Set(["li"])
+];
 
 // ../jsx/src/prop-rewrite.ts
 function collectAstPropRefs(node, propNames, out) {
@@ -189777,6 +189803,8 @@ function needsTypeBasedDetection(source) {
     return true;
   if (/\.map\s*\(/.test(source))
     return true;
+  if (source.includes("createSelector"))
+    return true;
   return false;
 }
 function findBrandPackageImportLoc(sourceFile, filePath) {
@@ -190753,6 +190781,7 @@ var CLIENT_EXPORTS = new Set([
   "createEffect",
   "createDisposableEffect",
   "createMemo",
+  "createSelector",
   "createRoot",
   "onCleanup",
   "onMount",
@@ -191536,12 +191565,13 @@ function extractProps(param, ctx) {
           continue;
         }
         const sourcePropName = element.propertyName && import_typescript8.default.isIdentifier(element.propertyName) ? element.propertyName.text : localName;
-        const resolvedType = memberTypes?.get(sourcePropName) ?? { kind: "unknown", raw: "unknown" };
+        const member = memberTypes?.get(sourcePropName);
+        const resolvedType = member?.type ?? { kind: "unknown", raw: "unknown" };
         const defaultContainsArrow = element.initializer ? nodeContainsArrow(element.initializer) : false;
         ctx.propsParams.push({
           name: localName,
           type: resolvedType,
-          optional: !!element.initializer,
+          optional: !!member?.optional || !!element.initializer,
           defaultValue,
           defaultContainsArrow: defaultContainsArrow || undefined
         });
@@ -191606,11 +191636,12 @@ function collectMemberTypes(typeNode, ctx) {
   const fromMembers = (members) => {
     const map = new Map;
     for (const member of members) {
-      if (import_typescript8.default.isPropertySignature(member) && member.name && member.type && !member.questionToken) {
-        const info = typeNodeToTypeInfo(member.type, ctx.sourceFile);
-        if (info && isResolvablePrimitive(info)) {
-          map.set(member.name.getText(ctx.sourceFile), info);
-        }
+      if (import_typescript8.default.isPropertySignature(member) && member.name) {
+        const info = member.type ? typeNodeToTypeInfo(member.type, ctx.sourceFile) : null;
+        map.set(member.name.getText(ctx.sourceFile), {
+          type: info && isResolvablePrimitive(info) ? info : null,
+          optional: !!member.questionToken
+        });
       }
     }
     return map;
@@ -192705,9 +192736,15 @@ function exprHasFunctionCalls(expr) {
   return found;
 }
 function rewriteBarePropRefs2(text, expr, ctx) {
-  const propNames = getDestructuredPropNames(ctx);
+  let propNames = getDestructuredPropNames(ctx);
   if (!propNames)
     return;
+  if (ctx.loopParams.size > 0) {
+    const filtered = new Set([...propNames].filter((n) => !ctx.loopParams.has(n)));
+    if (filtered.size === 0)
+      return;
+    propNames = filtered;
+  }
   const extraPropRefs = collectBranchLocalPropRefsViaSubstitution(expr, ctx);
   return rewriteBarePropRefs(text, expr, propNames, extraPropRefs);
 }
@@ -192873,26 +192910,29 @@ function makeBindingEnv(ctx) {
 function parseValueExpr(trimmed) {
   return parseExpression(trimmed.startsWith("{") ? `(${trimmed})` : trimmed);
 }
-function attachParsedExpressions(node) {
+var EMPTY_BOUND = new Set;
+function attachParsedExpressions(node, analyzer, bound = EMPTY_BOUND) {
+  const parse2 = (trimmed) => resolveCallbackMethodFunctionReferences(parseExpression(trimmed), analyzer, bound);
+  const parseValue = (trimmed) => resolveCallbackMethodFunctionReferences(parseValueExpr(trimmed), analyzer, bound);
   if (node.type === "expression") {
     const trimmed = node.expr.trim();
     if (trimmed)
-      node.parsed = parseExpression(trimmed);
+      node.parsed = parse2(trimmed);
   } else if (node.type === "conditional" || node.type === "if-statement") {
     const trimmed = node.condition.trim();
     if (trimmed)
-      node.parsedCondition = parseExpression(trimmed);
+      node.parsedCondition = parse2(trimmed);
   }
   if (node.type === "element") {
     for (const attr of node.attrs) {
       if (attr.value.kind === "expression") {
         const trimmed = attr.value.expr.trim();
         if (trimmed)
-          attr.value.parsed = parseValueExpr(trimmed);
+          attr.value.parsed = parseValue(trimmed);
       } else if (attr.value.kind === "spread") {
         const trimmed = attr.value.expr.trim();
         if (trimmed)
-          attr.value.parsed = parseExpression(trimmed);
+          attr.value.parsed = parse2(trimmed);
       }
     }
   } else if (node.type === "component") {
@@ -192900,14 +192940,14 @@ function attachParsedExpressions(node) {
       if (prop.value.kind === "expression") {
         const trimmed = prop.value.expr.trim();
         if (trimmed)
-          prop.value.parsed = parseValueExpr(trimmed);
+          prop.value.parsed = parseValue(trimmed);
       }
     }
   } else if (node.type === "provider") {
     if (node.valueProp.value.kind === "expression") {
       const trimmed = node.valueProp.value.expr.trim();
       if (trimmed)
-        node.valueProp.value.parsed = parseValueExpr(trimmed);
+        node.valueProp.value.parsed = parseValue(trimmed);
     }
   }
   switch (node.type) {
@@ -192916,47 +192956,51 @@ function attachParsedExpressions(node) {
     case "fragment":
     case "provider":
       for (const child of node.children)
-        attachParsedExpressions(child);
+        attachParsedExpressions(child, analyzer, bound);
       break;
     case "async":
-      attachParsedExpressions(node.fallback);
+      attachParsedExpressions(node.fallback, analyzer, bound);
       for (const child of node.children)
-        attachParsedExpressions(child);
+        attachParsedExpressions(child, analyzer, bound);
       break;
     case "loop": {
       const trimmedArray = node.array.trim();
       if (trimmedArray)
-        node.arrayParsed = parseExpression(trimmedArray);
+        node.arrayParsed = parse2(trimmedArray);
+      const loopBound = new Set(bound);
+      loopBound.add(node.param);
+      if (node.index)
+        loopBound.add(node.index);
       for (const child of node.children)
-        attachParsedExpressions(child);
+        attachParsedExpressions(child, analyzer, loopBound);
       if (node.childComponent) {
         for (const child of node.childComponent.children)
-          attachParsedExpressions(child);
+          attachParsedExpressions(child, analyzer, loopBound);
       }
       for (const nested of node.nestedComponents ?? []) {
         for (const child of nested.children)
-          attachParsedExpressions(child);
+          attachParsedExpressions(child, analyzer, loopBound);
       }
       for (const frag of node.flatMapCallback?.fragments ?? []) {
-        attachParsedExpressions(frag.ir);
+        attachParsedExpressions(frag.ir, analyzer, loopBound);
       }
       break;
     }
     case "conditional":
-      attachParsedExpressions(node.whenTrue);
-      attachParsedExpressions(node.whenFalse);
+      attachParsedExpressions(node.whenTrue, analyzer, bound);
+      attachParsedExpressions(node.whenFalse, analyzer, bound);
       break;
     case "if-statement":
-      attachParsedExpressions(node.consequent);
+      attachParsedExpressions(node.consequent, analyzer, bound);
       if (node.alternate)
-        attachParsedExpressions(node.alternate);
+        attachParsedExpressions(node.alternate, analyzer, bound);
       break;
   }
 }
 function jsxToIR(analyzer) {
   const root = buildIRRoot(analyzer);
   if (root)
-    attachParsedExpressions(root);
+    attachParsedExpressions(root, analyzer);
   return root;
 }
 function buildIRRoot(analyzer) {
@@ -194043,8 +194087,8 @@ function extractSortComparator(callback, _method, ctx) {
   };
 }
 function resolveSortComparatorIdentifier(name, ctx) {
-  const constInfo = findLocalConst(name, ctx);
-  const fnInfo = findLocalFunction(name, ctx);
+  const constInfo = findLocalConst(name, ctx.analyzer);
+  const fnInfo = findLocalFunction(name, ctx.analyzer);
   if (constInfo && fnInfo)
     return null;
   if (constInfo) {
@@ -194057,6 +194101,72 @@ function resolveSortComparatorIdentifier(name, ctx) {
   }
   return null;
 }
+function resolveCallbackMethodFunctionReferenceIdentifier(name, analyzer) {
+  const constInfo = findLocalConst(name, analyzer);
+  const fnInfo = findLocalFunction(name, analyzer);
+  if (constInfo && fnInfo)
+    return null;
+  if (constInfo) {
+    const ast = parseConstInitializer(constInfo);
+    return ast && (import_typescript11.default.isArrowFunction(ast) || import_typescript11.default.isFunctionExpression(ast)) ? ast : null;
+  }
+  if (fnInfo) {
+    const ast = parseFunctionInfoAsExpr(fnInfo);
+    return ast && (import_typescript11.default.isArrowFunction(ast) || import_typescript11.default.isFunctionExpression(ast)) ? ast : null;
+  }
+  return null;
+}
+function resolveCallbackMethodFunctionReferences(expr, analyzer, bound = EMPTY_BOUND) {
+  function visit2(e, bound2) {
+    switch (e.kind) {
+      case "literal":
+      case "identifier":
+      case "regex":
+      case "unsupported":
+        return e;
+      case "call": {
+        const callee = visit2(e.callee, bound2);
+        const args = e.args.map((a) => visit2(a, bound2));
+        if (callee.kind === "member" && !callee.computed && CALLBACK_METHODS.has(callee.property) && args[0]?.kind === "identifier" && !bound2.has(args[0].name)) {
+          const resolved = resolveCallbackMethodFunctionReferenceIdentifier(args[0].name, analyzer);
+          const arrow = resolved ? tsNodeToParsedExpr(resolved) : null;
+          if (arrow && arrow.kind === "arrow")
+            args[0] = arrow;
+        }
+        return { ...e, callee, args };
+      }
+      case "member":
+        return { ...e, object: visit2(e.object, bound2) };
+      case "index-access":
+        return { ...e, object: visit2(e.object, bound2), index: visit2(e.index, bound2) };
+      case "binary":
+      case "logical":
+        return { ...e, left: visit2(e.left, bound2), right: visit2(e.right, bound2) };
+      case "unary":
+        return { ...e, argument: visit2(e.argument, bound2) };
+      case "conditional":
+        return { ...e, test: visit2(e.test, bound2), consequent: visit2(e.consequent, bound2), alternate: visit2(e.alternate, bound2) };
+      case "template-literal":
+        return { ...e, parts: e.parts.map((p) => p.type === "expression" ? { ...p, expr: visit2(p.expr, bound2) } : p) };
+      case "array-literal":
+        return { ...e, elements: e.elements.map((el) => visit2(el, bound2)) };
+      case "array-method":
+        return {
+          ...e,
+          object: visit2(e.object, bound2),
+          args: e.args.map((a) => visit2(a, bound2)),
+          ...e.method === "flat" && e.depthExpr ? { depthExpr: visit2(e.depthExpr, bound2) } : {}
+        };
+      case "object-literal":
+        return { ...e, properties: e.properties.map((p) => ({ ...p, value: visit2(p.value, bound2) })) };
+      case "arrow": {
+        const inner = e.params.length === 0 ? bound2 : new Set([...bound2, ...e.params]);
+        return { ...e, body: visit2(e.body, inner) };
+      }
+    }
+  }
+  return visit2(expr, bound);
+}
 function extractFilterPredicate(callback, ctx) {
   if (!import_typescript11.default.isArrowFunction(callback))
     return { result: null };
@@ -194524,13 +194634,11 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
           setArray(innerSort.array);
         }
       } else {
-        array = ctx.getJS(filterInfo.array);
-        arrayExpr = filterInfo.array;
+        setArray(filterInfo.array);
       }
     }
   } else {
-    array = ctx.getJS(chainSource);
-    arrayExpr = chainSource;
+    setArray(chainSource);
   }
   const callback = node.arguments[0];
   let param = "item";
@@ -195080,7 +195188,7 @@ function parseTemplateLiteral(expr, ctx) {
 }
 function tryResolveTemplateSpanFromConst(expr, ctx) {
   if (import_typescript11.default.isIdentifier(expr)) {
-    const constInfo = findLocalConst(expr.text, ctx);
+    const constInfo = findLocalConst(expr.text, ctx.analyzer);
     if (!constInfo)
       return null;
     const ast = parseConstInitializer(constInfo);
@@ -195094,7 +195202,7 @@ function tryResolveTemplateSpanFromConst(expr, ctx) {
   if (import_typescript11.default.isElementAccessExpression(expr)) {
     if (!import_typescript11.default.isIdentifier(expr.expression))
       return null;
-    const constInfo = findLocalConst(expr.expression.text, ctx);
+    const constInfo = findLocalConst(expr.expression.text, ctx.analyzer);
     if (!constInfo)
       return null;
     const ast = parseConstInitializer(constInfo);
@@ -195120,16 +195228,16 @@ function tryResolveTemplateSpanFromConst(expr, ctx) {
   }
   return null;
 }
-function findLocalConst(name, ctx) {
-  const matches = ctx.analyzer.localConstants.filter((c) => c.name === name);
+function findLocalConst(name, analyzer) {
+  const matches = analyzer.localConstants.filter((c) => c.name === name);
   if (matches.length === 0)
     return;
   const fnScoped = matches.filter((c) => !c.isModule);
   const pool = fnScoped.length > 0 ? fnScoped : matches;
   return pool[pool.length - 1];
 }
-function findLocalFunction(name, ctx) {
-  const matches = ctx.analyzer.localFunctions.filter((f) => f.name === name);
+function findLocalFunction(name, analyzer) {
+  const matches = analyzer.localFunctions.filter((f) => f.name === name);
   if (matches.length === 0)
     return;
   const fnScoped = matches.filter((f) => !f.isModule);
@@ -195171,7 +195279,9 @@ function hasDynamicTagBinding(name, sourceFile) {
   return found;
 }
 function tryResolveIdentifierAsTemplateLiteral(ident, ctx) {
-  const constInfo = findLocalConst(ident.text, ctx);
+  if (ctx.loopParams.has(ident.text))
+    return null;
+  const constInfo = findLocalConst(ident.text, ctx.analyzer);
   if (!constInfo)
     return null;
   const ast = parseConstInitializer(constInfo);
@@ -195268,8 +195378,8 @@ function tryDesugarInterleaveTaggedTemplate(expr, ctx) {
   return rewritten ?? expr;
 }
 function resolveInterleaveTagIdentifier(name, ctx) {
-  const constInfo = findLocalConst(name, ctx);
-  const fnInfo = findLocalFunction(name, ctx);
+  const constInfo = findLocalConst(name, ctx.analyzer);
+  const fnInfo = findLocalFunction(name, ctx.analyzer);
   if (constInfo && fnInfo)
     return null;
   if (constInfo) {
@@ -195794,6 +195904,49 @@ function buildIfStatementChain(analyzer, ctx) {
   return alternate;
 }
 
+// ../jsx/src/ir-to-client-js/control-flow/stringify/template-parse.ts
+var SVG_ROOT_TAGS = new Set([
+  "svg",
+  "path",
+  "circle",
+  "rect",
+  "line",
+  "polyline",
+  "polygon",
+  "ellipse",
+  "text",
+  "tspan",
+  "textPath",
+  "g",
+  "defs",
+  "use",
+  "symbol",
+  "switch",
+  "clipPath",
+  "mask",
+  "marker",
+  "pattern",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "image",
+  "foreignObject",
+  "filter",
+  "feBlend",
+  "feColorMatrix",
+  "feComposite",
+  "feFlood",
+  "feGaussianBlur",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "feTurbulence",
+  "animate",
+  "animateTransform",
+  "animateMotion"
+]);
+
 // ../jsx/src/ir-to-client-js/collect-elements.ts
 var EMPTY_RENDER_EXPRS = new Set(["null", "undefined", "false", "''", '""', "``"]);
 
@@ -196009,49 +196162,6 @@ var QUERY_HREF_SOURCES = new Set([
   "@barefootjs/client/runtime"
 ]);
 
-// ../jsx/src/ir-to-client-js/control-flow/stringify/template-parse.ts
-var SVG_ROOT_TAGS = new Set([
-  "svg",
-  "path",
-  "circle",
-  "rect",
-  "line",
-  "polyline",
-  "polygon",
-  "ellipse",
-  "text",
-  "tspan",
-  "textPath",
-  "g",
-  "defs",
-  "use",
-  "symbol",
-  "switch",
-  "clipPath",
-  "mask",
-  "marker",
-  "pattern",
-  "linearGradient",
-  "radialGradient",
-  "stop",
-  "image",
-  "foreignObject",
-  "filter",
-  "feBlend",
-  "feColorMatrix",
-  "feComposite",
-  "feFlood",
-  "feGaussianBlur",
-  "feMerge",
-  "feMergeNode",
-  "feMorphology",
-  "feOffset",
-  "feTurbulence",
-  "animate",
-  "animateTransform",
-  "animateMotion"
-]);
-
 // ../jsx/src/ir-to-client-js/control-flow/stringify/event-delegation.ts
 var NON_BUBBLING_EVENTS = new Set([
   "blur",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/test",
-  "version": "0.18.5",
+  "version": "0.19.0",
   "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.18.5"
+    "@barefootjs/jsx": "0.19.0"
   },
   "devDependencies": {
     "typescript": "^5.0.0"