@barefootjs/mojolicious 0.5.1 → 0.5.3

package/dist/index.js

@@ -5,7 +5,6 @@ import {
   parseExpression as parseExpression2,
   isSupported,
   identifierPath,
-  stringifyParsedExpr,
   emitParsedExpr,
   emitIRNode,
   emitAttrValue
@@ -72,7 +71,6 @@ var MOJO_TEMPLATE_PRIMITIVES = {
   "Math.ceil": { arity: 1, emit: (args) => `bf->ceil(${args[0]})` },
   "Math.round": { arity: 1, emit: (args) => `bf->round(${args[0]})` }
 };
-var PRIMITIVE_SUBSTRING_RE = new RegExp(Object.keys(MOJO_TEMPLATE_PRIMITIVES).map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"));
 var MOJO_PRIMITIVE_EMIT_MAP = Object.fromEntries(Object.entries(MOJO_TEMPLATE_PRIMITIVES).map(([k, v]) => [k, v.emit]));
 function resolveJsxChildrenProp(props) {
   const prop = props.find((p) => p.name === "children");
@@ -93,9 +91,9 @@ class MojoAdapter extends BaseAdapter {
   options;
   errors = [];
   inLoop = false;
-  higherOrderInFlight = new Set;
   propsObjectName = null;
   propsParams = [];
+  stringValueNames = new Set;
   constructor(options = {}) {
     super();
     this.options = {
@@ -107,8 +105,17 @@ class MojoAdapter extends BaseAdapter {
     this.componentName = ir.metadata.componentName;
     this.propsObjectName = ir.metadata.propsObjectName ?? null;
     this.propsParams = ir.metadata.propsParams.map((p) => ({ name: p.name }));
+    this.stringValueNames = new Set;
+    for (const s of ir.metadata.signals) {
+      if (isStringTypeInfo(s.type) || isBareStringLiteral(s.initialValue)) {
+        this.stringValueNames.add(s.getter);
+      }
+    }
+    for (const p of ir.metadata.propsParams) {
+      if (isStringTypeInfo(p.type))
+        this.stringValueNames.add(p.name);
+    }
     this.errors = [];
-    this.higherOrderInFlight = new Set;
     this.childrenCaptureCounter = 0;
     if (!options?.siblingTemplatesRegistered) {
       this.checkImportedLoopChildComponents(ir);
@@ -574,7 +581,7 @@ ${children}`;
     return `${BF_COND}="${condId}"`;
   }
   renderPerlFilterExpr(expr, param, localVarMap = new Map) {
-    return emitParsedExpr(expr, new MojoFilterEmitter(param, localVarMap));
+    return emitParsedExpr(expr, new MojoFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n)));
   }
   renderBlockBodyCondition(statements, param) {
     const localVarMap = new Map;
@@ -707,154 +714,53 @@ ${reason}` : "";
     return true;
   }
   convertExpressionToPerl(expr) {
-    if (/\.\s*(?:filter|every|some|reduce|reduceRight|forEach|flatMap|flat)\s*\(/.test(expr)) {
-      return this.convertHigherOrderExpr(expr);
-    }
-    if (/\.\s*(?:includes|indexOf|lastIndexOf|at|concat|slice|reverse|toReversed|toLowerCase|toUpperCase|trim)\s*\(/.test(expr)) {
-      return this.convertHigherOrderExpr(expr);
-    }
-    if (/\.\s*join\s*\(/.test(expr)) {
-      return this.convertHigherOrderExpr(expr);
-    }
-    const mojoOnlyMatch = /\.\s*(?<method>find|findIndex|findLast|findLastIndex)\s*\(/.exec(expr);
-    if (mojoOnlyMatch) {
-      const methodName = mojoOnlyMatch.groups.method;
+    const trimmed = expr.trim();
+    if (trimmed === "")
+      return "''";
+    const parsed = parseExpression2(trimmed);
+    const support = isSupported(parsed);
+    if (!support.supported) {
       this.errors.push({
         code: "BF101",
         severity: "error",
-        message: `Mojo adapter has not lowered Array.prototype.${methodName} yet: ${expr.trim()}`,
+        message: `Expression not supported: ${trimmed}`,
         loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
         suggestion: {
-          message: `Options:
+          message: support.reason ? `${support.reason}
+
+Options:
+1. Use /* @client */ for client-side evaluation
+2. Pre-compute the value in Perl` : `Options:
 1. Use /* @client */ for client-side evaluation
 2. Pre-compute the value in Perl`
         }
       });
       return "''";
     }
-    expr = this.rewriteTemplatePrimitives(expr);
-    let result = expr.replace(/\b([a-z_]\w*)\(\)/g, (_, name) => `$${name}`);
-    result = result.replace(/\bprops\.(\w+)/g, (_, prop) => `$${prop}`);
-    result = result.replace(/(?<!\$)\b([a-z_]\w*)\.(\w+)/g, (match, obj, field) => {
-      if (match.startsWith("$"))
-        return match;
-      return `$${obj}->{${field}}`;
-    });
-    result = result.replace(/\$(\w+)\.(\w+)/g, (_, obj, field) => `$${obj}->{${field}}`);
-    result = result.replace(/\}->\{(\w+)\}\.(\w+)/g, (_, f1, f2) => `}->{${f1}}->{${f2}}`);
-    result = result.replace(/\$(\w+)->\{length\}/g, (_, arr) => `scalar(@{$${arr}})`);
-    result = result.replace(/\?\?/g, "//");
-    result = result.replace(/\s*===\s*(['"])/g, " eq $1");
-    result = result.replace(/\s*!==\s*(['"])/g, " ne $1");
-    result = result.replace(/(['"])\s*===\s*/g, "$1 eq ");
-    result = result.replace(/(['"])\s*!==\s*/g, "$1 ne ");
-    result = result.replace(/===/g, "==");
-    result = result.replace(/!==/g, "!=");
-    result = result.replace(/`([^`]*)`/g, (_, content) => {
-      const perlStr = content.replace(/\$\{([^}]+)\}/g, (_2, e) => `${this.convertExpressionToPerl(e)}`);
-      return `"${perlStr}"`;
-    });
-    if (/^[a-z_]\w*$/i.test(result) && !result.startsWith("$")) {
-      result = `$${result}`;
-    }
-    return result;
+    return this.renderParsedExprToPerl(parsed);
   }
-  rewriteTemplatePrimitives(expr) {
-    if (!PRIMITIVE_SUBSTRING_RE.test(expr))
-      return expr;
-    const parsed = parseExpression2(expr);
-    if (parsed.kind === "unsupported")
-      return expr;
-    let mutated = false;
-    const walk = (n) => {
-      if (n.kind === "call") {
-        const path = identifierPath(n.callee);
-        const spec = path ? MOJO_TEMPLATE_PRIMITIVES[path] : undefined;
-        if (path && spec) {
-          if (n.args.length !== spec.arity) {
-            this.errors.push({
-              code: "BF101",
-              severity: "error",
-              message: `templatePrimitive '${path}' expects ${spec.arity} arg(s), got ${n.args.length}`,
-              loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-              suggestion: {
-                message: `Call '${path}' with exactly ${spec.arity} argument(s), or wrap the JSX expression in /* @client */ to defer evaluation.`
-              }
-            });
-            return { kind: "call", callee: walk(n.callee), args: n.args.map(walk) };
-          }
-          const renderedArgs = n.args.map((a) => this.convertExpressionToPerl(stringifyParsedExpr(walk(a))));
-          mutated = true;
-          return { kind: "identifier", name: spec.emit(renderedArgs) };
-        }
-      }
-      switch (n.kind) {
-        case "call":
-          return { kind: "call", callee: walk(n.callee), args: n.args.map(walk) };
-        case "member":
-          return { kind: "member", object: walk(n.object), property: n.property, computed: n.computed };
-        case "binary":
-          return { kind: "binary", op: n.op, left: walk(n.left), right: walk(n.right) };
-        case "unary":
-          return { kind: "unary", op: n.op, argument: walk(n.argument) };
-        case "logical":
-          return { kind: "logical", op: n.op, left: walk(n.left), right: walk(n.right) };
-        case "conditional":
-          return { kind: "conditional", test: walk(n.test), consequent: walk(n.consequent), alternate: walk(n.alternate) };
-        default:
-          return n;
-      }
-    };
-    const transformed = walk(parsed);
-    if (!mutated)
-      return expr;
-    return stringifyParsedExpr(transformed);
+  renderParsedExprToPerl(expr) {
+    return emitParsedExpr(expr, new MojoTopLevelEmitter(this));
   }
-  convertHigherOrderExpr(expr) {
-    if (this.higherOrderInFlight.has(expr)) {
-      this.errors.push({
-        code: "BF101",
-        severity: "error",
-        message: `Cannot lower higher-order chain to Embedded Perl: ${expr.trim()}`,
-        loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-        suggestion: {
-          message: "The Mojo adapter cannot lower this `.filter()` / `.every()` / `.some()` chain — typically because the array source is a JS array literal or a non-signal expression the AST classifier doesn't recognise. Move the expression into a `'use client'` component (so hydration computes it client-side), or rewrite it to operate on a signal getter or a prop directly."
-        }
-      });
-      return "''";
-    }
-    this.higherOrderInFlight.add(expr);
-    try {
-      const parsed = parseExpression2(expr);
-      const support = isSupported(parsed);
-      if (!support.supported) {
-        this.errors.push({
-          code: "BF101",
-          severity: "error",
-          message: `Cannot lower higher-order chain to Embedded Perl: ${expr.trim()}`,
-          loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-          suggestion: {
-            message: support.reason ? `${support.reason}
+  _isStringValueName(name) {
+    return this.stringValueNames.has(name);
+  }
+  _recordExprBF101(message, reason) {
+    this.errors.push({
+      code: "BF101",
+      severity: "error",
+      message,
+      loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+      suggestion: {
+        message: reason ? `${reason}
 
 Options:
 1. Use /* @client */ for client-side evaluation
 2. Pre-compute the value in Perl` : `Options:
 1. Use /* @client */ for client-side evaluation
 2. Pre-compute the value in Perl`
-          }
-        });
-        return "''";
       }
-      return this.renderParsedExprToPerl(parsed);
-    } finally {
-      this.higherOrderInFlight.delete(expr);
-    }
-  }
-  renderParsedExprToPerl(expr) {
-    return emitParsedExpr(expr, new MojoTopLevelEmitter(this));
-  }
-  _convertExpressionToPerlPublic(raw) {
-    return this.convertExpressionToPerl(raw);
+    });
   }
   _renderPerlFilterExprPublic(expr, param) {
     return this.renderPerlFilterExpr(expr, param);
@@ -928,13 +834,35 @@ function renderSortMethod(recv, c) {
   });
   return `bf->sort(${recv}, { keys => [${keyHashes.join(", ")}] })`;
 }
+function isStringTypeInfo(type) {
+  return type?.kind === "primitive" && type.primitive === "string";
+}
+function isBareStringLiteral(initialValue) {
+  if (!initialValue)
+    return false;
+  const v = initialValue.trim();
+  return v.startsWith("'") && v.endsWith("'") || v.startsWith('"') && v.endsWith('"');
+}
+function isStringTypedOperand(expr, isStringName) {
+  if (expr.kind === "literal" && expr.literalType === "string")
+    return true;
+  if (expr.kind === "call" && expr.callee.kind === "identifier" && expr.args.length === 0) {
+    return isStringName(expr.callee.name);
+  }
+  if (expr.kind === "member" && expr.object.kind === "identifier" && expr.object.name === "props") {
+    return isStringName(expr.property);
+  }
+  return false;
+}
 
 class MojoFilterEmitter {
   param;
   localVarMap;
-  constructor(param, localVarMap) {
+  isStringName;
+  constructor(param, localVarMap, isStringName = () => false) {
     this.param = param;
     this.localVarMap = localVarMap;
+    this.isStringName = isStringName;
   }
   identifier(name) {
     if (name === this.param)
@@ -978,10 +906,12 @@ class MojoFilterEmitter {
   binary(op, left, right, emit) {
     const l = emit(left);
     const r = emit(right);
-    if ((op === "===" || op === "==") && right.kind === "literal" && right.literalType === "string") {
+    const isStr = (e) => isStringTypedOperand(e, this.isStringName);
+    const stringCmp = isStr(left) || isStr(right);
+    if ((op === "===" || op === "==") && stringCmp) {
       return `${l} eq ${r}`;
     }
-    if ((op === "!==" || op === "!=") && right.kind === "literal" && right.literalType === "string") {
+    if ((op === "!==" || op === "!=") && stringCmp) {
       return `${l} ne ${r}`;
     }
     const opMap = {
@@ -1009,7 +939,7 @@ class MojoFilterEmitter {
   }
   higherOrder(method, object, param, predicate, emit) {
     const arrayExpr = emit(object);
-    const predBody = emitParsedExpr(predicate, new MojoFilterEmitter(param, this.localVarMap));
+    const predBody = emitParsedExpr(predicate, new MojoFilterEmitter(param, this.localVarMap, this.isStringName));
     const grepBody = predBody.replace(new RegExp(`\\$${param}\\b`, "g"), "$_");
     if (method === "filter")
       return `[grep { ${grepBody} } @{${arrayExpr}}]`;
@@ -1060,6 +990,9 @@ class MojoTopLevelEmitter {
     return String(value);
   }
   member(object, property, _computed, emit) {
+    if (object.kind === "identifier" && object.name === "props") {
+      return `$${property}`;
+    }
     const obj = emit(object);
     if (property === "length")
       return `scalar(@{${obj}})`;
@@ -1069,6 +1002,15 @@ class MojoTopLevelEmitter {
     if (callee.kind === "identifier" && args.length === 0) {
       return `$${callee.name}`;
     }
+    const path = identifierPath(callee);
+    const spec = path ? MOJO_TEMPLATE_PRIMITIVES[path] : undefined;
+    if (path && spec) {
+      if (args.length === spec.arity) {
+        return spec.emit(args.map(emit));
+      }
+      this.adapter._recordExprBF101(`templatePrimitive '${path}' expects ${spec.arity} arg(s), got ${args.length}`, `Call '${path}' with exactly ${spec.arity} argument(s).`);
+      return "''";
+    }
     return emit(callee);
   }
   unary(op, argument, emit) {
@@ -1082,10 +1024,12 @@ class MojoTopLevelEmitter {
   binary(op, left, right, emit) {
     const l = emit(left);
     const r = emit(right);
-    if ((op === "===" || op === "==") && right.kind === "literal" && right.literalType === "string") {
+    const isStr = (e) => isStringTypedOperand(e, (n) => this.adapter._isStringValueName(n));
+    const stringCmp = isStr(left) || isStr(right);
+    if ((op === "===" || op === "==") && stringCmp) {
       return `${l} eq ${r}`;
     }
-    if ((op === "!==" || op === "!=") && right.kind === "literal" && right.literalType === "string") {
+    if ((op === "!==" || op === "!=") && stringCmp) {
       return `${l} ne ${r}`;
     }
     const opMap = {
@@ -1111,6 +1055,10 @@ class MojoTopLevelEmitter {
     return `(${l} // ${r})`;
   }
   higherOrder(method, object, param, predicate, emit) {
+    if (method === "find" || method === "findIndex" || method === "findLast" || method === "findLastIndex") {
+      this.adapter._recordExprBF101(`Mojo adapter has not lowered Array.prototype.${method} yet`);
+      return "''";
+    }
     const arrayExpr = emit(object);
     const predBody = this.adapter._renderPerlFilterExprPublic(predicate, param);
     const grepBody = predBody.replace(new RegExp(`\\$${param}\\b`, "g"), "$_");
@@ -1134,14 +1082,28 @@ class MojoTopLevelEmitter {
   conditional(test, consequent, alternate, emit) {
     return `(${emit(test)} ? ${emit(consequent)} : ${emit(alternate)})`;
   }
-  templateLiteral(_parts) {
-    return "";
+  templateLiteral(parts, emit) {
+    const terms = [];
+    for (const part of parts) {
+      if (part.type === "string") {
+        if (part.value !== "") {
+          terms.push(`"${part.value.replace(/[\\"$@]/g, (m) => `\\${m}`)}"`);
+        }
+      } else {
+        const rendered = emit(part.expr);
+        const needsParens = part.expr.kind === "binary" || part.expr.kind === "logical" || part.expr.kind === "conditional";
+        terms.push(needsParens ? `(${rendered})` : rendered);
+      }
+    }
+    if (terms.length === 0)
+      return '""';
+    return terms.join(" . ");
   }
   arrowFn(_param, _body) {
-    return "";
+    return "''";
   }
-  unsupported(raw, _reason) {
-    return this.adapter._convertExpressionToPerlPublic(raw);
+  unsupported(_raw, _reason) {
+    return "''";
   }
 }
 var mojoAdapter = new MojoAdapter;

package/dist/test-render.d.ts

@@ -35,4 +35,9 @@ export interface RenderOptions {
     components?: Record<string, string>;
 }
 export declare function renderMojoComponent(options: RenderOptions): Promise<string>;
+/**
+ * Evaluate a signal initializer expression using provided props.
+ * Handles patterns like: props.initial ?? 0, props.value, literal values.
+ */
+export declare function evaluateSignalInit(expr: string, props?: Record<string, unknown>): unknown;
 //# sourceMappingURL=test-render.d.ts.map

package/dist/test-render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKxE;AAkCD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,OAAO,iBAAiB,EAAE,eAAe,CAAA;IAClD,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CA2MjF"}
+{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKxE;AAkCD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,OAAO,iBAAiB,EAAE,eAAe,CAAA;IAClD,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CA2MjF;AAgND;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAuBT"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/mojolicious",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Mojolicious EP template adapter for BarefootJS - generates .html.ep files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -52,14 +52,14 @@
     "directory": "packages/adapter-mojolicious"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.5.1"
+    "@barefootjs/shared": "0.5.3"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.5.1",
+    "@barefootjs/jsx": "0.5.3",
     "typescript": "^5.0.0"
   }
 }

package/src/__tests__/evaluate-signal-init.test.ts

@@ -0,0 +1,35 @@
+import { describe, test, expect } from 'bun:test'
+import { evaluateSignalInit } from '../test-render'
+
+describe('evaluateSignalInit — SSR signal seeding (#1672)', () => {
+  test('parses an inline object-array initial value', () => {
+    // The whole-item loop-conditional fixture seeds `items` from an inline
+    // object array. Without array support this returned null, so `$items` was
+    // undefined in the Mojo SSR render and the loop rendered empty.
+    expect(evaluateSignalInit(`[{ id: 'a' }, { id: 'b' }, { id: 'c' }]`)).toEqual([
+      { id: 'a' },
+      { id: 'b' },
+      { id: 'c' },
+    ])
+  })
+
+  test('parses scalar and mixed arrays, including nested objects', () => {
+    expect(evaluateSignalInit(`['x', 'y']`)).toEqual(['x', 'y'])
+    expect(evaluateSignalInit(`[1, 2, 3]`)).toEqual([1, 2, 3])
+    expect(evaluateSignalInit(`[{ id: 'a', n: 1, ok: true }]`)).toEqual([
+      { id: 'a', n: 1, ok: true },
+    ])
+  })
+
+  test('still parses scalars, empty array, and props passthrough', () => {
+    expect(evaluateSignalInit(`'b'`)).toBe('b')
+    expect(evaluateSignalInit(`5`)).toBe(5)
+    expect(evaluateSignalInit(`[]`)).toEqual([])
+    expect(evaluateSignalInit(`props.value`, { value: 42 })).toBe(42)
+  })
+
+  test('bails to null for arrays with non-literal elements', () => {
+    // A call / identifier element can't be evaluated at seed time.
+    expect(evaluateSignalInit(`[foo(), bar]`)).toBeNull()
+  })
+})