babel-plugin-jsx-dom-expressions 0.35.8 → 0.35.10

package/index.js

@@ -1735,9 +1735,31 @@ function createTemplate$1(path, result) {
     });
   } else id = found.id;
 
+  if (result.wontEscape) {
+    if (!Array.isArray(result.template) || result.template.length === 1) return id;
+    else if (
+      Array.isArray(result.template) &&
+      result.template.length === 2 &&
+      result.templateValues[0].type === "CallExpression" &&
+      result.templateValues[0].callee.name === "_$ssrHydrationKey"
+    ) {
+      // remove unnecessary ssr call when only hydration key is used
+      return t__namespace.binaryExpression(
+        "+",
+        t__namespace.binaryExpression(
+          "+",
+          t__namespace.memberExpression(id, t__namespace.numericLiteral(0), true),
+          result.templateValues[0]
+        ),
+        t__namespace.memberExpression(id, t__namespace.numericLiteral(1), true)
+      );
+    }
+  }
   return t__namespace.callExpression(
     registerImportMethod(path, "ssr"),
-    Array.isArray(result.template) && result.template.length > 1 ? [id, ...result.templateValues] : [id]
+    Array.isArray(result.template) && result.template.length > 1
+      ? [id, ...result.templateValues]
+      : [id]
   );
 }
 
@@ -1772,6 +1794,7 @@ function transformElement$2(path, info) {
       exprs: [],
       dynamics: [],
       tagName,
+      wontEscape: path.node.wontEscape,
       renderer: "ssr"
     };
 
@@ -1838,44 +1861,60 @@ function setAttr$1(attribute, results, name, value, isSVG) {
   }
 }
 
-function escapeExpression(path, expression, attr) {
-  if (t__namespace.isStringLiteral(expression) || t__namespace.isNumericLiteral(expression)) {
+function escapeExpression(path, expression, attr, escapeLiterals) {
+  if (
+    t__namespace.isStringLiteral(expression) ||
+    t__namespace.isNumericLiteral(expression) ||
+    (t__namespace.isTemplateLiteral(expression) && expression.expressions.length === 0)
+  ) {
+    if (escapeLiterals) {
+      if (t__namespace.isStringLiteral(expression)) return t__namespace.stringLiteral(escapeHTML(expression.value, attr));
+      else if (t__namespace.isTemplateLiteral(expression))
+        return t__namespace.stringLiteral(escapeHTML(expression.quasis[0].value.raw, attr));
+    }
     return expression;
   } else if (t__namespace.isFunction(expression)) {
     if (t__namespace.isBlockStatement(expression.body)) {
       expression.body.body = expression.body.body.map(e => {
-        if (t__namespace.isReturnStatement(e)) e.argument = escapeExpression(path, e.argument, attr);
+        if (t__namespace.isReturnStatement(e))
+          e.argument = escapeExpression(path, e.argument, attr, escapeLiterals);
         return e;
       });
-    } else expression.body = escapeExpression(path, expression.body, attr);
+    } else expression.body = escapeExpression(path, expression.body, attr, escapeLiterals);
     return expression;
   } else if (t__namespace.isTemplateLiteral(expression)) {
-    expression.expressions = expression.expressions.map(e => escapeExpression(path, e, attr));
+    expression.expressions = expression.expressions.map(e =>
+      escapeExpression(path, e, attr, escapeLiterals)
+    );
     return expression;
   } else if (t__namespace.isUnaryExpression(expression)) {
-    expression.argument = escapeExpression(path, expression.argument, attr);
     return expression;
   } else if (t__namespace.isBinaryExpression(expression)) {
-    expression.left = escapeExpression(path, expression.left, attr);
-    expression.right = escapeExpression(path, expression.right, attr);
+    expression.left = escapeExpression(path, expression.left, attr, escapeLiterals);
+    expression.right = escapeExpression(path, expression.right, attr, escapeLiterals);
     return expression;
   } else if (t__namespace.isConditionalExpression(expression)) {
-    expression.consequent = escapeExpression(path, expression.consequent, attr);
-    expression.alternate = escapeExpression(path, expression.alternate, attr);
+    expression.consequent = escapeExpression(path, expression.consequent, attr, escapeLiterals);
+    expression.alternate = escapeExpression(path, expression.alternate, attr, escapeLiterals);
     return expression;
   } else if (t__namespace.isLogicalExpression(expression)) {
-    expression.right = escapeExpression(path, expression.right, attr);
+    expression.right = escapeExpression(path, expression.right, attr, escapeLiterals);
     if (expression.operator !== "&&") {
-      expression.left = escapeExpression(path, expression.left, attr);
+      expression.left = escapeExpression(path, expression.left, attr, escapeLiterals);
     }
     return expression;
   } else if (t__namespace.isCallExpression(expression) && t__namespace.isFunction(expression.callee)) {
     if (t__namespace.isBlockStatement(expression.callee.body)) {
       expression.callee.body.body = expression.callee.body.body.map(e => {
-        if (t__namespace.isReturnStatement(e)) e.argument = escapeExpression(path, e.argument, attr);
+        if (t__namespace.isReturnStatement(e))
+          e.argument = escapeExpression(path, e.argument, attr, escapeLiterals);
         return e;
       });
-    } else expression.callee.body = escapeExpression(path, expression.callee.body, attr);
+    } else
+      expression.callee.body = escapeExpression(path, expression.callee.body, attr, escapeLiterals);
+    return expression;
+  } else if(t__namespace.isJSXElement(expression) && !isComponent(getTagName(expression))) {
+    expression.wontEscape = true;
     return expression;
   }
 
@@ -2040,16 +2079,7 @@ function transformAttributes$1(path, results, info) {
                 t__namespace.stringLiteral(
                   (i ? ";" : "") + (t__namespace.isIdentifier(p.key) ? p.key.name : p.key.value) + ":"
                 ),
-                t__namespace.isStringLiteral(p.value)
-                  ? t__namespace.stringLiteral(escapeHTML(p.value.value))
-                  : t__namespace.isNumericLiteral(p.value)
-                  ? p.value
-                  : t__namespace.isTemplateLiteral(p.value) && p.value.expressions.length === 0
-                  ? t__namespace.stringLiteral(escapeHTML(p.value.quasis[0].value.raw))
-                  : t__namespace.callExpression(registerImportMethod(path, "escape"), [
-                      p.value,
-                      t__namespace.booleanLiteral(true)
-                    ])
+                escapeExpression(path, p.value, true, true)
               )
             );
             let res = props[0];
@@ -2201,10 +2231,13 @@ function createElement(path, { topLevel, hydratable }) {
         if (v.length) memo.push(t__namespace.stringLiteral(v));
       } else {
         const child = transformNode(path);
-        if (markers && child.exprs.length && !child.spreadElement) memo.push(t__namespace.stringLiteral("<!--#-->"));
-        if (child.exprs.length && !child.spreadElement) child.exprs[0] = escapeExpression(path, child.exprs[0]);
+        if (markers && child.exprs.length && !child.spreadElement)
+          memo.push(t__namespace.stringLiteral("<!--#-->"));
+        if (child.exprs.length && !child.spreadElement)
+          child.exprs[0] = escapeExpression(path, child.exprs[0]);
         memo.push(getCreateTemplate(config, path, child)(path, child, true));
-        if (markers && child.exprs.length && !child.spreadElement) memo.push(t__namespace.stringLiteral("<!--/-->"));
+        if (markers && child.exprs.length && !child.spreadElement)
+          memo.push(t__namespace.stringLiteral("<!--/-->"));
       }
       return memo;
     }, []);

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.35.8",
+  "version": "0.35.10",
   "author": "Ryan Carniato",
   "license": "MIT",
   "repository": {
@@ -27,5 +27,5 @@
   "peerDependencies": {
     "@babel/core": "^7.0.0"
   },
-  "gitHead": "17ea89fb40b4c65633bd7916f063be9751b25602"
+  "gitHead": "fa02473265bc994e8f858ae60be40527a584c66f"
 }