@plumeria/turbopack-loader 18.0.1 → 18.1.0

package/dist/index.js

@@ -809,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) {
@@ -862,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;
             };
@@ -1074,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;
@@ -1203,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(' ');
@@ -1241,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',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/turbopack-loader",
-  "version": "18.0.1",
+  "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.1",
-    "@plumeria/utils": "^18.0.1"
+    "@plumeria/compiler": "^18.1.0",
+    "@plumeria/utils": "^18.1.0"
   },
   "devDependencies": {
     "@swc/core": "1.15.43",