babel-plugin-essor 0.0.11 → 0.0.12

package/dist/index.cjs

@@ -71,8 +71,8 @@ var transformProgram = {
     state.opts = __spreadValues(__spreadValues({}, defaultOption), state.opts);
     path.state = {
       h: path.scope.generateUidIdentifier("h$"),
-      renderTemplate: path.scope.generateUidIdentifier("renderTemplate$"),
       template: path.scope.generateUidIdentifier("template$"),
+      ssg: path.scope.generateUidIdentifier("ssg$"),
       useSignal: path.scope.generateUidIdentifier("signal$"),
       useComputed: path.scope.generateUidIdentifier("computed$"),
       useReactive: path.scope.generateUidIdentifier("reactive$"),
@@ -163,7 +163,7 @@ function setNodeText(path, text) {
 }
 function isSymbolStart(path, name) {
   const state = path.state;
-  const { symbol } = state.opts;
+  const { symbol } = (state == null ? void 0 : state.opts) || "$";
   return startsWith(name, symbol);
 }
 
@@ -208,9 +208,13 @@ var svgTags = [
 
 // src/jsx/index.ts
 var isSsg = false;
-function addToTemplate(result, content) {
+function addToTemplate(result, content, join = false) {
   if (isSsg) {
-    result.template.push(content);
+    if (join && result.template.length > 0) {
+      result.template[result.template.length - 1] += content;
+    } else {
+      result.template.push(content);
+    }
   } else {
     result.template += content;
   }
@@ -231,14 +235,11 @@ function transformJSX(path) {
 function createEssorNode(path, result) {
   var _a;
   const state = path.state;
-  let tmpl;
-  if (path.isJSXElement() && isComponent(getTagName(path.node))) {
-    tmpl = import_core3.types.identifier(getTagName(path.node));
-  } else {
-    tmpl = path.scope.generateUidIdentifier("_tmpl$");
+  const isComponent2 = path.isJSXElement() && isComponent(getTagName(path.node));
+  const tmpl = isComponent2 ? import_core3.types.identifier(getTagName(path.node)) : path.scope.generateUidIdentifier("_tmpl$");
+  if (!isComponent2) {
     const template = isSsg ? import_core3.types.arrayExpression(result.template.map(import_core3.types.stringLiteral)) : import_core3.types.callExpression(state.template, [import_core3.types.stringLiteral(result.template)]);
-    const declarator = import_core3.types.variableDeclarator(tmpl, template);
-    state.tmplDeclaration.declarations.push(declarator);
+    state.tmplDeclaration.declarations.push(import_core3.types.variableDeclarator(tmpl, template));
     if (!isSsg) {
       imports.add("template");
     }
@@ -246,10 +247,11 @@ function createEssorNode(path, result) {
   const args = [tmpl, createProps(result.props)];
   const key = result.props.key || ((_a = result.props[0]) == null ? void 0 : _a.key);
   if (key) {
-    args.push(key);
+    args.push(import_core3.types.identifier(`${key}`));
   }
-  imports.add(isSsg ? "renderTemplate" : "h");
-  return import_core3.types.callExpression(isSsg ? state.renderTemplate : state.h, args);
+  const fnName = isSsg ? "ssg" : "h";
+  imports.add(fnName);
+  return import_core3.types.callExpression(state[fnName], args);
 }
 function createProps(props) {
   const toAstNode = (value) => {
@@ -288,7 +290,7 @@ function transformJSXElement(path, result, isRoot = false) {
     const tagIsComponent = isComponent(tagName);
     const isSelfClose = !tagIsComponent && selfClosingTags.includes(tagName);
     const isSvg = svgTags.includes(tagName) && result.index === 1;
-    const props = getAttrProps(path);
+    const { props, hasExpression } = getAttrProps(path);
     if (tagIsComponent) {
       if (isRoot) {
         result.props = props;
@@ -305,12 +307,12 @@ function transformJSXElement(path, result, isRoot = false) {
       if (isSvg) {
         result.template = isSsg ? ["<svg _svg_>"] : "<svg _svg_>";
       }
-      addToTemplate(result, `<${tagName}`);
+      addToTemplate(result, `<${tagName}`, true);
       handleAttributes(props, result);
-      addToTemplate(result, isSelfClose ? "/>" : ">");
+      addToTemplate(result, isSelfClose ? "/>" : ">", !hasExpression);
       if (!isSelfClose) {
         transformChildren(path, result);
-        if (hasSiblingElement(path)) {
+        if (hasSiblingElement(path) || isSsg) {
           addToTemplate(result, `</${tagName}>`);
         }
       }
@@ -373,54 +375,25 @@ function getNodeText(path) {
 function handleAttributes(props, result) {
   let klass = "";
   let style = "";
-  for (const prop in props) {
-    let value = props[prop];
+  for (const [prop, value] of Object.entries(props)) {
     if (prop === "class" && typeof value === "string") {
       klass += ` ${value}`;
       delete props[prop];
-      continue;
-    }
-    if (prop === "style" && typeof value === "string") {
+    } else if (prop === "style" && typeof value === "string") {
       style += `${value}${value.at(-1) === ";" ? "" : ";"}`;
       delete props[prop];
-      continue;
-    }
-    if (value === true) {
+    } else if (value === true) {
       addToTemplate(result, ` ${prop}`);
       delete props[prop];
-    }
-    if (value === false) {
+    } else if (value === false) {
       delete props[prop];
-    }
-    if (typeof value === "string" || typeof value === "number") {
+    } else if (typeof value === "string" || typeof value === "number") {
       addToTemplate(result, ` ${prop}="${value}"`);
       delete props[prop];
-    }
-    if (import_core3.types.isConditionalExpression(value)) {
-      const { test, consequent, alternate } = value;
-      value = import_core3.types.arrowFunctionExpression([], import_core3.types.conditionalExpression(test, consequent, alternate));
-      props[prop] = value;
-    }
-    if (import_core3.types.isObjectExpression(value)) {
-      let hasConditional = false;
-      value.properties.forEach((property) => {
-        if (import_core3.types.isObjectProperty(property) && import_core3.types.isConditionalExpression(property.value)) {
-          hasConditional = true;
-        }
-      });
-      if (hasConditional) {
-        value = import_core3.types.arrowFunctionExpression([], value);
-        props[prop] = value;
-      } else {
-        if (prop === "style") {
-          value.properties.forEach((property) => {
-            if (import_core3.types.isObjectProperty(property)) {
-              style += `${property.key.name}:${property.value.value};`;
-            }
-          });
-          delete props[prop];
-        }
-      }
+    } else if (import_core3.types.isConditionalExpression(value)) {
+      props[prop] = import_core3.types.arrowFunctionExpression([], value);
+    } else if (import_core3.types.isObjectExpression(value)) {
+      handleObjectExpression(prop, value, props, style);
     }
   }
   if (Object.keys(props).length > 0) {
@@ -435,6 +408,21 @@ function handleAttributes(props, result) {
     addToTemplate(result, ` style="${style}"`);
   }
 }
+function handleObjectExpression(prop, value, props, style) {
+  const hasConditional = value.properties.some(
+    (property) => import_core3.types.isObjectProperty(property) && import_core3.types.isConditionalExpression(property.value)
+  );
+  if (hasConditional) {
+    props[prop] = import_core3.types.arrowFunctionExpression([], value);
+  } else if (prop === "style") {
+    value.properties.forEach((property) => {
+      if (import_core3.types.isObjectProperty(property)) {
+        style += `${property.key.name}:${property.value.value};`;
+      }
+    });
+    delete props[prop];
+  }
+}
 function replaceChild(node, result) {
   var _a, _b, _c, _d, _e;
   if (result.isLastChild) {
@@ -474,6 +462,7 @@ function isValidChild(path) {
 }
 function getAttrProps(path) {
   const props = {};
+  let hasExpression = false;
   path.get("openingElement").get("attributes").forEach((attribute) => {
     if (attribute.isJSXAttribute()) {
       const name = getAttrName(attribute.node);
@@ -493,6 +482,7 @@ function getAttrProps(path) {
             transformJSX(expression);
             props[name] = expression.node;
           } else if (expression.isExpression()) {
+            hasExpression = true;
             if (/^key|ref|on.+$/.test(name)) {
               props[name] = expression.node;
             } else if (/^bind:.+/.test(name)) {
@@ -518,72 +508,54 @@ function getAttrProps(path) {
       }
     } else if (attribute.isJSXSpreadAttribute()) {
       props._$spread$ = attribute.get("argument").node;
+      hasExpression = true;
     } else {
       throw new Error("Unsupported attribute type");
     }
   });
-  return props;
+  return {
+    props,
+    hasExpression
+  };
 }
 
 // src/signal/symbol.ts
 var import_core4 = require("@babel/core");
 function replaceSymbol(path) {
-  const init = path.node.init;
-  const variableName = path.node.id.name;
-  if (import_core4.types.isObjectPattern(path.node.id) || import_core4.types.isArrayPattern(path.node.id)) {
-    return;
-  }
-  if (!isSymbolStart(path, variableName)) {
-    return;
-  }
-  if (init && (import_core4.types.isFunctionExpression(init) || import_core4.types.isArrowFunctionExpression(init)) && path.parent.kind === "const") {
-    const newInit = import_core4.types.callExpression(import_core4.types.identifier(path.state.useComputed.name), init ? [init] : []);
-    imports.add("useComputed");
-    path.node.init = newInit;
-  } else {
-    const newInit = import_core4.types.callExpression(import_core4.types.identifier(path.state.useSignal.name), init ? [init] : []);
-    imports.add("useSignal");
-    path.node.init = newInit;
-  }
+  const { init, id } = path.node;
+  const variableName = id.name;
+  if (import_core4.types.isObjectPattern(id) || import_core4.types.isArrayPattern(id) || !isSymbolStart(path, variableName)) return;
+  const isComputed = init && (import_core4.types.isFunctionExpression(init) || import_core4.types.isArrowFunctionExpression(init)) && path.parent.kind === "const";
+  const hookName = isComputed ? "useComputed" : "useSignal";
+  const newInit = import_core4.types.callExpression(import_core4.types.identifier(path.state[hookName].name), init ? [init] : []);
+  imports.add(hookName);
+  path.node.init = newInit;
 }
 function symbolIdentifier(path) {
   const parentPath = path.parentPath;
-  if (!parentPath || import_core4.types.isVariableDeclarator(parentPath) || import_core4.types.isImportSpecifier(parentPath) || import_core4.types.isObjectProperty(parentPath) || import_core4.types.isArrayPattern(parentPath) || import_core4.types.isObjectPattern(parentPath)) {
-    return;
-  }
+  if (!shouldProcessIdentifier(parentPath)) return;
   const { node } = path;
-  if (isSymbolStart(path, node.name)) {
-    let currentPath = path;
-    while (currentPath.parentPath && !currentPath.parentPath.isProgram()) {
-      if (currentPath.parentPath.isMemberExpression() && currentPath.parentPath.node.property.name === "value") {
-        return;
-      }
-      currentPath = currentPath.parentPath;
-    }
-    const newNode = import_core4.types.memberExpression(import_core4.types.identifier(node.name), import_core4.types.identifier("value"));
-    path.replaceWith(newNode);
+  if (!isSymbolStart(path, node.name)) return;
+  if (!path.findParent((p) => p.isMemberExpression() && p.node.property.name === "value")) {
+    path.replaceWith(import_core4.types.memberExpression(import_core4.types.identifier(node.name), import_core4.types.identifier("value")));
   }
 }
+function shouldProcessIdentifier(parentPath) {
+  return parentPath && !import_core4.types.isVariableDeclarator(parentPath) && !import_core4.types.isImportSpecifier(parentPath) && !import_core4.types.isObjectProperty(parentPath) && !import_core4.types.isArrayPattern(parentPath) && !import_core4.types.isObjectPattern(parentPath);
+}
 function symbolObjectPattern(path) {
   path.node.properties.forEach((property) => {
     if (import_core4.types.isObjectProperty(property) && import_core4.types.isIdentifier(property.key) && isSymbolStart(path, property.key.name)) {
-      const newKey = import_core4.types.identifier(property.key.name);
-      property.key = newKey;
+      property.key = import_core4.types.identifier(property.key.name);
     }
   });
 }
 function symbolArrayPattern(path) {
   path.node.elements.forEach((element) => {
     if (import_core4.types.isIdentifier(element) && element.name.startsWith("$")) {
-      const newElement = import_core4.types.identifier(element.name);
-      element.name = newElement.name;
+      element.name = import_core4.types.identifier(element.name).name;
     } else if (import_core4.types.isObjectPattern(element)) {
-      element.properties.forEach((property) => {
-        if (import_core4.types.isObjectProperty(property) && import_core4.types.isIdentifier(property.key) && isSymbolStart(path, property.key.name)) {
-          const newKey = import_core4.types.identifier(property.key.name);
-          property.key = newKey;
-        }
-      });
+      symbolObjectPattern({ node: element });
     }
   });
 }
@@ -591,35 +563,29 @@ function symbolArrayPattern(path) {
 // src/signal/import.ts
 var import_core5 = require("@babel/core");
 function replaceImportDeclaration(path) {
-  const imports2 = path.node.specifiers;
-  imports2.forEach((specifier) => {
+  path.node.specifiers.forEach((specifier) => {
     const variableName = specifier.local.name;
     if (startsWith(variableName, "$") && !isVariableUsedAsObject(path, variableName)) {
       path.scope.rename(variableName, `${variableName}.value`);
-      specifier.local.name = `${variableName}`;
+      specifier.local.name = variableName;
     }
   });
 }
 function isVariableUsedAsObject(path, variableName) {
+  var _a;
   const binding = path.scope.getBinding(variableName);
-  let isUsedObject = false;
-  if (!binding || !binding.referencePaths) {
-    return isUsedObject;
-  }
-  for (const referencePath of binding.referencePaths) {
+  return ((_a = binding == null ? void 0 : binding.referencePaths) == null ? void 0 : _a.some((referencePath) => {
     if (import_core5.types.isMemberExpression(referencePath.parent)) {
-      const memberExprParent = referencePath.parent;
-      if (import_core5.types.isIdentifier(memberExprParent.object, { name: variableName })) {
-        const newMemberExpr = import_core5.types.memberExpression(
-          import_core5.types.memberExpression(memberExprParent.object, import_core5.types.identifier("value")),
-          memberExprParent.property
+      const { object, property } = referencePath.parent;
+      if (import_core5.types.isIdentifier(object, { name: variableName })) {
+        referencePath.parentPath.replaceWith(
+          import_core5.types.memberExpression(import_core5.types.memberExpression(object, import_core5.types.identifier("value")), property)
         );
-        referencePath.parentPath.replaceWith(newMemberExpr);
-        isUsedObject = true;
+        return true;
       }
     }
-  }
-  return isUsedObject;
+    return false;
+  })) || false;
 }
 
 // src/signal/props.ts
@@ -628,65 +594,56 @@ function replaceProps(path) {
   var _a;
   const state = path.state;
   const firstParam = path.node.params[0];
-  if (!firstParam || !import_core6.types.isObjectPattern(firstParam)) {
-    return;
-  }
+  if (!firstParam || !import_core6.types.isObjectPattern(firstParam)) return;
   const returnStatement = path.get("body").get("body").find((statement) => statement.isReturnStatement());
-  if (!returnStatement) {
-    return;
-  }
-  const returnValue = (_a = returnStatement.node) == null ? void 0 : _a.argument;
-  if (!import_core6.types.isJSXElement(returnValue)) {
-    return;
-  }
-  function replaceProperties(properties2, parentPath) {
+  if (!returnStatement || !import_core6.types.isJSXElement((_a = returnStatement.node) == null ? void 0 : _a.argument)) return;
+  const replaceProperties = (properties2, parentPath) => {
     properties2.forEach((property) => {
-      if (import_core6.types.isObjectProperty(property)) {
+      if (import_core6.types.isObjectProperty(property) && import_core6.types.isIdentifier(property.key)) {
         const keyName = property.key.name;
         if (import_core6.types.isIdentifier(property.value)) {
-          const propertyName = property.value.name;
-          const newName = `${parentPath}${keyName}`;
-          path.scope.rename(propertyName, newName);
+          path.scope.rename(property.value.name, `${parentPath}${keyName}`);
         } else if (import_core6.types.isObjectPattern(property.value)) {
           replaceProperties(property.value.properties, `${parentPath}${keyName}.`);
         }
       }
     });
-  }
+  };
   const properties = firstParam.properties;
-  replaceProperties(
-    properties.filter((property) => !import_core6.types.isRestElement(property)),
-    "__props."
-  );
   const notRestProperties = properties.filter((property) => !import_core6.types.isRestElement(property));
-  const notRestNames = notRestProperties.map(
-    (property) => property.key.name
-  );
+  replaceProperties(notRestProperties, "__props.");
+  const notRestNames = notRestProperties.map((property) => property.key.name);
   if (notRestNames.some((name) => startsWith(name, "$"))) {
     console.warn("props name can not start with $");
     return;
   }
+  handleRestElement(path, state, properties, notRestNames);
+}
+function handleRestElement(path, state, properties, notRestNames) {
   const restElement = properties.find((property) => import_core6.types.isRestElement(property));
   path.node.params[0] = import_core6.types.identifier("__props");
   if (restElement) {
     const restName = restElement.argument.name;
-    if (notRestProperties.length === 0) {
+    if (notRestNames.length === 0) {
       path.node.params[0] = import_core6.types.identifier(restName);
     } else {
-      const restVariableDeclaration = import_core6.types.variableDeclaration("const", [
-        import_core6.types.variableDeclarator(
-          import_core6.types.identifier(restName),
-          import_core6.types.callExpression(state.useReactive, [
-            import_core6.types.identifier("__props"),
-            import_core6.types.arrayExpression(notRestNames.map((name) => import_core6.types.stringLiteral(name)))
-          ])
-        )
-      ]);
+      const restVariableDeclaration = createRestVariableDeclaration(state, restName, notRestNames);
       imports.add("useReactive");
       path.node.body.body.unshift(restVariableDeclaration);
     }
   }
 }
+function createRestVariableDeclaration(state, restName, notRestNames) {
+  return import_core6.types.variableDeclaration("const", [
+    import_core6.types.variableDeclarator(
+      import_core6.types.identifier(restName),
+      import_core6.types.callExpression(state.useReactive, [
+        import_core6.types.identifier("__props"),
+        import_core6.types.arrayExpression(notRestNames.map((name) => import_core6.types.stringLiteral(name)))
+      ])
+    )
+  ]);
+}
 
 // src/index.ts
 function src_default() {
@@ -713,7 +670,7 @@ function src_default() {
   };
 }
 /**
-* @estjs/shared v0.0.11
+* @estjs/shared v0.0.12
 * (c) 2023-Present jiangxd <jiangxd2016@gmail.com>
 * @license MIT
 **/