@plumeria/compiler 10.0.6 → 10.0.7

package/dist/index.js

@@ -190,7 +190,10 @@ function compileCSS(options) {
             mergedKeyframesTable[key] = scannedTables.keyframesHashTable[key];
         }
         for (const key of Object.keys(importMap)) {
-            mergedKeyframesTable[key] = importMap[key];
+            const val = importMap[key];
+            if (typeof val === 'string') {
+                mergedKeyframesTable[key] = val;
+            }
         }
         const mergedViewTransitionTable = {};
         for (const key of Object.keys(scannedTables.viewTransitionHashTable)) {
@@ -198,14 +201,20 @@ function compileCSS(options) {
                 scannedTables.viewTransitionHashTable[key];
         }
         for (const key of Object.keys(importMap)) {
-            mergedViewTransitionTable[key] = importMap[key];
+            const val = importMap[key];
+            if (typeof val === 'string') {
+                mergedViewTransitionTable[key] = val;
+            }
         }
         const mergedCreateThemeHashTable = {};
         for (const key of Object.keys(scannedTables.createThemeHashTable)) {
             mergedCreateThemeHashTable[key] = scannedTables.createThemeHashTable[key];
         }
         for (const key of Object.keys(importMap)) {
-            mergedCreateThemeHashTable[key] = importMap[key];
+            const val = importMap[key];
+            if (typeof val === 'string') {
+                mergedCreateThemeHashTable[key] = val;
+            }
         }
         const mergedCreateStaticHashTable = {};
         for (const key of Object.keys(scannedTables.createStaticHashTable)) {
@@ -213,21 +222,30 @@ function compileCSS(options) {
                 scannedTables.createStaticHashTable[key];
         }
         for (const key of Object.keys(importMap)) {
-            mergedCreateStaticHashTable[key] = importMap[key];
+            const val = importMap[key];
+            if (typeof val === 'string') {
+                mergedCreateStaticHashTable[key] = val;
+            }
         }
         const mergedCreateTable = {};
         for (const key of Object.keys(scannedTables.createHashTable)) {
             mergedCreateTable[key] = scannedTables.createHashTable[key];
         }
         for (const key of Object.keys(importMap)) {
-            mergedCreateTable[key] = importMap[key];
+            const val = importMap[key];
+            if (typeof val === 'string') {
+                mergedCreateTable[key] = val;
+            }
         }
         const mergedVariantsTable = {};
         for (const key of Object.keys(scannedTables.variantsHashTable)) {
             mergedVariantsTable[key] = scannedTables.variantsHashTable[key];
         }
         for (const key of Object.keys(importMap)) {
-            mergedVariantsTable[key] = importMap[key];
+            const val = importMap[key];
+            if (typeof val === 'string') {
+                mergedVariantsTable[key] = val;
+            }
         }
         const ctx = {
             mergedStaticTable,
@@ -285,8 +303,7 @@ function compileCSS(options) {
                     ]);
                     return true;
                 }
-                else if (node.type === 'BinaryExpression' &&
-                    node.operator === '&&') {
+                else if (node.type === 'BinaryExpression' && node.operator === '&&') {
                     collectConditions(node.right, [
                         ...testStrings,
                         `(${getSource(node.left)})`,
@@ -308,8 +325,10 @@ function compileCSS(options) {
                     const varName = node.callee.object.value;
                     const propKey = node.callee.property.value;
                     const styleInfo = ctx.localCreateStyles[varName];
-                    const atomMap = styleInfo?.obj?.[propKey];
-                    if (atomMap?.['__cssVars__']) {
+                    const atomMap = styleInfo?.obj[propKey];
+                    if (typeof atomMap === 'object' &&
+                        atomMap !== null &&
+                        '__cssVars__' in atomMap) {
                         throw new Error(`[plumeria] css.use(${getSource(node)}) cannot handle dynamic style functions. Use styleName instead.\n`);
                     }
                 }
@@ -348,8 +367,11 @@ function compileCSS(options) {
                     processStyle(cond.falsy);
             }
         };
+        const processedNodes = new WeakSet();
         const processCall = (node) => {
-            node._processed = true;
+            if (processedNodes.has(node))
+                return;
+            processedNodes.add(node);
             const callee = node.callee;
             let propName;
             if (utils_1.t.isMemberExpression(callee) &&
@@ -412,12 +434,10 @@ function compileCSS(options) {
                     if (utils_1.t.isMemberExpression(callee) &&
                         utils_1.t.isIdentifier(callee.object) &&
                         utils_1.t.isIdentifier(callee.property)) {
-                        if (plumeriaAliases[callee.object.value] ===
-                            'NAMESPACE')
+                        if (plumeriaAliases[callee.object.value] === 'NAMESPACE')
                             pName = callee.property.value;
                     }
-                    else if (utils_1.t.isIdentifier(callee) &&
-                        plumeriaAliases[callee.value]) {
+                    else if (utils_1.t.isIdentifier(callee) && plumeriaAliases[callee.value]) {
                         pName = plumeriaAliases[callee.value];
                     }
                     if (pName &&
@@ -446,12 +466,25 @@ function compileCSS(options) {
                                     if (!isArrow && !isFunc)
                                         return;
                                     const key = prop.key.value;
-                                    const params = prop.value.params.map((p) => p.type === 'Identifier' ? p.value : (p.pat?.value ?? 'arg'));
+                                    const func = prop.value;
+                                    if (func.type !== 'ArrowFunctionExpression' &&
+                                        func.type !== 'FunctionExpression')
+                                        return;
+                                    const params = func.params.map((p) => {
+                                        if (utils_1.t.isIdentifier(p))
+                                            return p.value;
+                                        if (typeof p === 'object' &&
+                                            p !== null &&
+                                            'pat' in p &&
+                                            utils_1.t.isIdentifier(p.pat))
+                                            return p.pat.value;
+                                        return 'arg';
+                                    });
                                     const tempStaticTable = { ...ctx.mergedStaticTable };
                                     params.forEach((paramName) => {
                                         tempStaticTable[paramName] = `var(--${key}-${paramName})`;
                                     });
-                                    let actualBody = prop.value.body;
+                                    let actualBody = func.body;
                                     if (actualBody?.type === 'ParenthesisExpression')
                                         actualBody = actualBody.expression;
                                     if (actualBody?.type === 'BlockStatement') {
@@ -498,19 +531,21 @@ function compileCSS(options) {
                     traverseInternal(node.body);
             },
             CallExpression: (path) => {
-                if (!path.node._processed)
+                if (!processedNodes.has(path.node))
                     processCall(path.node);
             },
             JSXAttribute({ node }) {
-                if (node.name?.value !== 'styleName')
+                if (node.name.value !== 'styleName')
                     return;
                 if (!node.value || node.value.type !== 'JSXExpressionContainer')
                     return;
+                if (node.value.expression.type === 'JSXEmptyExpression')
+                    return;
                 const expr = node.value.expression;
                 const args = expr.type === 'ArrayExpression'
                     ? expr.elements
-                        .filter(Boolean)
-                        .map((el) => ({ expression: el.expression ?? el }))
+                        .filter((el) => el !== undefined)
+                        .map((el) => ({ expression: el.expression }))
                     : [{ expression: expr }];
                 extractAndProcessConditionals(args, true);
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/compiler",
-  "version": "10.0.6",
+  "version": "10.0.7",
   "description": "Plumeria swc based compiler for statically extracting css",
   "author": "Refirst 11",
   "license": "MIT",
@@ -21,7 +21,7 @@
     "dist/"
   ],
   "dependencies": {
-    "@plumeria/utils": "^10.0.6"
+    "@plumeria/utils": "^10.0.7"
   },
   "devDependencies": {
     "@rust-gear/glob": "1.0.0",