@plumeria/utils 21.2.1 → 21.2.3

package/dist/compile.js

@@ -828,6 +828,7 @@ function compileCSS(options) {
                     ...argExpr,
                     properties: argExpr.properties.filter((prop) => prop.type === 'Identifier' ||
                         (prop.type === 'KeyValueProperty' &&
+                            prop.key.type !== 'Computed' &&
                             isStaticArgValue(prop.value))),
                 }, ctx.mergedStaticTable, ctx.mergedKeyframesTable, ctx.mergedViewTransitionTable, ctx.mergedCreateThemeHashTable, ctx.scannedTables.createThemeObjectTable, ctx.mergedCreateTable, ctx.mergedCreateStaticHashTable, ctx.scannedTables.createStaticObjectTable, undefined, ctx.mergedVarTypeTable, ctx.mergedPositionTryTable);
                 if (func.named) {

package/dist/parser.js

@@ -287,6 +287,10 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
             if (typeof spreadVal === 'object' && spreadVal !== null) {
                 Object.assign(obj, spreadVal);
             }
+            else if (spreadVal === null &&
+                !exports.t.isNullLiteral(unwrapExpression(arg))) {
+                throw new Error(`[plumeria] Cannot spread ${(0, exports.expressionLabel)(arg)} at build time. Spread a const object, or pass a runtime value through the function form, css.create({ name: (value) => ({ ... }) }).`);
+            }
             return;
         }
         if (exports.t.isIdentifier(prop) && !exports.t.isObjectProperty(prop)) {
@@ -298,13 +302,16 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
                     return;
                 }
             }
-            if (staticTable[key] !== undefined) {
-                obj[key] = staticTable[key];
+            try {
+                obj[key] = evaluateExpression(prop, staticTable, keyframesHashTable, viewTransitionHashTable, varTypeHashTable, positionTryHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
+            }
+            catch {
             }
             return;
         }
-        if (!exports.t.isObjectProperty(prop))
-            return;
+        if (!exports.t.isObjectProperty(prop)) {
+            throw new Error(`[plumeria] Cannot read the method or accessor "${prop.key?.value ?? ''}" at build time. Write it as a plain property.`);
+        }
         const rawKey = getPropertyKey(prop.key, staticTable, keyframesHashTable, viewTransitionHashTable, varTypeHashTable, positionTryHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
         if (!rawKey)
             return;
@@ -358,12 +365,12 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
                 obj[key] = 'cr-' + resolvedCreate;
                 return;
             }
-            const resolvedTheme = resolveCreateThemeTableMemberExpressionByNode(val, createThemeHashTable, createThemeObjectTable);
+            const resolvedTheme = resolveCreateThemeTableMemberExpressionByNode(val, staticTable, createThemeHashTable, createThemeObjectTable);
             if (resolvedTheme !== undefined) {
                 obj[key] = resolvedTheme;
                 return;
             }
-            const resolvedStatic = resolveCreateStaticTableMemberExpression(val, createStaticHashTable, createStaticObjectTable);
+            const resolvedStatic = resolveCreateStaticTableMemberExpression(val, staticTable, createStaticHashTable, createStaticObjectTable);
             if (resolvedStatic !== undefined) {
                 obj[key] = resolvedStatic;
                 return;
@@ -719,10 +726,10 @@ function getPropertyKey(node, staticTable, keyframesHashTable, viewTransitionHas
             const result = resolveStaticTableMemberExpression(expr, staticTable);
             if (typeof result === 'string')
                 return result;
-            const staticResult = resolveCreateStaticTableMemberExpression(expr, createStaticHashTable, createStaticObjectTable);
+            const staticResult = resolveCreateStaticTableMemberExpression(expr, staticTable, createStaticHashTable, createStaticObjectTable);
             if (typeof staticResult === 'string')
                 return staticResult;
-            const themeResult = resolveCreateThemeTableMemberExpressionByNode(expr, createThemeHashTable, createThemeObjectTable);
+            const themeResult = resolveCreateThemeTableMemberExpressionByNode(expr, staticTable, createThemeHashTable, createThemeObjectTable);
             if (typeof themeResult === 'string')
                 return themeResult;
         }
@@ -732,7 +739,7 @@ function getPropertyKey(node, staticTable, keyframesHashTable, viewTransitionHas
         if (exports.t.isBinaryExpression(expr)) {
             return evaluateBinaryExpression(expr, staticTable, keyframesHashTable, viewTransitionHashTable, varTypeHashTable, positionTryHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
         }
-        return '';
+        throw new Error(`[plumeria] Cannot inline the computed key [${(0, exports.expressionLabel)(expr)}] at build time. Declare it with css.createStatic, such as const breakpoints = css.createStatic({ sm: '...' }), and read it as [breakpoints.sm]. A definition in a package needs a plumeria export condition.`);
     }
     if (exports.t.isTemplateLiteral(node)) {
         return evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTransitionHashTable, varTypeHashTable, positionTryHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
@@ -905,11 +912,11 @@ function evaluateExpression(node, staticTable, keyframesHashTable, viewTransitio
         if (resolved !== undefined) {
             return resolved;
         }
-        const resolvedTheme = resolveCreateThemeTableMemberExpressionByNode(node, createThemeHashTable, createThemeObjectTable);
+        const resolvedTheme = resolveCreateThemeTableMemberExpressionByNode(node, staticTable, createThemeHashTable, createThemeObjectTable);
         if (resolvedTheme !== undefined) {
             return resolvedTheme;
         }
-        const resolvedStatic = resolveCreateStaticTableMemberExpression(node, createStaticHashTable, createStaticObjectTable);
+        const resolvedStatic = resolveCreateStaticTableMemberExpression(node, staticTable, createStaticHashTable, createStaticObjectTable);
         if (resolvedStatic !== undefined) {
             return resolvedStatic;
         }
@@ -965,26 +972,30 @@ function resolveCreateTableMemberExpression(node, createHashTable) {
         return createHashTable[node.value];
     }
 }
+function memberKey(node, staticTable) {
+    const property = node.property;
+    if (exports.t.isIdentifier(property))
+        return property.value;
+    if (property.type !== 'Computed')
+        return undefined;
+    const key = unwrapExpression(property.expression);
+    const value = exports.t.isStringLiteral(key) || exports.t.isNumericLiteral(key)
+        ? key.value
+        : exports.t.isIdentifier(key)
+            ? staticTable[key.value]
+            : undefined;
+    return typeof value === 'string' || typeof value === 'number'
+        ? String(value)
+        : undefined;
+}
 function resolveStaticTableMemberExpression(node, staticTable) {
     const keys = [];
     let current = node;
     while (exports.t.isMemberExpression(current)) {
-        const property = current.property;
-        const key = exports.t.isIdentifier(property)
-            ? property.value
-            : property.type === 'Computed'
-                ? unwrapExpression(property.expression)
-                : undefined;
-        const value = typeof key === 'string'
-            ? key
-            : exports.t.isStringLiteral(key) || exports.t.isNumericLiteral(key)
-                ? String(key.value)
-                : exports.t.isIdentifier(key)
-                    ? staticTable[key.value]
-                    : undefined;
-        if (typeof value !== 'string' && typeof value !== 'number')
+        const key = memberKey(current, staticTable);
+        if (key === undefined)
             return undefined;
-        keys.unshift(String(value));
+        keys.unshift(key);
         current = unwrapExpression(current.object);
     }
     if (!exports.t.isIdentifier(current))
@@ -997,21 +1008,14 @@ function resolveStaticTableMemberExpression(node, staticTable) {
     }
     return value;
 }
-function resolveCreateThemeTableMemberExpressionByNode(node, createThemeHashTable, createThemeObjectTable) {
+function resolveCreateThemeTableMemberExpressionByNode(node, staticTable, createThemeHashTable, createThemeObjectTable) {
     if (exports.t.isMemberExpression(node) && exports.t.isIdentifier(node.object)) {
         const varName = node.object.value;
         const hash = createThemeHashTable[varName];
         if (hash) {
             const themeObj = createThemeObjectTable[hash];
             if (themeObj) {
-                let key;
-                if (exports.t.isIdentifier(node.property)) {
-                    key = node.property.value;
-                }
-                else if (node.property.type === 'Computed' &&
-                    exports.t.isStringLiteral(node.property.expression)) {
-                    key = node.property.expression.value;
-                }
+                const key = memberKey(node, staticTable);
                 if (key && themeObj[key] !== undefined) {
                     const value = themeObj[key];
                     const atomicHash = (0, zss_engine_1.genBase36Hash)({ _theme: hash, [key]: value }, 1, 8);
@@ -1023,21 +1027,14 @@ function resolveCreateThemeTableMemberExpressionByNode(node, createThemeHashTabl
     }
     return undefined;
 }
-function resolveCreateStaticTableMemberExpression(node, createStaticHashTable, createStaticObjectTable) {
+function resolveCreateStaticTableMemberExpression(node, staticTable, createStaticHashTable, createStaticObjectTable) {
     if (exports.t.isMemberExpression(node) && exports.t.isIdentifier(node.object)) {
         const varName = node.object.value;
         const hash = createStaticHashTable[varName];
         if (hash) {
             const staticObj = createStaticObjectTable[hash];
             if (staticObj) {
-                let key;
-                if (exports.t.isIdentifier(node.property)) {
-                    key = node.property.value;
-                }
-                else if (node.property.type === 'Computed' &&
-                    exports.t.isStringLiteral(node.property.expression)) {
-                    key = node.property.expression.value;
-                }
+                const key = memberKey(node, staticTable);
                 if (key && staticObj[key] !== undefined) {
                     return staticObj[key];
                 }

package/dist/transform.js

@@ -1268,6 +1268,7 @@ const transformExpanded = async (env, scannedTables, namespaces) => {
             ...argExpr,
             properties: argExpr.properties.filter((prop) => prop.type === 'Identifier' ||
                 (prop.type === 'KeyValueProperty' &&
+                    prop.key.type !== 'Computed' &&
                     isStaticArgValue(prop.value))),
         }, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, undefined, mergedVarTypeTable, mergedPositionTryTable);
         if (func.named) {

package/dist/unresolvableValue.js

@@ -9,6 +9,11 @@ const keyValue = (key) => {
         ? value
         : undefined;
 };
+const asKeyValue = (prop) => prop.type === 'Identifier'
+    ? { key: prop, value: prop }
+    : prop.type === 'KeyValueProperty'
+        ? prop
+        : null;
 const unresolvableValue = (key, node, context) => new Error(`[plumeria] Cannot resolve the value of "${key}" at build time (${context?.sourceOf?.(node) ?? node.type}). ` +
     `Values in css.create must be statically known; pass a runtime value through the ` +
     `function form, css.create({ name: (value) => ({ ... }) }).`);
@@ -23,7 +28,8 @@ const overwrittenLater = (properties, index, key, context) => {
                 return true;
             continue;
         }
-        if (later.type === 'KeyValueProperty' && keyValue(later.key) === key)
+        const entry = asKeyValue(later);
+        if (entry && keyValue(entry.key) === key)
             return true;
     }
     return false;
@@ -86,14 +92,14 @@ const assertStyleFunction = (func, context) => {
     const walk = (object) => {
         const properties = object.properties ?? [];
         for (let index = 0; index < properties.length; index++) {
-            const prop = properties[index];
-            if (prop.type !== 'KeyValueProperty')
+            const entry = asKeyValue(properties[index]);
+            if (!entry)
                 continue;
-            const key = keyValue(prop.key);
+            const key = keyValue(entry.key);
             if ((typeof key === 'string' || typeof key === 'number') &&
                 overwrittenLater(properties, index, key, context))
                 continue;
-            const value = prop.value;
+            const value = entry.value;
             if (!value)
                 continue;
             if (value.type === 'ObjectExpression') {
@@ -123,9 +129,10 @@ const keysSuppliedAfter = (properties, index, context) => {
                 keys.add(name);
             continue;
         }
-        if (later.type !== 'KeyValueProperty')
+        const entry = asKeyValue(later);
+        if (!entry)
             continue;
-        const key = keyValue(later.key);
+        const key = keyValue(entry.key);
         if (typeof key !== 'string' && typeof key !== 'number')
             return null;
         keys.add(String(key));
@@ -146,16 +153,17 @@ const assertNoDroppedValues = (node, resolved, context, ignore) => {
                 (0, exports.assertNoDroppedValues)(provided.source, provided.values, context, replaced);
             continue;
         }
-        if (prop.type !== 'KeyValueProperty')
+        const entry = asKeyValue(prop);
+        if (!entry)
             continue;
-        const key = keyValue(prop.key);
+        const key = keyValue(entry.key);
         if (typeof key !== 'string' && typeof key !== 'number')
             continue;
         if (ignore?.has(String(key)))
             continue;
         if (overwrittenLater(node.properties, index, key, context))
             continue;
-        const value = prop.value;
+        const value = entry.value;
         if (!value)
             continue;
         if (value.type === 'ArrowFunctionExpression' ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/utils",
-  "version": "21.2.1",
+  "version": "21.2.3",
   "description": "Plumeria Utils",
   "author": "Refirst 11",
   "license": "MIT",