@plumeria/utils 18.4.2 → 18.5.0

package/dist/ast.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLeadingCommentLength = getLeadingCommentLength;
 function getLeadingCommentLength(source) {
-    let i = 0;
+    let i = source.charCodeAt(0) === 0xfeff ? 1 : 0;
     const len = source.length;
-    if (source.startsWith('#!')) {
+    if (source.startsWith('#!', i)) {
         while (i < len && source[i] !== '\n')
             i++;
     }

package/dist/dynamicKey.d.ts

@@ -6,6 +6,7 @@ export type NamedParam = {
 };
 export type StyleFunction = {
     params: string[];
+    unsupportedParams?: boolean;
     named?: NamedParam[];
     defaults?: Record<string, Expression>;
     body: ObjectExpression;

package/dist/dynamicKey.js

@@ -71,6 +71,13 @@ const styleFunctionsOf = (objExpr) => {
         if (actualBody && actualBody.type === 'ObjectExpression') {
             styleFunctions[prop.key.value] = {
                 params,
+                unsupportedParams: func.params.some((p) => {
+                    const pattern = p?.pat ?? p;
+                    return (pattern?.type === 'ArrayPattern' ||
+                        pattern?.type === 'RestElement' ||
+                        (pattern?.type === 'ObjectPattern' &&
+                            !namedParamsOf(func.params, {})));
+                }),
                 named: namedParamsOf(func.params, defaults),
                 defaults,
                 body: actualBody,
@@ -137,6 +144,8 @@ const applyVarFallback = (style, cssVar, literal) => {
 };
 exports.applyVarFallback = applyVarFallback;
 const resolveDynamicStyle = (func, runtimeParams, staticTable, tables) => {
+    if (func.unsupportedParams)
+        throw new Error('[plumeria] Dynamic styles require named parameters or object destructuring; array and rest parameters are not supported.');
     const tempStaticTable = { ...staticTable };
     const resolveBody = () => (0, parser_1.objectExpressionToObject)(func.body, tempStaticTable, tables.keyframesHashTable, tables.viewTransitionHashTable, tables.createThemeHashTable, tables.createThemeObjectTable, tables.createHashTable, tables.createStaticHashTable, tables.createStaticObjectTable, tables.variantsHashTable);
     const withDefault = Object.entries(func.defaults ?? {}).filter(([param]) => tempStaticTable[param] === undefined);
@@ -161,10 +170,24 @@ const resolveDynamicStyle = (func, runtimeParams, staticTable, tables) => {
             varGroups.set(param, (0, exports.splitVarByUnit)(style, cssVar));
     });
     withDefault.forEach(([param, expr]) => {
-        const literal = expr.type === 'StringLiteral' || expr.type === 'NumericLiteral'
-            ? expr.value
-            : undefined;
-        if (literal === undefined)
+        const resolved = (0, parser_1.objectExpressionToObject)({
+            type: 'ObjectExpression',
+            span: func.body.span,
+            properties: [
+                {
+                    type: 'KeyValueProperty',
+                    key: {
+                        type: 'Identifier',
+                        span: func.body.span,
+                        value: 'value',
+                        optional: false,
+                    },
+                    value: expr,
+                },
+            ],
+        }, staticTable, tables.keyframesHashTable, tables.viewTransitionHashTable, tables.createThemeHashTable, tables.createThemeObjectTable, tables.createHashTable, tables.createStaticHashTable, tables.createStaticObjectTable, tables.variantsHashTable);
+        const literal = resolved.value;
+        if (typeof literal !== 'string' && typeof literal !== 'number')
             return;
         (varGroups.get(param) ?? []).forEach(({ cssVar }) => (0, exports.applyVarFallback)(style, cssVar, literal));
     });

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export type { CSSObject, StaticTable, KeyframesHashTable, ViewTransitionHashTable, CreateHashTable, CreateFunctionTable, VariantsHashTable, CreateThemeHashTable, CreateStaticHashTable, } from './types';
-export { objectExpressionToObject, collectLocalConsts, traverse, t, getRootIdentifier, extractOndemandStyles, deepMerge, scanAll, resolveFileError, getFileDependencies, resolveExport, resolveComponentKey, resolveThemeSelector, } from './parser';
+export { objectExpressionToObject, collectLocalConsts, traverse, t, getRootIdentifier, unwrapExpression, extractOndemandStyles, deepMerge, scanAll, resolveFileError, getFileDependencies, resolveExport, resolveComponentKey, resolveThemeSelector, } from './parser';
 export type { StyleRecord } from './create';
 export { getStyleRecords } from './create';
 export type { NamedParam, StyleFunction, StyleFunctions, DynamicStyleTables, DynamicStyleResult, } from './dynamicKey';

package/dist/index.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertPropertyPolicy = exports.resolvePropertyPolicy = exports.DEFAULT_STYLE_PROP = exports.timedAsync = exports.timed = exports.tally = exports.measure = exports.mark = exports.profiling = exports.collectReferenceIdentifiers = exports.getLeadingCommentLength = exports.processVariants = exports.optimizer = exports.resolveImportPath = exports.themeHashOf = exports.getStateWeights = exports.getPseudoElement = exports.getSpecificity = exports.resolveDynamicStyle = exports.applyVarFallback = exports.splitVarByUnit = exports.isUnitlessProp = exports.styleFunctionsOf = exports.getStyleRecords = exports.resolveThemeSelector = exports.resolveComponentKey = exports.resolveExport = exports.getFileDependencies = exports.resolveFileError = exports.scanAll = exports.deepMerge = exports.extractOndemandStyles = exports.getRootIdentifier = exports.t = exports.traverse = exports.collectLocalConsts = exports.objectExpressionToObject = void 0;
+exports.assertPropertyPolicy = exports.resolvePropertyPolicy = exports.DEFAULT_STYLE_PROP = exports.timedAsync = exports.timed = exports.tally = exports.measure = exports.mark = exports.profiling = exports.collectReferenceIdentifiers = exports.getLeadingCommentLength = exports.processVariants = exports.optimizer = exports.resolveImportPath = exports.themeHashOf = exports.getStateWeights = exports.getPseudoElement = exports.getSpecificity = exports.resolveDynamicStyle = exports.applyVarFallback = exports.splitVarByUnit = exports.isUnitlessProp = exports.styleFunctionsOf = exports.getStyleRecords = exports.resolveThemeSelector = exports.resolveComponentKey = exports.resolveExport = exports.getFileDependencies = exports.resolveFileError = exports.scanAll = exports.deepMerge = exports.extractOndemandStyles = exports.unwrapExpression = exports.getRootIdentifier = exports.t = exports.traverse = exports.collectLocalConsts = exports.objectExpressionToObject = void 0;
 var parser_1 = require("./parser");
 Object.defineProperty(exports, "objectExpressionToObject", { enumerable: true, get: function () { return parser_1.objectExpressionToObject; } });
 Object.defineProperty(exports, "collectLocalConsts", { enumerable: true, get: function () { return parser_1.collectLocalConsts; } });
 Object.defineProperty(exports, "traverse", { enumerable: true, get: function () { return parser_1.traverse; } });
 Object.defineProperty(exports, "t", { enumerable: true, get: function () { return parser_1.t; } });
 Object.defineProperty(exports, "getRootIdentifier", { enumerable: true, get: function () { return parser_1.getRootIdentifier; } });
+Object.defineProperty(exports, "unwrapExpression", { enumerable: true, get: function () { return parser_1.unwrapExpression; } });
 Object.defineProperty(exports, "extractOndemandStyles", { enumerable: true, get: function () { return parser_1.extractOndemandStyles; } });
 Object.defineProperty(exports, "deepMerge", { enumerable: true, get: function () { return parser_1.deepMerge; } });
 Object.defineProperty(exports, "scanAll", { enumerable: true, get: function () { return parser_1.scanAll; } });

package/dist/parser.d.ts

@@ -1,5 +1,6 @@
 import type { CSSObject, Tables, StaticTable, KeyframesHashTable, ViewTransitionHashTable, CreateHashTable, VariantsHashTable, CreateThemeHashTable, CreateThemeObjectTable, CreateStaticHashTable, CreateStaticObjectTable } from './types';
 import type { Module, Expression, CallExpression, Identifier, KeyValueProperty, StringLiteral, NumericLiteral, BooleanLiteral, ObjectExpression, MemberExpression, TemplateLiteral, BinaryExpression, UnaryExpression, ParenthesisExpression, VariableDeclaration, VariableDeclarator, ExportDeclaration, ConditionalExpression, JSXExpression, ArrowFunctionExpression, FunctionExpression } from '@swc/core';
+export declare function unwrapExpression(node: any): any;
 export declare const getRootIdentifier: (node: Expression) => string | null;
 export declare function resolveComponentKey(nameNode: any, filePath: string, localImports: Record<string, {
     actualPath: string;

package/dist/parser.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.t = exports.getRootIdentifier = void 0;
+exports.unwrapExpression = unwrapExpression;
 exports.resolveComponentKey = resolveComponentKey;
 exports.traverse = traverse;
 exports.objectExpressionToObject = objectExpressionToObject;
@@ -55,12 +56,33 @@ const viewTransition_1 = require("./viewTransition");
 const create_1 = require("./create");
 const dynamicKey_1 = require("./dynamicKey");
 const resolver_1 = require("./resolver");
+function unwrapExpression(node) {
+    while (node &&
+        [
+            'ParenthesisExpression',
+            'TsConstAssertion',
+            'TsAsExpression',
+            'TsSatisfiesExpression',
+            'TsNonNullExpression',
+            'TsTypeAssertion',
+        ].includes(node.type))
+        node = node.expression;
+    if (node?.type === 'OptionalChainingExpression')
+        return unwrapExpression(node.base);
+    if (node?.type === 'MemberExpression') {
+        const object = unwrapExpression(node.object);
+        if (object !== node.object)
+            return { ...node, object };
+    }
+    return node;
+}
 const toIdent = (value) => value.replace(/[^A-Za-z0-9-]/g, '');
 const getMarkerVar = (id, pseudo) => {
     const hash = (0, zss_engine_1.genBase36Hash)({ [id]: pseudo }, 1, 8);
     return `--${hash}-${toIdent(id)}-${toIdent(pseudo.split('(')[0])}`;
 };
 const getRootIdentifier = (node) => {
+    node = unwrapExpression(node);
     if (exports.t.isIdentifier(node)) {
         return node.value;
     }
@@ -189,21 +211,14 @@ function traverse(node, visitor) {
     }
     walk(node);
 }
-const PROJECT_ROOT = process.cwd().split('node_modules')[0];
-const PATTERN_PATH = path.join(PROJECT_ROOT, '**/*.{js,jsx,ts,tsx}');
-const GLOB_OPTIONS = {
-    exclude: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**'],
-    cwd: PROJECT_ROOT,
-    sort: true,
-};
 function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createHashTable, createStaticHashTable, createStaticObjectTable, variantsHashTable, resolveVariable) {
-    const obj = {};
+    const obj = Object.create(null);
     node.properties.forEach((prop) => {
         if (prop.type === 'SpreadElement') {
             const arg = prop.arguments;
             const spreadVal = evaluateExpression(arg, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
             if (typeof spreadVal === 'object' && spreadVal !== null) {
-                Object.assign(obj, deepMerge(obj, spreadVal));
+                Object.assign(obj, spreadVal);
             }
             return;
         }
@@ -226,16 +241,20 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
         const key = getPropertyKey(prop.key, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
         if (!key)
             return;
-        const val = prop.value;
+        const val = unwrapExpression(prop.value);
         if (exports.t.isIdentifier(val) || exports.t.isMemberExpression(val)) {
             if (resolveVariable && exports.t.isMemberExpression(val)) {
-                if (exports.t.isIdentifier(val.object) && exports.t.isIdentifier(val.property)) {
-                    const resolved = resolveVariable(val.object.value);
-                    const prop = val.property.value;
-                    if (resolved && resolved[prop]) {
-                        obj[key] = resolved[prop];
-                        return;
-                    }
+                const root = (0, exports.getRootIdentifier)(val);
+                const resolved = root ? resolveVariable(root) : undefined;
+                if (resolved !== undefined && root) {
+                    const member = resolveStaticTableMemberExpression(val, {
+                        ...staticTable,
+                        [root]: resolved,
+                    });
+                    if (member === undefined)
+                        throw new Error(`[plumeria] Unknown style member on ${root}.`);
+                    obj[key] = member;
+                    return;
                 }
             }
             const resolvedKeyframe = resolveKeyframesTableMemberExpression(val, keyframesHashTable);
@@ -275,7 +294,7 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
             obj[key] = val.value;
         }
         else if (exports.t.isUnaryExpression(val)) {
-            obj[key] = evaluateUnaryExpression(val);
+            obj[key] = evaluateExpression(val, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
         }
         else if (exports.t.isObjectExpression(val)) {
             obj[key] = objectExpressionToObject(val, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createHashTable, createStaticHashTable, createStaticObjectTable, variantsHashTable, resolveVariable);
@@ -331,7 +350,7 @@ function collectLocalConsts(ast) {
         if (!decls.has(name) || visiting.has(name))
             return undefined;
         visiting.add(name);
-        const init = decls.get(name);
+        const init = unwrapExpression(decls.get(name));
         let result;
         try {
             if (exports.t.isStringLiteral(init) ||
@@ -431,6 +450,10 @@ function literalFromValue(value, span) {
 function inlineOuterScope(objExpression, resolveProperty) {
     const rewriteProperty = (prop, params) => {
         if (prop.type === 'KeyValueProperty') {
+            if (prop.key?.type === 'Computed') {
+                const expression = rewriteExpression(prop.key.expression, params);
+                prop = { ...prop, key: { ...prop.key, expression } };
+            }
             const val = prop.value;
             if (val.type === 'ObjectExpression') {
                 const rewritten = rewriteObject(val, params);
@@ -549,11 +572,26 @@ function inlineOuterScope(objExpression, resolveProperty) {
                 prop.value.type !== 'FunctionExpression'))
             return prop;
         const func = prop.value;
-        const body = rewriteBody(func.body, paramNames(func));
-        if (body === func.body)
-            return prop;
+        const names = paramNames(func);
+        const rewriteParam = (p) => {
+            if (!p || typeof p !== 'object')
+                return p;
+            if (p.type === 'AssignmentPattern')
+                return { ...p, right: rewriteExpression(p.right, names) };
+            if (p.type === 'AssignmentPatternProperty' && p.value)
+                return { ...p, value: rewriteExpression(p.value, names) };
+            if (p.pat)
+                return { ...p, pat: rewriteParam(p.pat) };
+            if (p.properties)
+                return { ...p, properties: p.properties.map(rewriteParam) };
+            if (p.type === 'KeyValuePatternProperty')
+                return { ...p, value: rewriteParam(p.value) };
+            return p;
+        };
+        const params = func.params.map(rewriteParam);
+        const body = rewriteBody(func.body, names);
         changed = true;
-        return { ...prop, value: { ...func, body } };
+        return { ...prop, value: { ...func, body, params } };
     });
     return changed ? { ...objExpression, properties } : objExpression;
 }
@@ -617,6 +655,8 @@ function evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTran
         if (i < node.expressions.length) {
             const expr = node.expressions[i];
             const evaluatedExpr = evaluateExpression(expr, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
+            if (evaluatedExpr === null || typeof evaluatedExpr === 'object')
+                throw new Error('[plumeria] Template value cannot be resolved to a primitive.');
             result += String(evaluatedExpr);
         }
     }
@@ -624,7 +664,15 @@ function evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTran
 }
 function evaluateBinaryExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable) {
     const left = evaluateExpression(node.left, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
+    if (node.operator === '&&' && !left)
+        return left;
+    if (node.operator === '||' && left)
+        return left;
+    if (node.operator === '??' && left !== null)
+        return left;
     const right = evaluateExpression(node.right, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
+    if (['&&', '||', '??'].includes(node.operator))
+        return right;
     if (typeof left === 'number' && typeof right === 'number') {
         if (node.operator === '+') {
             return left + right;
@@ -663,9 +711,19 @@ function evaluateBinaryExpression(node, staticTable, keyframesHashTable, viewTra
             return left | right;
         }
     }
-    if (node.operator === '+') {
+    if (node.operator === '+' &&
+        left !== null &&
+        right !== null &&
+        typeof left !== 'object' &&
+        typeof right !== 'object') {
         return String(left) + String(right);
     }
+    if (['+', '-', '*', '/', '%', '**', '&', '<<', '>>', '>>>', '^', '|'].includes(node.operator)) {
+        const expected = node.operator === '+' ? 'non-null primitive' : 'numeric';
+        const leftType = left === null ? 'null' : typeof left;
+        const rightType = right === null ? 'null' : typeof right;
+        throw new Error(`[plumeria] Binary operator ${node.operator} requires ${expected} operands; received ${leftType} and ${rightType}.`);
+    }
     throw new Error(`[plumeria] Unsupported binary operator: ${node.operator}`);
 }
 function evaluateCallExpression(node, staticTable) {
@@ -708,6 +766,7 @@ function evaluateCallExpression(node, staticTable) {
     return null;
 }
 function evaluateExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable) {
+    node = unwrapExpression(node);
     if (exports.t.isCallExpression(node)) {
         return evaluateCallExpression(node, staticTable);
     }
@@ -739,7 +798,7 @@ function evaluateExpression(node, staticTable, keyframesHashTable, viewTransitio
                 return createStaticObjectTable[hash];
             }
         }
-        return '';
+        throw new Error(`[plumeria] Cannot resolve static value: ${node.value}`);
     }
     if (exports.t.isMemberExpression(node)) {
         const resolved = resolveStaticTableMemberExpression(node, staticTable);
@@ -754,7 +813,7 @@ function evaluateExpression(node, staticTable, keyframesHashTable, viewTransitio
         if (resolvedStatic !== undefined) {
             return resolvedStatic;
         }
-        return '';
+        throw new Error('[plumeria] Cannot resolve static member expression.');
     }
     if (exports.t.isBinaryExpression(node)) {
         return evaluateBinaryExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
@@ -763,29 +822,24 @@ function evaluateExpression(node, staticTable, keyframesHashTable, viewTransitio
         return evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
     }
     if (exports.t.isUnaryExpression(node)) {
-        return evaluateUnaryExpression(node);
+        const value = evaluateExpression(node.argument, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
+        if (node.operator === '!')
+            return !value;
+        if (typeof value === 'number') {
+            if (node.operator === '-')
+                return -value;
+            if (node.operator === '+')
+                return value;
+            if (node.operator === '~')
+                return ~value;
+        }
+        throw new Error(`[plumeria] Unsupported unary operand for ${node.operator}`);
     }
     if (exports.t.isParenthesisExpression(node)) {
         return evaluateExpression(node.expression, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
     }
     throw new Error(`[plumeria] Unsupported expression type: ${node.type}`);
 }
-function evaluateUnaryExpression(node) {
-    const arg = node.argument;
-    switch (node.operator) {
-        case '-':
-            if (exports.t.isNumericLiteral(arg))
-                return -arg.value;
-            break;
-        case '+':
-            if (exports.t.isNumericLiteral(arg))
-                return +arg.value;
-            break;
-        default:
-            throw new Error(`[plumeria] Unsupported unary operator: ${node.operator}`);
-    }
-    throw new Error(`[plumeria] Unsupported UnaryExpression argument type: ${arg.type}`);
-}
 function resolveKeyframesTableMemberExpression(node, keyframesHashTable) {
     if (exports.t.isIdentifier(node)) {
         return keyframesHashTable[node.value];
@@ -810,11 +864,6 @@ function resolveCreateTableMemberExpression(node, createHashTable) {
     if (exports.t.isIdentifier(node)) {
         return createHashTable[node.value];
     }
-    if (exports.t.isMemberExpression(node)) {
-        if (exports.t.isIdentifier(node.object)) {
-            return createHashTable[node.object.value];
-        }
-    }
 }
 function resolveVariantsTableMemberExpression(node, variantsHashTable) {
     if (exports.t.isIdentifier(node)) {
@@ -830,16 +879,29 @@ function resolveStaticTableMemberExpression(node, staticTable) {
     const keys = [];
     let current = node;
     while (exports.t.isMemberExpression(current)) {
-        if (!exports.t.isIdentifier(current.property))
+        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')
             return undefined;
-        keys.unshift(current.property.value);
-        current = current.object;
+        keys.unshift(String(value));
+        current = unwrapExpression(current.object);
     }
     if (!exports.t.isIdentifier(current))
         return undefined;
     let value = staticTable[current.value];
     for (const key of keys) {
-        if (!value || typeof value !== 'object' || !(key in value))
+        if (!value || typeof value !== 'object' || !Object.hasOwn(value, key))
             return undefined;
         value = value[key];
     }
@@ -907,8 +969,9 @@ const fileErrors = {};
 const DIAGNOSTIC_PREFIX = '[plumeria] ';
 function recordFileError(filePath, e) {
     const message = e instanceof Error ? e.message : String(e);
-    if (message.startsWith(DIAGNOSTIC_PREFIX))
-        fileErrors[filePath] = message.slice(DIAGNOSTIC_PREFIX.length);
+    fileErrors[filePath] = message.startsWith(DIAGNOSTIC_PREFIX)
+        ? message.slice(DIAGNOSTIC_PREFIX.length)
+        : message;
 }
 function resolveFileError(actualPath, importedName) {
     const resolved = resolveExport(actualPath, importedName);
@@ -960,8 +1023,33 @@ const globalAgregatedTables = {
     componentPropsTable: {},
 };
 let hasComputedOnce = false;
+let resolutionConfigStamp;
 const objectTableOwners = new Map();
+const fileObjectContributions = new Map();
+function snapshotTables() {
+    return Object.fromEntries(Object.entries(globalAgregatedTables).map(([key, value]) => [
+        key,
+        { ...value },
+    ]));
+}
+function releaseFileObjects(filePath) {
+    const contributions = fileObjectContributions.get(filePath);
+    if (!contributions)
+        return;
+    for (const [tableName, hashes] of contributions) {
+        for (const hash of hashes)
+            releaseObjectOwner(tableName, hash, filePath, globalAgregatedTables[tableName]);
+    }
+    fileObjectContributions.delete(filePath);
+}
 function registerObjectOwner(tableName, hash, filePath) {
+    let contributions = fileObjectContributions.get(filePath);
+    if (!contributions)
+        fileObjectContributions.set(filePath, (contributions = new Map()));
+    let hashes = contributions.get(tableName);
+    if (!hashes)
+        contributions.set(tableName, (hashes = new Set()));
+    hashes.add(hash);
     const key = `${tableName}:${hash}`;
     let owners = objectTableOwners.get(key);
     if (!owners) {
@@ -982,8 +1070,17 @@ function releaseObjectOwner(tableName, hash, filePath, table) {
     }
 }
 function stripFileContributions(filePath, cached) {
-    if (!cached.hasCssUsage)
-        return;
+    releaseFileObjects(filePath);
+    for (const [name, table] of Object.entries(globalAgregatedTables)) {
+        if (name.endsWith('ObjectTable') ||
+            name === 'createAtomicMapTable' ||
+            name === 'createThemeSelectorTable' ||
+            name === 'componentPropsTable')
+            continue;
+        for (const key of Object.keys(table))
+            if (key.startsWith(`${filePath}-`))
+                delete table[key];
+    }
     const localTables = globalAgregatedTables;
     for (const key of Object.keys(cached.staticTable)) {
         delete localTables.staticTable[`${filePath}-${key}`];
@@ -1057,10 +1154,40 @@ function stripFileContributions(filePath, cached) {
 }
 function scanAll() {
     if (hasComputedOnce && process.env.NODE_ENV === 'production') {
-        return globalAgregatedTables;
+        return snapshotTables();
     }
     const localTables = globalAgregatedTables;
-    const files = rs.globSync(PATTERN_PATH, GLOB_OPTIONS);
+    const configPath = path.join(process.cwd(), 'tsconfig.json');
+    let configStamp = configPath;
+    try {
+        configStamp += `:${fs.statSync(configPath).mtimeMs}`;
+    }
+    catch {
+    }
+    const resolutionChanged = resolutionConfigStamp !== undefined &&
+        resolutionConfigStamp !== configStamp;
+    if (resolutionChanged)
+        (0, resolver_1.resetImportResolutionCache)();
+    resolutionConfigStamp = configStamp;
+    const cwd = process.cwd();
+    const segments = cwd.split(path.sep);
+    const dependencyDirectory = segments.indexOf('node_modules');
+    const root = dependencyDirectory < 0
+        ? cwd
+        : segments.slice(0, dependencyDirectory).join(path.sep) ||
+            path.parse(cwd).root;
+    const files = rs
+        .globSync(path.join(root, '**/*.{js,jsx,ts,tsx}'), {
+        exclude: [
+            '**/node_modules/**',
+            '**/dist/**',
+            '**/build/**',
+            '**/.next/**',
+        ],
+        cwd: root,
+        sort: true,
+    })
+        .sort();
     const currentFiles = new Set(files);
     const deletedFiles = [];
     for (const fp of knownFiles) {
@@ -1074,7 +1201,7 @@ function scanAll() {
         try {
             const stats = fs.statSync(filePath);
             const cached = fileCache[filePath];
-            if (!cached || cached.mtimeMs !== stats.mtimeMs) {
+            if (resolutionChanged || !cached || cached.mtimeMs !== stats.mtimeMs) {
                 invalidated.add(filePath);
                 queue.push(filePath);
             }
@@ -1084,6 +1211,26 @@ function scanAll() {
             queue.push(filePath);
         }
     }
+    for (const dependency of dependentsMap.keys()) {
+        if (currentFiles.has(dependency))
+            continue;
+        const cached = fileCache[dependency];
+        if (!cached)
+            continue;
+        let changed;
+        try {
+            changed =
+                (cached.exportsMtimeMs ?? cached.mtimeMs) !==
+                    fs.statSync(dependency).mtimeMs;
+        }
+        catch {
+            changed = true;
+        }
+        if (changed) {
+            invalidated.add(dependency);
+            queue.push(dependency);
+        }
+    }
     for (const fp of deletedFiles) {
         invalidated.add(fp);
         queue.push(fp);
@@ -1101,7 +1248,7 @@ function scanAll() {
         }
     }
     if (invalidated.size === 0 && hasComputedOnce) {
-        return localTables;
+        return snapshotTables();
     }
     for (const fp of deletedFiles) {
         const cached = fileCache[fp];
@@ -1154,9 +1301,34 @@ function scanAll() {
             parsedFiles.push({ filePath, ast, mtimeMs: stats.mtimeMs });
         }
         catch (e) {
+            recordFileError(filePath, e);
         }
     }
     const jsxPhaseQueue = [];
+    for (const file of parsedFiles) {
+        try {
+            extractAndCacheExports(file.filePath, file.ast, file.mtimeMs);
+        }
+        catch (error) {
+            recordFileError(file.filePath, error);
+        }
+    }
+    const byPath = new Map(parsedFiles.map((file) => [file.filePath, file]));
+    const ordered = [];
+    const visitedFiles = new Set();
+    const visitFile = (file) => {
+        if (visitedFiles.has(file.filePath))
+            return;
+        visitedFiles.add(file.filePath);
+        for (const dependency of getFileDependencies(file.filePath)) {
+            const imported = byPath.get(dependency);
+            if (imported)
+                visitFile(imported);
+        }
+        ordered.push(file);
+    };
+    parsedFiles.forEach(visitFile);
+    parsedFiles.splice(0, parsedFiles.length, ...ordered);
     for (let passNumber = 1; passNumber <= 2; passNumber++) {
         const isFirstPass = passNumber === 1;
         for (const { filePath, ast, mtimeMs } of parsedFiles) {
@@ -1267,6 +1439,8 @@ function scanAll() {
                                         if (localTables.createHashTable[uniqueKey]) {
                                             const hash = localTables.createHashTable[uniqueKey];
                                             localCreateHashTable[localName] = hash;
+                                            localCreateObjectTable[hash] =
+                                                localTables.createObjectTable[hash];
                                         }
                                     }
                                 });
@@ -1290,6 +1464,28 @@ function scanAll() {
                         }
                     }
                 }
+                const initializers = new Map();
+                for (const statement of ast.body) {
+                    const declaration = statement.type === 'ExportDeclaration'
+                        ? statement.declaration
+                        : statement;
+                    if (exports.t.isVariableDeclaration(declaration) &&
+                        declaration.kind === 'const') {
+                        for (const variable of declaration.declarations)
+                            if (exports.t.isIdentifier(variable.id) && variable.init)
+                                initializers.set(variable.id.value, variable.init);
+                    }
+                }
+                const objectArgument = (expression, visiting = new Set()) => {
+                    const value = unwrapExpression(expression);
+                    if (exports.t.isIdentifier(value) &&
+                        initializers.has(value.value) &&
+                        !visiting.has(value.value)) {
+                        visiting.add(value.value);
+                        return objectArgument(initializers.get(value.value), visiting);
+                    }
+                    return value;
+                };
                 for (const node of ast.body) {
                     let declarations = [];
                     if (exports.t.isVariableDeclaration(node)) {
@@ -1300,6 +1496,11 @@ function scanAll() {
                         declarations = node.declaration.declarations;
                     }
                     for (const decl of declarations) {
+                        if (decl.init)
+                            decl.init = unwrapExpression(decl.init);
+                        if (exports.t.isCallExpression(decl.init))
+                            for (const arg of decl.init.arguments)
+                                arg.expression = unwrapExpression(arg.expression);
                         if (exports.t.isVariableDeclarator(decl) &&
                             exports.t.isIdentifier(decl.id) &&
                             decl.init &&
@@ -1323,6 +1524,18 @@ function scanAll() {
                                     method = originalName;
                                 }
                             }
+                            if (method &&
+                                [
+                                    'create',
+                                    'createTheme',
+                                    'createStatic',
+                                    'keyframes',
+                                    'viewTransition',
+                                ].includes(method)) {
+                                const argument = decl.init.arguments[method === 'createTheme' ? 1 : 0];
+                                if (argument)
+                                    argument.expression = objectArgument(argument.expression);
+                            }
                             const isCreateTheme = method === 'createTheme';
                             if (method &&
                                 decl.init.arguments.length > 0 &&
@@ -1383,6 +1596,8 @@ function scanAll() {
                                 }
                                 else if (method === 'createTheme') {
                                     const selector = resolveThemeSelector(init.arguments[0].expression, scopedStaticTable, localCreateStaticHashTable, localCreateStaticObjectTable);
+                                    if (!selector)
+                                        throw new Error('[plumeria] createTheme requires a statically resolvable non-empty selector.');
                                     const hash = (0, createTheme_1.themeHashOf)(selector, obj);
                                     localTables.createThemeObjectTable[hash] = obj;
                                     localCreateThemeObjectTable[hash] = obj;
@@ -1505,7 +1720,7 @@ function scanAll() {
                 variantsHashTable: localVariantsHashTable,
             };
             const dynamicStaticTable = {
-                ...localTables.staticTable,
+                ...collectLocalConsts(ast),
                 ...localStaticTable,
             };
             const resolveDynamicCallInScan = (expr) => {
@@ -1563,6 +1778,7 @@ function scanAll() {
                 return { style: resolved.style, hasVars };
             };
             const resolveCallStylePropInScan = (expr) => {
+                expr = unwrapExpression(expr);
                 if (expr.type === 'ArrayExpression') {
                     let mergedStyle = {};
                     const classList = [];
@@ -1637,6 +1853,98 @@ function scanAll() {
                 }
                 return null;
             };
+            const containsStyleReference = (expr) => {
+                let found = false;
+                traverse(expr, {
+                    Identifier({ node }) {
+                        if (localCreateHashTable[node.value] ||
+                            localTables.createHashTable[`${filePath}-${node.value}`])
+                            found = true;
+                    },
+                });
+                return found;
+            };
+            const propAlternatives = (expr) => {
+                expr = unwrapExpression(expr);
+                const empty = {
+                    styleObj: {},
+                    conditions: [],
+                    dynamicCalls: [],
+                };
+                if (expr.type === 'NullLiteral' ||
+                    (expr.type === 'BooleanLiteral' && !expr.value) ||
+                    (expr.type === 'Identifier' && expr.value === 'undefined'))
+                    return [empty];
+                if (expr.type === 'ConditionalExpression') {
+                    if (expr.test.type === 'BooleanLiteral')
+                        return propAlternatives(expr.test.value ? expr.consequent : expr.alternate);
+                    const truthy = propAlternatives(expr.consequent);
+                    const falsy = propAlternatives(expr.alternate);
+                    if (!truthy || !falsy)
+                        return null;
+                    return [
+                        ...truthy.map((entry) => ({
+                            ...entry,
+                            conditions: [
+                                { test: expr.test, truthy: true },
+                                ...entry.conditions,
+                            ],
+                        })),
+                        ...falsy.map((entry) => ({
+                            ...entry,
+                            conditions: [
+                                { test: expr.test, truthy: false },
+                                ...entry.conditions,
+                            ],
+                        })),
+                    ];
+                }
+                if (expr.type === 'BinaryExpression' && expr.operator === '&&') {
+                    if (expr.left.type === 'BooleanLiteral')
+                        return expr.left.value ? propAlternatives(expr.right) : [empty];
+                    const truthy = propAlternatives(expr.right);
+                    if (!truthy)
+                        return null;
+                    return [
+                        ...truthy.map((entry) => ({
+                            ...entry,
+                            conditions: [
+                                { test: expr.left, truthy: true },
+                                ...entry.conditions,
+                            ],
+                        })),
+                        { ...empty, conditions: [{ test: expr.left, truthy: false }] },
+                    ];
+                }
+                if (expr.type === 'ArrayExpression') {
+                    let result = [empty];
+                    for (const element of expr.elements) {
+                        if (!element)
+                            continue;
+                        if (element.spread)
+                            return null;
+                        const choices = propAlternatives(element.expression);
+                        if (!choices)
+                            return null;
+                        result = result.flatMap((base) => choices.map((choice) => ({
+                            styleObj: deepMerge(base.styleObj, choice.styleObj),
+                            conditions: [...base.conditions, ...choice.conditions],
+                            dynamicCalls: [...base.dynamicCalls, ...choice.dynamicCalls],
+                        })));
+                    }
+                    return result;
+                }
+                const resolved = resolveCallStylePropInScan(expr);
+                return resolved
+                    ? [
+                        {
+                            styleObj: resolved.styleObj,
+                            conditions: [],
+                            dynamicCalls: resolved.hasVars ? [expr] : [],
+                        },
+                    ]
+                    : null;
+            };
             const localComponentPropsTable = {};
             const registerStyles = (node, propName, compKey, table) => {
                 if (node.type === 'ConditionalExpression') {
@@ -1652,6 +1960,39 @@ function scanAll() {
                     registerStyles(node.expression, propName, compKey, table);
                     return;
                 }
+                if (node.type === 'ArrayExpression') {
+                    const alternatives = propAlternatives(node);
+                    if (!alternatives) {
+                        if (!containsStyleReference(node))
+                            return;
+                        throw new Error('[plumeria] A style prop array contains an unsupported style expression. Use defined styles, null, false, undefined, or conditional branches of defined styles.');
+                    }
+                    if (!containsStyleReference(node))
+                        return;
+                    const list = ((table[compKey] ??= {})[propName] ??= []);
+                    for (const alternative of alternatives) {
+                        const atomMap = {};
+                        (0, create_1.getStyleRecords)(alternative.styleObj).forEach((record) => (atomMap[record.key] = record.hash));
+                        const classString = Object.values(atomMap).join(' ');
+                        list.push({
+                            key: (0, zss_engine_1.genBase36Hash)(classString, 1, 8),
+                            classString,
+                            styleObj: alternative.styleObj,
+                            spanStart: node.span.start,
+                            filePath,
+                            conditions: alternative.conditions,
+                            dynamicCalls: alternative.dynamicCalls,
+                            hasVars: alternative.dynamicCalls.length > 0,
+                        });
+                    }
+                    return;
+                }
+                if (node.type === 'BinaryExpression' &&
+                    (node.operator === '||' || node.operator === '??')) {
+                    if (!containsStyleReference(node))
+                        return;
+                    throw new Error('[plumeria] Style prop fallbacks using || or ?? cannot be resolved. Use a conditional expression with defined styles.');
+                }
                 const resolved = resolveCallStylePropInScan(node);
                 if (resolved) {
                     if (!table[compKey]) {
@@ -1702,7 +2043,10 @@ function scanAll() {
                     const entries = localComponentPropsTable[compKey][propName];
                     for (const entry of entries) {
                         const exists = globalTable[compKey][propName].some((x) => x.spanStart === entry.spanStart &&
-                            x.filePath === entry.filePath);
+                            x.filePath === entry.filePath &&
+                            x.key === entry.key &&
+                            JSON.stringify(x.conditions) ===
+                                JSON.stringify(entry.conditions));
                         if (!exists) {
                             globalTable[compKey][propName].push(entry);
                         }
@@ -1714,6 +2058,7 @@ function scanAll() {
                 mtimeMs: mtimeMs,
                 dependencies: Array.from(localDependencies),
                 exports: fileCache[filePath]?.exports,
+                exportsMtimeMs: fileCache[filePath]?.exportsMtimeMs,
                 staticTable: localStaticTable,
                 keyframesHashTable: localKeyframesHashTable,
                 keyframesObjectTable: localKeyframesObjectTable,
@@ -1738,8 +2083,26 @@ function scanAll() {
             recordFileError(entry.filePath, e);
         }
     }
+    for (const entry of jsxPhaseQueue) {
+        const cached = fileCache[entry.filePath];
+        if (!cached?.hasCssUsage || fileErrors[entry.filePath])
+            continue;
+        const contributions = fileObjectContributions.get(entry.filePath);
+        for (const [tableName, hashes] of contributions ?? []) {
+            for (const hash of [...hashes]) {
+                if (!Object.hasOwn(cached[tableName] ?? {}, hash)) {
+                    releaseObjectOwner(tableName, hash, entry.filePath, localTables[tableName]);
+                    hashes.delete(hash);
+                }
+            }
+        }
+    }
+    for (const props of Object.values(localTables.componentPropsTable ?? {})) {
+        for (const entries of Object.values(props))
+            entries.sort((a, b) => a.filePath.localeCompare(b.filePath) || a.spanStart - b.spanStart);
+    }
     hasComputedOnce = true;
-    return localTables;
+    return snapshotTables();
 }
 function getFileDependencies(filePath) {
     const visited = new Set();
@@ -1912,16 +2275,19 @@ function extractAndCacheExports(filePath, ast, mtimeMs) {
         };
         fileCache[filePath].dependencies = newDeps;
     }
+    fileCache[filePath].exportsMtimeMs = mtimeMs;
 }
 function resolveExport(filePath, exportName, visited = new Set()) {
     const key = `${filePath}-${exportName}`;
     if (visited.has(key))
         return null;
     visited.add(key);
-    if (!fileCache[filePath] || !fileCache[filePath].exports) {
+    {
         try {
             const stats = fs.statSync(filePath);
-            if (stats.isFile()) {
+            if ((!fileCache[filePath]?.exports ||
+                fileCache[filePath].exportsMtimeMs !== stats.mtimeMs) &&
+                stats.isFile()) {
                 const source = fs.readFileSync(filePath, 'utf8');
                 const ast = (0, core_1.parseSync)(source, {
                     syntax: 'typescript',
@@ -2071,8 +2437,8 @@ function extractOndemandStyles(obj, extractedSheets, t) {
     }
 }
 function deepMerge(target, source) {
-    const result = { ...target };
-    for (const key in source) {
+    const result = Object.assign(Object.create(null), target);
+    for (const key of Object.keys(source)) {
         const val = source[key];
         if (val && typeof val === 'object' && !Array.isArray(val)) {
             if (result[key] && typeof result[key] === 'object') {

package/dist/resolver.d.ts

@@ -1 +1,2 @@
+export declare function resetImportResolutionCache(): void;
 export declare function resolveImportPath(importPath: string, importerPath: string): string | null;

package/dist/resolver.js

@@ -33,10 +33,24 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetImportResolutionCache = resetImportResolutionCache;
 exports.resolveImportPath = resolveImportPath;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 let cachedTsConfig = undefined;
+function resetImportResolutionCache() {
+    const configPath = path.join(process.cwd(), 'tsconfig.json');
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        cachedTsConfig = {
+            config: config.compilerOptions || null,
+            basePath: path.dirname(configPath),
+        };
+    }
+    catch {
+        cachedTsConfig = null;
+    }
+}
 function getTsConfig() {
     if (cachedTsConfig !== undefined) {
         return cachedTsConfig;

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import { CSSProperties } from 'zss-engine';
-import type { ObjectExpression } from '@swc/core';
+import type { ObjectExpression, Expression } from '@swc/core';
 type CSSPrimitive = string | number | boolean;
 export type CSSValue = CSSPrimitive | CSSObject;
 export type CSSObject = {
@@ -28,6 +28,11 @@ export interface TableEntry {
     spanStart: number;
     filePath: string;
     hasVars?: boolean;
+    conditions?: Array<{
+        test: Expression;
+        truthy: boolean;
+    }>;
+    dynamicCalls?: Expression[];
 }
 export interface Tables {
     staticTable: StaticTable;

package/package.json

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