@plumeria/utils 4.1.3 → 4.2.1

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export type { CSSObject, FileStyles } from './types';
-export { scanForCreateStatic, scanForCreateTheme, scanForKeyframes, scanForViewTransition, objectExpressionToObject, collectLocalConsts, traverse, t, tables, extractOndemandStyles, deepMerge, } from './parser';
+export { objectExpressionToObject, collectLocalConsts, traverse, t, tables, extractOndemandStyles, deepMerge, scanAll, } from './parser';
 export { getStyleRecords } from './create';
 export type { StyleRecord } from './create';
+export { resolveImportPath } from './resolver';

package/dist/index.js

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStyleRecords = exports.deepMerge = exports.extractOndemandStyles = exports.tables = exports.t = exports.traverse = exports.collectLocalConsts = exports.objectExpressionToObject = exports.scanForViewTransition = exports.scanForKeyframes = exports.scanForCreateTheme = exports.scanForCreateStatic = void 0;
+exports.resolveImportPath = exports.getStyleRecords = exports.scanAll = exports.deepMerge = exports.extractOndemandStyles = exports.tables = exports.t = exports.traverse = exports.collectLocalConsts = exports.objectExpressionToObject = void 0;
 var parser_1 = require("./parser");
-Object.defineProperty(exports, "scanForCreateStatic", { enumerable: true, get: function () { return parser_1.scanForCreateStatic; } });
-Object.defineProperty(exports, "scanForCreateTheme", { enumerable: true, get: function () { return parser_1.scanForCreateTheme; } });
-Object.defineProperty(exports, "scanForKeyframes", { enumerable: true, get: function () { return parser_1.scanForKeyframes; } });
-Object.defineProperty(exports, "scanForViewTransition", { enumerable: true, get: function () { return parser_1.scanForViewTransition; } });
 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; } });
@@ -13,5 +9,8 @@ Object.defineProperty(exports, "t", { enumerable: true, get: function () { retur
 Object.defineProperty(exports, "tables", { enumerable: true, get: function () { return parser_1.tables; } });
 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; } });
 var create_1 = require("./create");
 Object.defineProperty(exports, "getStyleRecords", { enumerable: true, get: function () { return create_1.getStyleRecords; } });
+var resolver_1 = require("./resolver");
+Object.defineProperty(exports, "resolveImportPath", { enumerable: true, get: function () { return resolver_1.resolveImportPath; } });

package/dist/parser.d.ts

@@ -1,4 +1,4 @@
-import type { CSSObject, StaticTable, KeyframesHashTable, KeyframesObjectTable, ThemeTable, ViewTransitionObjectTable, ViewTransitionHashTable, Tables } from './types';
+import type { CSSObject, StaticTable, KeyframesHashTable, ThemeTable, ViewTransitionHashTable, Tables } 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;
@@ -27,20 +27,8 @@ export declare function traverse(node: Module, visitor: {
     }) => void;
 }): void;
 export declare const tables: Tables;
-export declare function objectExpressionToObject(node: ObjectExpression, staticTable: StaticTable, keyframesHashTable: KeyframesHashTable, viewTransitionHashTable: ViewTransitionHashTable, themeTable: ThemeTable): CSSObject;
+export declare function objectExpressionToObject(node: ObjectExpression, staticTable: StaticTable, keyframesHashTable: KeyframesHashTable, viewTransitionHashTable: ViewTransitionHashTable, themeTable: ThemeTable, resolveVariable?: (name: string) => any): CSSObject;
 export declare function collectLocalConsts(ast: Module): Record<string, any>;
-export declare function scanForKeyframes(addDependency: (path: string) => void): {
-    keyframesHashTableLocal: KeyframesHashTable;
-    keyframesObjectTableLocal: KeyframesObjectTable;
-};
-export declare function scanForViewTransition(addDependency: (path: string) => void): {
-    viewTransitionHashTableLocal: ViewTransitionHashTable;
-    viewTransitionObjectTableLocal: ViewTransitionObjectTable;
-};
-export declare function scanForCreateStatic(addDependency: (path: string) => void): StaticTable;
-export declare function scanForCreateTheme(addDependency: (path: string) => void): {
-    themeTableLocal: Record<string, Record<string, any>>;
-    createThemeObjectTableLocal: Record<string, Record<string, any>>;
-};
+export declare function scanAll(addDependency: (path: string) => void): Tables;
 export declare function extractOndemandStyles(obj: any, extractedSheets: string[]): void;
 export declare function deepMerge(target: Record<string, any>, source: Record<string, any>): Record<string, any>;

package/dist/parser.js

@@ -7,10 +7,7 @@ exports.tables = exports.t = void 0;
 exports.traverse = traverse;
 exports.objectExpressionToObject = objectExpressionToObject;
 exports.collectLocalConsts = collectLocalConsts;
-exports.scanForKeyframes = scanForKeyframes;
-exports.scanForViewTransition = scanForViewTransition;
-exports.scanForCreateStatic = scanForCreateStatic;
-exports.scanForCreateTheme = scanForCreateTheme;
+exports.scanAll = scanAll;
 exports.extractOndemandStyles = extractOndemandStyles;
 exports.deepMerge = deepMerge;
 const createTheme_1 = require("./createTheme");
@@ -87,12 +84,12 @@ exports.tables = {
     viewTransitionObjectTable: {},
     createThemeObjectTable: {},
 };
-function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable) {
+function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable, resolveVariable) {
     const obj = {};
     node.properties.forEach((prop) => {
         if (!exports.t.isObjectProperty(prop))
             return;
-        const key = getPropertyKey(prop.key, staticTable);
+        const key = getPropertyKey(prop.key, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
         if (!key)
             return;
         const val = prop.value;
@@ -122,13 +119,20 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
             obj[key] = evaluateUnaryExpression(val);
         }
         else if (exports.t.isObjectExpression(val)) {
-            obj[key] = objectExpressionToObject(val, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
+            obj[key] = objectExpressionToObject(val, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable, resolveVariable);
         }
         else if (exports.t.isMemberExpression(val)) {
             const resolved = resolveStaticTableMemberExpression(val, staticTable);
             obj[key] = resolved !== undefined ? resolved : '[unresolved]';
         }
         else if (exports.t.isIdentifier(val)) {
+            if (resolveVariable) {
+                const resolved = resolveVariable(val.value);
+                if (resolved !== undefined) {
+                    obj[key] = resolved;
+                    return;
+                }
+            }
             if (staticTable[val.value] !== undefined) {
                 obj[key] = staticTable[val.value];
             }
@@ -144,21 +148,43 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
 }
 function collectLocalConsts(ast) {
     const localConsts = {};
+    const decls = new Map();
     traverse(ast, {
         VariableDeclarator({ node }) {
             if (exports.t.isIdentifier(node.id) && node.init) {
-                if (exports.t.isStringLiteral(node.init)) {
-                    localConsts[node.id.value] = node.init.value;
-                }
-                else if (exports.t.isObjectExpression(node.init)) {
-                    localConsts[node.id.value] = objectExpressionToObject(node.init, localConsts, exports.tables.keyframesHashTable, exports.tables.viewTransitionHashTable, exports.tables.themeTable);
-                }
+                decls.set(node.id.value, node.init);
             }
         },
     });
+    const visiting = new Set();
+    function resolveValue(name) {
+        if (localConsts[name] !== undefined)
+            return localConsts[name];
+        if (!decls.has(name) || visiting.has(name))
+            return undefined;
+        visiting.add(name);
+        const init = decls.get(name);
+        let result;
+        if (exports.t.isStringLiteral(init) ||
+            exports.t.isNumericLiteral(init) ||
+            exports.t.isBooleanLiteral(init)) {
+            result = init.value;
+        }
+        else if (exports.t.isObjectExpression(init)) {
+            result = objectExpressionToObject(init, localConsts, exports.tables.keyframesHashTable, exports.tables.viewTransitionHashTable, exports.tables.themeTable, resolveValue);
+        }
+        visiting.delete(name);
+        if (result !== undefined) {
+            localConsts[name] = result;
+        }
+        return result;
+    }
+    for (const name of decls.keys()) {
+        resolveValue(name);
+    }
     return localConsts;
 }
-function getPropertyKey(node, staticTable) {
+function getPropertyKey(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable) {
     if (exports.t.isIdentifier(node)) {
         if (staticTable[node.value] &&
             typeof staticTable[node.value] === 'string') {
@@ -186,42 +212,42 @@ function getPropertyKey(node, staticTable) {
                 return result;
         }
         if (exports.t.isTemplateLiteral(expr)) {
-            return evaluateTemplateLiteral(expr, staticTable);
+            return evaluateTemplateLiteral(expr, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
         }
         if (exports.t.isBinaryExpression(expr)) {
-            return evaluateBinaryExpression(expr, staticTable);
+            return evaluateBinaryExpression(expr, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
         }
         return '';
     }
     if (exports.t.isTemplateLiteral(node)) {
-        return evaluateTemplateLiteral(node, staticTable);
+        return evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
     }
     if (exports.t.isBinaryExpression(node)) {
-        return evaluateBinaryExpression(node, staticTable);
+        return evaluateBinaryExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
     }
     return '';
 }
-function evaluateTemplateLiteral(node, staticTable) {
+function evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable) {
     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);
+            const evaluatedExpr = evaluateExpression(expr, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
             result += String(evaluatedExpr);
         }
     }
     return result;
 }
-function evaluateBinaryExpression(node, staticTable) {
-    const left = evaluateExpression(node.left, staticTable);
-    const right = evaluateExpression(node.right, staticTable);
+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);
     if (node.operator === '+') {
         return String(left) + String(right);
     }
     throw new Error(`Unsupported binary operator: ${node.operator}`);
 }
-function evaluateExpression(node, staticTable) {
+function evaluateExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable) {
     if (exports.t.isStringLiteral(node)) {
         return node.value;
     }
@@ -238,11 +264,11 @@ function evaluateExpression(node, staticTable) {
         if (staticTable[node.value] !== undefined) {
             return staticTable[node.value];
         }
-        if (exports.tables.keyframesHashTable[node.value] !== undefined) {
-            return exports.tables.keyframesHashTable[node.value];
+        if (keyframesHashTable[node.value] !== undefined) {
+            return keyframesHashTable[node.value];
         }
-        if (exports.tables.viewTransitionHashTable[node.value] !== undefined) {
-            return exports.tables.viewTransitionHashTable[node.value];
+        if (viewTransitionHashTable[node.value] !== undefined) {
+            return viewTransitionHashTable[node.value];
         }
         return `[unresolved: ${node.value}]`;
     }
@@ -251,17 +277,17 @@ function evaluateExpression(node, staticTable) {
         if (resolved !== undefined) {
             return resolved;
         }
-        const resolvedTheme = resolveThemeTableMemberExpressionByNode(node, exports.tables.themeTable);
+        const resolvedTheme = resolveThemeTableMemberExpressionByNode(node, themeTable);
         if (resolvedTheme !== undefined) {
             return resolvedTheme;
         }
         return `[unresolved member expression]`;
     }
     if (exports.t.isBinaryExpression(node)) {
-        return evaluateBinaryExpression(node, staticTable);
+        return evaluateBinaryExpression(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
     }
     if (exports.t.isTemplateLiteral(node)) {
-        return evaluateTemplateLiteral(node, staticTable);
+        return evaluateTemplateLiteral(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
     }
     if (exports.t.isUnaryExpression(node)) {
         return evaluateUnaryExpression(node);
@@ -333,224 +359,126 @@ function resolveThemeTableMemberExpressionByNode(node, themeTable) {
     }
     return undefined;
 }
-function scanForKeyframes(addDependency) {
-    const keyframesHashTableLocal = {};
-    const keyframesObjectTableLocal = {};
-    const files = fs_1.default.globSync(PATTERN_PATH, GLOB_OPTIONS);
-    for (const filePath of files) {
-        if (!isCSSDefineFile(filePath, 'keyframes'))
-            continue;
-        addDependency(filePath);
-        const source = fs_1.default.readFileSync(filePath, 'utf8');
-        const ast = (0, core_1.parseSync)(source, {
-            syntax: 'typescript',
-            tsx: true,
-            target: 'es2022',
-        });
-        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.isMemberExpression(decl.init.callee) &&
-                    exports.t.isIdentifier(decl.init.callee.object, { name: 'css' }) &&
-                    exports.t.isIdentifier(decl.init.callee.property, { name: 'keyframes' }) &&
-                    decl.init.arguments.length > 0 &&
-                    exports.t.isObjectExpression(decl.init.arguments[0].expression)) {
-                    const varName = decl.id.value;
-                    const obj = objectExpressionToObject(decl.init.arguments[0].expression, exports.tables.staticTable, keyframesHashTableLocal, exports.tables.viewTransitionHashTable, exports.tables.themeTable);
-                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                    keyframesHashTableLocal[varName] = hash;
-                    keyframesObjectTableLocal[hash] = obj;
-                }
-            }
+const fileCache = {};
+function scanAll(addDependency) {
+    for (const key in exports.tables) {
+        const table = exports.tables[key];
+        for (const prop in table) {
+            delete table[prop];
         }
     }
-    return {
-        keyframesHashTableLocal,
-        keyframesObjectTableLocal,
-    };
-}
-function scanForViewTransition(addDependency) {
-    const viewTransitionHashTableLocal = {};
-    const viewTransitionObjectTableLocal = {};
     const files = fs_1.default.globSync(PATTERN_PATH, GLOB_OPTIONS);
     for (const filePath of files) {
-        if (!isCSSDefineFile(filePath, 'viewTransition'))
-            continue;
-        addDependency(filePath);
-        const source = fs_1.default.readFileSync(filePath, 'utf8');
-        const ast = (0, core_1.parseSync)(source, {
-            syntax: 'typescript',
-            tsx: true,
-            target: 'es2022',
-        });
-        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.isMemberExpression(decl.init.callee) &&
-                    exports.t.isIdentifier(decl.init.callee.object, { name: 'css' }) &&
-                    exports.t.isIdentifier(decl.init.callee.property, {
-                        name: 'viewTransition',
-                    }) &&
-                    decl.init.arguments.length > 0 &&
-                    exports.t.isObjectExpression(decl.init.arguments[0].expression)) {
-                    const varName = decl.id.value;
-                    const obj = objectExpressionToObject(decl.init.arguments[0].expression, exports.tables.staticTable, exports.tables.keyframesHashTable, viewTransitionHashTableLocal, exports.tables.themeTable);
-                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                    viewTransitionHashTableLocal[varName] = hash;
-                    viewTransitionObjectTableLocal[hash] = obj;
+        try {
+            const stats = fs_1.default.statSync(filePath);
+            const cached = fileCache[filePath];
+            if (cached && cached.mtimeMs === stats.mtimeMs) {
+                if (cached.hasCssUsage) {
+                    addDependency(filePath);
+                    Object.assign(exports.tables.staticTable, cached.staticTable);
+                    Object.assign(exports.tables.keyframesHashTable, cached.keyframesHashTable);
+                    Object.assign(exports.tables.viewTransitionHashTable, cached.viewTransitionHashTable);
+                    Object.assign(exports.tables.themeTable, cached.themeTable);
+                    Object.assign(exports.tables.createThemeObjectTable, cached.createThemeObjectTable);
                 }
+                continue;
             }
-        }
-    }
-    return {
-        viewTransitionHashTableLocal,
-        viewTransitionObjectTableLocal,
-    };
-}
-function scanForCreateStatic(addDependency) {
-    const staticTableLocal = {};
-    const files = fs_1.default.globSync(PATTERN_PATH, GLOB_OPTIONS);
-    for (const filePath of files) {
-        if (!isCSSDefineFile(filePath, 'createStatic'))
-            continue;
-        addDependency(filePath);
-        const source = fs_1.default.readFileSync(filePath, 'utf8');
-        const ast = (0, core_1.parseSync)(source, {
-            syntax: 'typescript',
-            tsx: true,
-            target: 'es2022',
-        });
-        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;
+            const source = fs_1.default.readFileSync(filePath, 'utf8');
+            if (!source.includes('css.')) {
+                fileCache[filePath] = {
+                    mtimeMs: stats.mtimeMs,
+                    staticTable: {},
+                    keyframesHashTable: {},
+                    viewTransitionHashTable: {},
+                    themeTable: {},
+                    createThemeObjectTable: {},
+                    hasCssUsage: false,
+                };
+                continue;
             }
-            for (const decl of declarations) {
-                if (exports.t.isVariableDeclarator(decl) &&
-                    exports.t.isIdentifier(decl.id) &&
-                    decl.init &&
-                    exports.t.isCallExpression(decl.init) &&
-                    exports.t.isMemberExpression(decl.init.callee) &&
-                    exports.t.isIdentifier(decl.init.callee.object, { name: 'css' }) &&
-                    exports.t.isIdentifier(decl.init.callee.property, { name: 'createStatic' }) &&
-                    decl.init.arguments.length > 0 &&
-                    exports.t.isObjectExpression(decl.init.arguments[0].expression)) {
-                    const varName = decl.id.value;
-                    const obj = objectExpressionToObject(decl.init.arguments[0].expression, staticTableLocal, exports.tables.keyframesHashTable, exports.tables.viewTransitionHashTable, exports.tables.themeTable);
-                    staticTableLocal[varName] = obj;
+            const ast = (0, core_1.parseSync)(source, {
+                syntax: 'typescript',
+                tsx: true,
+                target: 'es2022',
+            });
+            addDependency(filePath);
+            const localStaticTable = {};
+            const localKeyframesHashTable = {};
+            const localViewTransitionHashTable = {};
+            const localThemeTable = {};
+            const localCreateThemeObjectTable = {};
+            for (const node of ast.body) {
+                let declarations = [];
+                if (exports.t.isVariableDeclaration(node)) {
+                    declarations = node.declarations;
                 }
-            }
-        }
-    }
-    return staticTableLocal;
-}
-function scanForCreateTheme(addDependency) {
-    const themeTableLocal = {};
-    const createThemeObjectTableLocal = {};
-    const files = fs_1.default.globSync(PATTERN_PATH, GLOB_OPTIONS);
-    for (const filePath of files) {
-        if (!isCSSDefineFile(filePath, 'createTheme'))
-            continue;
-        addDependency(filePath);
-        const source = fs_1.default.readFileSync(filePath, 'utf8');
-        const ast = (0, core_1.parseSync)(source, {
-            syntax: 'typescript',
-            tsx: true,
-            target: 'es2022',
-        });
-        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.isMemberExpression(decl.init.callee) &&
-                    exports.t.isIdentifier(decl.init.callee.object, { name: 'css' }) &&
-                    exports.t.isIdentifier(decl.init.callee.property, { name: 'createTheme' }) &&
-                    decl.init.arguments.length > 0 &&
-                    exports.t.isObjectExpression(decl.init.arguments[0].expression)) {
-                    const varName = decl.id.value;
-                    const obj = objectExpressionToObject(decl.init.arguments[0].expression, exports.tables.staticTable, exports.tables.keyframesHashTable, exports.tables.viewTransitionHashTable, themeTableLocal);
-                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
-                    themeTableLocal[varName] = obj;
-                    createThemeObjectTableLocal[hash] = obj;
+                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.isMemberExpression(decl.init.callee) &&
+                        exports.t.isIdentifier(decl.init.callee.object, { name: 'css' }) &&
+                        exports.t.isIdentifier(decl.init.callee.property) &&
+                        decl.init.arguments.length > 0 &&
+                        exports.t.isObjectExpression(decl.init.arguments[0].expression)) {
+                        const method = decl.init.callee.property.value;
+                        const name = decl.id.value;
+                        const init = decl.init;
+                        const obj = objectExpressionToObject(init.arguments[0].expression, localStaticTable, localKeyframesHashTable, localViewTransitionHashTable, localThemeTable);
+                        const uniqueKey = `${filePath}-${name}`;
+                        if (method === 'createStatic') {
+                            localStaticTable[name] = obj;
+                            exports.tables.staticTable[uniqueKey] = obj;
+                        }
+                        else if (method === 'keyframes') {
+                            const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                            localKeyframesHashTable[name] = hash;
+                            exports.tables.keyframesHashTable[uniqueKey] = hash;
+                            exports.tables.keyframesObjectTable[hash] = obj;
+                        }
+                        else if (method === 'viewTransition') {
+                            const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                            localViewTransitionHashTable[name] = hash;
+                            exports.tables.viewTransitionHashTable[uniqueKey] = hash;
+                            exports.tables.viewTransitionObjectTable[hash] = obj;
+                        }
+                        else if (method === 'createTheme') {
+                            const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                            localThemeTable[name] = obj;
+                            exports.tables.themeTable[uniqueKey] = obj;
+                            exports.tables.createThemeObjectTable[hash] = obj;
+                            localCreateThemeObjectTable[hash] = obj;
+                        }
+                    }
                 }
             }
+            fileCache[filePath] = {
+                mtimeMs: stats.mtimeMs,
+                staticTable: localStaticTable,
+                keyframesHashTable: localKeyframesHashTable,
+                viewTransitionHashTable: localViewTransitionHashTable,
+                themeTable: localThemeTable,
+                createThemeObjectTable: localCreateThemeObjectTable,
+                hasCssUsage: true,
+            };
+        }
+        catch (e) {
         }
     }
-    return { themeTableLocal, createThemeObjectTableLocal };
-}
-function isCSSDefineFile(filePath, target) {
-    if (fs_1.default.statSync(filePath).isDirectory())
-        return false;
-    const code = fs_1.default.readFileSync(filePath, 'utf8');
-    let ast;
-    try {
-        ast = (0, core_1.parseSync)(code, {
-            syntax: 'typescript',
-            tsx: true,
-            target: 'es2022',
-        });
-    }
-    catch (err) {
-        console.log(err);
-        return false;
-    }
-    let found = false;
-    traverse(ast, {
-        CallExpression({ node, stop }) {
-            const callee = node.callee;
-            if (callee.type === 'MemberExpression' &&
-                callee.object.type === 'Identifier' &&
-                callee.object.value === 'css' &&
-                callee.property.type === 'Identifier' &&
-                callee.property.value === target) {
-                found = true;
-                stop();
-            }
-        },
-    });
-    return found;
+    return exports.tables;
 }
 function extractOndemandStyles(obj, extractedSheets) {
     if (!obj || typeof obj !== 'object')
         return;
     const visited = new Set();
-    const processedThemes = new Set();
+    const keyframesHashes = new Set();
+    const viewTransitionHashes = new Set();
+    let needsTheme = false;
     function walk(n) {
         if (!n || typeof n !== 'object' || visited.has(n))
             return;
@@ -558,41 +486,13 @@ function extractOndemandStyles(obj, extractedSheets) {
         Object.values(n).forEach((val) => {
             if (typeof val === 'string') {
                 if (val.startsWith('kf-')) {
-                    const hash = val.slice(3);
-                    const definition = exports.tables.keyframesObjectTable[hash];
-                    if (definition) {
-                        const { styleSheet } = (0, zss_engine_1.transpile)({ [`@keyframes kf-${hash}`]: definition }, undefined, '--global');
-                        if (!extractedSheets.includes(styleSheet)) {
-                            extractedSheets.push(styleSheet);
-                        }
-                    }
+                    keyframesHashes.add(val.slice(3));
                 }
                 else if (val.startsWith('vt-')) {
-                    const hash = val.slice(3);
-                    const obj = exports.tables.viewTransitionObjectTable[hash];
-                    if (obj) {
-                        const { styleSheet } = (0, zss_engine_1.transpile)((0, viewTransition_1.createViewTransition)(obj, hash), undefined, '--global');
-                        if (!extractedSheets.includes(styleSheet)) {
-                            extractedSheets.push(styleSheet);
-                        }
-                    }
+                    viewTransitionHashes.add(val.slice(3));
                 }
-                else if (val.includes('var(--')) {
-                    Object.keys(exports.tables.themeTable).forEach((themeVarName) => {
-                        if (!processedThemes.has(themeVarName)) {
-                            processedThemes.add(themeVarName);
-                            const themeObj = exports.tables.themeTable[themeVarName];
-                            const hash = (0, zss_engine_1.genBase36Hash)(themeObj, 1, 8);
-                            const definition = exports.tables.createThemeObjectTable[hash];
-                            if (definition && typeof definition === 'object') {
-                                const styles = (0, createTheme_1.createTheme)(definition);
-                                const { styleSheet } = (0, zss_engine_1.transpile)(styles, undefined, '--global');
-                                if (!extractedSheets.includes(styleSheet)) {
-                                    extractedSheets.push(styleSheet);
-                                }
-                            }
-                        }
-                    });
+                else if (!needsTheme && val.includes('var(--')) {
+                    needsTheme = true;
                 }
             }
             else {
@@ -601,6 +501,43 @@ function extractOndemandStyles(obj, extractedSheets) {
         });
     }
     walk(obj);
+    const existingSheets = new Set(extractedSheets);
+    const addSheet = (sheet) => {
+        if (!existingSheets.has(sheet)) {
+            existingSheets.add(sheet);
+            extractedSheets.push(sheet);
+        }
+    };
+    if (keyframesHashes.size > 0) {
+        for (const hash of keyframesHashes) {
+            const definition = exports.tables.keyframesObjectTable[hash];
+            if (definition) {
+                const { styleSheet } = (0, zss_engine_1.transpile)({ [`@keyframes kf-${hash}`]: definition }, undefined, '--global');
+                addSheet(styleSheet);
+            }
+        }
+    }
+    if (viewTransitionHashes.size > 0) {
+        for (const hash of viewTransitionHashes) {
+            const obj = exports.tables.viewTransitionObjectTable[hash];
+            if (obj) {
+                const { styleSheet } = (0, zss_engine_1.transpile)((0, viewTransition_1.createViewTransition)(obj, hash), undefined, '--global');
+                addSheet(styleSheet);
+            }
+        }
+    }
+    if (needsTheme) {
+        for (const themeVarName in exports.tables.themeTable) {
+            const themeObj = exports.tables.themeTable[themeVarName];
+            const hash = (0, zss_engine_1.genBase36Hash)(themeObj, 1, 8);
+            const definition = exports.tables.createThemeObjectTable[hash];
+            if (definition && typeof definition === 'object') {
+                const styles = (0, createTheme_1.createTheme)(definition);
+                const { styleSheet } = (0, zss_engine_1.transpile)(styles, undefined, '--global');
+                addSheet(styleSheet);
+            }
+        }
+    }
 }
 function deepMerge(target, source) {
     const result = { ...target };

package/dist/resolver.d.ts

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

package/dist/resolver.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveImportPath = resolveImportPath;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+let tsConfigCache;
+function loadTsConfig() {
+    if (tsConfigCache !== undefined)
+        return tsConfigCache;
+    let currentDir = process.cwd();
+    while (currentDir !== path_1.default.parse(currentDir).root) {
+        const tsConfigPath = path_1.default.join(currentDir, 'tsconfig.json');
+        if (fs_1.default.existsSync(tsConfigPath)) {
+            try {
+                const content = fs_1.default.readFileSync(tsConfigPath, 'utf-8');
+                const config = JSON.parse(content.replace(/\/\/.*|\/\*[\s\S]*?\*\//g, ''));
+                tsConfigCache = config.compilerOptions || null;
+                return tsConfigCache;
+            }
+            catch {
+            }
+        }
+        currentDir = path_1.default.dirname(currentDir);
+    }
+    tsConfigCache = null;
+    return null;
+}
+const extensions = [
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '/index.ts',
+    '/index.tsx',
+    '/index.js',
+    '/index.jsx',
+];
+function resolveWithExtension(basePath) {
+    if (fs_1.default.existsSync(basePath) && fs_1.default.statSync(basePath).isFile())
+        return basePath;
+    for (const ext of extensions) {
+        const fullPath = basePath + ext;
+        if (fs_1.default.existsSync(fullPath) && fs_1.default.statSync(fullPath).isFile())
+            return fullPath;
+    }
+    return null;
+}
+function resolveImportPath(importPath, importerPath) {
+    if (importPath.startsWith('.')) {
+        return resolveWithExtension(path_1.default.resolve(path_1.default.dirname(importerPath), importPath));
+    }
+    const config = loadTsConfig();
+    if (config?.paths) {
+        const root = process.cwd();
+        for (const [alias, targets] of Object.entries(config.paths)) {
+            const prefix = alias.replace(/\*$/, '');
+            if (importPath.startsWith(prefix)) {
+                for (const target of targets) {
+                    const resolvedTarget = target.replace(/\*$/, '');
+                    const candidate = path_1.default.resolve(root, resolvedTarget + importPath.slice(prefix.length));
+                    const result = resolveWithExtension(candidate);
+                    if (result)
+                        return result;
+                }
+            }
+        }
+    }
+    let currentDir = path_1.default.dirname(importerPath);
+    while (currentDir !== path_1.default.parse(currentDir).root) {
+        if (fs_1.default.existsSync(path_1.default.join(currentDir, 'package.json'))) {
+            return resolveWithExtension(path_1.default.resolve(currentDir, importPath));
+        }
+        currentDir = path_1.default.dirname(currentDir);
+    }
+    return null;
+}

package/package.json

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