@plumeria/utils 5.0.1 → 6.0.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { CSSObject, FileStyles } from './types';
+export type { CSSObject, FileStyles, StaticTable, ThemeTable, KeyframesHashTable, KeyframesObjectTable, ViewTransitionHashTable, ViewTransitionObjectTable, CreateThemeObjectTable, CreateHashTable, CreateObjectTable, VariantsHashTable, VariantsObjectTable, } from './types';
 export { objectExpressionToObject, collectLocalConsts, traverse, t, tables, 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 } from './types';
+import type { CSSObject, ThemeTable, Tables, StaticTable, KeyframesHashTable, ViewTransitionHashTable, CreateHashTable, VariantsHashTable } 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,8 +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, resolveVariable?: (name: string) => any): CSSObject;
+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 collectLocalConsts(ast: Module): Record<string, any>;
-export declare function scanAll(addDependency: (path: string) => void): Tables;
-export declare function extractOndemandStyles(obj: any, extractedSheets: string[]): void;
+export declare function scanAll(): Tables;
+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

@@ -16,6 +16,7 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const zss_engine_1 = require("zss-engine");
 const viewTransition_1 = require("./viewTransition");
+const create_1 = require("./create");
 exports.t = {
     isObjectExpression: (node) => node?.type === 'ObjectExpression',
     isObjectProperty: (node) => node?.type === 'KeyValueProperty',
@@ -83,8 +84,12 @@ exports.tables = {
     viewTransitionHashTable: {},
     viewTransitionObjectTable: {},
     createThemeObjectTable: {},
+    createHashTable: {},
+    createObjectTable: {},
+    variantsHashTable: {},
+    variantsObjectTable: {},
 };
-function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable, resolveVariable) {
+function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable, createHashTable, variantsHashTable, resolveVariable) {
     const obj = {};
     node.properties.forEach((prop) => {
         if (!exports.t.isObjectProperty(prop))
@@ -94,6 +99,16 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
             return;
         const val = prop.value;
         if (exports.t.isIdentifier(val) || exports.t.isMemberExpression(val)) {
+            if (resolveVariable && exports.t.isMemberExpression(val)) {
+                if (exports.t.isIdentifier(val.object) && exports.t.isIdentifier(val.property)) {
+                    const resolved = resolveVariable(val.object.value);
+                    const prop = val.property.value;
+                    if (resolved && resolved[prop]) {
+                        obj[key] = resolved[prop];
+                        return;
+                    }
+                }
+            }
             const resolvedKeyframe = resolveKeyframesTableMemberExpression(val, keyframesHashTable);
             if (resolvedKeyframe !== undefined) {
                 obj[key] = 'kf-' + resolvedKeyframe;
@@ -104,11 +119,21 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
                 obj[key] = 'vt-' + resolvedViewTransitioin;
                 return;
             }
+            const resolvedCreate = resolveCreateTableMemberExpression(val, createHashTable);
+            if (resolvedCreate !== undefined) {
+                obj[key] = 'cr-' + resolvedCreate;
+                return;
+            }
             const resolvedTheme = resolveThemeTableMemberExpressionByNode(val, themeTable);
             if (resolvedTheme !== undefined) {
                 obj[key] = resolvedTheme;
                 return;
             }
+            const resolvedVariants = resolveVariantsTableMemberExpression(val, variantsHashTable);
+            if (resolvedVariants !== undefined) {
+                obj[key] = 'vr-' + resolvedVariants;
+                return;
+            }
         }
         if (exports.t.isStringLiteral(val) ||
             exports.t.isNumericLiteral(val) ||
@@ -119,7 +144,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, resolveVariable);
+            obj[key] = objectExpressionToObject(val, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable, createHashTable, variantsHashTable, resolveVariable);
         }
         else if (exports.t.isMemberExpression(val)) {
             const resolved = resolveStaticTableMemberExpression(val, staticTable);
@@ -171,7 +196,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, resolveValue);
+            result = objectExpressionToObject(init, localConsts, exports.tables.keyframesHashTable, exports.tables.viewTransitionHashTable, exports.tables.themeTable, exports.tables.createHashTable, exports.tables.variantsHashTable, resolveValue);
         }
         visiting.delete(name);
         if (result !== undefined) {
@@ -330,6 +355,26 @@ function resolveViewTransitionTableMemberExpression(node, viewTransitionHashTabl
         }
     }
 }
+function resolveCreateTableMemberExpression(node, createHashTable) {
+    if (exports.t.isIdentifier(node)) {
+        return createHashTable[node.value];
+    }
+    if (exports.t.isMemberExpression(node)) {
+        if (exports.t.isIdentifier(node.object)) {
+            return createHashTable[node.object.value];
+        }
+    }
+}
+function resolveVariantsTableMemberExpression(node, variantsHashTable) {
+    if (exports.t.isIdentifier(node)) {
+        return variantsHashTable[node.value];
+    }
+    if (exports.t.isMemberExpression(node)) {
+        if (exports.t.isIdentifier(node.object)) {
+            return variantsHashTable[node.object.value];
+        }
+    }
+}
 function resolveStaticTableMemberExpression(node, staticTable) {
     if (exports.t.isIdentifier(node.object) && exports.t.isIdentifier(node.property)) {
         const varName = node.object.value;
@@ -360,13 +405,20 @@ function resolveThemeTableMemberExpressionByNode(node, themeTable) {
     return undefined;
 }
 const fileCache = {};
-function scanAll(addDependency) {
-    for (const key in exports.tables) {
-        const table = exports.tables[key];
-        for (const prop in table) {
-            delete table[prop];
-        }
-    }
+function scanAll() {
+    const localTables = {
+        staticTable: {},
+        themeTable: {},
+        keyframesHashTable: {},
+        keyframesObjectTable: {},
+        viewTransitionHashTable: {},
+        viewTransitionObjectTable: {},
+        createThemeObjectTable: {},
+        createHashTable: {},
+        createObjectTable: {},
+        variantsHashTable: {},
+        variantsObjectTable: {},
+    };
     const files = fs_1.default.globSync(PATTERN_PATH, GLOB_OPTIONS);
     for (const filePath of files) {
         try {
@@ -374,31 +426,49 @@ function scanAll(addDependency) {
             const cached = fileCache[filePath];
             if (cached && cached.mtimeMs === stats.mtimeMs) {
                 if (cached.hasCssUsage) {
-                    addDependency(filePath);
                     for (const key of Object.keys(cached.staticTable)) {
-                        exports.tables.staticTable[key] = cached.staticTable[key];
+                        localTables.staticTable[`${filePath}-${key}`] =
+                            cached.staticTable[key];
                     }
                     for (const key of Object.keys(cached.keyframesHashTable)) {
-                        exports.tables.keyframesHashTable[key] = cached.keyframesHashTable[key];
+                        localTables.keyframesHashTable[`${filePath}-${key}`] =
+                            cached.keyframesHashTable[key];
                     }
                     for (const key of Object.keys(cached.keyframesObjectTable)) {
-                        exports.tables.keyframesObjectTable[key] = cached.keyframesObjectTable[key];
+                        localTables.keyframesObjectTable[key] =
+                            cached.keyframesObjectTable[key];
                     }
                     for (const key of Object.keys(cached.viewTransitionHashTable)) {
-                        exports.tables.viewTransitionHashTable[key] =
+                        localTables.viewTransitionHashTable[`${filePath}-${key}`] =
                             cached.viewTransitionHashTable[key];
                     }
                     for (const key of Object.keys(cached.viewTransitionObjectTable)) {
-                        exports.tables.viewTransitionObjectTable[key] =
+                        localTables.viewTransitionObjectTable[key] =
                             cached.viewTransitionObjectTable[key];
                     }
                     for (const key of Object.keys(cached.themeTable)) {
-                        exports.tables.themeTable[key] = cached.themeTable[key];
+                        localTables.themeTable[`${filePath}-${key}`] =
+                            cached.themeTable[key];
                     }
                     for (const key of Object.keys(cached.createThemeObjectTable)) {
-                        exports.tables.createThemeObjectTable[key] =
+                        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.variantsHashTable)) {
+                        localTables.variantsHashTable[`${filePath}-${key}`] =
+                            cached.variantsHashTable[key];
+                    }
+                    for (const key of Object.keys(cached.variantsObjectTable)) {
+                        localTables.variantsObjectTable[key] =
+                            cached.variantsObjectTable[key];
+                    }
                 }
                 continue;
             }
@@ -413,6 +483,10 @@ function scanAll(addDependency) {
                     viewTransitionObjectTable: {},
                     themeTable: {},
                     createThemeObjectTable: {},
+                    createHashTable: {},
+                    createObjectTable: {},
+                    variantsHashTable: {},
+                    variantsObjectTable: {},
                     hasCssUsage: false,
                 };
                 continue;
@@ -422,7 +496,6 @@ function scanAll(addDependency) {
                 tsx: true,
                 target: 'es2022',
             });
-            addDependency(filePath);
             const localStaticTable = {};
             const localKeyframesHashTable = {};
             const localKeyframesObjectTable = {};
@@ -430,6 +503,10 @@ function scanAll(addDependency) {
             const localViewTransitionObjectTable = {};
             const localThemeTable = {};
             const localCreateThemeObjectTable = {};
+            const localCreateHashTable = {};
+            const localCreateObjectTable = {};
+            const localVariantsHashTable = {};
+            const localVariantsObjectTable = {};
             for (const node of ast.body) {
                 let declarations = [];
                 if (exports.t.isVariableDeclaration(node)) {
@@ -452,33 +529,54 @@ function scanAll(addDependency) {
                         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 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, localThemeTable, localCreateHashTable, localVariantsHashTable, resolveVariable);
                         const uniqueKey = `${filePath}-${name}`;
                         if (method === 'createStatic') {
                             localStaticTable[name] = obj;
-                            exports.tables.staticTable[uniqueKey] = obj;
+                            localTables.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;
+                            localTables.keyframesHashTable[uniqueKey] = hash;
+                            localTables.keyframesObjectTable[hash] = obj;
                             localKeyframesObjectTable[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;
+                            localTables.viewTransitionHashTable[uniqueKey] = hash;
+                            localTables.viewTransitionObjectTable[hash] = obj;
                             localViewTransitionObjectTable[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;
+                            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;
+                        }
+                        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;
+                        }
                     }
                 }
             }
@@ -491,20 +589,25 @@ function scanAll(addDependency) {
                 viewTransitionObjectTable: localViewTransitionObjectTable,
                 themeTable: localThemeTable,
                 createThemeObjectTable: localCreateThemeObjectTable,
+                createHashTable: localCreateHashTable,
+                createObjectTable: localCreateObjectTable,
+                variantsHashTable: localVariantsHashTable,
+                variantsObjectTable: localVariantsObjectTable,
                 hasCssUsage: true,
             };
         }
         catch (e) {
         }
     }
-    return exports.tables;
+    return localTables;
 }
-function extractOndemandStyles(obj, extractedSheets) {
+function extractOndemandStyles(obj, extractedSheets, t = exports.tables) {
     if (!obj || typeof obj !== 'object')
         return;
     const visited = new Set();
     const keyframesHashes = new Set();
     const viewTransitionHashes = new Set();
+    const createHashes = new Set();
     let needsTheme = false;
     function walk(n) {
         if (!n || typeof n !== 'object' || visited.has(n))
@@ -518,6 +621,9 @@ function extractOndemandStyles(obj, extractedSheets) {
                 else if (val.startsWith('vt-')) {
                     viewTransitionHashes.add(val.slice(3));
                 }
+                else if (val.startsWith('cr-')) {
+                    createHashes.add(val.slice(3));
+                }
                 else if (!needsTheme && val.includes('var(--')) {
                     needsTheme = true;
                 }
@@ -537,7 +643,7 @@ function extractOndemandStyles(obj, extractedSheets) {
     };
     if (keyframesHashes.size > 0) {
         for (const hash of keyframesHashes) {
-            const definition = exports.tables.keyframesObjectTable[hash];
+            const definition = t.keyframesObjectTable[hash];
             if (definition) {
                 const { styleSheet } = (0, zss_engine_1.transpile)({ [`@keyframes kf-${hash}`]: definition }, undefined, '--global');
                 addSheet(styleSheet);
@@ -546,18 +652,29 @@ function extractOndemandStyles(obj, extractedSheets) {
     }
     if (viewTransitionHashes.size > 0) {
         for (const hash of viewTransitionHashes) {
-            const obj = exports.tables.viewTransitionObjectTable[hash];
+            const obj = t.viewTransitionObjectTable[hash];
             if (obj) {
                 const { styleSheet } = (0, zss_engine_1.transpile)((0, viewTransition_1.createViewTransition)(obj, hash), undefined, '--global');
                 addSheet(styleSheet);
             }
         }
     }
+    if (createHashes.size > 0) {
+        for (const hash of createHashes) {
+            const obj = t.createObjectTable[hash];
+            if (obj) {
+                Object.entries(obj).forEach(([key, style]) => {
+                    const records = (0, create_1.getStyleRecords)(key, style, 2);
+                    records.forEach((r) => addSheet(r.sheet));
+                });
+            }
+        }
+    }
     if (needsTheme) {
-        for (const themeVarName in exports.tables.themeTable) {
-            const themeObj = exports.tables.themeTable[themeVarName];
+        for (const themeVarName in t.themeTable) {
+            const themeObj = t.themeTable[themeVarName];
             const hash = (0, zss_engine_1.genBase36Hash)(themeObj, 1, 8);
-            const definition = exports.tables.createThemeObjectTable[hash];
+            const definition = t.createThemeObjectTable[hash];
             if (definition && typeof definition === 'object') {
                 const styles = (0, createTheme_1.createTheme)(definition);
                 const { styleSheet } = (0, zss_engine_1.transpile)(styles, undefined, '--global');

package/dist/resolver.js

@@ -6,26 +6,40 @@ 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();
+const tsConfigCache = new Map();
+const tsConfigPathCache = new Map();
+function getTsConfig(startDir) {
+    let currentDir = startDir;
+    if (tsConfigPathCache.has(currentDir)) {
+        const cachedPath = tsConfigPathCache.get(currentDir);
+        if (cachedPath === null)
+            return null;
+        return {
+            config: tsConfigCache.get(cachedPath) ?? null,
+            basePath: path_1.default.dirname(cachedPath),
+        };
+    }
     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 {
+            if (!tsConfigCache.has(tsConfigPath)) {
+                try {
+                    const config = require(tsConfigPath);
+                    tsConfigCache.set(tsConfigPath, config.compilerOptions || null);
+                }
+                catch {
+                    tsConfigCache.set(tsConfigPath, null);
+                }
             }
+            tsConfigPathCache.set(startDir, tsConfigPath);
+            return {
+                config: tsConfigCache.get(tsConfigPath) ?? null,
+                basePath: currentDir,
+            };
         }
         currentDir = path_1.default.dirname(currentDir);
     }
-    tsConfigCache = null;
+    tsConfigPathCache.set(startDir, null);
     return null;
 }
 const extensions = [
@@ -52,9 +66,10 @@ function resolveImportPath(importPath, importerPath) {
     if (importPath.startsWith('.')) {
         return resolveWithExtension(path_1.default.resolve(path_1.default.dirname(importerPath), importPath));
     }
-    const config = loadTsConfig();
+    const tsConfig = getTsConfig(path_1.default.dirname(importerPath));
+    const config = tsConfig?.config;
     if (config?.paths) {
-        const root = process.cwd();
+        const root = tsConfig.basePath;
         for (const [alias, targets] of Object.entries(config.paths)) {
             const prefix = alias.replace(/\*$/, '');
             if (importPath.startsWith(prefix)) {

package/dist/types.d.ts

@@ -4,13 +4,17 @@ export type CSSValue = CSSPrimitive | CSSObject | ParseErrorString;
 export type CSSObject = {
     [key: string]: CSSValue;
 };
-export type StaticTable = Record<string, CSSObject | string>;
+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>;
 export type ViewTransitionObjectTable = Record<string, CSSObject>;
 export type CreateThemeObjectTable = Record<string, CSSObject>;
+export type CreateHashTable = Record<string, string>;
+export type CreateObjectTable = Record<string, CSSObject>;
+export type VariantsHashTable = Record<string, string>;
+export type VariantsObjectTable = Record<string, CSSObject>;
 export interface Tables {
     staticTable: StaticTable;
     themeTable: ThemeTable;
@@ -19,6 +23,10 @@ export interface Tables {
     viewTransitionHashTable: ViewTransitionHashTable;
     viewTransitionObjectTable: ViewTransitionObjectTable;
     createThemeObjectTable: CreateThemeObjectTable;
+    createHashTable: CreateHashTable;
+    createObjectTable: CreateObjectTable;
+    variantsHashTable: VariantsHashTable;
+    variantsObjectTable: VariantsObjectTable;
 }
 export interface FileStyles {
     baseStyles?: string;

package/package.json

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