@plumeria/utils 6.2.0 → 6.2.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { CSSObject, FileStyles, StaticTable, ThemeTable, KeyframesHashTable, KeyframesObjectTable, ViewTransitionHashTable, ViewTransitionObjectTable, CreateThemeObjectTable, CreateHashTable, CreateObjectTable, VariantsHashTable, VariantsObjectTable, } from './types';
+export type { CSSObject, FileStyles, StaticTable, KeyframesHashTable, KeyframesObjectTable, ViewTransitionHashTable, ViewTransitionObjectTable, CreateThemeObjectTable, CreateHashTable, CreateObjectTable, VariantsHashTable, VariantsObjectTable, CreateThemeHashTable, CreateStaticHashTable, CreateStaticObjectTable, } from './types';
 export { objectExpressionToObject, collectLocalConsts, traverse, t, extractOndemandStyles, deepMerge, scanAll, } from './parser';
 export { getStyleRecords } from './create';
 export type { StyleRecord } from './create';

package/dist/parser.d.ts

@@ -1,4 +1,4 @@
-import type { CSSObject, ThemeTable, Tables, StaticTable, KeyframesHashTable, ViewTransitionHashTable, CreateHashTable, VariantsHashTable } from './types';
+import type { CSSObject, Tables, StaticTable, KeyframesHashTable, ViewTransitionHashTable, CreateThemeObjectTable, CreateHashTable, VariantsHashTable, CreateThemeHashTable, CreateStaticHashTable, CreateStaticObjectTable } from './types';
 import { Module, CallExpression, Identifier, KeyValueProperty, StringLiteral, NumericLiteral, BooleanLiteral, ObjectExpression, MemberExpression, TemplateLiteral, BinaryExpression, UnaryExpression, VariableDeclaration, VariableDeclarator, ExportDeclaration, ConditionalExpression } from '@swc/core';
 export declare const t: {
     isObjectExpression: (node: any) => node is ObjectExpression;
@@ -26,9 +26,8 @@ export declare function traverse(node: Module, visitor: {
         stop: () => void;
     }) => void;
 }): void;
-export declare const tables: Tables;
-export declare function objectExpressionToObject(node: ObjectExpression, staticTable: StaticTable, keyframesHashTable: KeyframesHashTable, viewTransitionHashTable: ViewTransitionHashTable, themeTable: ThemeTable, createHashTable: CreateHashTable, variantsHashTable: VariantsHashTable, resolveVariable?: (name: string) => any): CSSObject;
+export declare function objectExpressionToObject(node: ObjectExpression, staticTable: StaticTable, keyframesHashTable: KeyframesHashTable, viewTransitionHashTable: ViewTransitionHashTable, createThemeHashTable: CreateThemeHashTable, createThemeObjectTable: CreateThemeObjectTable, createHashTable: CreateHashTable, createStaticHashTable: CreateStaticHashTable, createStaticObjectTable: CreateStaticObjectTable, variantsHashTable: VariantsHashTable, resolveVariable?: (name: string) => any): CSSObject;
 export declare function collectLocalConsts(ast: Module): Record<string, any>;
 export declare function scanAll(): Tables;
-export declare function extractOndemandStyles(obj: any, extractedSheets: string[], t?: Tables): void;
+export declare function extractOndemandStyles(obj: any, extractedSheets: string[], t: Tables): void;
 export declare function deepMerge(target: Record<string, any>, source: Record<string, any>): Record<string, any>;

package/dist/parser.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tables = exports.t = void 0;
+exports.t = void 0;
 exports.traverse = traverse;
 exports.objectExpressionToObject = objectExpressionToObject;
 exports.collectLocalConsts = collectLocalConsts;
@@ -17,6 +17,7 @@ const fs_1 = __importDefault(require("fs"));
 const zss_engine_1 = require("zss-engine");
 const viewTransition_1 = require("./viewTransition");
 const create_1 = require("./create");
+const resolver_1 = require("./resolver");
 exports.t = {
     isObjectExpression: (node) => node?.type === 'ObjectExpression',
     isObjectProperty: (node) => node?.type === 'KeyValueProperty',
@@ -76,26 +77,12 @@ const GLOB_OPTIONS = {
     exclude: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**'],
     cwd: PROJECT_ROOT,
 };
-exports.tables = {
-    staticTable: {},
-    themeTable: {},
-    keyframesHashTable: {},
-    keyframesObjectTable: {},
-    viewTransitionHashTable: {},
-    viewTransitionObjectTable: {},
-    createThemeObjectTable: {},
-    createHashTable: {},
-    createObjectTable: {},
-    createAtomicMapTable: {},
-    variantsHashTable: {},
-    variantsObjectTable: {},
-};
-function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable, createHashTable, variantsHashTable, resolveVariable) {
+function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createHashTable, createStaticHashTable, createStaticObjectTable, variantsHashTable, resolveVariable) {
     const obj = {};
     node.properties.forEach((prop) => {
         if (!exports.t.isObjectProperty(prop))
             return;
-        const key = getPropertyKey(prop.key, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
+        const key = getPropertyKey(prop.key, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
         if (!key)
             return;
         const val = prop.value;
@@ -125,11 +112,16 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
                 obj[key] = 'cr-' + resolvedCreate;
                 return;
             }
-            const resolvedTheme = resolveThemeTableMemberExpressionByNode(val, themeTable);
+            const resolvedTheme = resolveCreateThemeTableMemberExpressionByNode(val, createThemeHashTable, createThemeObjectTable);
             if (resolvedTheme !== undefined) {
                 obj[key] = resolvedTheme;
                 return;
             }
+            const resolvedStatic = resolveCreateStaticTableMemberExpression(val, createStaticHashTable, createStaticObjectTable);
+            if (resolvedStatic !== undefined) {
+                obj[key] = resolvedStatic;
+                return;
+            }
             const resolvedVariants = resolveVariantsTableMemberExpression(val, variantsHashTable);
             if (resolvedVariants !== undefined) {
                 obj[key] = 'vr-' + resolvedVariants;
@@ -145,7 +137,7 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
             obj[key] = evaluateUnaryExpression(val);
         }
         else if (exports.t.isObjectExpression(val)) {
-            obj[key] = objectExpressionToObject(val, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable, createHashTable, variantsHashTable, resolveVariable);
+            obj[key] = objectExpressionToObject(val, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createHashTable, createStaticHashTable, createStaticObjectTable, variantsHashTable, resolveVariable);
         }
         else if (exports.t.isMemberExpression(val)) {
             const resolved = resolveStaticTableMemberExpression(val, staticTable);
@@ -197,7 +189,7 @@ function collectLocalConsts(ast) {
             result = init.value;
         }
         else if (exports.t.isObjectExpression(init)) {
-            result = objectExpressionToObject(init, localConsts, exports.tables.keyframesHashTable, exports.tables.viewTransitionHashTable, exports.tables.themeTable, exports.tables.createHashTable, exports.tables.variantsHashTable, resolveValue);
+            result = objectExpressionToObject(init, localConsts, {}, {}, {}, {}, {}, {}, {}, {}, resolveValue);
         }
         visiting.delete(name);
         if (result !== undefined) {
@@ -210,7 +202,7 @@ function collectLocalConsts(ast) {
     }
     return localConsts;
 }
-function getPropertyKey(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable) {
+function getPropertyKey(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable) {
     if (exports.t.isIdentifier(node)) {
         return node.value;
     }
@@ -232,44 +224,47 @@ function getPropertyKey(node, staticTable, keyframesHashTable, viewTransitionHas
             const result = resolveStaticTableMemberExpression(expr, staticTable);
             if (typeof result === 'string')
                 return result;
+            const staticResult = resolveCreateStaticTableMemberExpression(expr, createStaticHashTable, createStaticObjectTable);
+            if (typeof staticResult === 'string')
+                return staticResult;
         }
         if (exports.t.isTemplateLiteral(expr)) {
-            return evaluateTemplateLiteral(expr, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
+            return evaluateTemplateLiteral(expr, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
         }
         if (exports.t.isBinaryExpression(expr)) {
-            return evaluateBinaryExpression(expr, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
+            return evaluateBinaryExpression(expr, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
         }
         return '';
     }
     if (exports.t.isTemplateLiteral(node)) {
-        return evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
+        return evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
     }
     if (exports.t.isBinaryExpression(node)) {
-        return evaluateBinaryExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
+        return evaluateBinaryExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
     }
     return '';
 }
-function evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable) {
+function evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable) {
     let result = '';
     for (let i = 0; i < node.quasis.length; i++) {
         result += node.quasis[i].cooked || node.quasis[i].raw;
         if (i < node.expressions.length) {
             const expr = node.expressions[i];
-            const evaluatedExpr = evaluateExpression(expr, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
+            const evaluatedExpr = evaluateExpression(expr, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
             result += String(evaluatedExpr);
         }
     }
     return result;
 }
-function evaluateBinaryExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable) {
-    const left = evaluateExpression(node.left, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
-    const right = evaluateExpression(node.right, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
+function evaluateBinaryExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable) {
+    const left = evaluateExpression(node.left, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
+    const right = evaluateExpression(node.right, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
     if (node.operator === '+') {
         return String(left) + String(right);
     }
     throw new Error(`Unsupported binary operator: ${node.operator}`);
 }
-function evaluateExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable) {
+function evaluateExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable) {
     if (exports.t.isStringLiteral(node)) {
         return node.value;
     }
@@ -299,17 +294,21 @@ function evaluateExpression(node, staticTable, keyframesHashTable, viewTransitio
         if (resolved !== undefined) {
             return resolved;
         }
-        const resolvedTheme = resolveThemeTableMemberExpressionByNode(node, themeTable);
+        const resolvedTheme = resolveCreateThemeTableMemberExpressionByNode(node, createThemeHashTable, createThemeObjectTable);
         if (resolvedTheme !== undefined) {
             return resolvedTheme;
         }
+        const resolvedStatic = resolveCreateStaticTableMemberExpression(node, createStaticHashTable, createStaticObjectTable);
+        if (resolvedStatic !== undefined) {
+            return resolvedStatic;
+        }
         return `[unresolved member expression]`;
     }
     if (exports.t.isBinaryExpression(node)) {
-        return evaluateBinaryExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
+        return evaluateBinaryExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
     }
     if (exports.t.isTemplateLiteral(node)) {
-        return evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
+        return evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable);
     }
     if (exports.t.isUnaryExpression(node)) {
         return evaluateUnaryExpression(node);
@@ -383,20 +382,49 @@ function resolveStaticTableMemberExpression(node, staticTable) {
     }
     return undefined;
 }
-function resolveThemeTableMemberExpressionByNode(node, themeTable) {
+function resolveCreateThemeTableMemberExpressionByNode(node, createThemeHashTable, createThemeObjectTable) {
     if (exports.t.isMemberExpression(node) && exports.t.isIdentifier(node.object)) {
         const varName = node.object.value;
-        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 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;
+                }
+                if (key && themeObj[key] !== undefined) {
+                    const cssVarName = (0, zss_engine_1.camelToKebabCase)(key);
+                    return `var(--${cssVarName})`;
+                }
+            }
         }
-        if (key && themeTable[varName] && themeTable[varName][key] !== undefined) {
-            const cssVarName = (0, zss_engine_1.camelToKebabCase)(key);
-            return `var(--${cssVarName})`;
+    }
+    return undefined;
+}
+function resolveCreateStaticTableMemberExpression(node, 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;
+                }
+                if (key && staticObj[key] !== undefined) {
+                    return staticObj[key];
+                }
+            }
         }
     }
     return undefined;
@@ -409,7 +437,6 @@ function scanAll() {
     }
     const localTables = {
         staticTable: {},
-        themeTable: {},
         keyframesHashTable: {},
         keyframesObjectTable: {},
         viewTransitionHashTable: {},
@@ -420,276 +447,357 @@ function scanAll() {
         createAtomicMapTable: {},
         variantsHashTable: {},
         variantsObjectTable: {},
+        createThemeHashTable: {},
+        createStaticHashTable: {},
+        createStaticObjectTable: {},
         extractedSheet: '',
     };
     const files = fs_1.default.globSync(PATTERN_PATH, GLOB_OPTIONS);
+    files.sort((a, b) => {
+        const aPriority = a.includes('/lib/') || a.includes('/utils/') || a.includes('/common/')
+            ? 0
+            : 1;
+        const bPriority = b.includes('/lib/') || b.includes('/utils/') || b.includes('/common/')
+            ? 0
+            : 1;
+        if (aPriority !== bPriority)
+            return aPriority - bPriority;
+        return a.localeCompare(b);
+    });
     const totalExtractedSheets = [];
-    for (const filePath of files) {
-        try {
-            const stats = fs_1.default.statSync(filePath);
-            const cached = fileCache[filePath];
-            if (cached && cached.mtimeMs === stats.mtimeMs) {
-                if (cached.hasCssUsage) {
-                    for (const key of Object.keys(cached.staticTable)) {
-                        localTables.staticTable[`${filePath}-${key}`] =
-                            cached.staticTable[key];
-                    }
-                    for (const key of Object.keys(cached.keyframesHashTable)) {
-                        localTables.keyframesHashTable[`${filePath}-${key}`] =
-                            cached.keyframesHashTable[key];
-                    }
-                    for (const key of Object.keys(cached.keyframesObjectTable)) {
-                        localTables.keyframesObjectTable[key] =
-                            cached.keyframesObjectTable[key];
-                    }
-                    for (const key of Object.keys(cached.viewTransitionHashTable)) {
-                        localTables.viewTransitionHashTable[`${filePath}-${key}`] =
-                            cached.viewTransitionHashTable[key];
-                    }
-                    for (const key of Object.keys(cached.viewTransitionObjectTable)) {
-                        localTables.viewTransitionObjectTable[key] =
-                            cached.viewTransitionObjectTable[key];
-                    }
-                    for (const key of Object.keys(cached.themeTable)) {
-                        localTables.themeTable[`${filePath}-${key}`] =
-                            cached.themeTable[key];
-                    }
-                    for (const key of Object.keys(cached.createThemeObjectTable)) {
-                        localTables.createThemeObjectTable[key] =
-                            cached.createThemeObjectTable[key];
-                    }
-                    for (const key of Object.keys(cached.createHashTable)) {
-                        localTables.createHashTable[`${filePath}-${key}`] =
-                            cached.createHashTable[key];
-                    }
-                    for (const key of Object.keys(cached.createObjectTable)) {
-                        localTables.createObjectTable[key] = cached.createObjectTable[key];
-                    }
-                    for (const key of Object.keys(cached.createAtomicMapTable)) {
-                        localTables.createAtomicMapTable[key] =
-                            cached.createAtomicMapTable[key];
-                    }
-                    for (const key of Object.keys(cached.variantsHashTable)) {
-                        localTables.variantsHashTable[`${filePath}-${key}`] =
-                            cached.variantsHashTable[key];
-                    }
-                    for (const key of Object.keys(cached.variantsObjectTable)) {
-                        localTables.variantsObjectTable[key] =
-                            cached.variantsObjectTable[key];
-                    }
-                    if (cached.extractedSheet) {
-                        totalExtractedSheets.push(cached.extractedSheet);
+    for (let passNumber = 1; passNumber <= 2; passNumber++) {
+        const isFirstPass = passNumber === 1;
+        for (const filePath of files) {
+            try {
+                const stats = fs_1.default.statSync(filePath);
+                const cached = fileCache[filePath];
+                if (cached && cached.mtimeMs === stats.mtimeMs) {
+                    if (cached.hasCssUsage) {
+                        for (const key of Object.keys(cached.staticTable)) {
+                            localTables.staticTable[`${filePath}-${key}`] =
+                                cached.staticTable[key];
+                        }
+                        for (const key of Object.keys(cached.keyframesHashTable)) {
+                            localTables.keyframesHashTable[`${filePath}-${key}`] =
+                                cached.keyframesHashTable[key];
+                        }
+                        for (const key of Object.keys(cached.keyframesObjectTable)) {
+                            localTables.keyframesObjectTable[key] =
+                                cached.keyframesObjectTable[key];
+                        }
+                        for (const key of Object.keys(cached.viewTransitionHashTable)) {
+                            localTables.viewTransitionHashTable[`${filePath}-${key}`] =
+                                cached.viewTransitionHashTable[key];
+                        }
+                        for (const key of Object.keys(cached.viewTransitionObjectTable)) {
+                            localTables.viewTransitionObjectTable[key] =
+                                cached.viewTransitionObjectTable[key];
+                        }
+                        for (const key of Object.keys(cached.createThemeHashTable)) {
+                            localTables.createThemeHashTable[`${filePath}-${key}`] =
+                                cached.createThemeHashTable[key];
+                        }
+                        for (const key of Object.keys(cached.createThemeObjectTable)) {
+                            localTables.createThemeObjectTable[key] =
+                                cached.createThemeObjectTable[key];
+                        }
+                        for (const key of Object.keys(cached.createStaticHashTable)) {
+                            localTables.createStaticHashTable[`${filePath}-${key}`] =
+                                cached.createStaticHashTable[key];
+                        }
+                        for (const key of Object.keys(cached.createStaticObjectTable)) {
+                            localTables.createStaticObjectTable[key] =
+                                cached.createStaticObjectTable[key];
+                        }
+                        for (const key of Object.keys(cached.createHashTable)) {
+                            localTables.createHashTable[`${filePath}-${key}`] =
+                                cached.createHashTable[key];
+                        }
+                        for (const key of Object.keys(cached.createObjectTable)) {
+                            localTables.createObjectTable[key] =
+                                cached.createObjectTable[key];
+                        }
+                        for (const key of Object.keys(cached.createAtomicMapTable)) {
+                            localTables.createAtomicMapTable[key] =
+                                cached.createAtomicMapTable[key];
+                        }
+                        for (const key of Object.keys(cached.variantsHashTable)) {
+                            localTables.variantsHashTable[`${filePath}-${key}`] =
+                                cached.variantsHashTable[key];
+                        }
+                        for (const key of Object.keys(cached.variantsObjectTable)) {
+                            localTables.variantsObjectTable[key] =
+                                cached.variantsObjectTable[key];
+                        }
+                        if (cached.extractedSheet) {
+                            totalExtractedSheets.push(cached.extractedSheet);
+                        }
                     }
+                    continue;
                 }
-                continue;
-            }
-            const source = fs_1.default.readFileSync(filePath, 'utf8');
-            if (!source.includes('@plumeria/core')) {
-                fileCache[filePath] = {
-                    mtimeMs: stats.mtimeMs,
-                    staticTable: {},
-                    keyframesHashTable: {},
-                    keyframesObjectTable: {},
-                    viewTransitionHashTable: {},
-                    viewTransitionObjectTable: {},
-                    themeTable: {},
-                    createThemeObjectTable: {},
-                    createHashTable: {},
-                    createObjectTable: {},
-                    createAtomicMapTable: {},
-                    variantsHashTable: {},
-                    variantsObjectTable: {},
-                    hasCssUsage: false,
-                    extractedSheet: '',
-                };
-                continue;
-            }
-            const ast = (0, core_1.parseSync)(source, {
-                syntax: 'typescript',
-                tsx: true,
-                target: 'es2022',
-            });
-            const localStaticTable = {};
-            const localKeyframesHashTable = {};
-            const localKeyframesObjectTable = {};
-            const localViewTransitionHashTable = {};
-            const localViewTransitionObjectTable = {};
-            const localThemeTable = {};
-            const localCreateThemeObjectTable = {};
-            const localCreateHashTable = {};
-            const localCreateObjectTable = {};
-            const localCreateAtomicMapTable = {};
-            const localVariantsHashTable = {};
-            const localVariantsObjectTable = {};
-            const plumeriaAliases = {};
-            const fileExtractedSheets = [];
-            const isProduction = process.env.NODE_ENV === 'production';
-            for (const node of ast.body) {
-                if (node.type === 'ImportDeclaration') {
-                    const sourceValue = node.source.value;
-                    if (sourceValue === '@plumeria/core') {
-                        node.specifiers.forEach((specifier) => {
-                            if (specifier.type === 'ImportNamespaceSpecifier') {
-                                if (specifier.local) {
-                                    plumeriaAliases[specifier.local.value] = 'NAMESPACE';
+                const source = fs_1.default.readFileSync(filePath, 'utf8');
+                if (!source.includes('@plumeria/core')) {
+                    fileCache[filePath] = {
+                        mtimeMs: stats.mtimeMs,
+                        staticTable: {},
+                        keyframesHashTable: {},
+                        keyframesObjectTable: {},
+                        viewTransitionHashTable: {},
+                        viewTransitionObjectTable: {},
+                        createThemeHashTable: {},
+                        createThemeObjectTable: {},
+                        createHashTable: {},
+                        createObjectTable: {},
+                        createAtomicMapTable: {},
+                        variantsHashTable: {},
+                        variantsObjectTable: {},
+                        createStaticHashTable: {},
+                        createStaticObjectTable: {},
+                        hasCssUsage: false,
+                        extractedSheet: '',
+                    };
+                    continue;
+                }
+                const ast = (0, core_1.parseSync)(source, {
+                    syntax: 'typescript',
+                    tsx: true,
+                    target: 'es2022',
+                });
+                const localStaticTable = {};
+                const localKeyframesHashTable = {};
+                const localKeyframesObjectTable = {};
+                const localViewTransitionHashTable = {};
+                const localViewTransitionObjectTable = {};
+                const localCreateThemeObjectTable = {};
+                const localCreateHashTable = {};
+                const localCreateObjectTable = {};
+                const localCreateAtomicMapTable = {};
+                const localVariantsHashTable = {};
+                const localVariantsObjectTable = {};
+                const localCreateThemeHashTable = {};
+                const localCreateStaticHashTable = {};
+                const localCreateStaticObjectTable = {};
+                const plumeriaAliases = {};
+                const fileExtractedSheets = [];
+                const isProduction = process.env.NODE_ENV === 'production';
+                for (const node of ast.body) {
+                    if (node.type === 'ImportDeclaration') {
+                        const sourceValue = node.source.value;
+                        if (sourceValue === '@plumeria/core') {
+                            node.specifiers.forEach((specifier) => {
+                                if (specifier.type === 'ImportNamespaceSpecifier') {
+                                    if (specifier.local) {
+                                        plumeriaAliases[specifier.local.value] = 'NAMESPACE';
+                                    }
                                 }
-                            }
-                            else if (specifier.type === 'ImportSpecifier') {
-                                const importedName = specifier.imported
-                                    ? specifier.imported.value
-                                    : specifier.local.value;
-                                const localName = specifier.local.value;
-                                plumeriaAliases[localName] = importedName;
-                            }
-                            else if (specifier.type === 'ImportDefaultSpecifier') {
-                                if (specifier.local) {
-                                    plumeriaAliases[specifier.local.value] = 'NAMESPACE';
+                                else if (specifier.type === 'ImportSpecifier') {
+                                    const importedName = specifier.imported
+                                        ? specifier.imported.value
+                                        : specifier.local.value;
+                                    const localName = specifier.local.value;
+                                    plumeriaAliases[localName] = importedName;
                                 }
-                            }
-                        });
-                    }
-                }
-            }
-            for (const node of ast.body) {
-                let declarations = [];
-                if (exports.t.isVariableDeclaration(node)) {
-                    declarations = node.declarations;
-                }
-                else if (exports.t.isExportDeclaration(node) &&
-                    exports.t.isVariableDeclaration(node.declaration)) {
-                    declarations = node.declaration.declarations;
-                }
-                for (const decl of declarations) {
-                    if (exports.t.isVariableDeclarator(decl) &&
-                        exports.t.isIdentifier(decl.id) &&
-                        decl.init &&
-                        exports.t.isCallExpression(decl.init) &&
-                        exports.t.isCallExpression(decl.init)) {
-                        const callee = decl.init.callee;
-                        let method;
-                        if (exports.t.isMemberExpression(callee) &&
-                            exports.t.isIdentifier(callee.object) &&
-                            exports.t.isIdentifier(callee.property)) {
-                            const objectName = callee.object.value;
-                            const propertyName = callee.property.value;
-                            const alias = plumeriaAliases[objectName];
-                            if (alias === 'NAMESPACE' || objectName === 'css') {
-                                method = propertyName;
-                            }
+                                else if (specifier.type === 'ImportDefaultSpecifier') {
+                                    if (specifier.local) {
+                                        plumeriaAliases[specifier.local.value] = 'NAMESPACE';
+                                    }
+                                }
+                            });
                         }
-                        else if (exports.t.isIdentifier(callee)) {
-                            const calleeName = callee.value;
-                            const originalName = plumeriaAliases[calleeName];
-                            if (originalName) {
-                                method = originalName;
+                        else {
+                            const actualPath = (0, resolver_1.resolveImportPath)(sourceValue, filePath);
+                            if (actualPath) {
+                                node.specifiers.forEach((specifier) => {
+                                    if (specifier.type === 'ImportSpecifier') {
+                                        const importedName = specifier.imported
+                                            ? specifier.imported.value
+                                            : specifier.local.value;
+                                        const localName = specifier.local.value;
+                                        const uniqueKey = `${actualPath}-${importedName}`;
+                                        if (localTables.createStaticHashTable[uniqueKey]) {
+                                            const hash = localTables.createStaticHashTable[uniqueKey];
+                                            localCreateStaticHashTable[localName] = hash;
+                                            if (localTables.createStaticObjectTable[hash]) {
+                                                localCreateStaticObjectTable[hash] =
+                                                    localTables.createStaticObjectTable[hash];
+                                            }
+                                        }
+                                        if (localTables.createThemeHashTable[uniqueKey]) {
+                                            const hash = localTables.createThemeHashTable[uniqueKey];
+                                            localCreateThemeHashTable[localName] = hash;
+                                            if (localTables.createThemeObjectTable[hash]) {
+                                                localCreateThemeObjectTable[hash] =
+                                                    localTables.createThemeObjectTable[hash];
+                                            }
+                                        }
+                                    }
+                                });
                             }
                         }
-                        if (method &&
-                            decl.init.arguments.length > 0 &&
-                            exports.t.isObjectExpression(decl.init.arguments[0].expression)) {
-                            const name = decl.id.value;
-                            const init = decl.init;
-                            const resolveVariable = (name) => {
-                                const hash = localCreateHashTable[name];
-                                if (hash && localCreateObjectTable[hash]) {
-                                    return localCreateObjectTable[hash];
+                    }
+                }
+                for (const node of ast.body) {
+                    let declarations = [];
+                    if (exports.t.isVariableDeclaration(node)) {
+                        declarations = node.declarations;
+                    }
+                    else if (exports.t.isExportDeclaration(node) &&
+                        exports.t.isVariableDeclaration(node.declaration)) {
+                        declarations = node.declaration.declarations;
+                    }
+                    for (const decl of declarations) {
+                        if (exports.t.isVariableDeclarator(decl) &&
+                            exports.t.isIdentifier(decl.id) &&
+                            decl.init &&
+                            exports.t.isCallExpression(decl.init) &&
+                            exports.t.isCallExpression(decl.init)) {
+                            const callee = decl.init.callee;
+                            let method;
+                            if (exports.t.isMemberExpression(callee) &&
+                                exports.t.isIdentifier(callee.object) &&
+                                exports.t.isIdentifier(callee.property)) {
+                                const objectName = callee.object.value;
+                                const propertyName = callee.property.value;
+                                const alias = plumeriaAliases[objectName];
+                                if (alias === 'NAMESPACE' || objectName === 'css') {
+                                    method = propertyName;
                                 }
-                                return undefined;
-                            };
-                            const obj = objectExpressionToObject(init.arguments[0].expression, localStaticTable, localKeyframesHashTable, localViewTransitionHashTable, localThemeTable, localCreateHashTable, localVariantsHashTable, resolveVariable);
-                            const uniqueKey = `${filePath}-${name}`;
-                            if (method === 'createStatic') {
-                                localStaticTable[name] = obj;
-                                localTables.staticTable[uniqueKey] = obj;
                             }
-                            else if (method === 'keyframes') {
-                                const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                                localKeyframesHashTable[name] = hash;
-                                localTables.keyframesHashTable[uniqueKey] = hash;
-                                localTables.keyframesObjectTable[hash] = obj;
-                                localTables.keyframesObjectTable[hash] = obj;
-                                localKeyframesObjectTable[hash] = obj;
-                                if (!isProduction) {
-                                    extractOndemandStyles({ kf: `kf-${hash}` }, fileExtractedSheets, localTables);
+                            else if (exports.t.isIdentifier(callee)) {
+                                const calleeName = callee.value;
+                                const originalName = plumeriaAliases[calleeName];
+                                if (originalName) {
+                                    method = originalName;
                                 }
                             }
-                            else if (method === 'viewTransition') {
-                                const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                                localViewTransitionHashTable[name] = hash;
-                                localTables.viewTransitionHashTable[uniqueKey] = hash;
-                                localTables.viewTransitionObjectTable[hash] = obj;
-                                localTables.viewTransitionObjectTable[hash] = obj;
-                                localViewTransitionObjectTable[hash] = obj;
-                                if (!isProduction) {
-                                    extractOndemandStyles(obj, fileExtractedSheets, localTables);
-                                    extractOndemandStyles({ vt: `vt-${hash}` }, fileExtractedSheets, localTables);
+                            if (method &&
+                                decl.init.arguments.length > 0 &&
+                                exports.t.isObjectExpression(decl.init.arguments[0].expression)) {
+                                const name = decl.id.value;
+                                const init = decl.init;
+                                const resolveVariable = (name) => {
+                                    const hash = localCreateHashTable[name];
+                                    if (hash && localCreateObjectTable[hash]) {
+                                        return localCreateObjectTable[hash];
+                                    }
+                                    return undefined;
+                                };
+                                const obj = objectExpressionToObject(init.arguments[0].expression, localStaticTable, localKeyframesHashTable, localViewTransitionHashTable, localCreateThemeHashTable, localCreateThemeObjectTable, localCreateHashTable, localCreateStaticHashTable, localCreateStaticObjectTable, localVariantsHashTable, resolveVariable);
+                                const uniqueKey = `${filePath}-${name}`;
+                                const isPassOneMethod = method === 'createStatic' || method === 'createTheme';
+                                if (isFirstPass && !isPassOneMethod)
+                                    continue;
+                                if (method === 'createStatic') {
+                                    localStaticTable[name] = obj;
+                                    localTables.staticTable[uniqueKey] = obj;
+                                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                                    localCreateStaticHashTable[name] = hash;
+                                    localTables.createStaticHashTable[uniqueKey] = hash;
+                                    localTables.createStaticObjectTable[hash] = obj;
+                                    localCreateStaticObjectTable[hash] = obj;
+                                    const hashMap = {
+                                        __static: {},
+                                    };
+                                    for (const [key, value] of Object.entries(obj)) {
+                                        if (typeof value === 'string') {
+                                            hashMap.__static[key] = value;
+                                        }
+                                    }
+                                    localTables.createAtomicMapTable[hash] = hashMap;
                                 }
-                            }
-                            else if (method === 'createTheme') {
-                                const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                                localThemeTable[name] = obj;
-                                localTables.themeTable[uniqueKey] = obj;
-                                localTables.createThemeObjectTable[hash] = obj;
-                                localCreateThemeObjectTable[hash] = obj;
-                            }
-                            else if (method === 'create') {
-                                const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                                localCreateHashTable[name] = hash;
-                                localTables.createHashTable[uniqueKey] = hash;
-                                localTables.createObjectTable[hash] = obj;
-                                localCreateObjectTable[hash] = obj;
-                                const hashMap = {};
-                                Object.entries(obj).forEach(([key, style]) => {
-                                    const records = (0, create_1.getStyleRecords)(key, style, 2);
-                                    const atomMap = {};
-                                    records.forEach((r) => (atomMap[r.key] = r.hash));
-                                    hashMap[key] = atomMap;
+                                else if (method === 'keyframes') {
+                                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                                    localKeyframesHashTable[name] = hash;
+                                    localTables.keyframesHashTable[uniqueKey] = hash;
+                                    localTables.keyframesObjectTable[hash] = obj;
+                                    localTables.keyframesObjectTable[hash] = obj;
+                                    localKeyframesObjectTable[hash] = obj;
                                     if (!isProduction) {
-                                        extractOndemandStyles(style, fileExtractedSheets, localTables);
-                                        records.forEach((r) => {
-                                            if (!fileExtractedSheets.includes(r.sheet)) {
-                                                fileExtractedSheets.push(r.sheet);
-                                            }
-                                        });
+                                        extractOndemandStyles({ kf: `kf-${hash}` }, fileExtractedSheets, localTables);
                                     }
-                                });
-                                localCreateAtomicMapTable[hash] = hashMap;
-                                localTables.createAtomicMapTable[hash] = hashMap;
-                            }
-                            else if (method === 'variants') {
-                                const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                                localVariantsHashTable[name] = hash;
-                                localTables.variantsHashTable[uniqueKey] = hash;
-                                localTables.variantsObjectTable[hash] = obj;
-                                localVariantsObjectTable[hash] = obj;
+                                }
+                                else if (method === 'viewTransition') {
+                                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                                    localViewTransitionHashTable[name] = hash;
+                                    localTables.viewTransitionHashTable[uniqueKey] = hash;
+                                    localTables.viewTransitionObjectTable[hash] = obj;
+                                    localTables.viewTransitionObjectTable[hash] = obj;
+                                    localViewTransitionObjectTable[hash] = obj;
+                                    if (!isProduction) {
+                                        extractOndemandStyles(obj, fileExtractedSheets, localTables);
+                                        extractOndemandStyles({ vt: `vt-${hash}` }, fileExtractedSheets, localTables);
+                                    }
+                                }
+                                else if (method === 'createTheme') {
+                                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                                    localTables.createThemeObjectTable[hash] = obj;
+                                    localCreateThemeObjectTable[hash] = obj;
+                                    localCreateThemeHashTable[name] = hash;
+                                    localTables.createThemeHashTable[uniqueKey] = hash;
+                                }
+                                else if (method === 'create') {
+                                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                                    localCreateHashTable[name] = hash;
+                                    localTables.createHashTable[uniqueKey] = hash;
+                                    localTables.createObjectTable[hash] = obj;
+                                    localCreateObjectTable[hash] = obj;
+                                    const hashMap = {};
+                                    Object.entries(obj).forEach(([key, style]) => {
+                                        const records = (0, create_1.getStyleRecords)(key, style, 2);
+                                        const atomMap = {};
+                                        records.forEach((r) => (atomMap[r.key] = r.hash));
+                                        hashMap[key] = atomMap;
+                                        if (!isProduction) {
+                                            extractOndemandStyles(style, fileExtractedSheets, localTables);
+                                            records.forEach((r) => {
+                                                if (!fileExtractedSheets.includes(r.sheet)) {
+                                                    fileExtractedSheets.push(r.sheet);
+                                                }
+                                            });
+                                        }
+                                    });
+                                    localCreateAtomicMapTable[hash] = hashMap;
+                                    localTables.createAtomicMapTable[hash] = hashMap;
+                                }
+                                else if (method === 'variants') {
+                                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                                    localVariantsHashTable[name] = hash;
+                                    localTables.variantsHashTable[uniqueKey] = hash;
+                                    localTables.variantsObjectTable[hash] = obj;
+                                    localVariantsObjectTable[hash] = obj;
+                                }
                             }
                         }
                     }
                 }
+                if (!isFirstPass) {
+                    fileCache[filePath] = {
+                        mtimeMs: stats.mtimeMs,
+                        staticTable: localStaticTable,
+                        keyframesHashTable: localKeyframesHashTable,
+                        keyframesObjectTable: localKeyframesObjectTable,
+                        viewTransitionHashTable: localViewTransitionHashTable,
+                        viewTransitionObjectTable: localViewTransitionObjectTable,
+                        createThemeHashTable: localCreateThemeHashTable,
+                        createThemeObjectTable: localCreateThemeObjectTable,
+                        createHashTable: localCreateHashTable,
+                        createObjectTable: localCreateObjectTable,
+                        createAtomicMapTable: localCreateAtomicMapTable,
+                        variantsHashTable: localVariantsHashTable,
+                        variantsObjectTable: localVariantsObjectTable,
+                        createStaticHashTable: localCreateStaticHashTable,
+                        createStaticObjectTable: localCreateStaticObjectTable,
+                        hasCssUsage: true,
+                        extractedSheet: fileExtractedSheets.join(''),
+                    };
+                    if (fileExtractedSheets.length > 0) {
+                        totalExtractedSheets.push(fileExtractedSheets.join(''));
+                    }
+                }
             }
-            fileCache[filePath] = {
-                mtimeMs: stats.mtimeMs,
-                staticTable: localStaticTable,
-                keyframesHashTable: localKeyframesHashTable,
-                keyframesObjectTable: localKeyframesObjectTable,
-                viewTransitionHashTable: localViewTransitionHashTable,
-                viewTransitionObjectTable: localViewTransitionObjectTable,
-                themeTable: localThemeTable,
-                createThemeObjectTable: localCreateThemeObjectTable,
-                createHashTable: localCreateHashTable,
-                createObjectTable: localCreateObjectTable,
-                createAtomicMapTable: localCreateAtomicMapTable,
-                variantsHashTable: localVariantsHashTable,
-                variantsObjectTable: localVariantsObjectTable,
-                hasCssUsage: true,
-                extractedSheet: fileExtractedSheets.join(''),
-            };
-            if (fileExtractedSheets.length > 0) {
-                totalExtractedSheets.push(fileExtractedSheets.join(''));
+            catch (e) {
             }
         }
-        catch (e) {
-        }
     }
     localTables.extractedSheet = totalExtractedSheets.join('');
     if (process.env.NODE_ENV === 'production') {
@@ -697,7 +805,7 @@ function scanAll() {
     }
     return localTables;
 }
-function extractOndemandStyles(obj, extractedSheets, t = exports.tables) {
+function extractOndemandStyles(obj, extractedSheets, t) {
     if (!obj || typeof obj !== 'object')
         return;
     const visited = new Set();
@@ -767,9 +875,8 @@ function extractOndemandStyles(obj, extractedSheets, t = exports.tables) {
         }
     }
     if (needsTheme) {
-        for (const themeVarName in t.themeTable) {
-            const themeObj = t.themeTable[themeVarName];
-            const hash = (0, zss_engine_1.genBase36Hash)(themeObj, 1, 8);
+        for (const themeVarName in t.createThemeHashTable) {
+            const hash = t.createThemeHashTable[themeVarName];
             const definition = t.createThemeObjectTable[hash];
             if (definition && typeof definition === 'object') {
                 const styles = (0, createTheme_1.createTheme)(definition);

package/dist/types.d.ts

@@ -5,7 +5,6 @@ export type CSSObject = {
     [key: string]: CSSValue;
 };
 export type StaticTable = Record<string, CSSValue>;
-export type ThemeTable = Record<string, CSSObject>;
 export type KeyframesHashTable = Record<string, string>;
 export type KeyframesObjectTable = Record<string, CSSObject>;
 export type ViewTransitionHashTable = Record<string, string>;
@@ -16,17 +15,22 @@ export type CreateObjectTable = Record<string, CSSObject>;
 export type VariantsHashTable = Record<string, string>;
 export type VariantsObjectTable = Record<string, CSSObject>;
 export type CreateAtomicMapTable = Record<string, Record<string, Record<string, string>>>;
+export type CreateStaticHashTable = Record<string, string>;
+export type CreateStaticObjectTable = Record<string, CSSObject>;
+export type CreateThemeHashTable = Record<string, string>;
 export interface Tables {
     staticTable: StaticTable;
-    themeTable: ThemeTable;
     keyframesHashTable: KeyframesHashTable;
     keyframesObjectTable: KeyframesObjectTable;
     viewTransitionHashTable: ViewTransitionHashTable;
     viewTransitionObjectTable: ViewTransitionObjectTable;
+    createThemeHashTable: CreateThemeHashTable;
     createThemeObjectTable: CreateThemeObjectTable;
     createHashTable: CreateHashTable;
     createObjectTable: CreateObjectTable;
     createAtomicMapTable: CreateAtomicMapTable;
+    createStaticHashTable: CreateStaticHashTable;
+    createStaticObjectTable: CreateStaticObjectTable;
     variantsHashTable: VariantsHashTable;
     variantsObjectTable: VariantsObjectTable;
     extractedSheet?: string;

package/package.json

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