@fluixi/compiler 1.0.0-alpha.105 → 1.0.0-alpha.106

package/dist/frontend/babel/build-ir.js

@@ -30,7 +30,7 @@ function gen(node) {
  * for it (build-ir -> emit), so the resulting expression is plain JS. Runtime
  * symbols used by the nested code are added to `used`.
  */
-function transformNestedJSX(node, used, onNested) {
+function transformNestedJSX(node, used, onNested, emit) {
     const clone = t.cloneNode(node, true);
     const file = t.file(t.program([t.expressionStatement(clone)]));
     let changed = false;
@@ -48,9 +48,12 @@ function transformNestedJSX(node, used, onNested) {
             const jsx = path.node;
             // Resolve before emitting: the emitted call refers to the component by name,
             // and whoever injects the import has to have seen it.
-            const nestedIR = buildIR(jsx, used, onNested);
+            const nestedIR = buildIR(jsx, used, onNested, emit);
             onNested?.(nestedIR);
-            const { code, imports, templates } = imperativeBackend.emit(nestedIR, {});
+            const { code, imports, templates } = imperativeBackend.emit(nestedIR, {
+                templateClone: emit?.templateClone,
+                partialTemplates: emit?.partialTemplates ?? true,
+            });
             emitInto(path, inlineTemplates(code, templates), imports);
         },
         // Nested html templates compose: ${cond ? html`...` : html`...`},
@@ -59,9 +62,12 @@ function transformNestedJSX(node, used, onNested) {
             const tag = path.node.tag;
             if (!t.isIdentifier(tag) || (tag.name !== 'html' && tag.name !== 'svg'))
                 return;
-            const ir = buildIRFromHtml(path.node, used, { svg: tag.name === 'svg', onNested });
+            const ir = buildIRFromHtml(path.node, used, { svg: tag.name === 'svg', onNested, emit });
             onNested?.(ir);
-            const { code, imports, templates } = imperativeBackend.emit(ir, {});
+            const { code, imports, templates } = imperativeBackend.emit(ir, {
+                templateClone: emit?.templateClone,
+                partialTemplates: emit?.partialTemplates ?? true,
+            });
             emitInto(path, inlineTemplates(code, templates), imports);
         },
     });
@@ -70,8 +76,8 @@ function transformNestedJSX(node, used, onNested) {
         : node;
 }
 /** Stringify an expression, compiling any JSX nested inside it first. */
-export function genExpr(node, used, onNested) {
-    return gen(transformNestedJSX(node, used, onNested));
+export function genExpr(node, used, onNested, emit) {
+    return gen(transformNestedJSX(node, used, onNested, emit));
 }
 export const SVG_TAGS = new Set([
     'svg', 'path', 'circle', 'rect', 'line', 'polygon', 'polyline',
@@ -110,14 +116,14 @@ export function isReactiveExpr(node) {
  * front-end supplies is how an expression becomes source, `genExpr`, which also
  * compiles any JSX or `` html`` `` nested inside it.
  */
-export function buildIR(node, used = new Set(), onNested) {
+export function buildIR(node, used = new Set(), onNested, emit) {
     const ir = buildJsxIR(node, {
         code: (n) => 
         // A member-expression tag (`<ns.Foo/>`) is not an Expression, so it cannot go
         // through the nested-JSX compile: it only ever needs printing.
         n.type === 'JSXMemberExpression'
             ? gen(n)
-            : genExpr(n, used, onNested),
+            : genExpr(n, used, onNested, emit),
         used,
     });
     return ir;

package/dist/frontend/babel/build-ir.mjs

@@ -108,10 +108,64 @@ function isHole(node) {
 function isTemplateChild(node) {
   return node.kind === "text" || node.kind === "element" && isTemplateElement(node);
 }
+var PROPERTY_BINDS = /* @__PURE__ */ new Set(["indeterminate"]);
+function disposition(prop) {
+  if (prop.kind === "spread") return null;
+  if (prop.name === "ref") return "ref";
+  if (prop.name === "use") return "use";
+  if (prop.kind === "event") return prop.event ? "event" : null;
+  if (prop.kind === "prop") return "property";
+  if (prop.kind !== "attr") return null;
+  const name = prop.name;
+  if (name.startsWith("on:")) return "nativeEvent";
+  if (name.startsWith("prop:")) return "property";
+  if (name.startsWith("attr:")) return "attr";
+  if (name.startsWith("bool:")) return "boolAttr";
+  if (name === "className" || name === "class") {
+    return isPlainLiteralAttr(prop) ? "serialize" : "class";
+  }
+  if (name === "classList") {
+    if (isPlainLiteralAttr(prop)) return "serialize";
+    return prop.reactive ? "classListDynamic" : "classList";
+  }
+  if (name === "style") {
+    if (isPlainLiteralAttr(prop)) return "serialize";
+    return prop.reactive ? "styleDynamic" : "style";
+  }
+  if (name.includes(":")) return null;
+  if (PROPERTY_ONLY.has(name)) return null;
+  if (PROPERTY_BINDS.has(name)) return "property";
+  if (prop.expr === void 0) return isPlainLiteralAttr(prop) ? "serialize" : null;
+  return "attr";
+}
+function effectiveProps(el) {
+  const order = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const prop of el.props) {
+    if (!byName.has(prop.name)) order.push(prop.name);
+    byName.set(prop.name, prop);
+  }
+  return order.map((name) => byName.get(name));
+}
+function propPlan(el) {
+  const custom = el.tag.includes("-");
+  const plan = { serialize: [], bindings: [] };
+  for (const prop of effectiveProps(el)) {
+    const kind = disposition(prop);
+    if (kind === null) return null;
+    if (kind === "serialize") {
+      plan.serialize.push(prop);
+      continue;
+    }
+    if (custom) return null;
+    plan.bindings.push({ prop, kind });
+  }
+  return plan;
+}
 function isTemplateElement(node) {
   if (node.svg) return false;
   if (isRawTextElement(node.tag)) return false;
-  if (!node.props.every((p) => isPlainLiteralAttr(p))) return false;
+  if (!propPlan(node)) return false;
   return node.children.every((c) => isTemplateChild(c) || isHole(c));
 }
 function containsHole(node) {
@@ -119,6 +173,15 @@ function containsHole(node) {
   const children = node.children;
   return children ? children.some(containsHole) : false;
 }
+function containsBinding(node) {
+  if (node.kind !== "element") return false;
+  const plan = propPlan(node);
+  if (plan && plan.bindings.length > 0) return true;
+  return node.children.some(containsBinding);
+}
+function interesting(node) {
+  return containsHole(node) || containsBinding(node);
+}
 function addressable(el) {
   for (let i = 0; i < el.children.length; i++) {
     const child = el.children[i];
@@ -132,9 +195,10 @@ function addressable(el) {
 function planPartialTemplate(root) {
   if (!isTemplateElement(root)) return null;
   if (!addressable(root)) return null;
-  if (!root.children.some(containsHole)) return null;
+  if (!interesting(root)) return null;
   const steps = [];
   const holes = [];
+  const bindings = [];
   let refCount = 0;
   const declare = (expr) => {
     const ref = `_n$${refCount++}`;
@@ -142,11 +206,17 @@ function planPartialTemplate(root) {
     return ref;
   };
   walk(root, "_el$");
-  return { html: serializeWithMarkers(root), tag: root.tag, steps, holes };
+  return { html: serializeWithMarkers(root), tag: root.tag, steps, holes, bindings };
   function walk(el, elementRef) {
+    const plan = propPlan(el);
+    if (plan) {
+      for (const binding of plan.bindings) {
+        bindings.push({ ref: elementRef, prop: binding.prop, kind: binding.kind });
+      }
+    }
     let last = -1;
     el.children.forEach((child, i) => {
-      if (containsHole(child)) last = i;
+      if (interesting(child)) last = i;
     });
     let previous = null;
     for (let i = 0; i <= last; i++) {
@@ -160,19 +230,21 @@ function planPartialTemplate(root) {
         continue;
       }
       const ref = declare(expr);
-      if (child.kind === "element" && containsHole(child)) walk(child, ref);
+      if (child.kind === "element" && interesting(child)) walk(child, ref);
       previous = ref;
     }
   }
 }
 function serializeWithMarkers(el) {
-  return serializeStatic(withSentinels(el)).split(SENTINEL).join(HOLE_START + HOLE_END);
+  return serializeStatic(templateTree(el)).split(SENTINEL).join(HOLE_START + HOLE_END);
 }
-function withSentinels(el) {
+function templateTree(el) {
+  const plan = propPlan(el);
   return {
     ...el,
+    props: plan ? plan.serialize : [],
     children: el.children.map(
-      (child) => isHole(child) ? { kind: "text", value: SENTINEL } : child.kind === "element" ? withSentinels(child) : child
+      (child) => isHole(child) ? { kind: "text", value: SENTINEL } : child.kind === "element" ? templateTree(child) : child
     )
   };
 }
@@ -445,6 +517,55 @@ function emitComponent(name, props, children, used, templates, at) {
   const mark = at ? `globalThis.${SOURCE_MARKER}?.(${JSON.stringify(at.file)},${at.line},${at.column},${JSON.stringify(name)}), ` : "";
   return `createMemo(${paren(`${mark}() => createComponent(${name}, ${obj})`, "value")})`;
 }
+function bindingTarget(binding) {
+  const name = binding.prop.name;
+  if (binding.kind === "boolAttr") return name.slice("bool:".length);
+  if (name.startsWith("prop:")) return name.slice("prop:".length);
+  if (name.startsWith("attr:")) return name.slice("attr:".length);
+  return htmlAttrName(name);
+}
+function bindingStatement(binding, used) {
+  const { ref, prop, kind } = binding;
+  const value = propValue(prop);
+  switch (kind) {
+    case "class":
+      used.add("setClassName");
+      return `setClassName(${ref}, ${value});`;
+    case "classList":
+      used.add("setClassList");
+      return `setClassList(${ref}, ${value}, []);`;
+    case "classListDynamic":
+      used.add("setDynamicClassList");
+      return `setDynamicClassList(${ref}, ${value});`;
+    case "style":
+      used.add("setStyle");
+      return `setStyle(${ref}, ${value}, []);`;
+    case "styleDynamic":
+      used.add("setDynamicStyle");
+      return `setDynamicStyle(${ref}, ${value});`;
+    case "attr":
+      used.add("setDynamicAttribute");
+      return `setDynamicAttribute(${ref}, ${JSON.stringify(bindingTarget(binding))}, ${value});`;
+    case "property":
+      used.add("setDynamicProperty");
+      return `setDynamicProperty(${ref}, ${JSON.stringify(bindingTarget(binding))}, ${value});`;
+    case "boolAttr":
+      used.add("setDynamicBoolAttribute");
+      return `setDynamicBoolAttribute(${ref}, ${JSON.stringify(bindingTarget(binding))}, ${value});`;
+    case "event":
+      used.add("addDelegatedEventListener");
+      return `addDelegatedEventListener(${ref}, ${JSON.stringify(prop.event.name)}, ${value});`;
+    case "nativeEvent":
+      used.add("addNativeEventListener");
+      return `addNativeEventListener(${ref}, ${JSON.stringify(prop.name.slice(3))}, ${value});`;
+    case "ref":
+      used.add("handleRef");
+      return `handleRef(${value}, ${ref});`;
+    case "use":
+      used.add("applyUse");
+      return `applyUse(${ref}, ${value});`;
+  }
+}
 function staticAttrAssignment(el, prop) {
   const name = htmlAttrName(prop.name);
   const value = prop.literal;
@@ -495,6 +616,7 @@ function emitNode(node, used, templates) {
             `const _el$ = templateNode(${id}, ${JSON.stringify(plan.tag)}, true${at ? `, false, ${JSON.stringify(at)}` : ""});`
           ];
           for (const step of plan.steps) lines.push(`const ${step.ref} = ${step.expr};`);
+          for (const binding of plan.bindings) lines.push(bindingStatement(binding, used));
           for (const hole of plan.holes) {
             lines.push(
               `insert(${hole.parentRef}, holeScope(${hole.startRef}, () => ${paren(emitNode(hole.node, used, templates), "arrowBody")}), ${hole.endRef}, holeContent(${hole.startRef}, ${hole.endRef}));`
@@ -1347,16 +1469,16 @@ var generate = _generate.default ?? _generate;
 function gen(node) {
   return generate(node, { concise: true }).code;
 }
-function bindHole(expr, used, onNested) {
+function bindHole(expr, used, onNested, emit) {
   const hole = {
-    code: genExpr(expr, used, onNested),
+    code: genExpr(expr, used, onNested, emit),
     reactive: isReactiveExpr(expr)
   };
   if (t.isArrowFunctionExpression(expr) && !t.isBlockStatement(expr.body)) {
     const body = expr.body;
     hole.arrow = {
       params: expr.params.map((p) => gen(p)),
-      body: genExpr(body, used, onNested),
+      body: genExpr(body, used, onNested, emit),
       bodyReactive: isReactiveExpr(body)
     };
   }
@@ -1365,7 +1487,7 @@ function bindHole(expr, used, onNested) {
 }
 function lowerHtmlTemplate(node, used, opts = {}) {
   const quasi = node.quasi;
-  const holes = quasi.expressions.map((e) => bindHole(e, used, opts.onNested));
+  const holes = quasi.expressions.map((e) => bindHole(e, used, opts.onNested, opts.emit));
   return lowerTemplate(buildPieces(quasi), holes, used, opts);
 }
 function buildPieces(quasi) {
@@ -1853,7 +1975,7 @@ var generate2 = _generate2.default ?? _generate2;
 function gen2(node) {
   return generate2(node, { concise: true }).code;
 }
-function transformNestedJSX(node, used, onNested) {
+function transformNestedJSX(node, used, onNested, emit) {
   const clone = t2.cloneNode(node, true);
   const file = t2.file(t2.program([t2.expressionStatement(clone)]));
   let changed = false;
@@ -1866,9 +1988,12 @@ function transformNestedJSX(node, used, onNested) {
   traverse(file, {
     "JSXElement|JSXFragment"(path) {
       const jsx = path.node;
-      const nestedIR = buildIR(jsx, used, onNested);
+      const nestedIR = buildIR(jsx, used, onNested, emit);
       onNested?.(nestedIR);
-      const { code, imports, templates } = imperativeBackend.emit(nestedIR, {});
+      const { code, imports, templates } = imperativeBackend.emit(nestedIR, {
+        templateClone: emit?.templateClone,
+        partialTemplates: emit?.partialTemplates ?? true
+      });
       emitInto(path, inlineTemplates(code, templates), imports);
     },
     // Nested html templates compose: ${cond ? html`...` : html`...`},
@@ -1876,16 +2001,19 @@ function transformNestedJSX(node, used, onNested) {
     TaggedTemplateExpression(path) {
       const tag = path.node.tag;
       if (!t2.isIdentifier(tag) || tag.name !== "html" && tag.name !== "svg") return;
-      const ir = buildIRFromHtml(path.node, used, { svg: tag.name === "svg", onNested });
+      const ir = buildIRFromHtml(path.node, used, { svg: tag.name === "svg", onNested, emit });
       onNested?.(ir);
-      const { code, imports, templates } = imperativeBackend.emit(ir, {});
+      const { code, imports, templates } = imperativeBackend.emit(ir, {
+        templateClone: emit?.templateClone,
+        partialTemplates: emit?.partialTemplates ?? true
+      });
       emitInto(path, inlineTemplates(code, templates), imports);
     }
   });
   return changed ? file.program.body[0].expression : node;
 }
-function genExpr(node, used, onNested) {
-  return gen2(transformNestedJSX(node, used, onNested));
+function genExpr(node, used, onNested, emit) {
+  return gen2(transformNestedJSX(node, used, onNested, emit));
 }
 var SVG_TAGS2 = /* @__PURE__ */ new Set([
   "svg",
@@ -1904,12 +2032,12 @@ var SVG_TAGS2 = /* @__PURE__ */ new Set([
 function isReactiveExpr(node) {
   return isReactiveShape(shapeOf(node));
 }
-function buildIR(node, used = /* @__PURE__ */ new Set(), onNested) {
+function buildIR(node, used = /* @__PURE__ */ new Set(), onNested, emit) {
   const ir = buildJsxIR(node, {
     code: (n) => (
       // A member-expression tag (`<ns.Foo/>`) is not an Expression, so it cannot go
       // through the nested-JSX compile: it only ever needs printing.
-      n.type === "JSXMemberExpression" ? gen2(n) : genExpr(n, used, onNested)
+      n.type === "JSXMemberExpression" ? gen2(n) : genExpr(n, used, onNested, emit)
     ),
     used
   });