babel-plugin-jsx-dom-expressions 0.29.19 → 0.30.6

package/index.js

@@ -30,21 +30,6 @@ function _interopNamespace(e) {
 var SyntaxJSX__default = /*#__PURE__*/_interopDefaultLegacy(SyntaxJSX);
 var t__namespace = /*#__PURE__*/_interopNamespace(t);
 
-var config = {
-  moduleName: "dom",
-  generate: "dom",
-  hydratable: false,
-  delegateEvents: true,
-  delegatedEvents: [],
-  builtIns: [],
-  requireImportSource: false,
-  wrapConditionals: true,
-  contextToCustomElements: false,
-  staticMarker: "@once",
-  effectWrapper: "effect",
-  memoWrapper: "memo"
-};
-
 const booleans = [
   "allowfullscreen",
   "async",
@@ -235,12 +220,16 @@ const reservedNameSpaces = new Set([
   "attr"
 ]);
 
+function getConfig(path) {
+  return path.hub.file.metadata.config;
+}
+
 function registerImportMethod(path, name) {
   const imports =
     path.scope.getProgramParent().data.imports ||
     (path.scope.getProgramParent().data.imports = new Set());
   if (!imports.has(name)) {
-    helperModuleImports.addNamed(path, name, config.moduleName, {
+    helperModuleImports.addNamed(path, name, getConfig(path).moduleName, {
       nameHint: `_$${name}`
     });
     imports.add(name);
@@ -282,6 +271,7 @@ function isComponent(tagName) {
 }
 
 function isDynamic(path, { checkMember, checkTags, checkCallExpressions = true, native }) {
+  const config = getConfig(path);
   if (config.generate === "ssr" && native) {
     checkMember = false;
     checkCallExpressions = false;
@@ -379,11 +369,33 @@ function toPropertyName(name) {
   return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
 }
 
-function transformCondition(path, deep) {
-  const expr = path.node;
-  if (config.memoWrapper) {
-    registerImportMethod(path, config.memoWrapper);
+function wrappedByText(list, startIndex) {
+  let index = startIndex,
+    wrapped;
+  while (--index >= 0) {
+    const node = list[index];
+    if (!node) continue;
+    if (node.text) {
+      wrapped = true;
+      break;
+    }
+    if (node.id) return false;
+  }
+  if (!wrapped) return false;
+  index = startIndex;
+  while (++index < list.length) {
+    const node = list[index];
+    if (!node) continue;
+    if (node.text) return true;
+    if (node.id) return false;
   }
+  return false;
+}
+
+function transformCondition(path, inline, deep) {
+  const config = getConfig(path);
+  const expr = path.node;
+  registerImportMethod(path, config.memoWrapper);
   let dTest, cond, id;
   if (
     t__namespace.isConditionalExpression(expr) &&
@@ -395,15 +407,20 @@ function transformCondition(path, deep) {
     dTest = isDynamic(path.get("test"), { checkMember: true });
     if (dTest) {
       cond = expr.test;
-      id = path.scope.generateUidIdentifier("_c$");
       if (!t__namespace.isBinaryExpression(cond))
         cond = t__namespace.unaryExpression("!", t__namespace.unaryExpression("!", cond, true), true);
+      id = inline
+        ? t__namespace.callExpression(t__namespace.identifier(`_$${config.memoWrapper}`), [
+            t__namespace.arrowFunctionExpression([], cond),
+            t__namespace.booleanLiteral(true)
+          ])
+        : path.scope.generateUidIdentifier("_c$");
       expr.test = t__namespace.callExpression(id, []);
       if (t__namespace.isConditionalExpression(expr.consequent) || t__namespace.isLogicalExpression(expr.consequent)) {
-        expr.consequent = transformCondition(path.get("consequent"), true);
+        expr.consequent = transformCondition(path.get("consequent"), inline, true);
       }
       if (t__namespace.isConditionalExpression(expr.alternate) || t__namespace.isLogicalExpression(expr.alternate)) {
-        expr.alternate = transformCondition(path.get("alternate"), true);
+        expr.alternate = transformCondition(path.get("alternate"), inline, true);
       }
     }
   } else if (t__namespace.isLogicalExpression(expr)) {
@@ -419,13 +436,20 @@ function transformCondition(path, deep) {
       }));
     if (dTest) {
       cond = nextPath.node.left;
-      id = path.scope.generateUidIdentifier("_c$");
       if (!t__namespace.isBinaryExpression(cond))
         cond = t__namespace.unaryExpression("!", t__namespace.unaryExpression("!", cond, true), true);
+      id = inline
+        ? t__namespace.callExpression(t__namespace.identifier(`_$${config.memoWrapper}`), [
+            t__namespace.arrowFunctionExpression([], cond),
+            t__namespace.booleanLiteral(true)
+          ])
+        : path.scope.generateUidIdentifier("_c$");
       nextPath.node.left = t__namespace.callExpression(id, []);
     }
   }
   if (dTest) {
+    if (inline) return t__namespace.arrowFunctionExpression([], expr);
+
     const statements = [
       t__namespace.variableDeclaration("const", [
         t__namespace.variableDeclarator(
@@ -498,8 +522,9 @@ function escapeHTML(s, attr) {
   return left < s.length ? out + s.substring(left) : out;
 }
 
-function transformElement$1(path, info) {
+function transformElement$2(path, info) {
   let tagName = getTagName(path.node),
+    config = getConfig(path),
     wrapSVG = info.topLevel && tagName != "svg" && SVGElements.has(tagName),
     voidTag = VoidElements.indexOf(tagName) > -1,
     results = {
@@ -514,13 +539,13 @@ function transformElement$1(path, info) {
   if (tagName === "html" && config.hydratable) results.skipTemplate = true;
   if (wrapSVG) results.template = "<svg>" + results.template;
   if (!info.skipId) results.id = path.scope.generateUidIdentifier("el$");
-  transformAttributes$1(path, results);
+  transformAttributes$2(path, results);
   if (config.contextToCustomElements && (tagName === "slot" || tagName.indexOf("-") > -1)) {
     contextToCustomElement(path, results);
   }
   results.template += ">";
   if (!voidTag) {
-    transformChildren$1(path, results);
+    transformChildren$2(path, results, config);
     results.template += `</${tagName}>`;
   }
   if (info.topLevel && config.hydratable && results.hasHydratableEvent) {
@@ -533,7 +558,7 @@ function transformElement$1(path, info) {
   return results;
 }
 
-function setAttr$1(path, elem, name, value, { isSVG, dynamic, prevId, isCE }) {
+function setAttr$2(path, elem, name, value, { isSVG, dynamic, prevId, isCE }) {
   // pull out namespace
   let parts, namespace;
   if ((parts = name.split(":")) && parts[1] && reservedNameSpaces.has(parts[0])) {
@@ -629,7 +654,7 @@ function detectResolvableEventHandler(attribute, handler) {
   return t__namespace.isFunction(handler);
 }
 
-function transformAttributes$1(path, results) {
+function transformAttributes$2(path, results) {
   let elem = results.id,
     hasHydratableEvent = false,
     children,
@@ -638,7 +663,8 @@ function transformAttributes$1(path, results) {
     tagName = getTagName(path.node),
     isSVG = SVGElements.has(tagName),
     isCE = tagName.includes("-"),
-    hasChildren = path.node.children.length > 0;
+    hasChildren = path.node.children.length > 0,
+    config = getConfig(path);
 
   // preprocess styles
   const styleAttribute = attributes.find(
@@ -777,7 +803,9 @@ function transformAttributes$1(path, results) {
               isDynamic(attribute.get("argument"), {
                 checkMember: true
               })
-                ? t__namespace.arrowFunctionExpression([], node.argument)
+                ? t__namespace.isCallExpression(node.argument) && !node.argument.arguments.length
+                  ? node.argument.callee
+                  : t__namespace.arrowFunctionExpression([], node.argument)
                 : node.argument,
               t__namespace.booleanLiteral(isSVG),
               t__namespace.booleanLiteral(hasChildren)
@@ -795,6 +823,16 @@ function transformAttributes$1(path, results) {
           : node.name.name,
         reservedNameSpace =
           t__namespace.isJSXNamespacedName(node.name) && reservedNameSpaces.has(node.name.namespace.name);
+      if (t__namespace.isJSXExpressionContainer(value)) {
+        const evaluated = attribute.get("value").get("expression").evaluate().value;
+        let type;
+        if (
+          evaluated !== undefined &&
+          ((type = typeof evaluated) === "string" || type === "number")
+        ) {
+          value = t__namespace.stringLiteral(String(evaluated));
+        }
+      }
       if (
         t__namespace.isJSXNamespacedName(node.name) &&
         reservedNameSpace &&
@@ -1006,7 +1044,7 @@ function transformAttributes$1(path, results) {
           results.dynamics.push({ elem: nextElem, key, value: value.expression, isSVG, isCE });
         } else {
           results.exprs.push(
-            t__namespace.expressionStatement(setAttr$1(attribute, elem, key, value.expression, { isSVG, isCE }))
+            t__namespace.expressionStatement(setAttr$2(attribute, elem, key, value.expression, { isSVG, isCE }))
           );
         }
       } else {
@@ -1018,7 +1056,7 @@ function transformAttributes$1(path, results) {
         key = Aliases[key] || key;
         if (value && ChildProperties.has(key)) {
           results.exprs.push(
-            t__namespace.expressionStatement(setAttr$1(attribute, elem, key, value, { isSVG, isCE }))
+            t__namespace.expressionStatement(setAttr$2(attribute, elem, key, value, { isSVG, isCE }))
           );
         } else {
           !isSVG && (key = key.toLowerCase());
@@ -1034,31 +1072,7 @@ function transformAttributes$1(path, results) {
   results.hasHydratableEvent = results.hasHydratableEvent || hasHydratableEvent;
 }
 
-function wrappedByText(list, startIndex) {
-  let index = startIndex,
-    wrapped;
-  while (--index >= 0) {
-    const node = list[index];
-    if (!node) continue;
-    if (node.text) {
-      wrapped = true;
-      break;
-    }
-    if (node.id) return false;
-  }
-  if (!wrapped) return false;
-  index = startIndex;
-  while (++index < list.length) {
-    const node = list[index];
-    if (!node) continue;
-    if (node.text) return true;
-    if (node.id) return false;
-  }
-  return false;
-}
-
-function transformChildren$1(path, results) {
-  const { hydratable } = config;
+function transformChildren$2(path, results, config) {
   let tempPath = results.id && results.id.name,
     tagName = getTagName(path.node),
     nextPlaceholder,
@@ -1068,7 +1082,7 @@ function transformChildren$1(path, results) {
       .map(
         (child, index) =>
           transformNode(child, {
-            skipId: !results.id || !detectExpressions(filteredChildren, index)
+            skipId: !results.id || !detectExpressions(filteredChildren, index, config)
           })
         // combine adjacent textNodes
       )
@@ -1085,7 +1099,7 @@ function transformChildren$1(path, results) {
     if (!child) return;
     results.template += child.template;
     if (child.id) {
-      if (hydratable && tagName === "html") {
+      if (config.hydratable && tagName === "html") {
         registerImportMethod(path, "getNextMatch");
       }
       const walk = t__namespace.memberExpression(
@@ -1095,7 +1109,7 @@ function transformChildren$1(path, results) {
       results.decl.push(
         t__namespace.variableDeclarator(
           child.id,
-          hydratable && tagName === "html"
+          config.hydratable && tagName === "html"
             ? t__namespace.callExpression(t__namespace.identifier("_$getNextMatch"), [
                 walk,
                 t__namespace.stringLiteral(child.tagName)
@@ -1113,7 +1127,7 @@ function transformChildren$1(path, results) {
     } else if (child.exprs.length) {
       registerImportMethod(path, "insert");
       const multi = checkLength(filteredChildren),
-        markers = hydratable && multi;
+        markers = config.hydratable && multi;
       // boxed by textNodes
       if (markers || wrappedByText(childNodes, index)) {
         let exprId, contentId;
@@ -1141,7 +1155,7 @@ function transformChildren$1(path, results) {
             t__namespace.callExpression(t__namespace.identifier("_$insert"), [
               results.id,
               child.exprs[0],
-              nextChild(childNodes, index) || t__namespace.nullLiteral()
+              nextChild$1(childNodes, index) || t__namespace.nullLiteral()
             ])
           )
         );
@@ -1150,7 +1164,7 @@ function transformChildren$1(path, results) {
           t__namespace.expressionStatement(
             t__namespace.callExpression(
               t__namespace.identifier("_$insert"),
-              hydratable
+              config.hydratable
                 ? [
                     results.id,
                     child.exprs[0],
@@ -1179,7 +1193,8 @@ function transformChildren$1(path, results) {
 }
 
 function createPlaceholder(path, results, tempPath, i, char) {
-  const exprId = path.scope.generateUidIdentifier("el$");
+  const exprId = path.scope.generateUidIdentifier("el$"),
+    config = getConfig(path);
   let contentId;
   results.template += `<!${char}>`;
   if (config.hydratable && char === "/") {
@@ -1206,12 +1221,12 @@ function createPlaceholder(path, results, tempPath, i, char) {
   return [exprId, contentId];
 }
 
-function nextChild(children, index) {
-  return children[index + 1] && (children[index + 1].id || nextChild(children, index + 1));
+function nextChild$1(children, index) {
+  return children[index + 1] && (children[index + 1].id || nextChild$1(children, index + 1));
 }
 
 // reduce unnecessary refs
-function detectExpressions(children, index) {
+function detectExpressions(children, index, config) {
   if (children[index - 1]) {
     const node = children[index - 1].node;
     if (
@@ -1248,7 +1263,7 @@ function detectExpressions(children, index) {
       )
         return true;
       const nextChildren = filterChildren(children[i].get("children"));
-      if (nextChildren.length) if (detectExpressions(nextChildren, 0)) return true;
+      if (nextChildren.length) if (detectExpressions(nextChildren, 0, config)) return true;
     }
   }
 }
@@ -1266,7 +1281,8 @@ function contextToCustomElement(path, results) {
   );
 }
 
-function createTemplate$1(path, result, wrap) {
+function createTemplate$2(path, result, wrap) {
+  const config = getConfig(path);
   if (result.id) {
     registerTemplate(path, result);
     if (
@@ -1281,7 +1297,7 @@ function createTemplate$1(path, result, wrap) {
           t__namespace.blockStatement([
             result.decl,
             ...result.exprs.concat(
-              wrapDynamics(path, result.dynamics) || [],
+              wrapDynamics$1(path, result.dynamics) || [],
               result.postExprs || []
             ),
             t__namespace.returnStatement(result.id)
@@ -1320,7 +1336,7 @@ function appendTemplates$1(path, templates) {
 }
 
 function registerTemplate(path, results) {
-  const { hydratable } = config;
+  const { hydratable } = getConfig(path);
   let decl;
   if (results.template.length) {
     let templateDef, templateId;
@@ -1354,8 +1370,9 @@ function registerTemplate(path, results) {
   results.decl = t__namespace.variableDeclaration("const", results.decl);
 }
 
-function wrapDynamics(path, dynamics) {
+function wrapDynamics$1(path, dynamics) {
   if (!dynamics.length) return;
+  const config = getConfig(path);
   registerImportMethod(path, config.effectWrapper);
 
   const effectWrapperId = `_$${config.effectWrapper}`;
@@ -1370,7 +1387,7 @@ function wrapDynamics(path, dynamics) {
       t__namespace.callExpression(t__namespace.identifier(effectWrapperId), [
         t__namespace.arrowFunctionExpression(
           prevValue ? [prevValue] : [],
-          setAttr$1(path, dynamics[0].elem, dynamics[0].key, dynamics[0].value, {
+          setAttr$2(path, dynamics[0].elem, dynamics[0].key, dynamics[0].value, {
             isSVG: dynamics[0].isSVG,
             isCE: dynamics[0].isCE,
             dynamic: true,
@@ -1395,7 +1412,7 @@ function wrapDynamics(path, dynamics) {
           t__namespace.assignmentExpression(
             "=",
             prev,
-            setAttr$1(path, elem, key, identifier, { isSVG, isCE, dynamic: true, prevId: prev })
+            setAttr$2(path, elem, key, identifier, { isSVG, isCE, dynamic: true, prevId: prev })
           )
         )
       );
@@ -1405,7 +1422,7 @@ function wrapDynamics(path, dynamics) {
           t__namespace.logicalExpression(
             "&&",
             t__namespace.binaryExpression("!==", identifier, t__namespace.memberExpression(prevId, identifier)),
-            setAttr$1(
+            setAttr$2(
               path,
               elem,
               key,
@@ -1442,8 +1459,9 @@ function appendToTemplate(template, value) {
   if (array && array.length) template.push.apply(template, array);
 }
 
-function transformElement(path, info) {
+function transformElement$1(path, info) {
   let tagName = getTagName(path.node),
+    config = getConfig(path),
     voidTag = VoidElements.indexOf(tagName) > -1,
     results = {
       template: [`<${tagName}`],
@@ -1457,10 +1475,10 @@ function transformElement(path, info) {
     results.template.push("");
     results.templateValues.push(t__namespace.callExpression(t__namespace.identifier("_$ssrHydrationKey"), []));
   }
-  transformAttributes(path, results);
+  transformAttributes$1(path, results);
   appendToTemplate(results.template, ">");
   if (!voidTag) {
-    transformChildren(path, results);
+    transformChildren$1(path, results, config);
     appendToTemplate(results.template, `</${tagName}>`);
   }
   return results;
@@ -1472,7 +1490,7 @@ function toAttribute(key, isSVG) {
   return key;
 }
 
-function setAttr(results, name, value, isSVG) {
+function setAttr$1(results, name, value, isSVG) {
   // strip out namespaces for now, everything at this point is an attribute
   let parts;
   if ((parts = name.split(":")) && parts[1] && reservedNameSpaces.has(parts[0])) {
@@ -1556,7 +1574,7 @@ function transformToObject(attrName, attributes, selectedAttributes) {
   }
 }
 
-function transformAttributes(path, results) {
+function transformAttributes$1(path, results) {
   let children;
   const tagName = getTagName(path.node),
     isSVG = SVGElements.has(tagName),
@@ -1628,7 +1646,9 @@ function transformAttributes(path, results) {
             checkMember: true,
             native: true
           })
-            ? t__namespace.arrowFunctionExpression([], node.argument)
+            ? t__namespace.isCallExpression(node.argument) && !node.argument.arguments.length
+              ? node.argument.callee
+              : t__namespace.arrowFunctionExpression([], node.argument)
             : node.argument,
           t__namespace.booleanLiteral(isSVG),
           t__namespace.booleanLiteral(hasChildren)
@@ -1745,7 +1765,7 @@ function transformAttributes(path, results) {
             doEscape ? escapeExpression(path, value.expression, true) : value.expression
           );
         else if (doEscape) value.expression = escapeExpression(path, value.expression, true);
-        setAttr(results, key, value.expression, isSVG);
+        setAttr$1(results, key, value.expression, isSVG);
       }
     } else {
       if (key === "$ServerOnly") return;
@@ -1791,9 +1811,8 @@ function transformClasslistObject(path, expr, values, quasis) {
   });
 }
 
-function transformChildren(path, results) {
-  const { hydratable } = config,
-    doNotEscape = path.doNotEscape;
+function transformChildren$1(path, results, { hydratable }) {
+  const doNotEscape = path.doNotEscape;
   const filteredChildren = filterChildren(path.get("children"));
   filteredChildren.forEach(node => {
     const child = transformNode(node, { doNotEscape });
@@ -1819,7 +1838,7 @@ function transformChildren(path, results) {
   });
 }
 
-function createTemplate(path, result) {
+function createTemplate$1(path, result) {
   if (!result.template) {
     return result.exprs[0];
   }
@@ -1865,11 +1884,343 @@ function appendTemplates(path, templates) {
   path.node.body.unshift(t__namespace.variableDeclaration("const", declarators));
 }
 
+function transformElement(path, info) {
+  let tagName = getTagName(path.node),
+    results = {
+      id: path.scope.generateUidIdentifier("el$"),
+      decl: [],
+      exprs: [],
+      dynamics: [],
+      postExprs: [],
+      tagName
+    };
+
+  registerImportMethod(path, "createElement");
+  results.decl.push(
+    t__namespace.variableDeclarator(
+      results.id,
+      t__namespace.callExpression(t__namespace.identifier("_$createElement"), [t__namespace.stringLiteral(tagName)])
+    )
+  );
+
+  transformAttributes(path, results);
+  transformChildren(path, results);
+
+  return results;
+}
+
+function transformAttributes(path, results) {
+  let children;
+  const elem = results.id,
+    spread = t__namespace.identifier("_$spread"),
+    hasChildren = path.node.children.length > 0,
+    config = getConfig(path);
+
+  path
+    .get("openingElement")
+    .get("attributes")
+    .forEach(attribute => {
+      const node = attribute.node;
+      if (t__namespace.isJSXSpreadAttribute(node)) {
+        registerImportMethod(attribute, "spread");
+        results.exprs.push(
+          t__namespace.expressionStatement(
+            t__namespace.callExpression(spread, [
+              elem,
+              isDynamic(attribute.get("argument"), {
+                checkMember: true
+              })
+                ? t__namespace.isCallExpression(node.argument) && !node.argument.arguments.length
+                  ? node.argument.callee
+                  : t__namespace.arrowFunctionExpression([], node.argument)
+                : node.argument,
+              t__namespace.booleanLiteral(hasChildren)
+            ])
+          )
+        );
+        return;
+      }
+
+      let value = node.value,
+        key = t__namespace.isJSXNamespacedName(node.name)
+          ? `${node.name.namespace.name}:${node.name.name.name}`
+          : node.name.name,
+        reservedNameSpace = t__namespace.isJSXNamespacedName(node.name) && node.name.namespace.name === "use";
+      if (
+        t__namespace.isJSXNamespacedName(node.name) &&
+        reservedNameSpace &&
+        !t__namespace.isJSXExpressionContainer(value)
+      ) {
+        node.value = value = t__namespace.JSXExpressionContainer(value || t__namespace.JSXEmptyExpression());
+      }
+      if (t__namespace.isJSXExpressionContainer(value)) {
+        if (key === "ref") {
+          // Normalize expressions for non-null and type-as
+          while (
+            t__namespace.isTSNonNullExpression(value.expression) ||
+            t__namespace.isTSAsExpression(value.expression)
+          ) {
+            value.expression = value.expression.expression;
+          }
+          if (t__namespace.isLVal(value.expression)) {
+            const refIdentifier = path.scope.generateUidIdentifier("_ref$");
+            results.exprs.unshift(
+              t__namespace.variableDeclaration("const", [
+                t__namespace.variableDeclarator(refIdentifier, value.expression)
+              ]),
+              t__namespace.expressionStatement(
+                t__namespace.conditionalExpression(
+                  t__namespace.binaryExpression(
+                    "===",
+                    t__namespace.unaryExpression("typeof", refIdentifier),
+                    t__namespace.stringLiteral("function")
+                  ),
+                  t__namespace.callExpression(refIdentifier, [elem]),
+                  t__namespace.assignmentExpression("=", value.expression, elem)
+                )
+              )
+            );
+          } else if (t__namespace.isFunction(value.expression)) {
+            results.exprs.unshift(
+              t__namespace.expressionStatement(t__namespace.callExpression(value.expression, [elem]))
+            );
+          } else if (t__namespace.isCallExpression(value.expression)) {
+            const refIdentifier = path.scope.generateUidIdentifier("_ref$");
+            results.exprs.unshift(
+              t__namespace.variableDeclaration("const", [
+                t__namespace.variableDeclarator(refIdentifier, value.expression)
+              ]),
+              t__namespace.expressionStatement(
+                t__namespace.logicalExpression(
+                  "&&",
+                  t__namespace.binaryExpression(
+                    "===",
+                    t__namespace.unaryExpression("typeof", refIdentifier),
+                    t__namespace.stringLiteral("function")
+                  ),
+                  t__namespace.callExpression(refIdentifier, [elem])
+                )
+              )
+            );
+          }
+        } else if (key.startsWith("use:")) {
+          results.exprs.unshift(
+            t__namespace.expressionStatement(
+              t__namespace.callExpression(t__namespace.identifier(node.name.name.name), [
+                elem,
+                t__namespace.arrowFunctionExpression(
+                  [],
+                  t__namespace.isJSXEmptyExpression(value.expression)
+                    ? t__namespace.booleanLiteral(true)
+                    : value.expression
+                )
+              ])
+            )
+          );
+        } else if (key === "children") {
+          children = value;
+        } else if (
+          config.effectWrapper &&
+          isDynamic(attribute.get("value").get("expression"), {
+            checkMember: true
+          })
+        ) {
+          results.dynamics.push({ elem, key, value: value.expression });
+        } else {
+          results.exprs.push(
+            t__namespace.expressionStatement(setAttr(attribute, elem, key, value.expression))
+          );
+        }
+      } else {
+        results.exprs.push(t__namespace.expressionStatement(setAttr(attribute, elem, key, value)));
+      }
+    });
+  if (!hasChildren && children) {
+    path.node.children.push(children);
+  }
+}
+
+function setAttr(path, elem, name, value, { prevId } = {}) {
+  registerImportMethod(path, "setProp");
+  if (!value) value = t__namespace.booleanLiteral(true);
+  return t__namespace.callExpression(
+    t__namespace.identifier("_$setProp"),
+    prevId ? [elem, t__namespace.stringLiteral(name), value, prevId] : [elem, t__namespace.stringLiteral(name), value]
+  );
+}
+
+function transformChildren(path, results) {
+  const filteredChildren = filterChildren(path.get("children")),
+    multi = checkLength(filteredChildren),
+    childNodes = filteredChildren.map(transformNode).reduce((memo, child) => {
+      if (!child) return memo;
+      const i = memo.length;
+      if (child.text && i && memo[i - 1].text) {
+        memo[i - 1].template += child.template;
+      } else memo.push(child);
+      return memo;
+    }, []);
+
+  const appends = [];
+  childNodes.forEach((child, index) => {
+    if (!child) return;
+    if (child.id) {
+      registerImportMethod(path, "insertNode");
+      let insert = child.id;
+      if (child.text) {
+        registerImportMethod(path, "createTextNode");
+        if (multi) {
+          results.decl.push(
+            t__namespace.variableDeclarator(
+              child.id,
+              t__namespace.callExpression(t__namespace.identifier("_$createTextNode"), [
+                t__namespace.stringLiteral(htmlEntities.decode(child.template))
+              ])
+            )
+          );
+        } else
+          insert = t__namespace.callExpression(t__namespace.identifier("_$createTextNode"), [
+            t__namespace.stringLiteral(htmlEntities.decode(child.template))
+          ]);
+      }
+      appends.push(
+        t__namespace.expressionStatement(t__namespace.callExpression(t__namespace.identifier("_$insertNode"), [results.id, insert]))
+      );
+      results.decl.push(...child.decl);
+      results.exprs.push(...child.exprs);
+      results.dynamics.push(...child.dynamics);
+    } else if (child.exprs.length) {
+      registerImportMethod(path, "insert");
+      if (multi) {
+        results.exprs.push(
+          t__namespace.expressionStatement(
+            t__namespace.callExpression(t__namespace.identifier("_$insert"), [
+              results.id,
+              child.exprs[0],
+              nextChild(childNodes, index) || t__namespace.nullLiteral()
+            ])
+          )
+        );
+      } else {
+        results.exprs.push(
+          t__namespace.expressionStatement(
+            t__namespace.callExpression(t__namespace.identifier("_$insert"), [results.id, child.exprs[0]])
+          )
+        );
+      }
+    }
+  });
+  results.exprs.unshift(...appends);
+}
+
+function nextChild(children, index) {
+  return children[index + 1] && (children[index + 1].id || nextChild(children, index + 1));
+}
+
+function createTemplate(path, result, wrap) {
+  const config = getConfig(path);
+  if (result.id) {
+    result.decl = t__namespace.variableDeclaration("const", result.decl);
+    if (
+      !(result.exprs.length || result.dynamics.length || result.postExprs.length) &&
+      result.decl.declarations.length === 1
+    ) {
+      return result.decl.declarations[0].init;
+    } else {
+      return t__namespace.callExpression(
+        t__namespace.arrowFunctionExpression(
+          [],
+          t__namespace.blockStatement([
+            result.decl,
+            ...result.exprs.concat(
+              wrapDynamics(path, result.dynamics) || [],
+              result.postExprs || []
+            ),
+            t__namespace.returnStatement(result.id)
+          ])
+        ),
+        []
+      );
+    }
+  }
+  if (wrap && result.dynamic && config.memoWrapper) {
+    registerImportMethod(path, config.memoWrapper);
+    return t__namespace.callExpression(t__namespace.identifier(`_$${config.memoWrapper}`), [result.exprs[0]]);
+  }
+  return result.exprs[0];
+}
+
+function wrapDynamics(path, dynamics) {
+  if (!dynamics.length) return;
+  const config = getConfig(path);
+  registerImportMethod(path, config.effectWrapper);
+
+  const effectWrapperId = `_$${config.effectWrapper}`;
+
+  if (dynamics.length === 1) {
+    const prevValue = t__namespace.identifier("_$p");
+
+    return t__namespace.expressionStatement(
+      t__namespace.callExpression(t__namespace.identifier(effectWrapperId), [
+        t__namespace.arrowFunctionExpression(
+          [prevValue],
+          setAttr(path, dynamics[0].elem, dynamics[0].key, dynamics[0].value, {
+            dynamic: true,
+            prevId: prevValue
+          })
+        )
+      ])
+    );
+  }
+  const decls = [],
+    statements = [],
+    identifiers = [],
+    prevId = t__namespace.identifier("_p$");
+  dynamics.forEach(({ elem, key, value }) => {
+    const identifier = path.scope.generateUidIdentifier("v$");
+    identifiers.push(identifier);
+    decls.push(t__namespace.variableDeclarator(identifier, value));
+    const prev = t__namespace.memberExpression(prevId, identifier);
+    statements.push(
+      t__namespace.expressionStatement(
+        t__namespace.logicalExpression(
+          "&&",
+          t__namespace.binaryExpression("!==", identifier, t__namespace.memberExpression(prevId, identifier)),
+          t__namespace.assignmentExpression("=", t__namespace.memberExpression(prevId, identifier), setAttr(
+            path,
+            elem,
+            key,
+            identifier,
+            { dynamic: true, prevId: prev }
+          ))
+        )
+      )
+    );
+  });
+
+  return t__namespace.expressionStatement(
+    t__namespace.callExpression(t__namespace.identifier(effectWrapperId), [
+      t__namespace.arrowFunctionExpression(
+        [prevId],
+        t__namespace.blockStatement([
+          t__namespace.variableDeclaration("const", decls),
+          ...statements,
+          t__namespace.returnStatement(prevId)
+        ])
+      ),
+      t__namespace.objectExpression(identifiers.map(id => t__namespace.objectProperty(id, t__namespace.identifier("undefined"))))
+    ])
+  );
+}
+
 function transformComponent(path) {
-  let props = [],
+  let exprs = [],
+    config = getConfig(path),
+    tagName = getTagName(path.node),
+    props = [],
     runningObject = [],
-    exprs = [],
-    tagName = getTagName(path.node);
+    dynamicSpread = false,
+    hasChildren = path.node.children.length > 0;
 
   if (config.builtIns.indexOf(tagName) > -1 && !path.scope.hasBinding(tagName)) {
     registerImportMethod(path, tagName);
@@ -1886,25 +2237,37 @@ function transformComponent(path) {
           props.push(t__namespace.objectExpression(runningObject));
           runningObject = [];
         }
-        props.push(node.argument);
+        props.push(
+          isDynamic(attribute.get("argument"), {
+            checkMember: true
+          }) && (dynamicSpread = true)
+            ? t__namespace.isCallExpression(node.argument) && !node.argument.arguments.length
+              ? node.argument.callee
+              : t__namespace.arrowFunctionExpression([], node.argument)
+            : node.argument
+        );
       } else {
         const value = node.value || t__namespace.booleanLiteral(true),
           key = t__namespace.isJSXNamespacedName(node.name)
             ? `${node.name.namespace.name}:${node.name.name.name}`
             : node.name.name,
           wrapName = t__namespace.isValidIdentifier(key) ? t__namespace.identifier : t__namespace.stringLiteral;
+        if (hasChildren && key === "children") return;
         if (t__namespace.isJSXExpressionContainer(value))
           if (key === "ref") {
             if (config.generate === "ssr") return;
             // Normalize expressions for non-null and type-as
-            while (t__namespace.isTSNonNullExpression(value.expression) || t__namespace.isTSAsExpression(value.expression)) {
+            while (
+              t__namespace.isTSNonNullExpression(value.expression) ||
+              t__namespace.isTSAsExpression(value.expression)
+            ) {
               value.expression = value.expression.expression;
             }
             let binding,
-            isFunction =
-              t__namespace.isIdentifier(value.expression) &&
-              (binding = path.scope.getBinding(value.expression.name)) &&
-              binding.kind === "const";
+              isFunction =
+                t__namespace.isIdentifier(value.expression) &&
+                (binding = path.scope.getBinding(value.expression.name)) &&
+                binding.kind === "const";
             if (!isFunction && t__namespace.isLVal(value.expression)) {
               const refIdentifier = path.scope.generateUidIdentifier("_ref$");
               runningObject.push(
@@ -1969,12 +2332,8 @@ function transformComponent(path) {
               config.generate !== "ssr" &&
               (t__namespace.isLogicalExpression(value.expression) ||
                 t__namespace.isConditionalExpression(value.expression))
-                ? transformCondition(attribute.get("value").get("expression"))
+                ? transformCondition(attribute.get("value").get("expression"), true)
                 : t__namespace.arrowFunctionExpression([], value.expression);
-            if (expr.length > 1) {
-              exprs.push(expr[0]);
-              expr = expr[1];
-            }
             runningObject.push(
               t__namespace.objectMethod(
                 "get",
@@ -1989,7 +2348,7 @@ function transformComponent(path) {
       }
     });
 
-  const childResult = transformComponentChildren(path.get("children"));
+  const childResult = transformComponentChildren(path.get("children"), config);
   if (childResult && childResult[0]) {
     if (childResult[1]) {
       const body =
@@ -2008,7 +2367,7 @@ function transformComponent(path) {
   }
   if (runningObject.length || !props.length) props.push(t__namespace.objectExpression(runningObject));
 
-  if (props.length > 1) {
+  if (props.length > 1 || dynamicSpread) {
     registerImportMethod(path, "mergeProps");
     props = [t__namespace.callExpression(t__namespace.identifier("_$mergeProps"), props)];
   }
@@ -2029,15 +2388,20 @@ function transformComponent(path) {
   return { exprs, template: "", component: true };
 }
 
-function transformComponentChildren(children) {
-  const createTemplate$2 = config.generate === "ssr" ? createTemplate : createTemplate$1,
+function transformComponentChildren(children, config) {
+  const createTemplate$3 =
+      config.generate === "universal"
+        ? createTemplate
+        : config.generate === "ssr"
+        ? createTemplate$1
+        : createTemplate$2,
     filteredChildren = filterChildren(children);
   if (!filteredChildren.length) return;
   let dynamic = false;
 
   let transformedChildren = filteredChildren.reduce((memo, path) => {
     if (t__namespace.isJSXText(path.node)) {
-      const v =  htmlEntities.decode(trimWhitespace(path.node.extra.raw));
+      const v = htmlEntities.decode(trimWhitespace(path.node.extra.raw));
       if (v.length) memo.push(t__namespace.stringLiteral(v));
     } else {
       const child = transformNode(path, {
@@ -2045,7 +2409,7 @@ function transformComponentChildren(children) {
         componentChild: true
       });
       dynamic = dynamic || child.dynamic;
-      memo.push(createTemplate$2(path, child, filteredChildren.length > 1));
+      memo.push(createTemplate$3(path, child, filteredChildren.length > 1));
     }
     return memo;
   }, []);
@@ -2072,8 +2436,13 @@ function transformComponentChildren(children) {
   return [transformedChildren, dynamic];
 }
 
-function transformFragmentChildren(children, results) {
-  const createTemplate$2 = config.generate === "ssr" ? createTemplate : createTemplate$1,
+function transformFragmentChildren(children, results, config) {
+  const createTemplate$3 =
+      config.generate === "universal"
+        ? createTemplate
+        : config.generate === "ssr"
+        ? createTemplate$1
+        : createTemplate$2,
     filteredChildren = filterChildren(children),
     singleChild = filteredChildren.length === 1,
     childNodes = filteredChildren.reduce((memo, path) => {
@@ -2082,15 +2451,15 @@ function transformFragmentChildren(children, results) {
         if (v.length) memo.push(t__namespace.stringLiteral(v));
       } else {
         const child = transformNode(path, { topLevel: true, fragmentChild: true });
-        memo.push(createTemplate$2(path, child, !singleChild));
+        memo.push(createTemplate$3(path, child, !singleChild));
       }
       return memo;
     }, []);
   results.exprs.push(singleChild ? childNodes[0] : t__namespace.arrayExpression(childNodes));
 }
 
-function transformJSX(path, { opts }) {
-  Object.assign(config, opts);
+function transformJSX(path) {
+  const config = getConfig(path);
   const replace = transformThis(path);
   const result = transformNode(
     path,
@@ -2100,7 +2469,12 @@ function transformJSX(path, { opts }) {
           topLevel: true
         }
   );
-  const template = config.generate === "ssr" ? createTemplate : createTemplate$1;
+  const template =
+    config.generate === "universal"
+      ? createTemplate
+      : config.generate === "ssr"
+      ? createTemplate$1
+      : createTemplate$2;
   path.replaceWith(replace(template(path, result, false)));
 }
 
@@ -2128,16 +2502,22 @@ function transformThis(path) {
 }
 
 function transformNode(path, info = {}) {
+  const config = getConfig(path);
   const node = path.node;
   let staticValue;
   if (t__namespace.isJSXElement(node)) {
     let tagName = getTagName(node);
     if (isComponent(tagName)) return transformComponent(path);
-    const element = config.generate === "ssr" ? transformElement : transformElement$1;
+    const element =
+      config.generate === "universal"
+        ? transformElement
+        : config.generate === "ssr"
+        ? transformElement$1
+        : transformElement$2;
     return element(path, info);
   } else if (t__namespace.isJSXFragment(node)) {
     let results = { template: "", decl: [], exprs: [], dynamics: [] };
-    transformFragmentChildren(path.get("children"), results);
+    transformFragmentChildren(path.get("children"), results, config);
     return results;
   } else if (t__namespace.isJSXText(node) || (staticValue = getStaticExpression(path))) {
     const text =
@@ -2173,7 +2553,7 @@ function transformNode(path, info = {}) {
       config.wrapConditionals &&
       config.generate !== "ssr" &&
       (t__namespace.isLogicalExpression(node.expression) || t__namespace.isConditionalExpression(node.expression))
-        ? transformCondition(path.get("expression"))
+        ? transformCondition(path.get("expression"), info.componentChild)
         : !info.componentChild &&
           (config.generate !== "ssr" || info.fragmentChild) &&
           t__namespace.isCallExpression(node.expression) &&
@@ -2216,6 +2596,7 @@ function transformNode(path, info = {}) {
 
 // add to the top/bottom of the module.
 var postprocess = path => {
+  const config = getConfig(path);
   if (path.scope.data.events) {
     registerImportMethod(path, "delegateEvents");
     path.node.body.push(
@@ -2232,7 +2613,23 @@ var postprocess = path => {
   }
 };
 
-var preprocess = path => {
+var config = {
+  moduleName: "dom",
+  generate: "dom",
+  hydratable: false,
+  delegateEvents: true,
+  delegatedEvents: [],
+  builtIns: [],
+  requireImportSource: false,
+  wrapConditionals: true,
+  contextToCustomElements: false,
+  staticMarker: "@once",
+  effectWrapper: "effect",
+  memoWrapper: "memo"
+};
+
+var preprocess = (path, { opts })  => {
+  path.hub.file.metadata.config = Object.assign({}, config, opts);
   const lib = config.requireImportSource;
   if (lib) {
     const comments = path.hub.file.ast.comments;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "babel-plugin-jsx-dom-expressions",
   "description": "A JSX to DOM plugin that wraps expressions for fine grained change detection",
-  "version": "0.29.19",
+  "version": "0.30.6",
   "author": "Ryan Carniato",
   "license": "MIT",
   "repository": {
@@ -23,5 +23,5 @@
     "@babel/types": "^7.11.5",
     "html-entities": "2.3.2"
   },
-  "gitHead": "93a44cd3e222afc855780f32ab28c098452922a5"
+  "gitHead": "a2cc48a877bd4edff32f398c6c84d0b7bf6d584e"
 }