@barefootjs/test 0.18.3 → 0.18.5

package/dist/index.js

@@ -187301,7 +187301,6 @@ var UNSUPPORTED_METHODS = new Set([
   "some",
   "forEach",
   "flatMap",
-  "replaceAll",
   "charAt",
   "charCodeAt",
   "codePointAt",
@@ -187477,6 +187476,9 @@ function convertNode(node, raw) {
       if (callee.property === "trim") {
         return { kind: "array-method", method: "trim", object: callee.object, args };
       }
+      if (callee.property === "trimStart" || callee.property === "trimEnd") {
+        return { kind: "array-method", method: callee.property, object: callee.object, args };
+      }
       if (callee.property === "toFixed") {
         return { kind: "array-method", method: "toFixed", object: callee.object, args };
       }
@@ -187502,24 +187504,25 @@ function convertNode(node, raw) {
         }
         return { kind: "array-method", method: callee.property, object: callee.object, args };
       }
-      if (callee.property === "replace") {
+      if (callee.property === "replace" || callee.property === "replaceAll") {
+        const method = callee.property;
         if (args.length < 2) {
           return {
             kind: "unsupported",
             raw,
-            reason: `\`.replace(${args.length === 0 ? "" : "pattern"})\` needs both a pattern and a replacement — JS coerces the missing argument to the string "undefined", a degenerate result. Pass both arguments, or pre-compute the value before the template.`
+            reason: `\`.${method}(${args.length === 0 ? "" : "pattern"})\` needs both a pattern and a replacement — JS coerces the missing argument to the string "undefined", a degenerate result. Pass both arguments, or pre-compute the value before the template.`
           };
         }
         const patternNode = node.arguments[0];
         if (patternNode && import_typescript.default.isRegularExpressionLiteral(patternNode)) {
-          return { kind: "array-method", method: "replace", object: callee.object, args };
+          return { kind: "array-method", method, object: callee.object, args };
         }
         const badArg = args[0].kind === "unsupported" || args[0].kind === "object-literal" ? args[0] : args[1].kind === "unsupported" || args[1].kind === "object-literal" ? args[1] : undefined;
         if (badArg) {
           const reason = badArg.kind === "unsupported" ? badArg.reason : "Unsupported syntax: ObjectLiteralExpression";
           return { kind: "unsupported", raw, reason };
         }
-        return { kind: "array-method", method: "replace", object: callee.object, args };
+        return { kind: "array-method", method, object: callee.object, args };
       }
       if (callee.property === "repeat") {
         return { kind: "array-method", method: "repeat", object: callee.object, args };
@@ -187554,7 +187557,7 @@ function convertNode(node, raw) {
   if (import_typescript.default.isPropertyAccessExpression(node)) {
     const object = convertNode(node.expression, raw);
     const property = node.name.text;
-    return { kind: "member", object, property, computed: false };
+    return { kind: "member", object, property, computed: false, optional: !!node.questionDotToken };
   }
   if (import_typescript.default.isElementAccessExpression(node)) {
     const object = convertNode(node.expression, raw);
@@ -187563,10 +187566,10 @@ function convertNode(node, raw) {
       return { kind: "unsupported", raw, reason: "Element access with no index expression" };
     }
     if (import_typescript.default.isNumericLiteral(argNode)) {
-      return { kind: "member", object, property: argNode.text, computed: true };
+      return { kind: "member", object, property: argNode.text, computed: true, optional: !!node.questionDotToken };
     }
     if (import_typescript.default.isStringLiteral(argNode)) {
-      return { kind: "member", object, property: argNode.text, computed: true };
+      return { kind: "member", object, property: argNode.text, computed: true, optional: !!node.questionDotToken };
     }
     const index = convertNode(argNode, raw);
     if (index.kind === "unsupported" || index.kind === "object-literal")
@@ -188117,7 +188120,7 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
           return e;
         let node = { kind: "identifier", name: syntheticParam };
         for (const segment of entry.path) {
-          node = { kind: "member", object: node, property: segment, computed: false };
+          node = { kind: "member", object: node, property: segment, computed: false, optional: false };
         }
         if (entry.defaultExpr) {
           return { kind: "logical", op: "??", left: node, right: entry.defaultExpr };
@@ -188132,10 +188135,11 @@ function substituteDestructuredFields(expr, fieldMap, syntheticParam, restName)
             kind: "member",
             object: { kind: "identifier", name: syntheticParam },
             property: e.property,
-            computed: false
+            computed: false,
+            optional: e.optional
           };
         }
-        return { kind: "member", object: walk(e.object), property: e.property, computed: e.computed };
+        return { kind: "member", object: walk(e.object), property: e.property, computed: e.computed, optional: e.optional };
       case "index-access":
         return { kind: "index-access", object: walk(e.object), index: walk(e.index) };
       case "binary":
@@ -188247,10 +188251,10 @@ function checkSupport(expr) {
       return { supported: true, level: "L2" };
     }
     case "array-method": {
-      if (expr.method === "replace" && expr.args[0]?.kind === "regex") {
+      if ((expr.method === "replace" || expr.method === "replaceAll") && expr.args[0]?.kind === "regex") {
         return {
           supported: false,
-          reason: "String.prototype.replace supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */"
+          reason: `String.prototype.${expr.method} supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */`
         };
       }
       const objSupport = checkSupport(expr.object);
@@ -188596,7 +188600,7 @@ function inlineBinding(expr, name, value) {
       case "call":
         return { kind: "call", callee: walk(e.callee, enclosing), args: e.args.map((a) => walk(a, enclosing)) };
       case "member":
-        return { kind: "member", object: walk(e.object, enclosing), property: e.property, computed: e.computed };
+        return { kind: "member", object: walk(e.object, enclosing), property: e.property, computed: e.computed, optional: e.optional };
       case "index-access":
         return { kind: "index-access", object: walk(e.object, enclosing), index: walk(e.index, enclosing) };
       case "binary":
@@ -188929,6 +188933,93 @@ var BOOLEAN_ATTRS = new Set([
   "novalidate",
   "formnovalidate"
 ]);
+var SVG_CAMEL_TO_KEBAB = {
+  strokeWidth: "stroke-width",
+  strokeLinecap: "stroke-linecap",
+  strokeLinejoin: "stroke-linejoin",
+  strokeDasharray: "stroke-dasharray",
+  strokeDashoffset: "stroke-dashoffset",
+  strokeMiterlimit: "stroke-miterlimit",
+  strokeOpacity: "stroke-opacity",
+  fillOpacity: "fill-opacity",
+  fillRule: "fill-rule",
+  stopColor: "stop-color",
+  stopOpacity: "stop-opacity",
+  textAnchor: "text-anchor",
+  dominantBaseline: "dominant-baseline",
+  alignmentBaseline: "alignment-baseline",
+  fontFamily: "font-family",
+  fontSize: "font-size",
+  fontWeight: "font-weight",
+  fontStyle: "font-style",
+  letterSpacing: "letter-spacing",
+  wordSpacing: "word-spacing",
+  pointerEvents: "pointer-events",
+  vectorEffect: "vector-effect",
+  colorInterpolation: "color-interpolation",
+  clipPath: "clip-path",
+  clipRule: "clip-rule",
+  markerStart: "marker-start",
+  markerMid: "marker-mid",
+  markerEnd: "marker-end"
+};
+var HTML_CAMEL_ALIASES = {
+  acceptCharset: "accept-charset",
+  accessKey: "accesskey",
+  allowFullScreen: "allowfullscreen",
+  autoCapitalize: "autocapitalize",
+  autoComplete: "autocomplete",
+  autoCorrect: "autocorrect",
+  autoFocus: "autofocus",
+  autoPlay: "autoplay",
+  cellPadding: "cellpadding",
+  cellSpacing: "cellspacing",
+  charSet: "charset",
+  colSpan: "colspan",
+  contentEditable: "contenteditable",
+  controlsList: "controlslist",
+  crossOrigin: "crossorigin",
+  dateTime: "datetime",
+  dirName: "dirname",
+  encType: "enctype",
+  enterKeyHint: "enterkeyhint",
+  fetchPriority: "fetchpriority",
+  formAction: "formaction",
+  formEncType: "formenctype",
+  formMethod: "formmethod",
+  formNoValidate: "formnovalidate",
+  formTarget: "formtarget",
+  frameBorder: "frameborder",
+  hrefLang: "hreflang",
+  httpEquiv: "http-equiv",
+  imageSizes: "imagesizes",
+  imageSrcSet: "imagesrcset",
+  inputMode: "inputmode",
+  itemID: "itemid",
+  itemProp: "itemprop",
+  itemRef: "itemref",
+  itemScope: "itemscope",
+  itemType: "itemtype",
+  marginHeight: "marginheight",
+  marginWidth: "marginwidth",
+  maxLength: "maxlength",
+  minLength: "minlength",
+  noModule: "nomodule",
+  noValidate: "novalidate",
+  playsInline: "playsinline",
+  popoverTarget: "popovertarget",
+  popoverTargetAction: "popovertargetaction",
+  radioGroup: "radiogroup",
+  readOnly: "readonly",
+  referrerPolicy: "referrerpolicy",
+  rowSpan: "rowspan",
+  spellCheck: "spellcheck",
+  srcDoc: "srcdoc",
+  srcLang: "srclang",
+  srcSet: "srcset",
+  tabIndex: "tabindex",
+  useMap: "usemap"
+};
 var SVG_XML_CAMEL_ATTRS = new Set([
   "allowReorder",
   "attributeName",
@@ -188995,6 +189086,86 @@ var SVG_XML_CAMEL_ATTRS = new Set([
   "yChannelSelector",
   "zoomAndPan"
 ]);
+function toHTMLAttrName(key) {
+  if (key === "className")
+    return "class";
+  if (key === "htmlFor")
+    return "for";
+  const htmlAlias = HTML_CAMEL_ALIASES[key];
+  if (htmlAlias !== undefined)
+    return htmlAlias;
+  const svgKebab = SVG_CAMEL_TO_KEBAB[key];
+  if (svgKebab !== undefined)
+    return svgKebab;
+  return key;
+}
+// ../shared/src/html-entities.ts
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+  copy: "©",
+  reg: "®",
+  trade: "™",
+  deg: "°",
+  plusmn: "±",
+  times: "×",
+  divide: "÷",
+  middot: "·",
+  bull: "•",
+  hellip: "…",
+  ndash: "–",
+  mdash: "—",
+  lsquo: "‘",
+  rsquo: "’",
+  ldquo: "“",
+  rdquo: "”",
+  laquo: "«",
+  raquo: "»",
+  sect: "§",
+  para: "¶",
+  dagger: "†",
+  Dagger: "‡",
+  euro: "€",
+  pound: "£",
+  yen: "¥",
+  cent: "¢",
+  sup1: "¹",
+  sup2: "²",
+  sup3: "³",
+  frac12: "½",
+  frac14: "¼",
+  frac34: "¾",
+  larr: "←",
+  uarr: "↑",
+  rarr: "→",
+  darr: "↓",
+  harr: "↔",
+  minus: "−",
+  infin: "∞",
+  ne: "≠",
+  le: "≤",
+  ge: "≥"
+};
+function decodeEntities(text) {
+  return text.replace(/&(#[xX]?[0-9a-fA-F]+|[a-zA-Z][a-zA-Z0-9]*);/g, (match, body) => {
+    if (body[0] === "#") {
+      const isHex = body[1] === "x" || body[1] === "X";
+      const digits = body.slice(isHex ? 2 : 1);
+      if (!isHex && !/^[0-9]+$/.test(digits))
+        return match;
+      const code2 = parseInt(digits, isHex ? 16 : 10);
+      if (!Number.isFinite(code2) || code2 > 1114111 || code2 >= 55296 && code2 <= 57343) {
+        return match;
+      }
+      return String.fromCodePoint(code2);
+    }
+    return NAMED_ENTITIES[body] ?? match;
+  });
+}
 // ../jsx/src/ir-to-client-js/utils.ts
 var PROPS_PARAM = "_p";
 // ../jsx/src/ir-to-client-js/component-scope.ts
@@ -192601,6 +192772,7 @@ function createTransformContext(analyzer) {
     isRoot: true,
     insideComponentChildren: false,
     loopParams: new Set,
+    loopDepth: 0,
     patterns: {
       signals: analyzer.signals.map((s) => ({
         getter: s.getter,
@@ -193254,7 +193426,7 @@ function transformText(node, ctx) {
   }
   return {
     type: "text",
-    value: text,
+    value: decodeEntities(text),
     loc: getSourceLocation(node, ctx.sourceFile, ctx.filePath)
   };
 }
@@ -193810,6 +193982,22 @@ function isIteratorShapeCall(node) {
     return null;
   return { array: node.expression.expression, shape: name };
 }
+function isObjectIteratorCall(node) {
+  if (!import_typescript11.default.isCallExpression(node))
+    return null;
+  if (!import_typescript11.default.isPropertyAccessExpression(node.expression))
+    return null;
+  if (!import_typescript11.default.isIdentifier(node.expression.expression))
+    return null;
+  if (node.expression.expression.text !== "Object")
+    return null;
+  if (node.arguments.length !== 1)
+    return null;
+  const name = node.expression.name.text;
+  if (name !== "entries" && name !== "keys" && name !== "values")
+    return null;
+  return { object: node.arguments[0], shape: name };
+}
 function extractSortComparator(callback, _method, ctx) {
   const outerRaw = ctx.getJS(callback);
   const unsupported = () => ({
@@ -194228,6 +194416,7 @@ function extractItemConditionalKey(cond) {
 }
 function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   const isNested = ctx.loopParams.size > 0;
+  const depth = ctx.loopDepth;
   const propAccess = node.expression;
   const mapSource = propAccess.expression;
   let array = "";
@@ -194240,6 +194429,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   let templateMapPreamble;
   let typedMapPreamble;
   let iterationShape;
+  let objectIteration;
   const setArray = (node2) => {
     array = ctx.getJS(node2);
     templateArray = rewriteBarePropRefs2(array, node2, ctx);
@@ -194254,6 +194444,12 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     } else if (iteratorInfo.shape === "keys") {
       iterationShape = "keys";
     }
+  } else {
+    const objectIteratorInfo = isObjectIteratorCall(mapSource);
+    if (objectIteratorInfo) {
+      chainSource = objectIteratorInfo.object;
+      objectIteration = objectIteratorInfo.shape;
+    }
   }
   const filterInfo = isFilterCall(chainSource);
   const sortInfo = isSortCall(chainSource);
@@ -194351,7 +194547,8 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
       if (firstParam.type) {
         paramType = firstParam.type.getText(ctx.sourceFile);
       }
-      if (iterationShape === "entries" && import_typescript11.default.isArrayBindingPattern(firstParam.name)) {
+      const isEntriesShape = iterationShape === "entries" || objectIteration === "entries";
+      if (isEntriesShape && import_typescript11.default.isArrayBindingPattern(firstParam.name)) {
         const elements = firstParam.name.elements.filter((el) => !import_typescript11.default.isOmittedExpression(el));
         if (elements.length === 2 && import_typescript11.default.isBindingElement(elements[0]) && import_typescript11.default.isIdentifier(elements[0].name) && import_typescript11.default.isBindingElement(elements[1]) && import_typescript11.default.isIdentifier(elements[1].name)) {
           index = elements[0].name.text;
@@ -194373,7 +194570,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
         }
       }
     }
-    if (callback.parameters.length > 1 && iterationShape !== "entries") {
+    if (callback.parameters.length > 1 && iterationShape !== "entries" && objectIteration !== "entries") {
       const secondParam = callback.parameters[1];
       index = secondParam.name.getText(ctx.sourceFile);
       if (secondParam.type) {
@@ -194388,6 +194585,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     }
     if (index)
       ctx.loopParams.add(index);
+    ctx.loopDepth++;
     const tryTransformRenderableBody = (expr) => {
       if (!import_typescript11.default.isBinaryExpression(expr))
         return;
@@ -194484,6 +194682,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     }
     if (index)
       ctx.loopParams.delete(index);
+    ctx.loopDepth--;
   }
   if (children.length === 0 && !flatMapCallback) {
     return null;
@@ -194512,7 +194711,7 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
   const callsReactive = exprCallsReactiveGetters(arrayExpr, ctx);
   const hasCalls = exprHasFunctionCalls(arrayExpr);
   const isDirectPropArray = method !== "flatMap" && isArrayExprDirectPropRef(arrayExpr, ctx);
-  const isStaticArray = !isSignalOrMemoArray(array, ctx) && !isDirectPropArray && !hasCalls;
+  const isStaticArray = !isSignalOrMemoArray(array, ctx) && !isDirectPropArray && !hasCalls && !objectIteration;
   const nestedComponents = collectNestedComponents(children).filter((c) => c.name !== childComponent?.name);
   return {
     type: "loop",
@@ -194539,6 +194738,8 @@ function transformMapCall(node, ctx, isClientOnly = false, method = "map") {
     sortComparator,
     chainOrder,
     iterationShape,
+    objectIteration,
+    depth,
     clientOnly: isClientOnly || undefined,
     mapPreamble,
     templateMapPreamble,
@@ -194729,27 +194930,28 @@ function processAttributes(attributes, ctx) {
     }
     if (!import_typescript11.default.isJsxAttribute(attr))
       continue;
-    const name = attr.name.getText(ctx.sourceFile);
-    if (name === "ref") {
+    const rawName = attr.name.getText(ctx.sourceFile);
+    if (rawName === "ref") {
       if (attr.initializer && import_typescript11.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
         reportJsxBranchLocalInCallback(attr.initializer.expression, ctx);
         ref = ctx.getJS(attr.initializer.expression);
       }
       continue;
     }
-    if (/^on[A-Z]/.test(name)) {
+    if (/^on[A-Z]/.test(rawName)) {
       if (attr.initializer && import_typescript11.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
-        const eventName = name.slice(2).toLowerCase();
+        const eventName = rawName.slice(2).toLowerCase();
         reportJsxBranchLocalInCallback(attr.initializer.expression, ctx);
         events.push({
           name: eventName,
-          originalAttr: name,
+          originalAttr: rawName,
           handler: ctx.getJS(attr.initializer.expression),
           loc: getSourceLocation(attr, ctx.sourceFile, ctx.filePath)
         });
       }
       continue;
     }
+    const name = toHTMLAttrName(rawName);
     let value = getAttributeValue(attr, ctx);
     let clientOnly;
     if (attr.initializer && import_typescript11.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
@@ -194780,7 +194982,7 @@ function getAttributeValue(attr, ctx) {
     return AttrValueOf.booleanAttr();
   }
   if (import_typescript11.default.isStringLiteral(attr.initializer)) {
-    return AttrValueOf.literal(attr.initializer.text);
+    return AttrValueOf.literal(decodeEntities(attr.initializer.text));
   }
   if (import_typescript11.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
     let expr = attr.initializer.expression;

package/package.json

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