@barefootjs/erb 0.18.4 → 0.18.7

package/dist/build.js

@@ -187308,7 +187308,12 @@ import {
   prepareLoweringMatchers,
   queryHrefArgs,
   isValidHelperId,
-  sortComparatorFromArrow as sortComparatorFromArrow2
+  sortComparatorFromArrow as sortComparatorFromArrow2,
+  isDangerousInnerHtmlAttr,
+  resolveDangerousInnerHtml,
+  dangerousInnerHtmlMetacharViolation,
+  dangerousInnerHtmlDiagnostic,
+  resolveStaticLoopSource
 } from "@barefootjs/jsx";
 
 // src/adapter/boolean-result.ts
@@ -187371,7 +187376,7 @@ function isExplicitStringCall(expr) {
 }
 
 // src/adapter/erb-adapter.ts
-import { BF_SLOT, BF_COND, BF_REGION } from "@barefootjs/shared";
+import { BF_SLOT, BF_COND, BF_REGION, escapeHtml } from "@barefootjs/shared";
 
 // src/adapter/lib/constants.ts
 var ERB_TEMPLATE_PRIMITIVES = {
@@ -187380,7 +187385,10 @@ var ERB_TEMPLATE_PRIMITIVES = {
   Number: { arity: 1, emit: (args) => `bf.number(${args[0]})` },
   "Math.floor": { arity: 1, emit: (args) => `bf.floor(${args[0]})` },
   "Math.ceil": { arity: 1, emit: (args) => `bf.ceil(${args[0]})` },
-  "Math.round": { arity: 1, emit: (args) => `bf.round(${args[0]})` }
+  "Math.round": { arity: 1, emit: (args) => `bf.round(${args[0]})` },
+  "Math.min": { arity: 2, emit: (args) => `bf.min(${args[0]}, ${args[1]})` },
+  "Math.max": { arity: 2, emit: (args) => `bf.max(${args[0]}, ${args[1]})` },
+  "Math.abs": { arity: 1, emit: (args) => `bf.abs(${args[0]})` }
 };
 var ERB_PRIMITIVE_EMIT_MAP = Object.fromEntries(Object.entries(ERB_TEMPLATE_PRIMITIVES).map(([k, v]) => [k, v.emit]));
 
@@ -187548,6 +187556,12 @@ function renderArrayMethod(method, object, args, emit) {
       const recv = emit(object);
       return `bf.trim(${recv})`;
     }
+    case "trimStart":
+    case "trimEnd": {
+      const fn = method === "trimStart" ? "trim_start" : "trim_end";
+      const recv = emit(object);
+      return `bf.${fn}(${recv})`;
+    }
     case "toFixed": {
       const recv = emit(object);
       const digits = args.length >= 1 ? emit(args[0]) : "0";
@@ -187581,6 +187595,12 @@ function renderArrayMethod(method, object, args, emit) {
       const newS = emit(args[1]);
       return `bf.replace(${recv}, ${oldS}, ${newS})`;
     }
+    case "replaceAll": {
+      const recv = emit(object);
+      const oldS = emit(args[0]);
+      const newS = emit(args[1]);
+      return `bf.replace_all(${recv}, ${oldS}, ${newS})`;
+    }
     case "repeat": {
       const recv = emit(object);
       const count = args.length === 0 ? "0" : emit(args[0]);
@@ -187678,6 +187698,39 @@ function renderFlatMethod(recv, depth, emit) {
   return `bf.flat(${recv}, ${d})`;
 }
 
+// src/adapter/lib/static-value.ts
+function staticValueToRuby(value) {
+  if (value === null || value === undefined)
+    return "nil";
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "string")
+    return rubyStringLiteral(value);
+  if (Array.isArray(value)) {
+    const items = [];
+    for (const el of value) {
+      const serialized = staticValueToRuby(el);
+      if (serialized === null)
+        return null;
+      items.push(serialized);
+    }
+    return `[${items.join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = [];
+    for (const [key, val] of Object.entries(value)) {
+      const serialized = staticValueToRuby(val);
+      if (serialized === null)
+        return null;
+      entries.push(`${rubySymbolKey(key)} ${serialized}`);
+    }
+    return `{ ${entries.join(", ")} }`;
+  }
+  return null;
+}
+
 // src/adapter/expr/emitters.ts
 import {
   emitParsedExpr,
@@ -187723,16 +187776,18 @@ class ErbFilterEmitter {
   isLoopBoundOuter;
   isStringName;
   onUnsupported;
-  constructor(param, localVarMap, isLoopBoundOuter = () => false, isStringName = unusedIsStringName, onUnsupported) {
+  renderParamAs;
+  constructor(param, localVarMap, isLoopBoundOuter = () => false, isStringName = unusedIsStringName, onUnsupported, renderParamAs = rubyLocal(param)) {
     this.param = param;
     this.localVarMap = localVarMap;
     this.isLoopBoundOuter = isLoopBoundOuter;
     this.isStringName = isStringName;
     this.onUnsupported = onUnsupported;
+    this.renderParamAs = renderParamAs;
   }
   identifier(name) {
     if (name === this.param)
-      return rubyLocal(this.param);
+      return this.renderParamAs;
     const signal = this.localVarMap.get(name);
     if (signal)
       return `v[${rubySymbolLiteral(signal)}]`;
@@ -187749,9 +187804,11 @@ class ErbFilterEmitter {
       return "nil";
     return String(value);
   }
-  member(object, property, _computed, emit) {
+  member(object, property, _computed, optional, emit) {
     if (property === "length")
       return `${emit(object)}.length`;
+    if (optional)
+      return `${emit(object)}&.[](${rubySymbolLiteral(property)})`;
     return `${emit(object)}[${rubySymbolLiteral(property)}]`;
   }
   indexAccess(object, index, emit) {
@@ -187873,7 +187930,7 @@ class ErbTopLevelEmitter {
       return "nil";
     return String(value);
   }
-  member(object, property, _computed, emit) {
+  member(object, property, _computed, optional, emit) {
     if (object.kind === "identifier" && object.name === "props") {
       return `v[${rubySymbolLiteral(property)}]`;
     }
@@ -187885,6 +187942,8 @@ class ErbTopLevelEmitter {
     const obj = emit(object);
     if (property === "length")
       return `${obj}.length`;
+    if (optional)
+      return `${obj}&.[](${rubySymbolLiteral(property)})`;
     return `${obj}[${rubySymbolLiteral(property)}]`;
   }
   indexAccess(object, index, emit) {
@@ -188316,6 +188375,7 @@ class ErbAdapter extends BaseAdapter {
   options;
   errors = [];
   inLoop = false;
+  currentLoopKeyDepth = 0;
   propsObjectName = null;
   propsParams = [];
   booleanTypedProps = new Set;
@@ -188456,7 +188516,7 @@ class ErbAdapter extends BaseAdapter {
     return this.renderElement(node);
   }
   emitText(node) {
-    return node.value;
+    return escapeHtml(node.value);
   }
   emitExpression(node) {
     return this.renderExpression(node);
@@ -188527,7 +188587,8 @@ class ErbAdapter extends BaseAdapter {
   renderElement(element) {
     const tag = element.tag;
     const attrs = this.renderAttributes(element);
-    const children = this.renderChildren(element.children);
+    const dangerousHtml = this.renderDangerousInnerHtml(element);
+    const children = dangerousHtml !== null ? dangerousHtml : this.renderChildren(element.children);
     let hydrationAttrs = "";
     if (element.needsScope) {
       hydrationAttrs += ` ${this.renderScopeMarker("")}`;
@@ -188562,6 +188623,22 @@ class ErbAdapter extends BaseAdapter {
     }
     return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
   }
+  renderDangerousInnerHtml(element) {
+    const resolution = resolveDangerousInnerHtml(element);
+    if (!resolution)
+      return null;
+    if (resolution.kind === "dynamic") {
+      this.errors.push(dangerousInnerHtmlDiagnostic(resolution.expr, resolution.loc));
+      return "";
+    }
+    const violation = dangerousInnerHtmlMetacharViolation(resolution.html, this.name);
+    if (violation) {
+      const attr = element.attrs.find(isDangerousInnerHtmlAttr);
+      this.errors.push(dangerousInnerHtmlDiagnostic(`{ __html: ${JSON.stringify(resolution.html)} }`, attr.loc, violation));
+      return "";
+    }
+    return resolution.html;
+  }
   renderExpression(expr) {
     if (expr.clientOnly) {
       if (expr.slotId) {
@@ -188569,7 +188646,7 @@ class ErbAdapter extends BaseAdapter {
       }
       return "";
     }
-    const rubyExpr = this.convertExpressionToRuby(expr.expr);
+    const rubyExpr = this.convertExpressionToRuby(expr.expr, expr.parsed);
     const wrapped = this.isChildrenValueExpr(expr) ? rubyExpr : `bf.h(${rubyExpr})`;
     if (expr.slotId) {
       return `<%= bf.text_start("${expr.slotId}") %><%= ${wrapped} %><%= bf.text_end %>`;
@@ -188678,7 +188755,11 @@ ${whenTrue}
         }
       });
     }
-    if (loop.arrayParsed?.kind === "identifier") {
+    const staticItems = resolveStaticLoopSource(loop.arrayParsed, this.localConstants, {
+      isNameShadowed: (name) => this.loopBoundNames.has(name)
+    });
+    const staticArray = staticItems !== null ? staticValueToRuby(staticItems) : null;
+    if (staticArray === null && loop.arrayParsed?.kind === "identifier") {
       const arrayName = loop.arrayParsed.name;
       const isUnresolvableLocalConst = !this.loopBoundNames.has(arrayName) && this.resolveModuleStringConst(arrayName) === null && this.resolveLiteralConst(arrayName) === null && this.localConstants.some((c) => c.name === arrayName && !c.isModule);
       if (isUnresolvableLocalConst) {
@@ -188688,7 +188769,7 @@ ${whenTrue}
 3. Precompute the value server-side and pass it in as a prop.`);
       }
     }
-    const rawArray = this.convertExpressionToRuby(loop.array);
+    const rawArray = staticArray ?? this.convertExpressionToRuby(loop.array);
     let sortedHoist = null;
     let array = rawArray;
     if (loop.sortComparator) {
@@ -188697,13 +188778,16 @@ ${whenTrue}
     }
     const param = loop.param;
     const indexVar = loop.iterationShape === "keys" ? rubyLocal(param) : rubyLocal(loop.index ?? "_i");
-    const loopBound = loop.iterationShape === "keys" ? [param] : supportableDestructure ? ["__bf_item", ...(loop.paramBindings ?? []).map((b) => b.name), loop.index ?? "_i"] : [param, loop.index ?? "_i"];
+    const loopBound = loop.objectIteration === "entries" ? [param, loop.index ?? "_k"] : loop.objectIteration === "keys" || loop.objectIteration === "values" || loop.iterationShape === "keys" ? [param] : supportableDestructure ? ["__bf_item", ...(loop.paramBindings ?? []).map((b) => b.name), loop.index ?? "_i"] : [param, loop.index ?? "_i"];
     for (const n of loopBound) {
       this.loopBoundNames.set(n, (this.loopBoundNames.get(n) ?? 0) + 1);
     }
     const prevInLoop = this.inLoop;
     this.inLoop = true;
+    const prevLoopKeyDepth = this.currentLoopKeyDepth;
+    this.currentLoopKeyDepth = loop.depth;
     const renderedChildren = this.renderChildren(loop.children);
+    this.currentLoopKeyDepth = prevLoopKeyDepth;
     this.inLoop = prevInLoop;
     const children = loop.bodyIsItemConditional && loop.key ? `<%= bf.comment("loop-i:" + bf.string(${this.convertExpressionToRuby(loop.key)})) %>
 ${renderedChildren}` : renderedChildren;
@@ -188737,29 +188821,37 @@ ${renderedChildren}` : renderedChildren;
       }
       lines.push(`<%- ${sortedHoist} = ${sorted} -%>`);
     }
-    lines.push(`<%- (0...${array}.length).each do |${indexVar}| -%>`);
-    if (loop.iterationShape !== "keys") {
-      if (supportableDestructure) {
-        lines.push(`<%- __bf_item = ${array}[${indexVar}] -%>`);
-        for (const b of loop.paramBindings ?? []) {
-          const accessor = rubyAccessorFromSegments("__bf_item", b.segments ?? []);
-          if (b.rest?.kind === "array") {
-            lines.push(`<%- ${rubyLocal(b.name)} = bf.slice(${accessor}, ${b.rest.from}) -%>`);
-          } else if (b.rest?.kind === "object") {
-            const excludeSyms = b.rest.exclude.map((k) => rubySymbolLiteral(k.key)).join(", ");
-            lines.push(`<%- ${rubyLocal(b.name)} = ${accessor}.except(${excludeSyms}) -%>`);
-          } else {
-            lines.push(`<%- ${rubyLocal(b.name)} = ${accessor} -%>`);
+    if (loop.objectIteration) {
+      const method = loop.objectIteration === "entries" ? "each_pair" : loop.objectIteration === "keys" ? "each_key" : "each_value";
+      const blockParams = loop.objectIteration === "entries" ? `${rubyLocal(loop.index ?? param)}, ${rubyLocal(param)}` : rubyLocal(param);
+      lines.push(`<%- ${array}.${method} do |${blockParams}| -%>`);
+    } else {
+      lines.push(`<%- (0...${array}.length).each do |${indexVar}| -%>`);
+      if (loop.iterationShape !== "keys") {
+        if (supportableDestructure) {
+          lines.push(`<%- __bf_item = ${array}[${indexVar}] -%>`);
+          for (const b of loop.paramBindings ?? []) {
+            const accessor = rubyAccessorFromSegments("__bf_item", b.segments ?? []);
+            if (b.rest?.kind === "array") {
+              lines.push(`<%- ${rubyLocal(b.name)} = bf.slice(${accessor}, ${b.rest.from}) -%>`);
+            } else if (b.rest?.kind === "object") {
+              const excludeSyms = b.rest.exclude.map((k) => rubySymbolLiteral(k.key)).join(", ");
+              lines.push(`<%- ${rubyLocal(b.name)} = ${accessor}.except(${excludeSyms}) -%>`);
+            } else {
+              lines.push(`<%- ${rubyLocal(b.name)} = ${accessor} -%>`);
+            }
           }
+        } else {
+          lines.push(`<%- ${rubyLocal(param)} = ${array}[${indexVar}] -%>`);
         }
-      } else {
-        lines.push(`<%- ${rubyLocal(param)} = ${array}[${indexVar}] -%>`);
       }
     }
     if (loop.filterPredicate) {
       let filterCond;
       if (loop.filterPredicate.predicate) {
-        filterCond = this.renderRubyFilterExpr(loop.filterPredicate.predicate, param);
+        const filterOwnParam = loop.filterPredicate.param;
+        const matchParam = filterOwnParam && !filterOwnParam.startsWith("[") && !filterOwnParam.startsWith("{") ? filterOwnParam : param;
+        filterCond = this.renderRubyFilterExpr(loop.filterPredicate.predicate, matchParam, undefined, rubyLocal(param));
       } else {
         filterCond = "true";
       }
@@ -188805,9 +188897,23 @@ ${renderedChildren}` : renderedChildren;
   };
   renderComponent(comp) {
     const propParts = [];
+    const namedSlotCaptures = [];
     for (const p of comp.props) {
       if ((p.name.match(/^on[A-Z]/) || p.name === "ref") && p.value.kind === "expression")
         continue;
+      if (p.value.kind === "jsx-children" && p.name !== "children") {
+        const prevInLoop = this.inLoop;
+        this.inLoop = false;
+        const slotBody = this.renderChildren(p.value.children);
+        this.inLoop = prevInLoop;
+        const suffix = `${this.childrenCaptureCounter++}`;
+        const lenVar = `__bf_len_${suffix}`;
+        const rawVar = `__bf_praw_${suffix}`;
+        const capVar = `__bf_prop_${suffix}`;
+        namedSlotCaptures.push(`<% ${lenVar} = _erbout.length %>${slotBody}<% ${rawVar} = _erbout.slice!(${lenVar}..); ${capVar} = bf.backend.mark_raw(${rawVar}) %>`);
+        propParts.push(`${rubySymbolKey(p.name)} ${capVar}`);
+        continue;
+      }
       const lowered = emitAttrValue(p.value, this.componentPropEmitter, p.name);
       if (lowered)
         propParts.push(lowered);
@@ -188826,10 +188932,10 @@ ${renderedChildren}` : renderedChildren;
       const lenVar = `__bf_len_${suffix}`;
       const capVar = `__bf_children_${suffix}`;
       const propsHash2 = `{ ${[...propParts, `children: ${capVar}`].join(", ")} }`;
-      return `<% ${lenVar} = _erbout.length %>${childrenBody}<% ${capVar} = _erbout.slice!(${lenVar}..) %><%= bf.render_child('${tplName}', ${propsHash2}) %>`;
+      return `${namedSlotCaptures.join("")}<% ${lenVar} = _erbout.length %>${childrenBody}<% ${capVar} = _erbout.slice!(${lenVar}..) %><%= bf.render_child('${tplName}', ${propsHash2}) %>`;
     }
     const propsHash = propParts.length > 0 ? `{ ${propParts.join(", ")} }` : "{}";
-    return `<%= bf.render_child('${tplName}', ${propsHash}) %>`;
+    return `${namedSlotCaptures.join("")}<%= bf.render_child('${tplName}', ${propsHash}) %>`;
   }
   childrenCaptureCounter = 0;
   toTemplateName(componentName) {
@@ -188874,7 +188980,7 @@ ${alternate}
 ${children}`;
   }
   elementAttrEmitter = {
-    emitLiteral: (value, name) => `${name}="${value.value}"`,
+    emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
     emitExpression: (value, name) => {
       if (name === "style") {
         const css = this.tryLowerStyleObject(value.expr);
@@ -188966,12 +189072,15 @@ ${children}`;
     for (const attr of element.attrs) {
       if (attr.clientOnly)
         continue;
+      if (isDangerousInnerHtmlAttr(attr))
+        continue;
       let attrName;
       if (attr.name === "className")
         attrName = "class";
-      else if (attr.name === "key")
-        attrName = "data-key";
-      else
+      else if (attr.name === "key") {
+        const depth = this.currentLoopKeyDepth;
+        attrName = depth > 0 ? `data-key-${depth}` : "data-key";
+      } else
         attrName = attr.name;
       const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName);
       if (lowered)
@@ -188988,8 +189097,8 @@ ${children}`;
   renderCondMarker(condId) {
     return `${BF_COND}="${condId}"`;
   }
-  renderRubyFilterExpr(expr, param, localVarMap = new Map) {
-    return emitParsedExpr2(expr, new ErbFilterEmitter(param, localVarMap, (n) => this.isLoopBoundName(n), (n) => this._isStringValueName(n), (message, reason) => this._recordExprBF101(message, reason)));
+  renderRubyFilterExpr(expr, param, localVarMap = new Map, renderParamAs) {
+    return emitParsedExpr2(expr, new ErbFilterEmitter(param, localVarMap, (n) => this.isLoopBoundName(n), (n) => this._isStringValueName(n), (message, reason) => this._recordExprBF101(message, reason), renderParamAs));
   }
   convertTemplateLiteralPartsToRuby(literalParts) {
     const parts = [];

package/dist/conformance-pins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conformance-pins.d.ts","sourceRoot":"","sources":["../src/conformance-pins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtD,eAAO,MAAM,eAAe,EAAE,eAiG7B,CAAA"}
+{"version":3,"file":"conformance-pins.d.ts","sourceRoot":"","sources":["../src/conformance-pins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtD,eAAO,MAAM,eAAe,EAAE,eA4F7B,CAAA"}