@plumeria/utils 4.2.0 → 4.2.1

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export type { CSSObject, FileStyles } from './types';
 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,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStyleRecords = exports.scanAll = exports.deepMerge = exports.extractOndemandStyles = exports.tables = exports.t = exports.traverse = exports.collectLocalConsts = exports.objectExpressionToObject = 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, "objectExpressionToObject", { enumerable: true, get: function () { return parser_1.objectExpressionToObject; } });
 Object.defineProperty(exports, "collectLocalConsts", { enumerable: true, get: function () { return parser_1.collectLocalConsts; } });
@@ -12,3 +12,5 @@ Object.defineProperty(exports, "deepMerge", { enumerable: true, get: function ()
 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

@@ -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): CSSObject;
-export declare function collectLocalConsts(ast: Module, filePath: string): Record<string, any>;
+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 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

@@ -84,14 +84,7 @@ exports.tables = {
     viewTransitionObjectTable: {},
     createThemeObjectTable: {},
 };
-function genFileId(filePath) {
-    const relativePath = path_1.default
-        .relative(PROJECT_ROOT, filePath)
-        .split(path_1.default.sep)
-        .join('/');
-    return (0, zss_engine_1.genBase36Hash)(relativePath, 1, 8);
-}
-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))
@@ -126,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];
             }
@@ -146,31 +146,42 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
     });
     return obj;
 }
-function collectLocalConsts(ast, filePath) {
+function collectLocalConsts(ast) {
     const localConsts = {};
-    const fileId = genFileId(filePath);
-    const createProxy = (table) => {
-        return new Proxy(table, {
-            get: (target, prop) => {
-                if (typeof prop === 'string') {
-                    return target[`${fileId}-${prop}`];
-                }
-                return Reflect.get(target, prop);
-            },
-        });
-    };
+    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, createProxy(exports.tables.keyframesHashTable), createProxy(exports.tables.viewTransitionHashTable), createProxy(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, keyframesHashTable, viewTransitionHashTable, themeTable) {
@@ -351,7 +362,10 @@ function resolveThemeTableMemberExpressionByNode(node, themeTable) {
 const fileCache = {};
 function scanAll(addDependency) {
     for (const key in exports.tables) {
-        exports.tables[key] = {};
+        const table = exports.tables[key];
+        for (const prop in table) {
+            delete table[prop];
+        }
     }
     const files = fs_1.default.globSync(PATTERN_PATH, GLOB_OPTIONS);
     for (const filePath of files) {
@@ -388,7 +402,6 @@ function scanAll(addDependency) {
                 target: 'es2022',
             });
             addDependency(filePath);
-            const fileId = genFileId(filePath);
             const localStaticTable = {};
             const localKeyframesHashTable = {};
             const localViewTransitionHashTable = {};
@@ -417,7 +430,7 @@ function scanAll(addDependency) {
                         const name = decl.id.value;
                         const init = decl.init;
                         const obj = objectExpressionToObject(init.arguments[0].expression, localStaticTable, localKeyframesHashTable, localViewTransitionHashTable, localThemeTable);
-                        const uniqueKey = `${fileId}-${name}`;
+                        const uniqueKey = `${filePath}-${name}`;
                         if (method === 'createStatic') {
                             localStaticTable[name] = obj;
                             exports.tables.staticTable[uniqueKey] = obj;

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.2.0",
+  "version": "4.2.1",
   "description": "Plumeria Utils",
   "author": "Refirst 11",
   "license": "MIT",