@plumeria/turbopack-loader 18.0.0 → 18.1.0

package/dist/index.js

@@ -222,6 +222,13 @@ async function loader(source) {
                 const actualPath = (0, utils_1.resolveImportPath)(sourcePath, resourcePath);
                 if (actualPath) {
                     node.specifiers.forEach((specifier) => {
+                        if (specifier.type === 'ImportNamespaceSpecifier') {
+                            localImports[specifier.local.value] = {
+                                actualPath,
+                                importedName: '*',
+                            };
+                            return;
+                        }
                         if (specifier.type === 'ImportSpecifier' ||
                             specifier.type === 'ImportDefaultSpecifier') {
                             const importedName = specifier.type === 'ImportDefaultSpecifier'
@@ -802,6 +809,95 @@ async function loader(source) {
                     return scannedTables.createObjectTable[hash];
                 return null;
             };
+            const resolveBracketGroup = (node) => {
+                if (!utils_1.t.isMemberExpression(node) ||
+                    !utils_1.t.isIdentifier(node.object) ||
+                    node.property.type !== 'Computed' ||
+                    utils_1.t.isStringLiteral(node.property.expression)) {
+                    return null;
+                }
+                const varName = node.object.value;
+                const obj = resolveCreateObject(varName);
+                return obj ? { varName, keyExpr: node.property.expression, obj } : null;
+            };
+            const buildDecision = (node, prefix, off, counter) => {
+                if (node.type === 'ParenthesisExpression') {
+                    return buildDecision(node.expression, prefix, off, counter);
+                }
+                if (node.type === 'ConditionalExpression') {
+                    const a = buildDecision(node.consequent, prefix, off, counter);
+                    if (!a)
+                        return null;
+                    const b = buildDecision(node.alternate, prefix, off, counter);
+                    if (!b)
+                        return null;
+                    return {
+                        keyExpr: `((${getSource(node.test)}) ? ${a.keyExpr} : ${b.keyExpr})`,
+                        options: [...a.options, ...b.options],
+                        leaves: a.leaves + b.leaves,
+                        hasGroup: a.hasGroup || b.hasGroup,
+                    };
+                }
+                if (node.type === 'BinaryExpression' && node.operator === '&&') {
+                    const right = buildDecision(node.right, prefix, off, counter);
+                    if (!right)
+                        return null;
+                    return {
+                        keyExpr: `((${getSource(node.left)}) ? ${right.keyExpr} : ${JSON.stringify(off)})`,
+                        options: right.options,
+                        leaves: right.leaves,
+                        hasGroup: right.hasGroup,
+                    };
+                }
+                const group = resolveBracketGroup(node);
+                if (group) {
+                    return {
+                        keyExpr: getSource(group.keyExpr),
+                        options: Object.entries(group.obj).map(([value, style]) => ({
+                            value,
+                            style: style,
+                        })),
+                        leaves: 1,
+                        hasGroup: true,
+                    };
+                }
+                const style = resolveStyleObject(node);
+                if (!style)
+                    return null;
+                const value = `${prefix}${counter.n++}`;
+                return {
+                    keyExpr: JSON.stringify(value),
+                    options: [{ value, style }],
+                    leaves: 1,
+                    hasGroup: false,
+                };
+            };
+            const collectGroupKeys = (node, acc) => {
+                if (node.type === 'ParenthesisExpression') {
+                    collectGroupKeys(node.expression, acc);
+                }
+                else if (node.type === 'ConditionalExpression') {
+                    collectGroupKeys(node.consequent, acc);
+                    collectGroupKeys(node.alternate, acc);
+                }
+                else if (node.type === 'BinaryExpression' && node.operator === '&&') {
+                    collectGroupKeys(node.right, acc);
+                }
+                else {
+                    const group = resolveBracketGroup(node);
+                    if (group)
+                        Object.keys(group.obj).forEach((k) => acc.add(k));
+                }
+            };
+            const resolveDecision = (node) => {
+                const groupKeys = new Set();
+                collectGroupKeys(node, groupKeys);
+                let prefix = '#';
+                while ([...groupKeys].some((k) => k.startsWith(prefix)))
+                    prefix += '#';
+                const off = groupKeys.has('') ? `${prefix}off` : '';
+                return buildDecision(node, prefix, off, { n: 0 });
+            };
             const collectConditions = (node, currentTestStrings = []) => {
                 const staticStyle = resolveStyleObject(node);
                 if (staticStyle) {
@@ -855,14 +951,6 @@ async function loader(source) {
                 else if (node.type === 'ParenthesisExpression') {
                     return collectConditions(node.expression, currentTestStrings);
                 }
-                if (currentTestStrings.length > 0 &&
-                    utils_1.t.isMemberExpression(node) &&
-                    utils_1.t.isIdentifier(node.object) &&
-                    node.property.type === 'Computed' &&
-                    resolveCreateObject(node.object.value)) {
-                    const varName = node.object.value;
-                    throwCompilationError(`Plumeria: "${getSource(node)}" cannot be used inside a condition, because its bracket key is not a literal.\nMove the condition into the brackets instead, e.g. ${varName}[cond ? 'a' : 'b'].`, node);
-                }
                 assertResolvable(node);
                 return false;
             };
@@ -1067,6 +1155,22 @@ async function loader(source) {
                         continue;
                     }
                 }
+                const decision = resolveDecision(expr);
+                if (decision && (decision.hasGroup || decision.leaves > 2)) {
+                    const groupId = ++groupIdCounter;
+                    decision.options.forEach(({ value, style }) => conditionals.push({
+                        test: expr,
+                        testLHS: decision.keyExpr,
+                        testString: `${decision.keyExpr} === '${value}'`,
+                        truthy: style,
+                        falsy: {},
+                        groupId,
+                        groupName: undefined,
+                        valueName: value,
+                        varName: undefined,
+                    }));
+                    continue;
+                }
                 const handled = collectConditions(expr);
                 if (handled)
                     continue;
@@ -1196,7 +1300,7 @@ async function loader(source) {
                     getSource(options[0].test);
                 const lookupMap = {};
                 options.forEach((opt) => {
-                    if (opt.valueName && opt.truthy) {
+                    if (opt.valueName !== undefined && opt.truthy) {
                         const className = processStyleRecords(opt.truthy)
                             .map((r) => r.hash)
                             .join(' ');
@@ -1234,6 +1338,15 @@ async function loader(source) {
                         conflictVarGroups[c.groupId].push(c);
                     }
                 });
+                Object.keys(conflictVarGroups).forEach((id) => {
+                    const groupId = Number(id);
+                    const opts = conflictVarGroups[groupId];
+                    if (opts.some((c) => c.valueName === ''))
+                        return;
+                    const off = conditionals.find((c) => c.groupId === groupId && c.valueName === '');
+                    if (off)
+                        opts.push({ ...off, truthy: {}, falsy: {} });
+                });
                 Object.entries(conflictVarGroups).forEach(([, opts]) => {
                     dimensions.push({
                         type: 'var',
@@ -1278,12 +1391,8 @@ async function loader(source) {
         };
         (0, utils_1.traverse)(ast, {
             JSXOpeningElement({ node }) {
-                let tagName = '';
-                if (node.name.type === 'Identifier') {
-                    tagName = node.name.value;
-                }
                 jsxOpeningElementMap.set(node.span.start, {
-                    tagName,
+                    compKey: (0, utils_1.resolveComponentKey)(node.name, resourcePath, localImports),
                     attributes: node.attributes,
                 });
             },
@@ -1463,30 +1572,17 @@ async function loader(source) {
                     return;
                 const attrName = node.name.value;
                 if (attrName !== styleProp) {
-                    let parentTagName = '';
+                    let compKey = null;
                     for (const [, val] of jsxOpeningElementMap) {
                         const found = val.attributes
                             .filter((a) => a.type === 'JSXAttribute')
                             .find((a) => a.span.start === node.span.start);
                         if (found) {
-                            parentTagName = val.tagName;
+                            compKey = val.compKey;
                             break;
                         }
                     }
-                    if (parentTagName &&
-                        parentTagName[0] === parentTagName[0].toUpperCase()) {
-                        let compKey;
-                        const imported = localImports[parentTagName];
-                        if (imported) {
-                            compKey = `${imported.actualPath}-${imported.importedName}`;
-                            const resolved = (0, utils_1.resolveExport)(imported.actualPath, imported.importedName);
-                            if (resolved) {
-                                compKey = `${resolved.filePath}-${resolved.localName}`;
-                            }
-                        }
-                        else {
-                            compKey = `${resourcePath}-${parentTagName}`;
-                        }
+                    if (compKey) {
                         const list = scannedTables.componentPropsTable?.[compKey]?.[attrName];
                         if (list &&
                             node.value &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/turbopack-loader",
-  "version": "18.0.0",
+  "version": "18.1.0",
   "description": "Plumeria Turbopack-loader",
   "author": "Refirst 11",
   "license": "MIT",
@@ -22,8 +22,8 @@
     "zero-virtual.css"
   ],
   "dependencies": {
-    "@plumeria/compiler": "^18.0.0",
-    "@plumeria/utils": "^18.0.0"
+    "@plumeria/compiler": "^18.1.0",
+    "@plumeria/utils": "^18.1.0"
   },
   "devDependencies": {
     "@swc/core": "1.15.43",