babel-plugin-essor 0.0.15-beta.12 → 0.0.15-beta.13

package/dist/index.cjs

@@ -21245,7 +21245,8 @@ var DEFAULT_OPTIONS = {
   symbol: "$",
   props: true,
   hmr: true,
-  styled: false
+  styled: false,
+  enableFor: false
 };
 var IMPORTS_MAPS = [
   // Reactive API
@@ -21262,6 +21263,7 @@ var IMPORTS_MAPS = [
   "Portal",
   // Template related
   "mapNodes",
+  "mapArray",
   "template",
   "delegateEvents",
   // styled
@@ -22815,34 +22817,16 @@ function generateIndexMap({
 }) {
   const indexSet = /* @__PURE__ */ new Set();
   for (const item of children) {
-    if (!O(item.parentIndex)) {
-      indexSet.add(item.parentIndex);
-    }
-    if (!O(item.before)) {
-      indexSet.add(item.before);
-    }
+    if (!O(item.parentIndex)) indexSet.add(item.parentIndex);
+    if (!O(item.before)) indexSet.add(item.before);
   }
   for (const item of props) {
-    if (!O(item.parentIndex)) {
-      indexSet.add(item.parentIndex);
-    }
+    if (!O(item.parentIndex)) indexSet.add(item.parentIndex);
   }
-  if (operations && operations.length > 0) {
-    for (const item of operations) {
-      if (!O(item.nodeIndex)) {
-        indexSet.add(item.nodeIndex);
-      }
-    }
+  for (const item of operations) {
+    if (!O(item.nodeIndex)) indexSet.add(item.nodeIndex);
   }
-  const indexMap = Array.from(indexSet).sort((a, b) => a - b);
-  {
-    for (const index of indexMap) {
-      if (!Number.isInteger(index) || index < 1) {
-        re(`Invalid index in index map: ${index}. All indices must be positive integers.`);
-      }
-    }
-  }
-  return indexMap;
+  return Array.from(indexSet).sort((a, b) => a - b);
 }
 function createRefStatement(nodesId, nodeIndex, value) {
   const elementRef = core.types.memberExpression(nodesId, core.types.numericLiteral(nodeIndex), true);
@@ -23002,7 +22986,123 @@ function createInsertArguments(dynamicContent, nodesIdentifier, indexMap) {
 function generateDynamicChildrenCode(dynamicChildren, statements, state, nodesId, indexMap) {
   addImport(importMap.insert);
   for (const dynamicContent of dynamicChildren) {
-    const processedNode = processIIFEExpression(dynamicContent.node);
+    let node = dynamicContent.node;
+    let mapCall = null;
+    if (core.types.isCallExpression(node) && core.types.isMemberExpression(node.callee) && core.types.isIdentifier(node.callee.property) && node.callee.property.name === "map" && node.arguments.length > 0) {
+      mapCall = node;
+    } else if (core.types.isArrowFunctionExpression(node) && core.types.isCallExpression(node.body) && core.types.isMemberExpression(node.body.callee) && core.types.isIdentifier(node.body.callee.property) && node.body.callee.property.name === "map" && node.body.arguments.length > 0) {
+      mapCall = node.body;
+    }
+    if (mapCall && state.opts.enableFor !== false) {
+      const listExpr = mapCall.callee.object;
+      const mapFn = mapCall.arguments[0];
+      if (core.types.isExpression(listExpr) && (core.types.isArrowFunctionExpression(mapFn) || core.types.isFunctionExpression(mapFn))) {
+        addImport(importMap.createComponent);
+        addImport(importMap.For);
+        let keyFnExpr = null;
+        let transformedMapFn = mapFn;
+        const mapFnBody = core.types.isArrowFunctionExpression(mapFn) ? mapFn.body : null;
+        const mapFnParams = mapFn.params;
+        let itemParamName = null;
+        if (mapFnParams.length > 0 && core.types.isIdentifier(mapFnParams[0])) {
+          itemParamName = mapFnParams[0].name;
+        }
+        if (itemParamName && mapFnBody) {
+          if (core.types.isCallExpression(mapFnBody)) {
+            const callee = mapFnBody.callee;
+            const args = mapFnBody.arguments;
+            const isCreateComponentCall = core.types.isIdentifier(callee) && callee.name.includes("createComponent") || core.types.isMemberExpression(callee) && core.types.isIdentifier(callee.property) && callee.property.name === "createComponent";
+            if (isCreateComponentCall && args.length >= 2) {
+              const componentRef = args[0];
+              const propsArg = args[1];
+              if (core.types.isExpression(componentRef) && core.types.isObjectExpression(propsArg)) {
+                const newProps = [];
+                for (const prop of propsArg.properties) {
+                  if (core.types.isObjectProperty(prop) && core.types.isIdentifier(prop.key) && prop.key.name === "key" && core.types.isExpression(prop.value)) {
+                    keyFnExpr = core.types.arrowFunctionExpression(
+                      [core.types.identifier(itemParamName)],
+                      prop.value
+                    );
+                  } else if (core.types.isObjectProperty(prop) || core.types.isSpreadElement(prop)) {
+                    newProps.push(prop);
+                  }
+                }
+                const newPropsObj = core.types.objectExpression(newProps);
+                const directCall = core.types.callExpression(componentRef, [newPropsObj]);
+                transformedMapFn = core.types.arrowFunctionExpression(mapFnParams, directCall);
+              }
+            }
+          } else if (core.types.isJSXElement(mapFnBody)) {
+            const opening = mapFnBody.openingElement;
+            const tagName = opening.name;
+            let componentRef = null;
+            if (core.types.isJSXIdentifier(tagName) && /^[A-Z]/.test(tagName.name)) {
+              componentRef = core.types.identifier(tagName.name);
+            } else if (core.types.isJSXMemberExpression(tagName)) {
+              const convertJSXName = (name) => {
+                if (core.types.isJSXIdentifier(name)) return core.types.identifier(name.name);
+                if (core.types.isJSXMemberExpression(name))
+                  return core.types.memberExpression(
+                    convertJSXName(name.object),
+                    convertJSXName(name.property)
+                  );
+                throw new Error("Unsupported JSX Member Expression");
+              };
+              componentRef = core.types.memberExpression(
+                convertJSXName(tagName.object),
+                convertJSXName(tagName.property)
+              );
+            }
+            if (componentRef) {
+              const newProps = [];
+              for (const attr of opening.attributes) {
+                if (core.types.isJSXAttribute(attr)) {
+                  const nameNode = attr.name;
+                  const name = core.types.isJSXIdentifier(nameNode) ? nameNode.name : nameNode.name.name;
+                  let valueExpr = core.types.booleanLiteral(true);
+                  if (attr.value) {
+                    if (core.types.isJSXExpressionContainer(attr.value)) {
+                      if (core.types.isExpression(attr.value.expression)) {
+                        valueExpr = attr.value.expression;
+                      } else {
+                        continue;
+                      }
+                    } else if (core.types.isStringLiteral(attr.value)) {
+                      valueExpr = attr.value;
+                    }
+                  }
+                  if (name === "key") {
+                    keyFnExpr = core.types.arrowFunctionExpression([core.types.identifier(itemParamName)], valueExpr);
+                  } else {
+                    newProps.push(core.types.objectProperty(core.types.identifier(name), valueExpr));
+                  }
+                } else if (core.types.isJSXSpreadAttribute(attr)) {
+                  newProps.push(core.types.spreadElement(attr.argument));
+                }
+              }
+              const newPropsObj = core.types.objectExpression(newProps);
+              const directCall = core.types.callExpression(componentRef, [newPropsObj]);
+              transformedMapFn = core.types.arrowFunctionExpression(mapFnParams, directCall);
+            }
+          }
+        }
+        const propsProperties = [
+          core.types.objectProperty(core.types.identifier("each"), core.types.arrowFunctionExpression([], listExpr)),
+          core.types.objectProperty(core.types.identifier("children"), transformedMapFn)
+        ];
+        if (keyFnExpr) {
+          propsProperties.push(core.types.objectProperty(core.types.identifier("keyFn"), keyFnExpr));
+        }
+        const propsObject = core.types.objectExpression(propsProperties);
+        const newExpr = core.types.callExpression(state.imports.createComponent, [
+          state.imports.For,
+          propsObject
+        ]);
+        dynamicContent.node = newExpr;
+        node = newExpr;
+      }
+    }
+    const processedNode = processIIFEExpression(node);
     const insertArgs = createInsertArguments(
       __spreadProps(__spreadValues({}, dynamicContent), { node: processedNode }),
       nodesId,