@plumeria/compiler 0.25.1 → 0.25.3

package/dist/extract.js

@@ -5,10 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generatedTsMap = void 0;
 exports.extractTSFile = extractTSFile;
-exports.restoreAllOriginals = restoreAllOriginals;
 exports.extractVueAndSvelte = extractVueAndSvelte;
 const core_1 = require("@swc/core");
-const fs_1 = __importDefault(require("fs"));
+const promises_1 = require("fs/promises");
 const path_1 = __importDefault(require("path"));
 const generatedTsMap = new Map();
 exports.generatedTsMap = generatedTsMap;
@@ -159,11 +158,14 @@ function expressionToString(expr) {
     console.warn(`css.props: Argument unsupported ${expr.type}: Use css.create instead.`);
     return '';
 }
-function extractCssProps(ast) {
+async function extractCssProps(ast, code) {
     const propsMatches = [];
+    if (code && !code.includes('css.props')) {
+        return propsMatches;
+    }
     try {
-        visit(ast, {
-            CallExpression: (node) => {
+        await visit(ast, {
+            CallExpression: async (node) => {
                 if (node.callee.type === 'MemberExpression' &&
                     node.callee.object.type === 'Identifier' &&
                     node.callee.object.value === 'css' &&
@@ -176,7 +178,7 @@ function extractCssProps(ast) {
                             if (arg.expression.type === 'ConditionalExpression' ||
                                 (arg.expression.type === 'BinaryExpression' &&
                                     arg.expression.operator === '&&')) {
-                                const styles = extractStyleObjectsFromExpression(arg.expression);
+                                const styles = await extractStyleObjectsFromExpression(arg.expression);
                                 conditionalStyleObjects.push(...styles);
                             }
                             else {
@@ -237,23 +239,23 @@ function extractStyleObjectsFromExpression(expression) {
     }
     return [];
 }
-function extractStaticStringLiteralVariable(ast) {
+async function extractStaticStringLiteralVariable(ast) {
     const matches = [];
     try {
-        visit(ast, {
-            VariableDeclaration: (node) => {
+        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 } = (0, core_1.printSync)({
+                    const { code: extractedCode } = await (0, core_1.print)({
                         type: 'Module',
                         body: [node],
                         span: { start: 0, end: 0, ctxt: 0 },
                     });
                     matches.push(extractedCode.trim());
                 }
-            },
-        });
+            }
+        }
     }
     catch (e) {
         console.error(`Failed to parse code to extract static string literal variables: ${e}`);
@@ -286,22 +288,22 @@ function extractCssPropsFromTemplate(code) {
     }
     return matches;
 }
-function visit(node, visitor) {
+async function visit(node, visitor) {
     if (!node)
         return;
     const visitorFunc = visitor[node.type];
     if (visitorFunc) {
-        visitorFunc(node);
+        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]) {
-                    visit(child, visitor);
+                    await visit(child, visitor);
                 }
             }
             else {
-                visit(node[key], visitor);
+                await visit(node[key], visitor);
             }
         }
     }
@@ -336,10 +338,10 @@ function importDeclarationToString(node) {
     }
     return `import '${source}';`;
 }
-function extractImportDeclarations(ast) {
+async function extractImportDeclarations(ast) {
     const importDeclarations = [];
     try {
-        visit(ast, {
+        await visit(ast, {
             ImportDeclaration: (node) => {
                 importDeclarations.push(importDeclarationToString(node));
             },
@@ -350,11 +352,14 @@ function extractImportDeclarations(ast) {
     }
     return importDeclarations.join('\n');
 }
-function extractCssMethod(ast, methodName) {
+async function extractCssMethod(ast, methodName, code) {
+    if (!code.includes(`css.${methodName}`)) {
+        return '';
+    }
     const matches = [];
     try {
-        visit(ast, {
-            VariableDeclaration: (node) => {
+        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' &&
@@ -363,15 +368,15 @@ function extractCssMethod(ast, methodName) {
                     decl.init.callee.property.type === 'Identifier' &&
                     decl.init.callee.property.value === methodName);
                 if (containsCssMethod && node.span) {
-                    const { code: extractedCode } = (0, core_1.printSync)({
+                    const { code: extractedCode } = await (0, core_1.print)({
                         type: 'Module',
                         body: [node],
                         span: { start: 0, end: 0, ctxt: 0 },
                     });
                     matches.push(extractedCode.trim());
                 }
-            },
-        });
+            }
+        }
     }
     catch (e) {
         console.error(`Failed to parse code to extract css.${methodName}: ${e}`);
@@ -382,7 +387,7 @@ 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 = [];
@@ -401,30 +406,29 @@ async function extractVueAndSvelte(filePath) {
         }
     }
     const tsCode = contentLines.join('\n');
+    const tsPath = filePath.replace(ext, '.ts');
     if (!tsCode.trim()) {
-        const tsPath = filePath.replace(ext, '.ts');
-        fs_1.default.writeFileSync(tsPath, '', 'utf8');
-        generatedTsMap.set(filePath, tsPath);
+        generatedTsMap.set(filePath, '');
         return tsPath;
     }
-    const ast = (0, core_1.parseSync)(tsCode, {
+    const ast = await (0, core_1.parse)(tsCode, {
         syntax: 'typescript',
         tsx: true,
     });
-    const propsFromScript = extractCssProps(ast);
+    const propsFromScript = await extractCssProps(ast, code);
     const propsFromTemplate = extractCssPropsFromTemplate(code);
     const propsMatches = [...new Set([...propsFromScript, ...propsFromTemplate])];
     const calls = propsMatches
         .filter(Boolean)
         .map((call) => `${call};`)
         .join('\n');
-    const importSection = extractImportDeclarations(ast);
-    const staticVariableSection = extractStaticStringLiteralVariable(ast);
-    const cssCreateSection = extractCssMethod(ast, 'create');
-    const cssKeyframesSection = extractCssMethod(ast, 'keyframes');
-    const cssViewTransitionSection = extractCssMethod(ast, 'viewTransition');
-    const cssDefineConstsSection = extractCssMethod(ast, 'defineConsts');
-    const cssDefineTokensSection = extractCssMethod(ast, 'defineTokens');
+    const importSection = await extractImportDeclarations(ast);
+    const staticVariableSection = await extractStaticStringLiteralVariable(ast);
+    const cssCreateSection = await extractCssMethod(ast, 'create', code);
+    const cssKeyframesSection = await extractCssMethod(ast, 'keyframes', code);
+    const cssViewTransitionSection = await extractCssMethod(ast, 'viewTransition', code);
+    const cssDefineConstsSection = await extractCssMethod(ast, 'defineConsts', code);
+    const cssDefineTokensSection = await extractCssMethod(ast, 'defineTokens', code);
     let finalCode = '';
     if (importSection)
         finalCode += importSection + '\n';
@@ -442,25 +446,23 @@ async function extractVueAndSvelte(filePath) {
         finalCode += cssCreateSection + '\n';
     if (calls)
         finalCode += calls + '\n';
-    const tsPath = filePath.replace(ext, '.ts');
-    fs_1.default.writeFileSync(tsPath, finalCode, 'utf8');
-    generatedTsMap.set(filePath, tsPath);
-    return tsPath;
+    generatedTsMap.set(filePath, finalCode);
+    return filePath;
 }
 async function extractTSFile(filePath) {
-    const code = fs_1.default.readFileSync(filePath, 'utf8');
-    const ast = (0, core_1.parseSync)(code, {
+    const code = await (0, promises_1.readFile)(filePath, 'utf8');
+    const ast = await (0, core_1.parse)(code, {
         syntax: 'typescript',
         tsx: true,
     });
-    const importSection = extractImportDeclarations(ast);
-    const staticVariableSection = extractStaticStringLiteralVariable(ast);
-    const cssCreateSection = extractCssMethod(ast, 'create');
-    const cssKeyframesSection = extractCssMethod(ast, 'keyframes');
-    const cssViewTransitionSection = extractCssMethod(ast, 'viewTransition');
-    const cssDefineConstsSection = extractCssMethod(ast, 'defineConsts');
-    const cssDefineTokensSection = extractCssMethod(ast, 'defineTokens');
-    const propsMatches = extractCssProps(ast);
+    const importSection = await extractImportDeclarations(ast);
+    const staticVariableSection = await extractStaticStringLiteralVariable(ast);
+    const cssCreateSection = await extractCssMethod(ast, 'create', code);
+    const cssKeyframesSection = await extractCssMethod(ast, 'keyframes', code);
+    const cssViewTransitionSection = await extractCssMethod(ast, 'viewTransition', code);
+    const cssDefineConstsSection = await extractCssMethod(ast, 'defineConsts', code);
+    const cssDefineTokensSection = await extractCssMethod(ast, 'defineTokens', code);
+    const propsMatches = await extractCssProps(ast, code);
     const calls = propsMatches
         .filter(Boolean)
         .map((call) => `${call};`)
@@ -481,27 +483,16 @@ 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);
-    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();
+    generatedTsMap.set(filePath, finalCode);
+    return filePath;
 }
 process.on('uncaughtException', async (error) => {
     console.error('Uncaught Exception:', error);
-    await restoreAllOriginals();
+    generatedTsMap.clear();
     process.exit(1);
 });
 process.on('unhandledRejection', async (reason, promise) => {
     console.error('Unhandled Rejection at:', promise, 'reason:', reason);
-    await restoreAllOriginals();
+    generatedTsMap.clear();
     process.exit(1);
 });

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,193 @@ 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 filesSupportExtensions = await Promise.all(files.map(async (file) => {
+            const ext = path_1.default.extname(file);
+            if (ext === '.vue' || ext === '.svelte') {
+                return await (0, extract_1.extractVueAndSvelte)(file);
+            }
+            else {
+                return await (0, extract_1.extractTSFile)(file);
+            }
+        }));
+        const styleFiles = await Promise.all(filesSupportExtensions.map(async (file) => {
+            const code = extract_1.generatedTsMap.get(file);
+            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 code = extract_1.generatedTsMap.get(file);
+            if (code) {
+                const ext = path_1.default.extname(file);
+                const tsPath = ext === '.vue' || ext === '.svelte' ? file.replace(ext, '.ts') : file;
+                await (0, execute_1.executeCode)(code, { filePath: tsPath });
+                if (process.argv.includes('--paths')) {
+                    console.log(`✅: ${projectName}/${path_1.default.relative(projectRoot, 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();
+        extract_1.generatedTsMap.clear();
+        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.1",
+  "version": "0.25.3",
   "description": "Plumeria Rust-based compiler",
   "repository": {
     "type": "git",
@@ -16,12 +16,12 @@
     "css": "./bin/css.js"
   },
   "dependencies": {
-    "@swc/core": "1.15.0",
+    "@swc/core": "1.15.1",
     "find-up": "^8.0.0",
     "lightningcss": "^1.30.2",
     "postcss": "^8.5.6",
     "postcss-combine-media-query": "^2.1.0",
-    "rscute": "^1.0.0"
+    "rscute": "^1.1.1"
   },
   "publishConfig": {
     "access": "public"