@plumeria/turbopack-loader 15.1.3 → 16.0.0

package/dist/index.js

@@ -125,6 +125,7 @@ async function loader(source) {
         const createThemeImportMap = {};
         const createStaticImportMap = {};
         const plumeriaAliases = {};
+        const localImports = {};
         (0, utils_1.traverse)(ast, {
             ImportDeclaration({ node }) {
                 const sourcePath = node.source.value;
@@ -153,6 +154,7 @@ async function loader(source) {
                                 : specifier.local.value;
                             const localName = specifier.local.value;
                             const uniqueKey = `${actualPath}-${importedName}`;
+                            localImports[localName] = { actualPath, importedName };
                             if (scannedTables.staticTable[uniqueKey]) {
                                 importMap[localName] = scannedTables.staticTable[uniqueKey];
                             }
@@ -267,6 +269,19 @@ async function loader(source) {
             mergedCreateStaticHashTable[key] = createStaticImportMap[key];
         }
         const localCreateStyles = {};
+        const localStyleAliases = {};
+        const checkStyleAliasAssignment = (decl) => {
+            if (!utils_1.t.isIdentifier(decl.id) || !decl.init)
+                return;
+            const init = decl.init;
+            if (utils_1.t.isMemberExpression(init) && utils_1.t.isIdentifier(init.object)) {
+                const objName = init.object.value;
+                if (localCreateStyles[objName] !== undefined ||
+                    mergedCreateTable[objName] !== undefined) {
+                    localStyleAliases[decl.id.value] = init;
+                }
+            }
+        };
         const replacements = [];
         const processedDecls = new Set();
         const idSpans = new Set();
@@ -382,42 +397,6 @@ async function loader(source) {
                         }
                     }
                 }
-                else if (propName === 'variants' &&
-                    utils_1.t.isObjectExpression(init.arguments[0].expression)) {
-                    if (utils_1.t.isIdentifier(node.id)) {
-                        idSpans.add(node.id.span.start);
-                    }
-                    const obj = (0, utils_1.objectExpressionToObject)(init.arguments[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable, (name) => {
-                        if (localCreateStyles[name]) {
-                            return localCreateStyles[name].obj;
-                        }
-                        if (mergedCreateTable[name]) {
-                            const hash = mergedCreateTable[name];
-                            if (scannedTables.createObjectTable[hash]) {
-                                return scannedTables.createObjectTable[hash];
-                            }
-                        }
-                        return undefined;
-                    });
-                    const { hashMap } = (0, utils_1.processVariants)(obj);
-                    if (utils_1.t.isIdentifier(node.id)) {
-                        localCreateStyles[node.id.value] = {
-                            name: node.id.value,
-                            type: 'variant',
-                            obj,
-                            hashMap,
-                            isExported,
-                            initSpan: {
-                                start: init.span.start - baseByteOffset,
-                                end: init.span.end - baseByteOffset,
-                            },
-                            declSpan: {
-                                start: declSpan.start - baseByteOffset,
-                                end: declSpan.end - baseByteOffset,
-                            },
-                        };
-                    }
-                }
                 else if (propName === 'createTheme' &&
                     init.arguments.length >= 2 &&
                     utils_1.t.isObjectExpression(init.arguments[1].expression)) {
@@ -544,6 +523,7 @@ async function loader(source) {
                     node.declaration.declarations.forEach((decl) => {
                         checkVariantAssignment(decl);
                         registerStyle(decl, node.span, true);
+                        checkStyleAliasAssignment(decl);
                     });
                 }
             },
@@ -553,6 +533,7 @@ async function loader(source) {
                 node.declarations.forEach((decl) => {
                     checkVariantAssignment(decl);
                     registerStyle(decl, node.span, false);
+                    checkStyleAliasAssignment(decl);
                 });
             },
             CallExpression({ node }) {
@@ -639,6 +620,42 @@ async function loader(source) {
             },
         });
         const jsxOpeningElementMap = new Map();
+        const componentParamNames = new Set();
+        for (const node of ast.body) {
+            let declarations = [];
+            if (utils_1.t.isVariableDeclaration(node)) {
+                declarations = node.declarations;
+            }
+            else if (utils_1.t.isExportDeclaration(node) &&
+                utils_1.t.isVariableDeclaration(node.declaration)) {
+                declarations = node.declaration.declarations;
+            }
+            for (const decl of declarations) {
+                if (!utils_1.t.isIdentifier(decl.id) || !decl.init)
+                    continue;
+                const init = decl.init;
+                if (init.type !== 'ArrowFunctionExpression' &&
+                    init.type !== 'FunctionExpression')
+                    continue;
+                if (init.params.length > 0) {
+                    const p = init.params[0];
+                    if (utils_1.t.isIdentifier(p)) {
+                        componentParamNames.add(p.value);
+                    }
+                    else if (p.pat && utils_1.t.isIdentifier(p.pat)) {
+                        componentParamNames.add(p.pat.value);
+                    }
+                }
+            }
+        }
+        const excludeSubtreeSpans = (n) => {
+            if (!n || typeof n !== 'object')
+                return;
+            if (n.span) {
+                excludedSpans.add(n.span.start);
+            }
+            Object.values(n).forEach((val) => excludeSubtreeSpans(val));
+        };
         const getSource = (node) => {
             const start = node.span.start - baseByteOffset;
             const end = node.span.end - baseByteOffset;
@@ -652,7 +669,7 @@ async function loader(source) {
                 utils_1.t.isIdentifier(expr.object) &&
                 (utils_1.t.isIdentifier(expr.property) || expr.property.type === 'Computed')) {
                 if (expr.property.type === 'Computed')
-                    return {};
+                    return null;
                 const varName = expr.object.value;
                 const propName = expr.property.value;
                 const styleInfo = localCreateStyles[varName];
@@ -689,6 +706,12 @@ async function loader(source) {
             return null;
         };
         const buildClassParts = (args, dynamicClassParts = [], existingClass = '') => {
+            args.forEach((arg) => {
+                const expr = arg.expression;
+                if (utils_1.t.isIdentifier(expr) && localStyleAliases[expr.value]) {
+                    arg.expression = localStyleAliases[expr.value];
+                }
+            });
             const conditionals = [];
             let groupIdCounter = 0;
             let baseStyle = {};
@@ -711,6 +734,17 @@ async function loader(source) {
                 }
                 return null;
             };
+            const resolveCreateObject = (varName) => {
+                const localStyle = localCreateStyles[varName];
+                if (localStyle?.type === 'create')
+                    return localStyle.obj;
+                let hash = scannedTables.createHashTable[`${resourcePath}-${varName}`];
+                if (!hash)
+                    hash = mergedCreateTable[varName];
+                if (hash && scannedTables.createObjectTable[hash])
+                    return scannedTables.createObjectTable[hash];
+                return null;
+            };
             const collectConditions = (node, currentTestStrings = []) => {
                 const staticStyle = resolveStyleObject(node);
                 if (staticStyle) {
@@ -768,6 +802,49 @@ async function loader(source) {
             };
             for (const arg of args) {
                 const expr = arg.expression;
+                if (utils_1.t.isIdentifier(expr) ||
+                    (utils_1.t.isMemberExpression(expr) &&
+                        utils_1.t.isIdentifier(expr.object) &&
+                        componentParamNames.has(expr.object.value) &&
+                        utils_1.t.isIdentifier(expr.property))) {
+                    const varName = utils_1.t.isIdentifier(expr)
+                        ? expr.value
+                        : expr.property.value;
+                    const testLHS = utils_1.t.isIdentifier(expr) ? varName : getSource(expr);
+                    let propPossibilities;
+                    for (const key of Object.keys(scannedTables.componentPropsTable || {})) {
+                        if (key.startsWith(`${resourcePath}-`)) {
+                            if (scannedTables.componentPropsTable?.[key]?.[varName]) {
+                                propPossibilities =
+                                    scannedTables.componentPropsTable?.[key]?.[varName];
+                                break;
+                            }
+                        }
+                    }
+                    if (propPossibilities && propPossibilities.length > 0) {
+                        const currentGroupId = ++groupIdCounter;
+                        const uniqueEntries = [];
+                        propPossibilities.forEach((entry) => {
+                            if (!uniqueEntries.some((x) => x.index === entry.index)) {
+                                uniqueEntries.push(entry);
+                            }
+                        });
+                        uniqueEntries.forEach((entry) => {
+                            conditionals.push({
+                                test: expr,
+                                testLHS,
+                                testString: `${testLHS} === ${entry.index}`,
+                                truthy: entry.styleObj,
+                                falsy: {},
+                                groupId: currentGroupId,
+                                groupName: undefined,
+                                valueName: String(entry.index),
+                                varName,
+                            });
+                        });
+                        continue;
+                    }
+                }
                 if (utils_1.t.isCallExpression(expr) && utils_1.t.isIdentifier(expr.callee)) {
                     const varName = expr.callee.value;
                     const uniqueKey = `${resourcePath}-${varName}`;
@@ -899,6 +976,31 @@ async function loader(source) {
                         continue;
                     }
                 }
+                if (utils_1.t.isMemberExpression(expr) &&
+                    utils_1.t.isIdentifier(expr.object) &&
+                    expr.property.type === 'Computed') {
+                    const varName = expr.object.value;
+                    const styleObj = resolveCreateObject(varName);
+                    if (styleObj) {
+                        const dynExpr = expr.property.expression;
+                        const dynSource = getSource(dynExpr);
+                        const currentGroupId = ++groupIdCounter;
+                        Object.entries(styleObj).forEach(([optionName, style]) => {
+                            conditionals.push({
+                                test: dynExpr,
+                                testLHS: dynSource,
+                                testString: `${dynSource} === '${optionName}'`,
+                                truthy: style,
+                                falsy: {},
+                                groupId: currentGroupId,
+                                groupName: undefined,
+                                valueName: optionName,
+                                varName,
+                            });
+                        });
+                        continue;
+                    }
+                }
                 const handled = collectConditions(expr);
                 if (handled)
                     continue;
@@ -1120,13 +1222,56 @@ async function loader(source) {
         };
         (0, utils_1.traverse)(ast, {
             JSXOpeningElement({ node }) {
-                jsxOpeningElementMap.set(node.span.start, node.attributes);
+                let tagName = '';
+                if (node.name.type === 'Identifier') {
+                    tagName = node.name.value;
+                }
+                jsxOpeningElementMap.set(node.span.start, {
+                    tagName,
+                    attributes: node.attributes,
+                });
             },
             MemberExpression({ node }) {
-                if (utils_1.t.isIdentifier(node.object) && utils_1.t.isIdentifier(node.property)) {
+                if (utils_1.t.isIdentifier(node.object) &&
+                    (utils_1.t.isIdentifier(node.property) || node.property.type === 'Computed')) {
                     const varName = node.object.value;
-                    const propName = node.property.value;
                     const uniqueKey = `${resourcePath}-${varName}`;
+                    if (node.property.type === 'Computed') {
+                        const dynExpr = node.property.expression;
+                        const dynSource = getSource(dynExpr);
+                        const localStyle = localCreateStyles[varName];
+                        let hashMap;
+                        if (localStyle) {
+                            hashMap = localStyle.hashMap;
+                        }
+                        else {
+                            let hash = scannedTables.createHashTable[uniqueKey];
+                            if (!hash) {
+                                hash = mergedCreateTable[varName];
+                            }
+                            if (hash) {
+                                const obj = scannedTables.createObjectTable[hash];
+                                const atomicMap = scannedTables.createAtomicMapTable[hash];
+                                if (obj && atomicMap) {
+                                    hashMap = {};
+                                    Object.keys(obj).forEach((key) => {
+                                        if (atomicMap[key]) {
+                                            hashMap[key] = atomicMap[key];
+                                        }
+                                    });
+                                }
+                            }
+                        }
+                        if (hashMap) {
+                            replacements.push({
+                                start: node.span.start - baseByteOffset,
+                                end: node.span.end - baseByteOffset,
+                                content: `((${JSON.stringify(hashMap)})[${dynSource}] || {})`,
+                            });
+                        }
+                        return;
+                    }
+                    const propName = node.property.value;
                     const localStyle = localCreateStyles[varName];
                     if (localStyle && localStyle.type === 'create') {
                         const atomMap = localStyle.hashMap[propName];
@@ -1273,8 +1418,65 @@ async function loader(source) {
                 }
             },
             JSXAttribute({ node }) {
-                if (node.name.type !== 'Identifier' || node.name.value !== 'styleName')
+                if (node.name.type !== 'Identifier')
                     return;
+                const attrName = node.name.value;
+                if (attrName !== 'styleName') {
+                    let parentTagName = '';
+                    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;
+                            break;
+                        }
+                    }
+                    if (parentTagName &&
+                        parentTagName[0] === parentTagName[0].toUpperCase()) {
+                        let compKey;
+                        const imported = localImports[parentTagName];
+                        if (imported) {
+                            compKey = `${imported.actualPath}-${imported.importedName}`;
+                        }
+                        else {
+                            compKey = `${resourcePath}-${parentTagName}`;
+                        }
+                        const list = scannedTables.componentPropsTable?.[compKey]?.[attrName];
+                        if (list &&
+                            node.value &&
+                            node.value.type === 'JSXExpressionContainer') {
+                            const expr = node.value.expression;
+                            (0, utils_1.traverse)(expr, {
+                                MemberExpression({ node: subNode }) {
+                                    const entry = list.find((x) => x.spanStart === subNode.span.start &&
+                                        x.filePath === resourcePath);
+                                    if (entry) {
+                                        replacements.push({
+                                            start: subNode.span.start - baseByteOffset,
+                                            end: subNode.span.end - baseByteOffset,
+                                            content: String(entry.index),
+                                        });
+                                        excludeSubtreeSpans(subNode);
+                                    }
+                                },
+                                ArrayExpression({ node: subNode }) {
+                                    const entry = list.find((x) => x.spanStart === subNode.span.start &&
+                                        x.filePath === resourcePath);
+                                    if (entry) {
+                                        replacements.push({
+                                            start: subNode.span.start - baseByteOffset,
+                                            end: subNode.span.end - baseByteOffset,
+                                            content: String(entry.index),
+                                        });
+                                        excludeSubtreeSpans(subNode);
+                                    }
+                                },
+                            });
+                        }
+                    }
+                    return;
+                }
                 if (!node.value || node.value.type !== 'JSXExpressionContainer')
                     return;
                 const expr = node.value.expression;
@@ -1286,12 +1488,12 @@ async function loader(source) {
                 const dynamicClassParts = [];
                 const dynamicStyleParts = [];
                 let attributes = [];
-                for (const [, attrs] of jsxOpeningElementMap) {
-                    const found = attrs
+                for (const [, val] of jsxOpeningElementMap) {
+                    const found = val.attributes
                         .filter((a) => a.type === 'JSXAttribute')
                         .find((a) => a.span.start === node.span.start);
                     if (found) {
-                        attributes = attrs;
+                        attributes = val.attributes;
                         break;
                     }
                 }

package/package.json

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