@barefootjs/mojolicious 0.14.0 → 0.15.0

package/dist/build.js

@@ -6,6 +6,8 @@ import {
   parseExpression as parseExpression2,
   parseStyleObjectEntries,
   isSupported,
+  exprToString,
+  parseProviderObjectLiteral,
   identifierPath,
   emitParsedExpr,
   emitIRNode,
@@ -16,7 +18,10 @@ import {
   extractArrowBodyExpression,
   collectContextConsumers,
   isLowerableObjectRestDestructure,
-  extractSsrDefaults
+  collectModuleStringConsts,
+  lookupStaticRecordLiteral,
+  searchParamsLocalNames,
+  matchSearchParamsMethodCall
 } from "@barefootjs/jsx";
 
 // src/adapter/boolean-result.ts
@@ -63,6 +68,8 @@ var ARIA_BOOLEAN_ATTRS = new Set([
   "aria-multiselectable",
   "aria-readonly",
   "aria-required",
+  "aria-selected",
+  "aria-expanded",
   "aria-checked",
   "aria-pressed"
 ]);
@@ -71,7 +78,7 @@ function isAriaBooleanAttr(name) {
 }
 
 // src/adapter/mojo-adapter.ts
-import { BF_SLOT, BF_COND } from "@barefootjs/shared";
+import { BF_SLOT, BF_COND, BF_REGION } from "@barefootjs/shared";
 var MOJO_TEMPLATE_PRIMITIVES = {
   "JSON.stringify": { arity: 1, emit: (args) => `bf->json(${args[0]})` },
   String: { arity: 1, emit: (args) => `bf->string(${args[0]})` },
@@ -89,22 +96,6 @@ function resolveJsxChildrenProp(props) {
     return [];
   return prop.value.children;
 }
-function parsePureStringLiteral(source) {
-  const sf = ts.createSourceFile("__const.ts", `const __x = (${source});`, ts.ScriptTarget.Latest, false);
-  const stmt = sf.statements[0];
-  if (!stmt || !ts.isVariableStatement(stmt))
-    return null;
-  const decl = stmt.declarationList.declarations[0];
-  let init = decl?.initializer;
-  while (init && ts.isParenthesizedExpression(init))
-    init = init.expression;
-  if (!init)
-    return null;
-  if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
-    return init.text;
-  }
-  return evalStringArrayJoin(source);
-}
 function perlHashKey(name) {
   return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `'${name.replace(/'/g, "\\'")}'`;
 }
@@ -152,7 +143,9 @@ class MojoAdapter extends BaseAdapter {
   inLoop = false;
   propsObjectName = null;
   propsParams = [];
+  booleanTypedProps = new Set;
   stringValueNames = new Set;
+  _searchParamsLocals = new Set;
   moduleStringConsts = new Map;
   localConstants = [];
   loopBoundNames = new Map;
@@ -169,6 +162,7 @@ class MojoAdapter extends BaseAdapter {
     this.propsObjectName = ir.metadata.propsObjectName ?? null;
     augmentInheritedPropAccesses(ir);
     this.propsParams = ir.metadata.propsParams.map((p) => ({ name: p.name }));
+    this.booleanTypedProps = new Set(ir.metadata.propsParams.filter((prop) => prop.type?.primitive === "boolean" || prop.type?.raw === "boolean").map((prop) => prop.name));
     this.nullableOptionalProps = new Set(ir.metadata.propsParams.filter((p) => p.defaultValue === undefined && !p.isRest && p.type?.kind !== "primitive").map((p) => p.name));
     this.stringValueNames = new Set;
     for (const s of ir.metadata.signals) {
@@ -180,7 +174,8 @@ class MojoAdapter extends BaseAdapter {
       if (isStringTypeInfo(p.type))
         this.stringValueNames.add(p.name);
     }
-    this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants);
+    this.moduleStringConsts = collectModuleStringConsts(ir.metadata.localConstants);
+    this._searchParamsLocals = searchParamsLocalNames(ir.metadata);
     this.localConstants = ir.metadata.localConstants ?? [];
     this.loopBoundNames.clear();
     this.errors = [];
@@ -210,18 +205,49 @@ class MojoAdapter extends BaseAdapter {
       extension: this.extension
     };
   }
-  collectModuleStringConsts(constants) {
-    const map = new Map;
-    for (const c of constants ?? []) {
-      if (!c.isModule)
-        continue;
-      if (c.value === undefined)
-        continue;
-      const literal = parsePureStringLiteral(c.value);
-      if (literal !== null)
-        map.set(c.name, literal);
+  isBooleanTypedPropRef(expr) {
+    let bare = expr.trim();
+    if (this.propsObjectName && bare.startsWith(`${this.propsObjectName}.`)) {
+      bare = bare.slice(this.propsObjectName.length + 1);
     }
-    return map;
+    if (!/^[A-Za-z_$][\w$]*$/.test(bare))
+      return false;
+    return this.booleanTypedProps.has(bare);
+  }
+  parseUndefinedAlternateTernary(expr) {
+    const parsed = parseExpression2(expr.trim());
+    if (parsed?.kind !== "conditional")
+      return null;
+    const alt = parsed.alternate;
+    const isUndef = alt.kind === "identifier" && (alt.name === "undefined" || alt.name === "null") || alt.kind === "literal" && (alt.value === null || alt.value === undefined);
+    if (!isUndef)
+      return null;
+    return {
+      condition: exprToString(parsed.test),
+      consequent: exprToString(parsed.consequent)
+    };
+  }
+  resolveLiteralConst(name) {
+    if (this.loopBoundNames?.has?.(name))
+      return null;
+    const c = (this.localConstants ?? []).find((lc) => lc.name === name);
+    if (c?.value === undefined)
+      return null;
+    const v = c.value.trim();
+    if (/^-?\d+(\.\d+)?$/.test(v))
+      return v;
+    const strLit = /^'([^'\\]*)'$/.exec(v) ?? /^"([^"\\]*)"$/.exec(v);
+    if (strLit)
+      return `'${strLit[1].replace(/[\\']/g, (m) => `\\${m}`)}'`;
+    return null;
+  }
+  resolveStaticRecordLiteral(objectName, key) {
+    if (this.loopBoundNames?.has?.(objectName))
+      return null;
+    const hit = lookupStaticRecordLiteral(objectName, key, this.localConstants);
+    if (!hit)
+      return null;
+    return hit.kind === "number" ? hit.text : `'${hit.text.replace(/[\\']/g, (m) => `\\${m}`)}'`;
   }
   resolveModuleStringConst(name) {
     if (this.loopBoundNames.has(name))
@@ -289,12 +315,29 @@ class MojoAdapter extends BaseAdapter {
     if (v.kind === "literal") {
       return typeof v.value === "string" ? `'${v.value.replace(/[\\']/g, (m) => `\\${m}`)}'` : String(v.value);
     }
-    if (v.kind === "expression")
+    if (v.kind === "expression") {
+      const hashref = this.providerObjectLiteralPerl(v.expr);
+      if (hashref !== null)
+        return hashref;
       return this.convertExpressionToPerl(v.expr);
+    }
     if (v.kind === "template")
       return this.convertTemplateLiteralPartsToPerl(v.parts);
     return "undef";
   }
+  providerObjectLiteralPerl(expr) {
+    const members = parseProviderObjectLiteral(expr.trim());
+    if (members === null)
+      return null;
+    const entries = members.map((m) => {
+      const key = `'${m.name.replace(/[\\']/g, (c) => `\\${c}`)}'`;
+      if (m.kind === "function" || /^on[A-Z]/.test(m.name))
+        return `${key} => undef`;
+      const src = m.kind === "getter" ? m.body : m.expr;
+      return `${key} => ${this.convertExpressionToPerl(src)}`;
+    });
+    return `{ ${entries.join(", ")} }`;
+  }
   contextDefaultPerl(c) {
     const d = c.defaultValue;
     if (d === null || d === undefined)
@@ -318,7 +361,6 @@ class MojoAdapter extends BaseAdapter {
     const signals = ir.metadata.signals ?? [];
     if (memos.length === 0 && signals.length === 0)
       return "";
-    const ssrDefaults = extractSsrDefaults(ir.metadata) ?? {};
     const available = new Set(ir.metadata.propsParams.map((p) => p.name));
     const lines = [];
     for (const signal of signals) {
@@ -328,18 +370,12 @@ class MojoAdapter extends BaseAdapter {
       available.add(signal.getter);
     }
     for (const memo of memos) {
-      const def = ssrDefaults[memo.name];
-      const isNull = !def || typeof def === "object" && "value" in def && def.value === null;
-      if (!isNull) {
-        available.add(memo.name);
-        continue;
-      }
       const body = extractArrowBodyExpression(memo.computation);
-      if (body === null)
-        continue;
-      const perl = this.tryLowerToPerl(body, available);
-      if (perl !== null)
-        lines.push(`% my $${memo.name} = ${perl};`);
+      if (body !== null) {
+        const perl = this.tryLowerToPerl(body, available);
+        if (perl !== null)
+          lines.push(`% my $${memo.name} = ${perl};`);
+      }
       available.add(memo.name);
     }
     return lines.length > 0 ? lines.join(`
@@ -374,6 +410,9 @@ class MojoAdapter extends BaseAdapter {
     if (element.slotId) {
       hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`;
     }
+    if (element.regionId) {
+      hydrationAttrs += ` ${BF_REGION}="${element.regionId}"`;
+    }
     const voidElements = [
       "area",
       "base",
@@ -654,7 +693,7 @@ ${renderedChildren}` : renderedChildren;
   renderComponent(comp) {
     const propParts = [];
     for (const p of comp.props) {
-      if (p.name.match(/^on[A-Z]/) && p.value.kind === "expression")
+      if ((p.name.match(/^on[A-Z]/) || p.name === "ref") && p.value.kind === "expression")
         continue;
       const lowered = emitAttrValue(p.value, this.componentPropEmitter, p.name);
       if (lowered)
@@ -667,13 +706,17 @@ ${renderedChildren}` : renderedChildren;
     const tplName = this.toTemplateName(comp.name);
     const effectiveChildren = comp.children.length > 0 ? comp.children : resolveJsxChildrenProp(comp.props);
     if (effectiveChildren.length > 0) {
+      const prevInLoop = this.inLoop;
+      this.inLoop = false;
       const childrenBody = this.renderChildren(effectiveChildren);
+      this.inLoop = prevInLoop;
       const varName = `$bf_children_${comp.slotId ?? "c" + this.childrenCaptureCounter++}`;
       return `<% my ${varName} = begin %>${childrenBody}<% end %><%== bf->render_child('${tplName}'${propsStr}, children => ${varName}) %>`;
     }
     return `<%== bf->render_child('${tplName}'${propsStr}) %>`;
   }
   childrenCaptureCounter = 0;
+  presenceVarCounter = 0;
   toTemplateName(componentName) {
     return componentName.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
   }
@@ -729,14 +772,28 @@ ${children}`;
       const normalizedBareId = this.propsObjectName && bareId.startsWith(`${this.propsObjectName}.`) ? bareId.slice(this.propsObjectName.length + 1) : bareId;
       if (!isBooleanAttr(name) && !value.presenceOrUndefined && /^[A-Za-z_$][\w$]*$/.test(normalizedBareId) && this.nullableOptionalProps.has(normalizedBareId)) {
         const perl2 = this.convertExpressionToPerl(value.expr);
-        const body = isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) ? `${name}="<%= bf->bool_str(${perl2}) %>"` : `${name}="<%= ${perl2} %>"`;
+        const body = isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr) ? `${name}="<%= bf->bool_str(${perl2}) %>"` : `${name}="<%= ${perl2} %>"`;
         return `<% if (defined ${perl2}) { %>${body}<% } %>`;
       }
-      if (isBooleanAttr(name) || value.presenceOrUndefined) {
+      if (isBooleanAttr(name)) {
         return `<%= ${this.convertExpressionToPerl(value.expr)} ? '${name}' : '' %>`;
       }
+      if (value.presenceOrUndefined) {
+        const perl2 = this.convertExpressionToPerl(value.expr);
+        const tmp = `$bf_pu${this.presenceVarCounter++}`;
+        const body = isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr) ? `${name}="<%= bf->bool_str(${tmp}) %>"` : `${name}="<%= ${tmp} %>"`;
+        return `<% my ${tmp} = ${perl2}; if (${tmp}) { %>${body}<% } %>`;
+      }
+      {
+        const m = this.parseUndefinedAlternateTernary(value.expr);
+        if (m) {
+          const cond = this.convertExpressionToPerl(m.condition);
+          const val = this.convertExpressionToPerl(m.consequent);
+          return `<% if (${cond}) { %>${name}="<%= ${val} %>"<% } %>`;
+        }
+      }
       const perl = this.convertExpressionToPerl(value.expr);
-      if (isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name)) {
+      if (isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr)) {
         return `${name}="<%= bf->bool_str(${perl}) %>"`;
       }
       return `${name}="<%= ${perl} %>"`;
@@ -995,6 +1052,18 @@ ${reason}` : "";
         return n;
       })();
       const indexed = this.recordIndexAccessToPerl(initNode);
+      if (indexed === null && ts.isElementAccessExpression(initNode) && initNode.argumentExpression && !ts.isNumericLiteral(initNode.argumentExpression) && !ts.isStringLiteral(initNode.argumentExpression)) {
+        this.errors.push({
+          code: "BF101",
+          severity: "error",
+          message: `Spread object value '${initNode.getText(sf)}' indexes a record map whose values aren't scalar literals — it can't lower to an inline Perl hashref.`,
+          loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+          suggestion: {
+            message: "Index a record whose values are number/string literals, or move the spread into a `'use client'` component so hydration computes it."
+          }
+        });
+        return null;
+      }
       const valPerl = indexed !== null ? indexed : this.convertExpressionToPerl(prop.initializer.getText(sf));
       entries.push(`'${key.replace(/'/g, "\\'")}' => ${valPerl}`);
     }
@@ -1118,6 +1187,11 @@ function renderArrayMethod(method, object, args, emit) {
       const recv = emit(object);
       return `bf->trim(${recv})`;
     }
+    case "toFixed": {
+      const recv = emit(object);
+      const digits = args.length >= 1 ? emit(args[0]) : "0";
+      return `bf->to_fixed(${recv}, ${digits})`;
+    }
     case "split": {
       const recv = emit(object);
       if (args.length === 0) {
@@ -1220,6 +1294,10 @@ function isStringTypedOperand(expr, isStringName) {
   }
   return false;
 }
+function emitIndexAccessPerl(object, index, emit, isStringName) {
+  const i = emit(index);
+  return isStringTypedOperand(index, isStringName) ? `${emit(object)}->{${i}}` : `${emit(object)}->[${i}]`;
+}
 
 class MojoFilterEmitter {
   param;
@@ -1253,6 +1331,9 @@ class MojoFilterEmitter {
     }
     return `${emit(object)}->{${property}}`;
   }
+  indexAccess(object, index, emit) {
+    return emitIndexAccessPerl(object, index, emit, this.isStringName);
+  }
   call(callee, args, emit) {
     if (callee.kind === "identifier" && args.length === 0) {
       return `$${callee.name}`;
@@ -1353,9 +1434,14 @@ class MojoTopLevelEmitter {
     this.adapter = adapter;
   }
   identifier(name) {
+    if (name === "undefined" || name === "null")
+      return "undef";
     const inlined = this.adapter.resolveModuleStringConst(name);
     if (inlined !== null)
       return inlined;
+    const literalConst = this.adapter.resolveLiteralConst(name);
+    if (literalConst !== null)
+      return literalConst;
     return `$${name}`;
   }
   literal(value, literalType) {
@@ -1371,15 +1457,29 @@ class MojoTopLevelEmitter {
     if (object.kind === "identifier" && object.name === "props") {
       return `$${property}`;
     }
+    if (object.kind === "identifier") {
+      const staticValue = this.adapter.resolveStaticRecordLiteral(object.name, property);
+      if (staticValue !== null)
+        return staticValue;
+    }
     const obj = emit(object);
     if (property === "length")
       return `scalar(@{${obj}})`;
     return `${obj}->{${property}}`;
   }
+  indexAccess(object, index, emit) {
+    return emitIndexAccessPerl(object, index, emit, (n) => this.adapter._isStringValueName(n));
+  }
   call(callee, args, emit) {
     if (callee.kind === "identifier" && args.length === 0) {
       return `$${callee.name}`;
     }
+    if (this.adapter._searchParamsLocals.size > 0) {
+      const sp = matchSearchParamsMethodCall(callee, args, this.adapter._searchParamsLocals);
+      if (sp) {
+        return `$searchParams->${sp.method}(${sp.args.map(emit).join(", ")})`;
+      }
+    }
     const path = identifierPath(callee);
     const spec = path ? MOJO_TEMPLATE_PRIMITIVES[path] : undefined;
     if (path && spec) {