@plumeria/utils 0.29.0

package/dist/index.d.ts

@@ -0,0 +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';

package/dist/index.js

@@ -0,0 +1,17 @@
+"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;
+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; } });
+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, "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; } });
+Object.defineProperty(exports, "t", { enumerable: true, get: function () { return parser_1.t; } });
+Object.defineProperty(exports, "tables", { enumerable: true, get: function () { return parser_1.tables; } });

package/dist/parser.d.ts

@@ -0,0 +1,43 @@
+import type { CSSObject, ConstTable, KeyframesHashTable, KeyframesObjectTable, TokensTable, 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;
+    isObjectProperty: (node: any) => node is KeyValueProperty;
+    isIdentifier: (node: any, opts?: {
+        name?: string;
+    }) => node is Identifier;
+    isStringLiteral: (node: any) => node is StringLiteral;
+    isNumericLiteral: (node: any) => node is NumericLiteral;
+    isBooleanLiteral: (node: any) => node is BooleanLiteral;
+    isMemberExpression: (node: any) => node is MemberExpression;
+    isUnaryExpression: (node: any) => node is UnaryExpression;
+    isTemplateLiteral: (node: any) => node is TemplateLiteral;
+    isBinaryExpression: (node: any) => node is BinaryExpression;
+    isVariableDeclaration: (node: any) => node is VariableDeclaration;
+    isExportDeclaration: (node: any) => node is ExportDeclaration;
+    isVariableDeclarator: (node: any) => node is VariableDeclarator;
+    isCallExpression: (node: any) => node is CallExpression;
+    isNullLiteral: (node: any) => boolean;
+};
+export declare function traverse(node: Module, visitor: {
+    [key: string]: (path: {
+        node: any;
+        stop: () => void;
+    }) => 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 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 scanForDefineConsts(addDependency: (path: string) => void): ConstTable;
+export declare function scanForDefineTokens(addDependency: (path: string) => void): {
+    tokensTableLocal: Record<string, Record<string, any>>;
+    defineTokensObjectTableLocal: Record<string, any>;
+};

package/dist/parser.js

@@ -0,0 +1,543 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tables = exports.t = void 0;
+exports.traverse = traverse;
+exports.objectExpressionToObject = objectExpressionToObject;
+exports.collectLocalConsts = collectLocalConsts;
+exports.scanForKeyframes = scanForKeyframes;
+exports.scanForViewTransition = scanForViewTransition;
+exports.scanForDefineConsts = scanForDefineConsts;
+exports.scanForDefineTokens = scanForDefineTokens;
+const core_1 = require("@swc/core");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const zss_engine_1 = require("zss-engine");
+exports.t = {
+    isObjectExpression: (node) => node?.type === 'ObjectExpression',
+    isObjectProperty: (node) => node?.type === 'KeyValueProperty',
+    isIdentifier: (node, opts) => {
+        if (node?.type !== 'Identifier')
+            return false;
+        if (opts?.name && node.value !== opts.name)
+            return false;
+        return true;
+    },
+    isStringLiteral: (node) => node?.type === 'StringLiteral',
+    isNumericLiteral: (node) => node?.type === 'NumericLiteral',
+    isBooleanLiteral: (node) => node?.type === 'BooleanLiteral',
+    isMemberExpression: (node) => node?.type === 'MemberExpression',
+    isUnaryExpression: (node) => node?.type === 'UnaryExpression',
+    isTemplateLiteral: (node) => node?.type === 'TemplateLiteral',
+    isBinaryExpression: (node) => node?.type === 'BinaryExpression',
+    isVariableDeclaration: (node) => node?.type === 'VariableDeclaration',
+    isExportDeclaration: (node) => node?.type === 'ExportDeclaration',
+    isVariableDeclarator: (node) => node?.type === 'VariableDeclarator',
+    isCallExpression: (node) => node?.type === 'CallExpression',
+    isNullLiteral: (node) => node?.type === 'NullLiteral',
+};
+function traverse(node, visitor) {
+    let stopped = false;
+    const stop = () => {
+        stopped = true;
+    };
+    function walk(n) {
+        if (stopped)
+            return;
+        if (!n || typeof n !== 'object')
+            return;
+        if (n.type && visitor[n.type]) {
+            visitor[n.type]({ node: n, stop });
+        }
+        for (const key in n) {
+            if (key === 'span')
+                continue;
+            const child = n[key];
+            if (Array.isArray(child)) {
+                for (const c of child) {
+                    walk(c);
+                }
+            }
+            else {
+                walk(child);
+            }
+        }
+    }
+    walk(node);
+}
+const PROJECT_ROOT = process.cwd().split('node_modules')[0];
+const PATTERN_PATH = path_1.default.join(PROJECT_ROOT, '**/*.{js,jsx,ts,tsx}');
+const GLOB_OPTIONS = {
+    exclude: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**'],
+    cwd: PROJECT_ROOT,
+};
+exports.tables = {
+    constTable: {},
+    tokensTable: {},
+    keyframesHashTable: {},
+    keyframesObjectTable: {},
+    viewTransitionHashTable: {},
+    viewTransitionObjectTable: {},
+    defineTokensObjectTable: {},
+};
+function objectExpressionToObject(node, constTable, keyframesHashTable, viewTransitionHashTable, tokensTable) {
+    const obj = {};
+    node.properties.forEach((prop) => {
+        if (!exports.t.isObjectProperty(prop))
+            return;
+        const key = getPropertyKey(prop.key, constTable);
+        if (!key)
+            return;
+        const val = prop.value;
+        if (exports.t.isIdentifier(val) || exports.t.isMemberExpression(val)) {
+            const resolvedKeyframe = resolveKeyframesTableMemberExpression(val, keyframesHashTable);
+            if (resolvedKeyframe !== undefined) {
+                obj[key] = 'kf-' + resolvedKeyframe;
+                return;
+            }
+            const resolvedViewTransitioin = resolveViewTransitionTableMemberExpression(val, viewTransitionHashTable);
+            if (resolvedViewTransitioin !== undefined) {
+                obj[key] = 'vt-' + resolvedViewTransitioin;
+                return;
+            }
+            const resolvedTheme = resolveTokensTableMemberExpressionByNode(val, tokensTable);
+            if (resolvedTheme !== undefined) {
+                obj[key] = resolvedTheme;
+                return;
+            }
+        }
+        if (exports.t.isStringLiteral(val) ||
+            exports.t.isNumericLiteral(val) ||
+            exports.t.isBooleanLiteral(val)) {
+            obj[key] = val.value;
+        }
+        else if (exports.t.isUnaryExpression(val)) {
+            obj[key] = evaluateUnaryExpression(val);
+        }
+        else if (exports.t.isObjectExpression(val)) {
+            obj[key] = objectExpressionToObject(val, constTable, keyframesHashTable, viewTransitionHashTable, tokensTable);
+        }
+        else if (exports.t.isMemberExpression(val)) {
+            const resolved = resolveConstTableMemberExpression(val, constTable);
+            obj[key] = resolved !== undefined ? resolved : '[unresolved]';
+        }
+        else if (exports.t.isIdentifier(val)) {
+            if (constTable[val.value] !== undefined) {
+                obj[key] = constTable[val.value];
+            }
+            else {
+                obj[key] = '[unresolved identifier]';
+            }
+        }
+        else {
+            obj[key] = '[unsupported value type]';
+        }
+    });
+    return obj;
+}
+function collectLocalConsts(ast) {
+    const localConsts = {};
+    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.tokensTable);
+                }
+            }
+        },
+    });
+    return localConsts;
+}
+function getPropertyKey(node, constTable) {
+    if (exports.t.isIdentifier(node)) {
+        if (constTable[node.value] && typeof constTable[node.value] === 'string') {
+            return constTable[node.value];
+        }
+        return node.value;
+    }
+    if (exports.t.isStringLiteral(node)) {
+        return node.value;
+    }
+    if (node.type === 'Computed') {
+        const expr = node.expression;
+        if (exports.t.isStringLiteral(expr)) {
+            return expr.value;
+        }
+        if (exports.t.isIdentifier(expr)) {
+            if (constTable[expr.value] &&
+                typeof constTable[expr.value] === 'string') {
+                return constTable[expr.value];
+            }
+        }
+        if (exports.t.isMemberExpression(expr)) {
+            const result = resolveConstTableMemberExpression(expr, constTable);
+            if (typeof result === 'string')
+                return result;
+        }
+        if (exports.t.isTemplateLiteral(expr)) {
+            return evaluateTemplateLiteral(expr, constTable);
+        }
+        if (exports.t.isBinaryExpression(expr)) {
+            return evaluateBinaryExpression(expr, constTable);
+        }
+        return '';
+    }
+    if (exports.t.isTemplateLiteral(node)) {
+        return evaluateTemplateLiteral(node, constTable);
+    }
+    if (exports.t.isBinaryExpression(node)) {
+        return evaluateBinaryExpression(node, constTable);
+    }
+    return '';
+}
+function evaluateTemplateLiteral(node, constTable) {
+    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);
+            result += String(evaluatedExpr);
+        }
+    }
+    return result;
+}
+function evaluateBinaryExpression(node, constTable) {
+    const left = evaluateExpression(node.left, constTable);
+    const right = evaluateExpression(node.right, constTable);
+    if (node.operator === '+') {
+        return String(left) + String(right);
+    }
+    throw new Error(`Unsupported binary operator: ${node.operator}`);
+}
+function evaluateExpression(node, constTable) {
+    if (exports.t.isStringLiteral(node)) {
+        return node.value;
+    }
+    if (exports.t.isNumericLiteral(node)) {
+        return node.value;
+    }
+    if (exports.t.isBooleanLiteral(node)) {
+        return node.value;
+    }
+    if (exports.t.isNullLiteral(node)) {
+        return null;
+    }
+    if (exports.t.isIdentifier(node)) {
+        if (constTable[node.value] !== undefined) {
+            return constTable[node.value];
+        }
+        if (exports.tables.keyframesHashTable[node.value] !== undefined) {
+            return exports.tables.keyframesHashTable[node.value];
+        }
+        if (exports.tables.viewTransitionHashTable[node.value] !== undefined) {
+            return exports.tables.viewTransitionHashTable[node.value];
+        }
+        return `[unresolved: ${node.value}]`;
+    }
+    if (exports.t.isMemberExpression(node)) {
+        const resolved = resolveConstTableMemberExpression(node, constTable);
+        if (resolved !== undefined) {
+            return resolved;
+        }
+        const resolvedTheme = resolveTokensTableMemberExpressionByNode(node, exports.tables.tokensTable);
+        if (resolvedTheme !== undefined) {
+            return resolvedTheme;
+        }
+        return `[unresolved member expression]`;
+    }
+    if (exports.t.isBinaryExpression(node)) {
+        return evaluateBinaryExpression(node, constTable);
+    }
+    if (exports.t.isTemplateLiteral(node)) {
+        return evaluateTemplateLiteral(node, constTable);
+    }
+    if (exports.t.isUnaryExpression(node)) {
+        return evaluateUnaryExpression(node);
+    }
+    throw new Error(`Unsupported expression type: ${node.type}`);
+}
+function evaluateUnaryExpression(node) {
+    const arg = node.argument;
+    switch (node.operator) {
+        case '-':
+            if (exports.t.isNumericLiteral(arg))
+                return -arg.value;
+            break;
+        case '+':
+            if (exports.t.isNumericLiteral(arg))
+                return +arg.value;
+            break;
+        default:
+            throw new Error(`Unsupported unary operator: ${node.operator}`);
+    }
+    throw new Error(`Unsupported UnaryExpression argument type: ${arg.type}`);
+}
+function resolveKeyframesTableMemberExpression(node, keyframesHashTable) {
+    if (exports.t.isIdentifier(node)) {
+        return keyframesHashTable[node.value];
+    }
+    if (exports.t.isMemberExpression(node)) {
+        if (exports.t.isIdentifier(node.object)) {
+            return keyframesHashTable[node.object.value];
+        }
+    }
+}
+function resolveViewTransitionTableMemberExpression(node, viewTransitionHashTable) {
+    if (exports.t.isIdentifier(node)) {
+        return viewTransitionHashTable[node.value];
+    }
+    if (exports.t.isMemberExpression(node)) {
+        if (exports.t.isIdentifier(node.object)) {
+            return viewTransitionHashTable[node.object.value];
+        }
+    }
+}
+function resolveConstTableMemberExpression(node, constTable) {
+    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];
+        if (tableValue && typeof tableValue === 'object' && key in tableValue) {
+            return tableValue[key];
+        }
+    }
+    return undefined;
+}
+function resolveTokensTableMemberExpressionByNode(node, tokensTable) {
+    if (exports.t.isMemberExpression(node) && exports.t.isIdentifier(node.object)) {
+        const varName = node.object.value;
+        let key;
+        if (exports.t.isIdentifier(node.property)) {
+            key = node.property.value;
+        }
+        else if (node.property.type === 'Computed' &&
+            exports.t.isStringLiteral(node.property.expression)) {
+            key = node.property.expression.value;
+        }
+        if (key &&
+            tokensTable[varName] &&
+            tokensTable[varName][key] !== undefined) {
+            const cssVarName = (0, zss_engine_1.camelToKebabCase)(key);
+            return `var(--${cssVarName})`;
+        }
+    }
+    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.constTable, keyframesHashTableLocal, exports.tables.viewTransitionHashTable, exports.tables.tokensTable);
+                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                    keyframesHashTableLocal[varName] = hash;
+                    keyframesObjectTableLocal[hash] = obj;
+                }
+            }
+        }
+    }
+    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.constTable, exports.tables.keyframesHashTable, viewTransitionHashTableLocal, exports.tables.tokensTable);
+                    const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
+                    viewTransitionHashTableLocal[varName] = hash;
+                    viewTransitionObjectTableLocal[hash] = obj;
+                }
+            }
+        }
+    }
+    return {
+        viewTransitionHashTableLocal,
+        viewTransitionObjectTableLocal,
+    };
+}
+function scanForDefineConsts(addDependency) {
+    const constTableLocal = {};
+    const files = fs_1.default.globSync(PATTERN_PATH, GLOB_OPTIONS);
+    for (const filePath of files) {
+        if (!isCSSDefineFile(filePath, 'defineConsts'))
+            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: 'defineConsts' }) &&
+                    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;
+                }
+            }
+        }
+    }
+    return constTableLocal;
+}
+function scanForDefineTokens(addDependency) {
+    const tokensTableLocal = {};
+    const defineTokensObjectTableLocal = {};
+    const files = fs_1.default.globSync(PATTERN_PATH, GLOB_OPTIONS);
+    for (const filePath of files) {
+        if (!isCSSDefineFile(filePath, 'defineTokens'))
+            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: 'defineTokens' }) &&
+                    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;
+                }
+            }
+        }
+    }
+    return { tokensTableLocal, defineTokensObjectTableLocal };
+}
+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;
+}

package/dist/transform.d.ts

@@ -0,0 +1,5 @@
+import type { CSSProperties, CreateStyleType, CreateTokens, 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 };

package/dist/transform.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTokens = exports.createVars = void 0;
+exports.createCSS = createCSS;
+const zss_engine_1 = require("zss-engine");
+function compileToSingleCSS(object) {
+    const baseSheets = [];
+    const querySheets = [];
+    const processedHashes = new Set();
+    Object.entries(object).forEach(([key, styleObj]) => {
+        const flat = {};
+        const nonFlat = {};
+        (0, zss_engine_1.splitAtomicAndNested)(styleObj, flat, nonFlat);
+        const finalFlat = (0, zss_engine_1.overrideLonghand)(flat);
+        const records = [];
+        Object.entries(finalFlat).forEach(([prop, value]) => {
+            const hashes = new Set();
+            const sheets = new Set();
+            (0, zss_engine_1.processAtomicProps)({ [prop]: value }, hashes, sheets);
+            const hashArray = [...hashes];
+            const sheetArray = [...sheets];
+            const baseSheetParts = [];
+            const baseHashParts = [];
+            const querySheetParts = [];
+            const queryHashParts = [];
+            for (let i = 0; i < sheetArray.length; i++) {
+                const sheet = sheetArray[i];
+                const hash = hashArray[i];
+                if (sheet.includes('@media') || sheet.includes('@container')) {
+                    querySheetParts.push(sheet.replace(`.${hash}`, `.${hash}:not(#\\#)`));
+                    queryHashParts.push(hash);
+                }
+                else {
+                    baseSheetParts.push(sheet);
+                    baseHashParts.push(hash);
+                }
+            }
+            if (baseSheetParts.length > 0) {
+                records.push({
+                    key: prop,
+                    hash: baseHashParts.join(' '),
+                    sheet: baseSheetParts.join(''),
+                });
+            }
+            if (querySheetParts.length > 0) {
+                records.push({
+                    key: prop + '__queries__',
+                    hash: queryHashParts.join(' '),
+                    sheet: querySheetParts.join(''),
+                });
+            }
+        });
+        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;
+            Object.entries(nonFlat).forEach(([atRule, nestedObj]) => {
+                Object.keys(nestedObj).forEach((prop) => {
+                    records.push({
+                        key: atRule + prop,
+                        hash: nonFlatHash,
+                        sheet: finalSheet,
+                    });
+                });
+            });
+        }
+        records.reverse().forEach(({ hash, sheet }) => {
+            if (!processedHashes.has(hash)) {
+                processedHashes.add(hash);
+                if (sheet.includes('@media') || sheet.includes('@container')) {
+                    querySheets.push(sheet);
+                }
+                else {
+                    baseSheets.push(sheet);
+                }
+            }
+        });
+    });
+    return [...baseSheets, ...querySheets].filter(Boolean).join('');
+}
+function createCSS(object) {
+    const compiledCSS = compileToSingleCSS(object);
+    return compiledCSS;
+}
+const createVars = (object) => {
+    const styles = {
+        ':root': {},
+    };
+    Object.entries(object).forEach(([key, value]) => {
+        styles[':root'][`--${key}`] = value;
+    });
+    return styles;
+};
+exports.createVars = createVars;
+const createTokens = (object) => {
+    const styles = {};
+    Object.entries(object).forEach(([key, value]) => {
+        const kebabKey = (0, zss_engine_1.camelToKebabCase)(key);
+        Object.entries(value).forEach(([subKey, subValue]) => {
+            if (subKey.startsWith('@media')) {
+                styles[':root'] ||= {};
+                styles[':root'][subKey] ||= {};
+                styles[':root'][subKey][`--${kebabKey}`] = subValue;
+            }
+            else {
+                const themeSelector = subKey === 'default' ? ':root' : `:root[data-theme="${subKey}"]`;
+                styles[themeSelector] ||= {};
+                styles[themeSelector][`--${kebabKey}`] = subValue;
+            }
+        });
+    });
+    return styles;
+};
+exports.createTokens = createTokens;

package/dist/types.d.ts

@@ -0,0 +1,29 @@
+type CSSPrimitive = string | number | boolean | null;
+type ParseErrorString = `[unresolved]` | `[unresolved identifier]` | `[unsupported value type]` | `[unresolved: ${string}]` | `[unresolved member expression]`;
+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 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 interface Tables {
+    constTable: ConstTable;
+    tokensTable: TokensTable;
+    keyframesHashTable: KeyframesHashTable;
+    keyframesObjectTable: KeyframesObjectTable;
+    viewTransitionHashTable: ViewTransitionHashTable;
+    viewTransitionObjectTable: ViewTransitionObjectTable;
+    defineTokensObjectTable: DefineTokensObjectTable;
+}
+export interface FileStyles {
+    baseStyles?: string;
+    keyframeStyles?: string;
+    viewTransitionStyles?: string;
+    tokenStyles?: string;
+}
+export {};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@plumeria/utils",
+  "version": "0.29.0",
+  "description": "Plumeria Utils",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zss-in-js/plumeria.git",
+    "directory": "packages/utils"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "rimraf dist && pnpm cjs",
+    "cjs": "tsc --project tsconfig.cjs.json"
+  },
+  "dependencies": {
+    "@swc/core": "1.15.2"
+  },
+  "devDependencies": {
+    "zss-engine": "^0.2.102"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}