@plumeria/compiler 0.25.0 → 0.25.2

package/dist/extract.js

@@ -7,7 +7,8 @@ exports.generatedTsMap = void 0;
 exports.extractTSFile = extractTSFile;
 exports.restoreAllOriginals = restoreAllOriginals;
 exports.extractVueAndSvelte = extractVueAndSvelte;
-const fs_1 = __importDefault(require("fs"));
+const core_1 = require("@swc/core");
+const promises_1 = require("fs/promises");
 const path_1 = __importDefault(require("path"));
 const generatedTsMap = new Map();
 exports.generatedTsMap = generatedTsMap;
@@ -115,177 +116,273 @@ function isInHtmlText(code, position) {
     }
     return lastCloseTag > lastOpenTag && nextOpenTag > position;
 }
-function extractCssProps(code) {
-    const propsMatches = [];
-    const regex = /css\.props\s*\(/g;
-    let match;
-    while ((match = regex.exec(code))) {
-        if (isInComment(code, match.index) ||
-            isInString(code, match.index) ||
-            isInHtmlText(code, match.index)) {
-            continue;
-        }
-        const startIndex = match.index + match[0].length;
-        let parenCount = 1;
-        let currentIndex = startIndex;
-        let args = '';
-        while (parenCount > 0 && currentIndex < code.length) {
-            const char = code[currentIndex];
-            if (char === '(') {
-                parenCount++;
-            }
-            else if (char === ')') {
-                parenCount--;
+function expressionToString(expr) {
+    switch (expr.type) {
+        case 'Identifier':
+            return expr.value;
+        case 'MemberExpression': {
+            const obj = expressionToString(expr.object);
+            if (obj && expr.property.type === 'Identifier') {
+                return `${obj}.${expr.property.value}`;
             }
-            if (parenCount > 0 || char !== ')') {
-                args += char;
+            break;
+        }
+        case 'CallExpression': {
+            if (expr.callee.type !== 'Super' && expr.callee.type !== 'Import') {
+                const callee = expressionToString(expr.callee);
+                if (callee) {
+                    const args = expr.arguments
+                        .map((arg) => expressionToString(arg.expression))
+                        .join(', ');
+                    return `${callee}(${args})`;
+                }
             }
-            currentIndex++;
+            break;
+        }
+        case 'ObjectExpression': {
+            const properties = expr.properties
+                .map((prop) => {
+                if ('key' in prop && prop.key && prop.key.type === 'Identifier') {
+                    const key = prop.key.value;
+                    const value = expressionToString(prop.value);
+                    return `${key}: ${value}`;
+                }
+                return '[complex property]';
+            })
+                .join(', ');
+            console.warn(`css.props: Argument unsupported ${expr.type}: { ${properties} } Use css.create instead.`);
+            return '';
         }
-        if (parenCount === 0) {
-            const originalArgs = args.split(/\s*,\s*(?![^(]*\))/);
-            const staticArgs = [];
-            const conditionalStyleObjects = [];
-            for (const arg of originalArgs) {
-                const trimmedArg = arg.trim();
-                if (trimmedArg) {
-                    if (trimmedArg.includes('&&') || trimmedArg.includes('?')) {
-                        const styles = parseCssPropsArguments(trimmedArg);
-                        conditionalStyleObjects.push(...styles);
+        case 'StringLiteral':
+            return String(expr.value);
+    }
+    console.warn(`css.props: Argument unsupported ${expr.type}: Use css.create instead.`);
+    return '';
+}
+async function extractCssProps(ast) {
+    const propsMatches = [];
+    try {
+        await visit(ast, {
+            CallExpression: async (node) => {
+                if (node.callee.type === 'MemberExpression' &&
+                    node.callee.object.type === 'Identifier' &&
+                    node.callee.object.value === 'css' &&
+                    node.callee.property.type === 'Identifier' &&
+                    node.callee.property.value === 'props') {
+                    const staticArgs = [];
+                    const conditionalStyleObjects = [];
+                    for (const arg of node.arguments) {
+                        if (arg.expression) {
+                            if (arg.expression.type === 'ConditionalExpression' ||
+                                (arg.expression.type === 'BinaryExpression' &&
+                                    arg.expression.operator === '&&')) {
+                                const styles = await extractStyleObjectsFromExpression(arg.expression);
+                                conditionalStyleObjects.push(...styles);
+                            }
+                            else {
+                                const argStr = expressionToString(arg.expression);
+                                if (argStr) {
+                                    staticArgs.push(argStr);
+                                }
+                            }
+                        }
+                    }
+                    if (staticArgs.length > 0) {
+                        propsMatches.push(`css.props(${staticArgs.join(', ')})`);
                     }
-                    else {
-                        staticArgs.push(trimmedArg);
+                    for (const styleObj of conditionalStyleObjects) {
+                        if (styleObj &&
+                            styleObj !== 'false' &&
+                            styleObj !== 'null' &&
+                            styleObj !== 'undefined') {
+                            propsMatches.push(`css.props(${styleObj})`);
+                        }
                     }
                 }
+            },
+        });
+    }
+    catch (e) {
+        console.error(`Failed to parse code to extract css.props: ${e}`);
+    }
+    return propsMatches;
+}
+function extractStyleObjectsFromExpression(expression) {
+    switch (expression.type) {
+        case 'BinaryExpression':
+            if (expression.operator === '&&') {
+                return extractStyleObjectsFromExpression(expression.right);
             }
-            if (staticArgs.length > 0) {
-                propsMatches.push(`css.props(${staticArgs.join(', ')})`);
-            }
-            for (const styleObj of conditionalStyleObjects) {
-                if (styleObj &&
-                    styleObj !== 'false' &&
-                    styleObj !== 'null' &&
-                    styleObj !== 'undefined') {
-                    propsMatches.push(`css.props(${styleObj})`);
-                }
+            break;
+        case 'ConditionalExpression':
+            return [
+                ...extractStyleObjectsFromExpression(expression.consequent),
+                ...extractStyleObjectsFromExpression(expression.alternate),
+            ];
+        case 'BooleanLiteral':
+        case 'NullLiteral':
+            return [];
+        case 'Identifier':
+            if (expression.value === 'undefined') {
+                return [];
             }
+        case 'ObjectExpression': {
+            const str = expressionToString(expression);
+            return str ? [str] : [];
         }
     }
-    return propsMatches;
+    const str = expressionToString(expression);
+    if (str) {
+        return [str];
+    }
+    return [];
 }
-function extractStaticStringLiteralVariable(code) {
+async function extractStaticStringLiteralVariable(ast) {
     const matches = [];
-    const regex = /\b(?:var|let|const)\s+[a-zA-Z_$][\w$]*\s*=\s*(['"])(.*?)\1\s*;?/gm;
-    let match;
-    while ((match = regex.exec(code))) {
-        const index = match.index;
-        if (isInComment(code, index) ||
-            isInString(code, index) ||
-            isInHtmlText(code, index)) {
-            continue;
+    try {
+        for (const node of ast.body) {
+            if (node.type === 'VariableDeclaration') {
+                const allStringLiterals = node.declarations.length > 0 &&
+                    node.declarations.every((decl) => decl.init && decl.init.type === 'StringLiteral');
+                if (allStringLiterals) {
+                    const { code: extractedCode } = await (0, core_1.print)({
+                        type: 'Module',
+                        body: [node],
+                        span: { start: 0, end: 0, ctxt: 0 },
+                    });
+                    matches.push(extractedCode.trim());
+                }
+            }
         }
-        matches.push(match[0]);
+    }
+    catch (e) {
+        console.error(`Failed to parse code to extract static string literal variables: ${e}`);
     }
     return matches.join('\n');
 }
-function extractCssCreate(code) {
-    const cssCreateMatches = [];
-    const regex = /(?:(?:\s*const\s+[a-zA-Z0-9_$]+\s*=\s*css\.create\([\s\S]*?\);\s*))/g;
+function extractCssPropsFromTemplate(code) {
+    const matches = [];
+    const regex = /css\.props\(([^)]*)\)/g;
     let match;
-    while ((match = regex.exec(code))) {
-        if (isInComment(code, match.index) ||
-            isInString(code, match.index) ||
-            isInHtmlText(code, match.index)) {
+    while ((match = regex.exec(code)) !== null) {
+        const matchStart = match.index;
+        if (isInComment(code, matchStart) ||
+            isInString(code, matchStart) ||
+            isInHtmlText(code, matchStart)) {
             continue;
         }
-        cssCreateMatches.push(match[0]);
-    }
-    return cssCreateMatches.join('\n');
-}
-function extractCssKeyframes(code) {
-    const cssCreateMatches = [];
-    const regex = /(?:(?:\s*const\s+[a-zA-Z0-9_$]+\s*=\s*css\.keyframes\([\s\S]*?\);\s*))/g;
-    let match;
-    while ((match = regex.exec(code))) {
-        if (isInComment(code, match.index) ||
-            isInString(code, match.index) ||
-            isInHtmlText(code, match.index)) {
+        const scriptStartIndex = code.indexOf('<script');
+        const scriptEndIndex = code.indexOf('</script>');
+        if (scriptStartIndex !== -1 &&
+            scriptEndIndex !== -1 &&
+            match.index > scriptStartIndex &&
+            match.index < scriptEndIndex) {
             continue;
         }
-        cssCreateMatches.push(match[0]);
+        const args = match[1];
+        if (args && !args.includes('{') && !args.includes('(')) {
+            matches.push(`css.props(${args})`);
+        }
     }
-    return cssCreateMatches.join('\n');
+    return matches;
 }
-function extractCssViewTransition(code) {
-    const cssCreateMatches = [];
-    const regex = /(?:(?:\s*const\s+[a-zA-Z0-9_$]+\s*=\s*css\.viewTransition\([\s\S]*?\);\s*))/g;
-    let match;
-    while ((match = regex.exec(code))) {
-        if (isInComment(code, match.index) ||
-            isInString(code, match.index) ||
-            isInHtmlText(code, match.index)) {
-            continue;
+async function visit(node, visitor) {
+    if (!node)
+        return;
+    const visitorFunc = visitor[node.type];
+    if (visitorFunc) {
+        await visitorFunc(node);
+    }
+    for (const key in node) {
+        if (typeof node[key] === 'object' && node[key] !== null) {
+            if (Array.isArray(node[key])) {
+                for (const child of node[key]) {
+                    await visit(child, visitor);
+                }
+            }
+            else {
+                await visit(node[key], visitor);
+            }
         }
-        cssCreateMatches.push(match[0]);
     }
-    return cssCreateMatches.join('\n');
 }
-function extractCssDefineConsts(code) {
-    const cssCreateMatches = [];
-    const regex = /(?:(?:\s*const\s+[a-zA-Z0-9_$]+\s*=\s*css\.defineConsts\([\s\S]*?\);\s*))/g;
-    let match;
-    while ((match = regex.exec(code))) {
-        if (isInComment(code, match.index) ||
-            isInString(code, match.index) ||
-            isInHtmlText(code, match.index)) {
-            continue;
-        }
-        cssCreateMatches.push(match[0]);
+function importDeclarationToString(node) {
+    const source = node.source.value;
+    const defaultImport = node.specifiers.find((s) => s.type === 'ImportDefaultSpecifier');
+    const namespaceImport = node.specifiers.find((s) => s.type === 'ImportNamespaceSpecifier');
+    const namedImports = node.specifiers.filter((s) => s.type === 'ImportSpecifier');
+    let importClause = '';
+    if (defaultImport) {
+        importClause += defaultImport.local.value;
+    }
+    if (namespaceImport) {
+        if (importClause)
+            importClause += ', ';
+        importClause += `* as ${namespaceImport.local.value}`;
     }
-    return cssCreateMatches.join('\n');
+    if (namedImports.length > 0) {
+        if (importClause)
+            importClause += ', ';
+        const namedParts = namedImports.map((spec) => {
+            if (spec.imported && spec.imported.value !== spec.local.value) {
+                return `${spec.imported.value} as ${spec.local.value}`;
+            }
+            return spec.local.value;
+        });
+        importClause += `{ ${namedParts.join(', ')} }`;
+    }
+    if (importClause) {
+        return `import ${importClause} from '${source}';`;
+    }
+    return `import '${source}';`;
 }
-function extractCssDefineTokens(code) {
-    const cssCreateMatches = [];
-    const regex = /(?:(?:\s*const\s+[a-zA-Z0-9_$]+\s*=\s*css\.defineTokens\([\s\S]*?\);\s*))/g;
-    let match;
-    while ((match = regex.exec(code))) {
-        if (isInComment(code, match.index) ||
-            isInString(code, match.index) ||
-            isInHtmlText(code, match.index)) {
-            continue;
-        }
-        cssCreateMatches.push(match[0]);
+async function extractImportDeclarations(ast) {
+    const importDeclarations = [];
+    try {
+        await visit(ast, {
+            ImportDeclaration: (node) => {
+                importDeclarations.push(importDeclarationToString(node));
+            },
+        });
+    }
+    catch (e) {
+        console.error(`Failed to parse code to extract import declarations: ${e}`);
     }
-    return cssCreateMatches.join('\n');
+    return importDeclarations.join('\n');
 }
-function parseCssPropsArguments(args) {
-    const results = [];
-    const splitArgs = args.split(/\s*,\s*(?![^(]*\))/);
-    for (const arg of splitArgs) {
-        if (arg.includes('&&')) {
-            const match = arg.match(/&&\s*([^\s,]+)/);
-            if (match) {
-                results.push(match[1]);
-                continue;
-            }
-        }
-        if (arg.includes('?')) {
-            const match = arg.match(/([^?]+)\?([^:]+):(.+)$/);
-            if (match) {
-                results.push(match[2].trim());
-                results.push(match[3].trim());
-                continue;
+async function extractCssMethod(ast, methodName) {
+    const matches = [];
+    try {
+        for (const node of ast.body) {
+            if (node.type === 'VariableDeclaration') {
+                const containsCssMethod = node.declarations.some((decl) => decl.init &&
+                    decl.init.type === 'CallExpression' &&
+                    decl.init.callee.type === 'MemberExpression' &&
+                    decl.init.callee.object.type === 'Identifier' &&
+                    decl.init.callee.object.value === 'css' &&
+                    decl.init.callee.property.type === 'Identifier' &&
+                    decl.init.callee.property.value === methodName);
+                if (containsCssMethod && node.span) {
+                    const { code: extractedCode } = await (0, core_1.print)({
+                        type: 'Module',
+                        body: [node],
+                        span: { start: 0, end: 0, ctxt: 0 },
+                    });
+                    matches.push(extractedCode.trim());
+                }
             }
         }
-        results.push(arg.trim());
     }
-    return results;
+    catch (e) {
+        console.error(`Failed to parse code to extract css.${methodName}: ${e}`);
+    }
+    return matches.join('\n');
 }
 async function extractVueAndSvelte(filePath) {
     const ext = path_1.default.extname(filePath);
     if (!(ext === '.svelte' || ext === '.vue'))
         return filePath;
-    const code = fs_1.default.readFileSync(filePath, 'utf8');
+    const code = await (0, promises_1.readFile)(filePath, 'utf8');
     const lines = code.split(/\r?\n/);
     let inScript = false;
     const contentLines = [];
@@ -304,62 +401,63 @@ async function extractVueAndSvelte(filePath) {
         }
     }
     const tsCode = contentLines.join('\n');
-    const propsMatches = [...extractCssProps(tsCode), ...extractCssProps(code)];
+    const tsPath = filePath.replace(ext, '.ts');
+    if (!tsCode.trim()) {
+        generatedTsMap.set(filePath, '');
+        return tsPath;
+    }
+    const ast = await (0, core_1.parse)(tsCode, {
+        syntax: 'typescript',
+        tsx: true,
+    });
+    const propsFromScript = await extractCssProps(ast);
+    const propsFromTemplate = extractCssPropsFromTemplate(code);
+    const propsMatches = [...new Set([...propsFromScript, ...propsFromTemplate])];
     const calls = propsMatches
         .filter(Boolean)
         .map((call) => `${call};`)
         .join('\n');
-    const importRegex = /^(\s*import\s[^;]+;\s*)+/m;
-    const importMatch = tsCode.match(importRegex);
-    const importSection = importMatch ? importMatch[0] : '';
-    const staticVariableSection = extractStaticStringLiteralVariable(tsCode);
-    const cssCreateSection = extractCssCreate(tsCode);
-    const cssKeyframesSection = extractCssKeyframes(tsCode);
-    const cssViewTransitionSection = extractCssViewTransition(tsCode);
-    const cssDefineConstsSection = extractCssDefineConsts(tsCode);
-    const cssDefineTokensSection = extractCssDefineTokens(tsCode);
+    const importSection = await extractImportDeclarations(ast);
+    const staticVariableSection = await extractStaticStringLiteralVariable(ast);
+    const cssCreateSection = await extractCssMethod(ast, 'create');
+    const cssKeyframesSection = await extractCssMethod(ast, 'keyframes');
+    const cssViewTransitionSection = await extractCssMethod(ast, 'viewTransition');
+    const cssDefineConstsSection = await extractCssMethod(ast, 'defineConsts');
+    const cssDefineTokensSection = await extractCssMethod(ast, 'defineTokens');
     let finalCode = '';
-    if (importSection) {
+    if (importSection)
         finalCode += importSection + '\n';
-    }
-    if (staticVariableSection) {
+    if (staticVariableSection)
         finalCode += staticVariableSection + '\n';
-    }
-    if (cssKeyframesSection) {
+    if (cssKeyframesSection)
         finalCode += cssKeyframesSection + '\n';
-    }
-    if (cssViewTransitionSection) {
+    if (cssViewTransitionSection)
         finalCode += cssViewTransitionSection + '\n';
-    }
-    if (cssDefineConstsSection) {
+    if (cssDefineConstsSection)
         finalCode += cssDefineConstsSection + '\n';
-    }
-    if (cssDefineTokensSection) {
+    if (cssDefineTokensSection)
         finalCode += cssDefineTokensSection + '\n';
-    }
-    if (cssCreateSection) {
+    if (cssCreateSection)
         finalCode += cssCreateSection + '\n';
-    }
-    if (calls) {
+    if (calls)
         finalCode += calls + '\n';
-    }
-    const tsPath = filePath.replace(ext, '.ts');
-    fs_1.default.writeFileSync(tsPath, finalCode, 'utf8');
-    generatedTsMap.set(filePath, tsPath);
+    generatedTsMap.set(filePath, finalCode);
     return tsPath;
 }
 async function extractTSFile(filePath) {
-    const code = fs_1.default.readFileSync(filePath, 'utf8');
-    const importRegex = /^(?:\s*import\s[^;]+;\s*)+/m;
-    const importMatch = code.match(importRegex);
-    const importSection = importMatch ? importMatch[0] : '';
-    const staticVariableSection = extractStaticStringLiteralVariable(code);
-    const cssCreateSection = extractCssCreate(code);
-    const cssKeyframesSection = extractCssKeyframes(code);
-    const cssViewTransitionSection = extractCssViewTransition(code);
-    const cssDefineConstsSection = extractCssDefineConsts(code);
-    const cssDefineTokensSection = extractCssDefineTokens(code);
-    const propsMatches = extractCssProps(code);
+    const code = await (0, promises_1.readFile)(filePath, 'utf8');
+    const ast = await (0, core_1.parse)(code, {
+        syntax: 'typescript',
+        tsx: true,
+    });
+    const importSection = await extractImportDeclarations(ast);
+    const staticVariableSection = await extractStaticStringLiteralVariable(ast);
+    const cssCreateSection = await extractCssMethod(ast, 'create');
+    const cssKeyframesSection = await extractCssMethod(ast, 'keyframes');
+    const cssViewTransitionSection = await extractCssMethod(ast, 'viewTransition');
+    const cssDefineConstsSection = await extractCssMethod(ast, 'defineConsts');
+    const cssDefineTokensSection = await extractCssMethod(ast, 'defineTokens');
+    const propsMatches = await extractCssProps(ast);
     const calls = propsMatches
         .filter(Boolean)
         .map((call) => `${call};`)
@@ -380,18 +478,11 @@ async function extractTSFile(filePath) {
     if (cssCreateSection)
         finalCode += cssCreateSection + '\n';
     finalCode += calls;
-    const ext = path_1.default.extname(filePath);
-    const tempFilePath = filePath.replace(ext, '-temp.ts');
-    fs_1.default.writeFileSync(tempFilePath, finalCode, 'utf8');
-    generatedTsMap.set(filePath, tempFilePath);
+    const tempFilePath = filePath.replace(path_1.default.extname(filePath), '-temp.ts');
+    generatedTsMap.set(filePath, finalCode);
     return tempFilePath;
 }
 async function restoreAllOriginals() {
-    for (const [originalPath, genPath] of generatedTsMap.entries()) {
-        if (genPath !== originalPath && fs_1.default.existsSync(genPath)) {
-            fs_1.default.unlinkSync(genPath);
-        }
-    }
     generatedTsMap.clear();
 }
 process.on('uncaughtException', async (error) => {

package/dist/index.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
-const fs_1 = require("fs");
 const promises_1 = require("fs/promises");
 const postcss_1 = __importDefault(require("postcss"));
 const postcss_combine_media_query_1 = __importDefault(require("postcss-combine-media-query"));
@@ -14,7 +13,7 @@ const core_1 = require("@swc/core");
 const find_up_1 = require("find-up");
 const processors_1 = require("@plumeria/core/processors");
 const extract_1 = require("./extract");
-async function generateStats(buildTime) {
+async function generateStats(buildTime, coreFilePath) {
     const cssCode = await (0, promises_1.readFile)(coreFilePath, 'utf8');
     const cssSize = Buffer.byteLength(cssCode, 'utf8');
     let rules = 0;
@@ -48,177 +47,199 @@ async function generateStats(buildTime) {
     console.log(`Build time:               ${buildTime.toFixed(2)}s`);
     console.log('────────────────────────────\n');
 }
-let projectRoot;
-const workspaceRootFile = (0, find_up_1.findUpSync)((directory) => {
-    const pnpmWsPath = path_1.default.join(directory, 'pnpm-workspace.yaml');
-    if ((0, fs_1.existsSync)(pnpmWsPath)) {
-        return pnpmWsPath;
-    }
-    const pkgJsonPath = path_1.default.join(directory, 'package.json');
-    if ((0, fs_1.existsSync)(pkgJsonPath)) {
+async function main() {
+    let projectRoot;
+    const workspaceRootFile = await (0, find_up_1.findUp)(async (directory) => {
+        const pnpmWsPath = path_1.default.join(directory, 'pnpm-workspace.yaml');
+        try {
+            await (0, promises_1.access)(pnpmWsPath);
+            return pnpmWsPath;
+        }
+        catch {
+        }
+        const pkgJsonPath = path_1.default.join(directory, 'package.json');
         try {
-            const pkgJson = JSON.parse((0, fs_1.readFileSync)(pkgJsonPath, 'utf-8'));
+            await (0, promises_1.access)(pkgJsonPath);
+            const pkgJson = JSON.parse(await (0, promises_1.readFile)(pkgJsonPath, 'utf-8'));
             if (pkgJson.workspaces) {
                 return pkgJsonPath;
             }
         }
-        catch (err) {
-            console.error(err);
+        catch {
         }
-    }
-    return undefined;
-});
-if (workspaceRootFile) {
-    projectRoot = path_1.default.dirname(workspaceRootFile);
-}
-else {
-    const singleProjectRootFile = (0, find_up_1.findUpSync)('package.json');
-    if (singleProjectRootFile) {
-        projectRoot = path_1.default.dirname(singleProjectRootFile);
+        return undefined;
+    });
+    if (workspaceRootFile) {
+        projectRoot = path_1.default.dirname(workspaceRootFile);
     }
     else {
-        projectRoot = process.cwd();
+        const singleProjectRootFile = await (0, find_up_1.findUp)('package.json');
+        if (singleProjectRootFile) {
+            projectRoot = path_1.default.dirname(singleProjectRootFile);
+        }
+        else {
+            projectRoot = process.cwd();
+        }
     }
-}
-let coreFilePath;
-const coreSourcePackageJsonPath = path_1.default.join(process.cwd(), 'package.json');
-const coreSourcePackageJson = JSON.parse((0, fs_1.readFileSync)(coreSourcePackageJsonPath, 'utf-8'));
-const dependencies = {
-    ...coreSourcePackageJson.dependencies,
-    ...coreSourcePackageJson.devDependencies,
-};
-const coreVersion = dependencies['@plumeria/core'];
-const resolvedCorePackageJsonPath = require.resolve('@plumeria/core/package.json', {
-    paths: [projectRoot, process.cwd()],
-});
-if (workspaceRootFile) {
-    if (coreVersion.includes('workspace')) {
-        coreFilePath = path_1.default.join(path_1.default.dirname(resolvedCorePackageJsonPath), 'stylesheet.css');
+    let coreFilePath;
+    const coreSourcePackageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+    const coreSourcePackageJson = JSON.parse(await (0, promises_1.readFile)(coreSourcePackageJsonPath, 'utf-8'));
+    const dependencies = {
+        ...coreSourcePackageJson.dependencies,
+        ...coreSourcePackageJson.devDependencies,
+    };
+    const coreVersion = dependencies['@plumeria/core'];
+    const resolvedCorePackageJsonPath = require.resolve('@plumeria/core/package.json', {
+        paths: [projectRoot, process.cwd()],
+    });
+    if (workspaceRootFile) {
+        if (coreVersion.includes('workspace')) {
+            coreFilePath = path_1.default.join(path_1.default.dirname(resolvedCorePackageJsonPath), 'stylesheet.css');
+        }
+        else {
+            const corePackageJson = JSON.parse(await (0, promises_1.readFile)(resolvedCorePackageJsonPath, 'utf-8'));
+            const exactCoreVersion = corePackageJson.version;
+            coreFilePath = path_1.default.join(projectRoot, 'node_modules', '.pnpm', `@plumeria+core@${exactCoreVersion}`, 'node_modules', '@plumeria', 'core', 'stylesheet.css');
+        }
     }
     else {
-        const corePackageJson = JSON.parse((0, fs_1.readFileSync)(resolvedCorePackageJsonPath, 'utf-8'));
-        const exactCoreVersion = corePackageJson.version;
-        coreFilePath = path_1.default.join(projectRoot, 'node_modules', '.pnpm', `@plumeria+core@${exactCoreVersion}`, 'node_modules', '@plumeria', 'core', 'stylesheet.css');
-    }
-}
-else {
-    coreFilePath = path_1.default.join(path_1.default.dirname(resolvedCorePackageJsonPath), 'stylesheet.css');
-}
-const cleanUp = async () => {
-    if (process.env.CI && (0, fs_1.existsSync)(coreFilePath)) {
-        (0, fs_1.unlinkSync)(coreFilePath);
-        console.log('File deleted successfully');
-    }
-    try {
-        await (0, promises_1.writeFile)(coreFilePath, '', 'utf-8');
-    }
-    catch (err) {
-        console.error('An error occurred:', err);
-    }
-};
-function isCSS(filePath) {
-    if ((0, fs_1.statSync)(filePath).isDirectory()) {
-        return false;
+        coreFilePath = path_1.default.join(path_1.default.dirname(resolvedCorePackageJsonPath), 'stylesheet.css');
     }
-    const code = (0, fs_1.readFileSync)(filePath, 'utf8');
-    const ast = (0, core_1.parseSync)(code, {
-        syntax: 'typescript',
-        tsx: filePath.endsWith('.tsx'),
-        decorators: false,
-        dynamicImport: true,
-    });
-    let found = false;
-    function visit(node) {
-        if (node.type === 'MemberExpression' && node.property?.value) {
-            if (node.object?.type === 'Identifier' && node.object.value === 'css') {
-                if (node.property.value === 'props') {
-                    found = true;
+    const cleanUp = async () => {
+        if (process.env.CI) {
+            try {
+                await (0, promises_1.access)(coreFilePath);
+                await (0, promises_1.unlink)(coreFilePath);
+                console.log('File deleted successfully');
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    console.error(`Error deleting ${coreFilePath}:`, error);
                 }
             }
         }
-        for (const key in node) {
-            const value = node[key];
-            if (value && typeof value === 'object') {
-                if (Array.isArray(value)) {
-                    for (const item of value) {
-                        visit(item);
+        try {
+            await (0, promises_1.writeFile)(coreFilePath, '', 'utf-8');
+        }
+        catch (err) {
+            console.error('An error occurred:', err);
+        }
+    };
+    async function isCSS(code, filePath) {
+        if (!code.includes('css.props')) {
+            return false;
+        }
+        const ast = await (0, core_1.parse)(code, {
+            syntax: 'typescript',
+            tsx: filePath.endsWith('.tsx'),
+            decorators: false,
+            dynamicImport: true,
+        });
+        let found = false;
+        function visit(node) {
+            if (node.type === 'MemberExpression' && node.property?.value) {
+                if (node.object?.type === 'Identifier' && node.object.value === 'css') {
+                    if (node.property.value === 'props') {
+                        found = true;
                     }
                 }
-                else {
-                    visit(value);
+            }
+            for (const key in node) {
+                const value = node[key];
+                if (value && typeof value === 'object') {
+                    if (Array.isArray(value)) {
+                        for (const item of value) {
+                            visit(item);
+                        }
+                    }
+                    else {
+                        visit(value);
+                    }
                 }
             }
         }
-    }
-    visit(ast);
-    return found;
-}
-async function optimizeCSS() {
-    const cssCode = await (0, promises_1.readFile)(coreFilePath, 'utf8');
-    const merged = (0, postcss_1.default)([(0, postcss_combine_media_query_1.default)()]).process(cssCode, {
-        from: coreFilePath,
-        to: coreFilePath,
-    });
-    const light = (0, lightningcss_1.transform)({
-        filename: coreFilePath,
-        code: Buffer.from(merged.css),
-        minify: process.env.NODE_ENV === 'production',
-        targets: {
-            safari: 16,
-            edge: 110,
-            firefox: 110,
-            chrome: 110,
-        },
-    });
-    const optimizedCss = Buffer.from(light.code).toString('utf-8');
-    await (0, promises_1.writeFile)(coreFilePath, optimizedCss, 'utf-8');
-}
-(async () => {
-    const startTime = performance.now();
-    await cleanUp();
-    const scanRoot = process.cwd();
-    const files = (0, fs_1.globSync)('**/*.{js,jsx,ts,tsx,vue,svelte}', {
-        cwd: scanRoot,
-        exclude: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**'],
-    });
-    const projectName = path_1.default.basename(projectRoot);
-    const filesSupportExtensions = [];
-    for (const file of files) {
-        const ext = path_1.default.extname(file);
-        if (ext === '.vue' || ext === '.svelte') {
-            const tsFile = await (0, extract_1.extractVueAndSvelte)(file);
-            filesSupportExtensions.push(tsFile);
-        }
-        else {
-            const tempFile = await (0, extract_1.extractTSFile)(file);
-            filesSupportExtensions.push(tempFile);
+        visit(ast);
+        return found;
+    }
+    async function optimizeCSS() {
+        const cssCode = await (0, promises_1.readFile)(coreFilePath, 'utf8');
+        const merged = (0, postcss_1.default)([(0, postcss_combine_media_query_1.default)()]).process(cssCode, {
+            from: coreFilePath,
+            to: coreFilePath,
+        });
+        const light = (0, lightningcss_1.transform)({
+            filename: coreFilePath,
+            code: Buffer.from(merged.css),
+            minify: process.env.NODE_ENV === 'production',
+            targets: {
+                safari: 16,
+                edge: 110,
+                firefox: 110,
+                chrome: 110,
+            },
+        });
+        const optimizedCss = Buffer.from(light.code).toString('utf-8');
+        await (0, promises_1.writeFile)(coreFilePath, optimizedCss, 'utf-8');
+    }
+    (async () => {
+        const startTime = performance.now();
+        await cleanUp();
+        const scanRoot = process.cwd();
+        const files = [];
+        for await (const entry of (0, promises_1.glob)('**/*.{js,jsx,ts,tsx,vue,svelte}', {
+            cwd: scanRoot,
+            exclude: [
+                '**/node_modules/**',
+                '**/dist/**',
+                '**/build/**',
+                '**/.next/**',
+            ],
+        })) {
+            files.push(entry);
         }
-    }
-    const styleFiles = filesSupportExtensions
-        .filter((file) => isCSS(file))
-        .sort();
-    const tempToOriginalMap = new Map();
-    for (const [original, temp] of extract_1.generatedTsMap.entries()) {
-        tempToOriginalMap.set(temp, original);
-    }
-    for (let i = 0; i < styleFiles.length; i++) {
-        await (0, execute_1.execute)(path_1.default.resolve(styleFiles[i]));
-        if (process.argv.includes('--paths')) {
-            const originalFile = tempToOriginalMap.get(styleFiles[i]);
-            console.log(`✅: ${projectName}/${path_1.default.relative(projectRoot, originalFile)}`);
+        const projectName = path_1.default.basename(projectRoot);
+        const tempToOriginalMap = new Map();
+        const filesSupportExtensions = await Promise.all(files.map(async (file) => {
+            const ext = path_1.default.extname(file);
+            let tempFile;
+            if (ext === '.vue' || ext === '.svelte') {
+                tempFile = await (0, extract_1.extractVueAndSvelte)(file);
+            }
+            else {
+                tempFile = await (0, extract_1.extractTSFile)(file);
+            }
+            tempToOriginalMap.set(tempFile, file);
+            return tempFile;
+        }));
+        const styleFiles = await Promise.all(filesSupportExtensions.map(async (file) => {
+            const originalFile = tempToOriginalMap.get(file);
+            const code = extract_1.generatedTsMap.get(originalFile);
+            const isCssFile = code ? await isCSS(code, file) : false;
+            return isCssFile ? file : null;
+        }))
+            .then((results) => results.filter(Boolean))
+            .then((results) => results.sort());
+        for (const file of styleFiles) {
+            const originalFile = tempToOriginalMap.get(file);
+            const code = extract_1.generatedTsMap.get(originalFile);
+            if (code) {
+                await (0, promises_1.writeFile)(file, code, 'utf8');
+                await (0, execute_1.execute)(path_1.default.resolve(file));
+                if (process.argv.includes('--paths')) {
+                    console.log(`✅: ${projectName}/${path_1.default.relative(projectRoot, originalFile)}`);
+                }
+                await (0, promises_1.unlink)(file);
+            }
         }
-    }
-    for (let i = 0; i < styleFiles.length; i++) {
         await (0, processors_1.buildGlobal)(coreFilePath);
-    }
-    for (let i = 0; i < styleFiles.length; i++) {
         await (0, processors_1.buildProps)(coreFilePath);
-    }
-    await optimizeCSS();
-    await (0, extract_1.restoreAllOriginals)();
-    if (process.argv.includes('--stats')) {
-        const endTime = performance.now();
-        const buildTime = (endTime - startTime) / 1000;
-        await generateStats(buildTime);
-    }
-})();
+        await optimizeCSS();
+        await (0, extract_1.restoreAllOriginals)();
+        if (process.argv.includes('--stats')) {
+            const endTime = performance.now();
+            const buildTime = (endTime - startTime) / 1000;
+            await generateStats(buildTime, coreFilePath);
+        }
+    })();
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/compiler",
-  "version": "0.25.0",
+  "version": "0.25.2",
   "description": "Plumeria Rust-based compiler",
   "repository": {
     "type": "git",
@@ -21,7 +21,7 @@
     "lightningcss": "^1.30.2",
     "postcss": "^8.5.6",
     "postcss-combine-media-query": "^2.1.0",
-    "rscute": "^1.0.0"
+    "rscute": "^1.0.2"
   },
   "publishConfig": {
     "access": "public"