@plumeria/turbopack-loader 18.5.0 → 18.5.2

package/dist/index.js

@@ -130,6 +130,28 @@ const destructuredPropAliases = (fn) => {
     }
     return aliases;
 };
+const propDefaultMessage = (source) => `Plumeria: A style prop default must be a defined style: "${source}". ` +
+    `Apply a conditional or dynamic style where the element is styled.`;
+const spreadStyleMessage = (source) => `Plumeria: Spread elements in a style array are not supported: "...${source}". ` +
+    `List each style explicitly.`;
+const resolveLocalStyleAlias = (aliases, expression) => {
+    let current = expression;
+    const seen = new Set();
+    while (utils_1.t.isIdentifier(current)) {
+        const name = current.value;
+        if (seen.has(name))
+            break;
+        seen.add(name);
+        const candidates = aliases[name];
+        if (!candidates || candidates.length === 0)
+            break;
+        const candidate = candidates.find((candidate) => candidate.context === current.ctxt);
+        if (!candidate)
+            break;
+        current = candidate.expression;
+    }
+    return current;
+};
 const isStaticArgValue = (node) => node.type === 'StringLiteral' ||
     node.type === 'NumericLiteral' ||
     node.type === 'BooleanLiteral' ||
@@ -270,11 +292,32 @@ async function loader(source) {
         }
         const components = [];
         const propAliases = new Map();
+        const propDefaults = new Map();
+        const declaredProps = new Map();
         const addComponent = (name, fn) => {
             components.push({ name, node: fn });
+            const first = fn.params[0];
+            const pattern = unwrapPatternDefault(first?.pat ?? first);
+            const defaults = new Map();
+            for (const item of pattern?.properties ?? []) {
+                if (item.type === 'AssignmentPatternProperty' && item.value)
+                    defaults.set(item.key.value, item.value);
+                if (item.type === 'KeyValuePatternProperty' &&
+                    item.value?.type === 'AssignmentPattern')
+                    defaults.set(item.key.value, item.value.right);
+            }
+            propDefaults.set(name, defaults);
             const aliases = destructuredPropAliases(fn);
             if (aliases.size > 0)
                 propAliases.set(name, aliases);
+            const declared = new Set();
+            for (const item of pattern?.properties ?? []) {
+                const key = item.key;
+                if (utils_1.t.isIdentifier(key) || utils_1.t.isStringLiteral(key))
+                    declared.add(String(key.value));
+            }
+            if (declared.size > 0)
+                declaredProps.set(name, declared);
         };
         for (const node of ast.body) {
             const statement = unwrapExport(node);
@@ -507,12 +550,15 @@ async function loader(source) {
         const checkStyleAliasAssignment = (decl) => {
             if (!utils_1.t.isIdentifier(decl.id) || !decl.init)
                 return;
-            const init = decl.init;
+            const init = (0, utils_1.unwrapExpression)(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;
+                    (localStyleAliases[decl.id.value] ??= []).push({
+                        expression: init,
+                        context: decl.id.ctxt,
+                    });
                 }
             }
         };
@@ -943,8 +989,23 @@ async function loader(source) {
         };
         const resolveStyleObject = (expr) => {
             expr = (0, utils_1.unwrapExpression)(expr);
+            expr = resolveLocalStyleAlias(localStyleAliases, expr);
             if (!isVisibleReference(expr))
                 return null;
+            if (expr.type === 'ArrayExpression') {
+                let merged = {};
+                for (const element of expr.elements ?? []) {
+                    if (!element)
+                        continue;
+                    if (element.spread)
+                        throwCompilationError(spreadStyleMessage(getSource(element.expression)), element.expression);
+                    const style = resolveStyleObject(element.expression);
+                    if (!style)
+                        return null;
+                    merged = (0, utils_1.deepMerge)(merged, style);
+                }
+                return merged;
+            }
             if (utils_1.t.isObjectExpression(expr)) {
                 return (0, utils_1.objectExpressionToObject)(expr, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable);
             }
@@ -1004,6 +1065,26 @@ async function loader(source) {
             return Boolean(localCreateStyles[callee.object.value]?.functions?.[callee.property.value] ??
                 createFunctionImportMap[callee.object.value]?.[callee.property.value]);
         };
+        const carriesStyleReference = (expression) => {
+            const node = (0, utils_1.unwrapExpression)(expression);
+            if (node.type === 'ArrayExpression')
+                return node.elements.some((element) => !!element && carriesStyleReference(element.expression));
+            if (isStyleFunctionCall(node))
+                return true;
+            if (utils_1.t.isObjectExpression(node))
+                return false;
+            return resolveStyleObject(node) !== null;
+        };
+        const assertNoStyleArraySpread = (expression) => {
+            const node = (0, utils_1.unwrapExpression)(expression);
+            if (node.type !== 'ArrayExpression')
+                return;
+            const spread = node.elements.find((element) => element?.spread);
+            if (!spread)
+                return;
+            if (carriesStyleReference(node))
+                throwCompilationError(spreadStyleMessage(getSource(spread.expression)), spread.expression);
+        };
         const resolveDynamicCall = (expr, forceRuntime = false) => {
             if (!utils_1.t.isCallExpression(expr) || !utils_1.t.isMemberExpression(expr.callee))
                 return null;
@@ -1021,6 +1102,7 @@ async function loader(source) {
             if (callArgs.some((a) => a.spread))
                 return null;
             const tempStaticTable = { ...mergedStaticTable };
+            const providedParams = new Set();
             const runtime = [];
             const resolveObjectArg = (argExpr) => (0, utils_1.objectExpressionToObject)({
                 ...argExpr,
@@ -1057,8 +1139,10 @@ async function loader(source) {
                     }
                     if (!forceRuntime &&
                         isStaticArgValue(source) &&
-                        argObj[key] !== undefined)
+                        argObj[key] !== undefined) {
                         tempStaticTable[local] = argObj[key];
+                        providedParams.add(local);
+                    }
                     else
                         runtime.push({ param: local, source });
                 });
@@ -1069,8 +1153,10 @@ async function loader(source) {
                     return null;
                 const argObj = resolveObjectArg(callArgs[0].expression) ?? {};
                 func.params.forEach((p) => {
-                    if (argObj[p] !== undefined)
+                    if (argObj[p] !== undefined) {
                         tempStaticTable[p] = argObj[p];
+                        providedParams.add(p);
+                    }
                 });
             }
             else {
@@ -1081,7 +1167,7 @@ async function loader(source) {
                     runtime.push({ param: p, source: callArg.expression });
                 });
             }
-            const resolved = (0, utils_1.resolveDynamicStyle)(func, runtime.map(({ param }) => param), tempStaticTable, dynamicStyleTables);
+            const resolved = (0, utils_1.resolveDynamicStyle)(func, runtime.map(({ param }) => param), tempStaticTable, dynamicStyleTables, providedParams);
             if (!resolved)
                 return null;
             const { style, varGroups } = resolved;
@@ -1118,10 +1204,7 @@ async function loader(source) {
         };
         const buildClassParts = (args, dynamicClassParts = [], existingClass = '', isStyleProp = false) => {
             args.forEach((arg) => {
-                const expr = arg.expression;
-                if (utils_1.t.isIdentifier(expr) && localStyleAliases[expr.value]) {
-                    arg.expression = localStyleAliases[expr.value];
-                }
+                arg.expression = resolveLocalStyleAlias(localStyleAliases, arg.expression);
             });
             const conditionals = [];
             const dynamicVars = [];
@@ -1245,12 +1328,17 @@ async function loader(source) {
             };
             const collectConditions = (node, currentTestStrings = [], argOrder) => {
                 node = (0, utils_1.unwrapExpression)(node);
+                node = resolveLocalStyleAlias(localStyleAliases, node);
                 if (isNoOpStyle(node))
                     return true;
                 if (node.type === 'ArrayExpression') {
-                    return node.elements.every((element) => !element ||
-                        (!element.spread &&
-                            collectConditions(element.expression, currentTestStrings, argOrder)));
+                    return node.elements.every((element) => {
+                        if (!element)
+                            return true;
+                        if (element.spread)
+                            throwCompilationError(spreadStyleMessage(getSource(element.expression)), element.expression);
+                        return collectConditions(element.expression, currentTestStrings, argOrder);
+                    });
                 }
                 let branchStyle = resolveStyleObject(node);
                 if (!branchStyle) {
@@ -1326,6 +1414,12 @@ async function loader(source) {
                     utils_1.t.isIdentifier(expr.property);
                 if (!utils_1.t.isIdentifier(expr) && !isParamMember)
                     return false;
+                const paramObject = isParamMember
+                    ? expr.object.value
+                    : undefined;
+                const isPropsMember = Boolean(paramObject &&
+                    localCreateStyles[paramObject] === undefined &&
+                    mergedCreateTable[paramObject] === undefined);
                 const varName = utils_1.t.isIdentifier(expr)
                     ? expr.value
                     : expr.property.value;
@@ -1350,8 +1444,34 @@ async function loader(source) {
                     if (candidates.length > 0)
                         possibilities = candidates;
                 }
-                if (!possibilities || possibilities.length === 0)
-                    return false;
+                const fallback = owner && propDefaults.get(owner)?.get(propName);
+                if (fallback && !isNoOpStyle((0, utils_1.unwrapExpression)(fallback))) {
+                    const style = resolveStyleObject(fallback);
+                    if (!style)
+                        throwCompilationError(propDefaultMessage(getSource(fallback)), fallback);
+                    const atoms = {};
+                    (0, utils_1.getStyleRecords)(style).forEach((record) => {
+                        atoms[record.key] = record.hash;
+                    });
+                    const key = (0, zss_engine_1.genBase36Hash)(Object.values(atoms).join(' '), 1, 8);
+                    possibilities = [...(possibilities ?? []), { key, styleObj: style }];
+                    const span = fallback.span;
+                    for (let index = replacements.length - 1; index >= 0; index--) {
+                        const replacement = replacements[index];
+                        if (replacement.start >= span.start - baseByteOffset &&
+                            replacement.end <= span.end - baseByteOffset)
+                            replacements.splice(index, 1);
+                    }
+                    excludeSubtreeSpans(fallback);
+                    replacements.push({
+                        start: span.start - baseByteOffset,
+                        end: span.end - baseByteOffset,
+                        content: JSON.stringify(key),
+                    });
+                }
+                if (!possibilities || possibilities.length === 0) {
+                    return Boolean(isPropsMember || (owner && declaredProps.get(owner)?.has(propName)));
+                }
                 const carriesVars = possibilities.some((entry) => entry.hasVars);
                 if (carriesVars && !isStyleProp) {
                     throwCompilationError(`Plumeria: "${varName}" carries a dynamic function key, and css.use() returns only a class name. ` +
@@ -2079,6 +2199,8 @@ async function loader(source) {
                         }
                     }
                     if (compKey) {
+                        if (node.value?.type === 'JSXExpressionContainer')
+                            assertNoStyleArraySpread(node.value.expression);
                         const list = scannedTables.componentPropsTable?.[compKey]?.[attrName];
                         if (list &&
                             node.value &&
@@ -2160,7 +2282,11 @@ async function loader(source) {
                 const args = expr.type === 'ArrayExpression'
                     ? expr.elements
                         .filter((el) => el != null)
-                        .map((el) => ({ expression: el.expression }))
+                        .map((el) => {
+                        if (el.spread)
+                            throwCompilationError(spreadStyleMessage(getSource(el.expression)), el.expression);
+                        return { expression: el.expression };
+                    })
                     : [{ expression: expr }];
                 const dynamicClassParts = [];
                 const existingStyleParts = [];

package/package.json

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