@plumeria/utils 1.0.3 → 2.0.0

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { CSSObject, FileStyles } from './types';
-export { createCSS, createVars, createTokens } from './transform';
-export { scanForDefineConsts, scanForDefineTokens, scanForKeyframes, scanForViewTransition, objectExpressionToObject, collectLocalConsts, traverse, t, tables, } from './parser';
+export type { CSSObject, FileStyles } from './types';
+export { createCSS, createVars, createTheme } from './transform';
+export { scanForCreateStatic, scanForCreateTheme, scanForKeyframes, scanForViewTransition, objectExpressionToObject, collectLocalConsts, traverse, t, tables, } from './parser';

package/dist/index.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tables = exports.t = exports.traverse = exports.collectLocalConsts = exports.objectExpressionToObject = exports.scanForViewTransition = exports.scanForKeyframes = exports.scanForDefineTokens = exports.scanForDefineConsts = exports.createTokens = exports.createVars = exports.createCSS = void 0;
+exports.tables = exports.t = exports.traverse = exports.collectLocalConsts = exports.objectExpressionToObject = exports.scanForViewTransition = exports.scanForKeyframes = exports.scanForCreateTheme = exports.scanForCreateStatic = exports.createTheme = exports.createVars = exports.createCSS = void 0;
 var transform_1 = require("./transform");
 Object.defineProperty(exports, "createCSS", { enumerable: true, get: function () { return transform_1.createCSS; } });
 Object.defineProperty(exports, "createVars", { enumerable: true, get: function () { return transform_1.createVars; } });
-Object.defineProperty(exports, "createTokens", { enumerable: true, get: function () { return transform_1.createTokens; } });
+Object.defineProperty(exports, "createTheme", { enumerable: true, get: function () { return transform_1.createTheme; } });
 var parser_1 = require("./parser");
-Object.defineProperty(exports, "scanForDefineConsts", { enumerable: true, get: function () { return parser_1.scanForDefineConsts; } });
-Object.defineProperty(exports, "scanForDefineTokens", { enumerable: true, get: function () { return parser_1.scanForDefineTokens; } });
+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; } });

package/dist/parser.d.ts

@@ -1,4 +1,4 @@
-import type { CSSObject, ConstTable, KeyframesHashTable, KeyframesObjectTable, TokensTable, ViewTransitionObjectTable, ViewTransitionHashTable, Tables } from './types';
+import type { CSSObject, StaticTable, KeyframesHashTable, KeyframesObjectTable, ThemeTable, ViewTransitionObjectTable, ViewTransitionHashTable, Tables } from './types';
 import { Module, CallExpression, Identifier, KeyValueProperty, StringLiteral, NumericLiteral, BooleanLiteral, ObjectExpression, MemberExpression, TemplateLiteral, BinaryExpression, UnaryExpression, VariableDeclaration, VariableDeclarator, ExportDeclaration } from '@swc/core';
 export declare const t: {
     isObjectExpression: (node: any) => node is ObjectExpression;
@@ -26,7 +26,7 @@ export declare function traverse(node: Module, visitor: {
     }) => void;
 }): void;
 export declare const tables: Tables;
-export declare function objectExpressionToObject(node: ObjectExpression, constTable: ConstTable, keyframesHashTable: KeyframesHashTable, viewTransitionHashTable: ViewTransitionHashTable, tokensTable: TokensTable): CSSObject;
+export declare function objectExpressionToObject(node: ObjectExpression, staticTable: StaticTable, keyframesHashTable: KeyframesHashTable, viewTransitionHashTable: ViewTransitionHashTable, themeTable: ThemeTable): CSSObject;
 export declare function collectLocalConsts(ast: Module): Record<string, any>;
 export declare function scanForKeyframes(addDependency: (path: string) => void): {
     keyframesHashTableLocal: KeyframesHashTable;
@@ -36,8 +36,8 @@ export declare function scanForViewTransition(addDependency: (path: string) => v
     viewTransitionHashTableLocal: ViewTransitionHashTable;
     viewTransitionObjectTableLocal: ViewTransitionObjectTable;
 };
-export declare function scanForDefineConsts(addDependency: (path: string) => void): ConstTable;
-export declare function scanForDefineTokens(addDependency: (path: string) => void): {
-    tokensTableLocal: Record<string, Record<string, any>>;
-    defineTokensObjectTableLocal: Record<string, any>;
+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, any>;
 };

package/dist/parser.js

@@ -9,8 +9,8 @@ exports.objectExpressionToObject = objectExpressionToObject;
 exports.collectLocalConsts = collectLocalConsts;
 exports.scanForKeyframes = scanForKeyframes;
 exports.scanForViewTransition = scanForViewTransition;
-exports.scanForDefineConsts = scanForDefineConsts;
-exports.scanForDefineTokens = scanForDefineTokens;
+exports.scanForCreateStatic = scanForCreateStatic;
+exports.scanForCreateTheme = scanForCreateTheme;
 const core_1 = require("@swc/core");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -74,20 +74,20 @@ const GLOB_OPTIONS = {
     cwd: PROJECT_ROOT,
 };
 exports.tables = {
-    constTable: {},
-    tokensTable: {},
+    staticTable: {},
+    themeTable: {},
     keyframesHashTable: {},
     keyframesObjectTable: {},
     viewTransitionHashTable: {},
     viewTransitionObjectTable: {},
-    defineTokensObjectTable: {},
+    createThemeObjectTable: {},
 };
-function objectExpressionToObject(node, constTable, keyframesHashTable, viewTransitionHashTable, tokensTable) {
+function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable) {
     const obj = {};
     node.properties.forEach((prop) => {
         if (!exports.t.isObjectProperty(prop))
             return;
-        const key = getPropertyKey(prop.key, constTable);
+        const key = getPropertyKey(prop.key, staticTable);
         if (!key)
             return;
         const val = prop.value;
@@ -102,7 +102,7 @@ function objectExpressionToObject(node, constTable, keyframesHashTable, viewTran
                 obj[key] = 'vt-' + resolvedViewTransitioin;
                 return;
             }
-            const resolvedTheme = resolveTokensTableMemberExpressionByNode(val, tokensTable);
+            const resolvedTheme = resolveThemeTableMemberExpressionByNode(val, themeTable);
             if (resolvedTheme !== undefined) {
                 obj[key] = resolvedTheme;
                 return;
@@ -117,15 +117,15 @@ function objectExpressionToObject(node, constTable, keyframesHashTable, viewTran
             obj[key] = evaluateUnaryExpression(val);
         }
         else if (exports.t.isObjectExpression(val)) {
-            obj[key] = objectExpressionToObject(val, constTable, keyframesHashTable, viewTransitionHashTable, tokensTable);
+            obj[key] = objectExpressionToObject(val, staticTable, keyframesHashTable, viewTransitionHashTable, themeTable);
         }
         else if (exports.t.isMemberExpression(val)) {
-            const resolved = resolveConstTableMemberExpression(val, constTable);
+            const resolved = resolveStaticTableMemberExpression(val, staticTable);
             obj[key] = resolved !== undefined ? resolved : '[unresolved]';
         }
         else if (exports.t.isIdentifier(val)) {
-            if (constTable[val.value] !== undefined) {
-                obj[key] = constTable[val.value];
+            if (staticTable[val.value] !== undefined) {
+                obj[key] = staticTable[val.value];
             }
             else {
                 obj[key] = '[unresolved identifier]';
@@ -146,17 +146,18 @@ function collectLocalConsts(ast) {
                     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.tokensTable);
+                    localConsts[node.id.value] = objectExpressionToObject(node.init, localConsts, exports.tables.keyframesHashTable, exports.tables.viewTransitionHashTable, exports.tables.themeTable);
                 }
             }
         },
     });
     return localConsts;
 }
-function getPropertyKey(node, constTable) {
+function getPropertyKey(node, staticTable) {
     if (exports.t.isIdentifier(node)) {
-        if (constTable[node.value] && typeof constTable[node.value] === 'string') {
-            return constTable[node.value];
+        if (staticTable[node.value] &&
+            typeof staticTable[node.value] === 'string') {
+            return staticTable[node.value];
         }
         return node.value;
     }
@@ -169,53 +170,53 @@ function getPropertyKey(node, constTable) {
             return expr.value;
         }
         if (exports.t.isIdentifier(expr)) {
-            if (constTable[expr.value] &&
-                typeof constTable[expr.value] === 'string') {
-                return constTable[expr.value];
+            if (staticTable[expr.value] &&
+                typeof staticTable[expr.value] === 'string') {
+                return staticTable[expr.value];
             }
         }
         if (exports.t.isMemberExpression(expr)) {
-            const result = resolveConstTableMemberExpression(expr, constTable);
+            const result = resolveStaticTableMemberExpression(expr, staticTable);
             if (typeof result === 'string')
                 return result;
         }
         if (exports.t.isTemplateLiteral(expr)) {
-            return evaluateTemplateLiteral(expr, constTable);
+            return evaluateTemplateLiteral(expr, staticTable);
         }
         if (exports.t.isBinaryExpression(expr)) {
-            return evaluateBinaryExpression(expr, constTable);
+            return evaluateBinaryExpression(expr, staticTable);
         }
         return '';
     }
     if (exports.t.isTemplateLiteral(node)) {
-        return evaluateTemplateLiteral(node, constTable);
+        return evaluateTemplateLiteral(node, staticTable);
     }
     if (exports.t.isBinaryExpression(node)) {
-        return evaluateBinaryExpression(node, constTable);
+        return evaluateBinaryExpression(node, staticTable);
     }
     return '';
 }
-function evaluateTemplateLiteral(node, constTable) {
+function evaluateTemplateLiteral(node, staticTable) {
     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, constTable);
+            const evaluatedExpr = evaluateExpression(expr, staticTable);
             result += String(evaluatedExpr);
         }
     }
     return result;
 }
-function evaluateBinaryExpression(node, constTable) {
-    const left = evaluateExpression(node.left, constTable);
-    const right = evaluateExpression(node.right, constTable);
+function evaluateBinaryExpression(node, staticTable) {
+    const left = evaluateExpression(node.left, staticTable);
+    const right = evaluateExpression(node.right, staticTable);
     if (node.operator === '+') {
         return String(left) + String(right);
     }
     throw new Error(`Unsupported binary operator: ${node.operator}`);
 }
-function evaluateExpression(node, constTable) {
+function evaluateExpression(node, staticTable) {
     if (exports.t.isStringLiteral(node)) {
         return node.value;
     }
@@ -229,8 +230,8 @@ function evaluateExpression(node, constTable) {
         return null;
     }
     if (exports.t.isIdentifier(node)) {
-        if (constTable[node.value] !== undefined) {
-            return constTable[node.value];
+        if (staticTable[node.value] !== undefined) {
+            return staticTable[node.value];
         }
         if (exports.tables.keyframesHashTable[node.value] !== undefined) {
             return exports.tables.keyframesHashTable[node.value];
@@ -241,21 +242,21 @@ function evaluateExpression(node, constTable) {
         return `[unresolved: ${node.value}]`;
     }
     if (exports.t.isMemberExpression(node)) {
-        const resolved = resolveConstTableMemberExpression(node, constTable);
+        const resolved = resolveStaticTableMemberExpression(node, staticTable);
         if (resolved !== undefined) {
             return resolved;
         }
-        const resolvedTheme = resolveTokensTableMemberExpressionByNode(node, exports.tables.tokensTable);
+        const resolvedTheme = resolveThemeTableMemberExpressionByNode(node, exports.tables.themeTable);
         if (resolvedTheme !== undefined) {
             return resolvedTheme;
         }
         return `[unresolved member expression]`;
     }
     if (exports.t.isBinaryExpression(node)) {
-        return evaluateBinaryExpression(node, constTable);
+        return evaluateBinaryExpression(node, staticTable);
     }
     if (exports.t.isTemplateLiteral(node)) {
-        return evaluateTemplateLiteral(node, constTable);
+        return evaluateTemplateLiteral(node, staticTable);
     }
     if (exports.t.isUnaryExpression(node)) {
         return evaluateUnaryExpression(node);
@@ -298,18 +299,18 @@ function resolveViewTransitionTableMemberExpression(node, viewTransitionHashTabl
         }
     }
 }
-function resolveConstTableMemberExpression(node, constTable) {
+function resolveStaticTableMemberExpression(node, staticTable) {
     if (exports.t.isIdentifier(node.object) && exports.t.isIdentifier(node.property)) {
         const varName = node.object.value;
         const key = node.property.value;
-        const tableValue = constTable[varName];
+        const tableValue = staticTable[varName];
         if (tableValue && typeof tableValue === 'object' && key in tableValue) {
             return tableValue[key];
         }
     }
     return undefined;
 }
-function resolveTokensTableMemberExpressionByNode(node, tokensTable) {
+function resolveThemeTableMemberExpressionByNode(node, themeTable) {
     if (exports.t.isMemberExpression(node) && exports.t.isIdentifier(node.object)) {
         const varName = node.object.value;
         let key;
@@ -320,9 +321,7 @@ function resolveTokensTableMemberExpressionByNode(node, tokensTable) {
             exports.t.isStringLiteral(node.property.expression)) {
             key = node.property.expression.value;
         }
-        if (key &&
-            tokensTable[varName] &&
-            tokensTable[varName][key] !== undefined) {
+        if (key && themeTable[varName] && themeTable[varName][key] !== undefined) {
             const cssVarName = (0, zss_engine_1.camelToKebabCase)(key);
             return `var(--${cssVarName})`;
         }
@@ -363,7 +362,7 @@ function scanForKeyframes(addDependency) {
                     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.constTable, keyframesHashTableLocal, exports.tables.viewTransitionHashTable, exports.tables.tokensTable);
+                    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;
@@ -412,7 +411,7 @@ function scanForViewTransition(addDependency) {
                     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.constTable, exports.tables.keyframesHashTable, viewTransitionHashTableLocal, exports.tables.tokensTable);
+                    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;
@@ -425,11 +424,11 @@ function scanForViewTransition(addDependency) {
         viewTransitionObjectTableLocal,
     };
 }
-function scanForDefineConsts(addDependency) {
-    const constTableLocal = {};
+function scanForCreateStatic(addDependency) {
+    const staticTableLocal = {};
     const files = fs_1.default.globSync(PATTERN_PATH, GLOB_OPTIONS);
     for (const filePath of files) {
-        if (!isCSSDefineFile(filePath, 'defineConsts'))
+        if (!isCSSDefineFile(filePath, 'createStatic'))
             continue;
         addDependency(filePath);
         const source = fs_1.default.readFileSync(filePath, 'utf8');
@@ -454,24 +453,24 @@ function scanForDefineConsts(addDependency) {
                     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: 'defineConsts' }) &&
+                    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, constTableLocal, exports.tables.keyframesHashTable, exports.tables.viewTransitionHashTable, exports.tables.tokensTable);
-                    constTableLocal[varName] = obj;
+                    const obj = objectExpressionToObject(decl.init.arguments[0].expression, staticTableLocal, exports.tables.keyframesHashTable, exports.tables.viewTransitionHashTable, exports.tables.themeTable);
+                    staticTableLocal[varName] = obj;
                 }
             }
         }
     }
-    return constTableLocal;
+    return staticTableLocal;
 }
-function scanForDefineTokens(addDependency) {
-    const tokensTableLocal = {};
-    const defineTokensObjectTableLocal = {};
+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, 'defineTokens'))
+        if (!isCSSDefineFile(filePath, 'createTheme'))
             continue;
         addDependency(filePath);
         const source = fs_1.default.readFileSync(filePath, 'utf8');
@@ -496,18 +495,18 @@ function scanForDefineTokens(addDependency) {
                     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: 'defineTokens' }) &&
+                    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.constTable, exports.tables.keyframesHashTable, exports.tables.viewTransitionHashTable, tokensTableLocal);
-                    tokensTableLocal[varName] = obj;
-                    defineTokensObjectTableLocal[varName] = obj;
+                    const obj = objectExpressionToObject(decl.init.arguments[0].expression, exports.tables.staticTable, exports.tables.keyframesHashTable, exports.tables.viewTransitionHashTable, themeTableLocal);
+                    themeTableLocal[varName] = obj;
+                    createThemeObjectTableLocal[varName] = obj;
                 }
             }
         }
     }
-    return { tokensTableLocal, defineTokensObjectTableLocal };
+    return { themeTableLocal, createThemeObjectTableLocal };
 }
 function isCSSDefineFile(filePath, target) {
     if (fs_1.default.statSync(filePath).isDirectory())

package/dist/transform.d.ts

@@ -1,5 +1,5 @@
-import type { CSSProperties, CreateStyleType, CreateTokens, CreateValues } from 'zss-engine';
+import type { CSSProperties, CreateStyleType, CreateTheme, CreateValues } from 'zss-engine';
 declare function createCSS<T extends Record<string, CSSProperties>>(object: CreateStyleType<T>): string;
 declare const createVars: <const T extends CreateValues>(object: T) => Record<string, CreateValues>;
-declare const createTokens: <const T extends CreateTokens>(object: T) => Record<string, Record<string, string | number | object>>;
-export { createCSS, createVars, createTokens };
+declare const createTheme: <const T extends CreateTheme>(object: T) => Record<string, Record<string, string | number | object>>;
+export { createCSS, createVars, createTheme };

package/dist/transform.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTokens = exports.createVars = void 0;
+exports.createTheme = exports.createVars = void 0;
 exports.createCSS = createCSS;
 const zss_engine_1 = require("zss-engine");
 function compileToSingleCSS(object) {
@@ -27,7 +27,7 @@ function compileToSingleCSS(object) {
                 const sheet = sheetArray[i];
                 const hash = hashArray[i];
                 if (sheet.includes('@media') || sheet.includes('@container')) {
-                    querySheetParts.push(sheet.replace(`.${hash}`, `.${hash}:not(#\\#)`));
+                    querySheetParts.push(sheet.replace(`.${hash}`, `.${hash}:not(#\\#):not(#\\#)`));
                     queryHashParts.push(hash);
                 }
                 else {
@@ -51,20 +51,33 @@ function compileToSingleCSS(object) {
             }
         });
         if (Object.keys(nonFlat).length > 0) {
-            const modNonFlat = (0, zss_engine_1.transformNestedSelectors)(nonFlat);
-            const nonFlatObj = { [key]: modNonFlat };
-            const nonFlatHash = (0, zss_engine_1.genBase36Hash)(nonFlatObj, 1, 7);
-            const { styleSheet } = (0, zss_engine_1.transpile)(nonFlatObj, nonFlatHash);
-            const isQuery = styleSheet.includes('@media') || styleSheet.includes('@container');
-            const finalSheet = isQuery
-                ? styleSheet.replace(`.${nonFlatHash}`, `.${nonFlatHash}:not(#\\#)`)
-                : styleSheet;
+            const nonFlatBase = {};
+            const nonFlatQuery = {};
             Object.entries(nonFlat).forEach(([atRule, nestedObj]) => {
-                Object.keys(nestedObj).forEach((prop) => {
-                    records.push({
-                        key: atRule + prop,
-                        hash: nonFlatHash,
-                        sheet: finalSheet,
+                if (atRule.startsWith('@media') || atRule.startsWith('@container')) {
+                    nonFlatQuery[atRule] = nestedObj;
+                }
+                else {
+                    nonFlatBase[atRule] = nestedObj;
+                }
+            });
+            [nonFlatBase, nonFlatQuery].forEach((targetNonFlat) => {
+                if (Object.keys(targetNonFlat).length === 0)
+                    return;
+                const nonFlatObj = { [key]: targetNonFlat };
+                const nonFlatHash = (0, zss_engine_1.genBase36Hash)(nonFlatObj, 1, 7);
+                const { styleSheet } = (0, zss_engine_1.transpile)(nonFlatObj, nonFlatHash);
+                const isQuery = styleSheet.includes('@media') || styleSheet.includes('@container');
+                const finalSheet = isQuery
+                    ? styleSheet.replace(`.${nonFlatHash}`, `.${nonFlatHash}:not(#\\#):not(#\\#)`)
+                    : styleSheet;
+                Object.entries(targetNonFlat).forEach(([atRule, nestedObj]) => {
+                    Object.keys(nestedObj).forEach((prop) => {
+                        records.push({
+                            key: atRule + prop,
+                            hash: nonFlatHash,
+                            sheet: finalSheet,
+                        });
                     });
                 });
             });
@@ -97,7 +110,7 @@ const createVars = (object) => {
     return styles;
 };
 exports.createVars = createVars;
-const createTokens = (object) => {
+const createTheme = (object) => {
     const styles = {};
     Object.entries(object).forEach(([key, value]) => {
         const kebabKey = (0, zss_engine_1.camelToKebabCase)(key);
@@ -116,4 +129,4 @@ const createTokens = (object) => {
     });
     return styles;
 };
-exports.createTokens = createTokens;
+exports.createTheme = createTheme;

package/dist/types.d.ts

@@ -4,26 +4,26 @@ export type CSSValue = CSSPrimitive | CSSObject | ParseErrorString;
 export type CSSObject = {
     [key: string]: CSSValue;
 };
-export type ConstTable = Record<string, CSSObject | string>;
-export type TokensTable = Record<string, CSSObject>;
+export type StaticTable = Record<string, CSSObject | string>;
+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 DefineTokensObjectTable = Record<string, CSSObject>;
+export type CreateThemeObjectTable = Record<string, CSSObject>;
 export interface Tables {
-    constTable: ConstTable;
-    tokensTable: TokensTable;
+    staticTable: StaticTable;
+    themeTable: ThemeTable;
     keyframesHashTable: KeyframesHashTable;
     keyframesObjectTable: KeyframesObjectTable;
     viewTransitionHashTable: ViewTransitionHashTable;
     viewTransitionObjectTable: ViewTransitionObjectTable;
-    defineTokensObjectTable: DefineTokensObjectTable;
+    createThemeObjectTable: CreateThemeObjectTable;
 }
 export interface FileStyles {
     baseStyles?: string;
     keyframeStyles?: string;
     viewTransitionStyles?: string;
-    tokenStyles?: string;
+    themeStyles?: string;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/utils",
-  "version": "1.0.3",
+  "version": "2.0.0",
   "description": "Plumeria Utils",
   "repository": {
     "type": "git",
@@ -18,7 +18,7 @@
     "@swc/core": "1.15.2"
   },
   "devDependencies": {
-    "zss-engine": "1.0.0"
+    "zss-engine": "1.1.0"
   },
   "publishConfig": {
     "access": "public",