@plumeria/compiler 0.20.4 → 0.21.0

package/dist/extract.js

@@ -1,7 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const fs = require('fs');
-const path = require('path');
+exports.extractTSFile = extractTSFile;
+exports.restoreAllOriginals = restoreAllOriginals;
+exports.extractVueAndSvelte = extractVueAndSvelte;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const generatedTsMap = new Map();
 function isInComment(code, position) {
     const beforePosition = code.substring(0, position);
@@ -274,10 +280,10 @@ function parseCssPropsArguments(args) {
     return results;
 }
 async function extractVueAndSvelte(filePath) {
-    const ext = path.extname(filePath);
+    const ext = path_1.default.extname(filePath);
     if (!(ext === '.svelte' || ext === '.vue'))
         return filePath;
-    const code = fs.readFileSync(filePath, 'utf8');
+    const code = fs_1.default.readFileSync(filePath, 'utf8');
     const lines = code.split(/\r?\n/);
     let inScript = false;
     const contentLines = [];
@@ -336,12 +342,12 @@ async function extractVueAndSvelte(filePath) {
         finalCode += calls + '\n';
     }
     const tsPath = filePath.replace(ext, '.ts');
-    fs.writeFileSync(tsPath, finalCode, 'utf8');
+    fs_1.default.writeFileSync(tsPath, finalCode, 'utf8');
     generatedTsMap.set(filePath, tsPath);
     return tsPath;
 }
 async function extractTSFile(filePath) {
-    const code = fs.readFileSync(filePath, 'utf8');
+    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] : '';
@@ -372,16 +378,16 @@ async function extractTSFile(filePath) {
     if (cssCreateSection)
         finalCode += cssCreateSection + '\n';
     finalCode += calls;
-    const ext = path.extname(filePath);
+    const ext = path_1.default.extname(filePath);
     const tempFilePath = filePath.replace(ext, '-temp.ts');
-    fs.writeFileSync(tempFilePath, finalCode, 'utf8');
+    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.existsSync(genPath)) {
-            fs.unlinkSync(genPath);
+        if (genPath !== originalPath && fs_1.default.existsSync(genPath)) {
+            fs_1.default.unlinkSync(genPath);
         }
     }
     generatedTsMap.clear();
@@ -396,8 +402,3 @@ process.on('unhandledRejection', async (reason, promise) => {
     await restoreAllOriginals();
     process.exit(1);
 });
-module.exports = {
-    extractTSFile,
-    restoreAllOriginals,
-    extractVueAndSvelte,
-};

package/dist/index.js

@@ -1,28 +1,63 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const path = require('path');
-const fs = require('fs');
-const { unlinkSync, existsSync, readFileSync, statSync } = require('fs');
-const { readFile, writeFile } = require('fs/promises');
-const { glob } = require('@rust-gear/glob');
-const postcss = require('postcss');
-const combineMediaQuery = require('postcss-combine-media-query');
-const { execute } = require('rscute/execute');
-const { transform: lightningCSSTransform } = require('lightningcss');
-const { parseSync } = require('@swc/core');
-const { findUpSync } = require('find-up');
-const { buildGlobal, buildProps } = require('@plumeria/core/processors');
-const { extractTSFile, restoreAllOriginals, extractVueAndSvelte, } = require('./extract');
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importStar(require("fs"));
+const promises_1 = require("fs/promises");
+const glob_1 = require("@rust-gear/glob");
+const postcss_1 = __importDefault(require("postcss"));
+const postcss_combine_media_query_1 = __importDefault(require("postcss-combine-media-query"));
+const execute_1 = require("rscute/execute");
+const lightningcss_1 = require("lightningcss");
+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");
 let projectRoot;
-const workspaceRootFile = findUpSync((directory) => {
-    const pnpmWsPath = path.join(directory, 'pnpm-workspace.yaml');
-    if (fs.existsSync(pnpmWsPath)) {
+const workspaceRootFile = (0, find_up_1.findUpSync)((directory) => {
+    const pnpmWsPath = path_1.default.join(directory, 'pnpm-workspace.yaml');
+    if (fs_1.default.existsSync(pnpmWsPath)) {
         return pnpmWsPath;
     }
-    const pkgJsonPath = path.join(directory, 'package.json');
-    if (fs.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path_1.default.join(directory, 'package.json');
+    if (fs_1.default.existsSync(pkgJsonPath)) {
         try {
-            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+            const pkgJson = JSON.parse(fs_1.default.readFileSync(pkgJsonPath, 'utf-8'));
             if (pkgJson.workspaces) {
                 return pkgJsonPath;
             }
@@ -34,20 +69,20 @@ const workspaceRootFile = findUpSync((directory) => {
     return undefined;
 });
 if (workspaceRootFile) {
-    projectRoot = path.dirname(workspaceRootFile);
+    projectRoot = path_1.default.dirname(workspaceRootFile);
 }
 else {
-    const singleProjectRootFile = findUpSync('package.json');
+    const singleProjectRootFile = (0, find_up_1.findUpSync)('package.json');
     if (singleProjectRootFile) {
-        projectRoot = path.dirname(singleProjectRootFile);
+        projectRoot = path_1.default.dirname(singleProjectRootFile);
     }
     else {
         projectRoot = process.cwd();
     }
 }
 let coreFilePath;
-const coreSourcePackageJsonPath = path.join(process.cwd(), 'package.json');
-const coreSourcePackageJson = JSON.parse(fs.readFileSync(coreSourcePackageJsonPath, 'utf-8'));
+const coreSourcePackageJsonPath = path_1.default.join(process.cwd(), 'package.json');
+const coreSourcePackageJson = JSON.parse(fs_1.default.readFileSync(coreSourcePackageJsonPath, 'utf-8'));
 const dependencies = {
     ...coreSourcePackageJson.dependencies,
     ...coreSourcePackageJson.devDependencies,
@@ -58,35 +93,35 @@ const resolvedCorePackageJsonPath = require.resolve('@plumeria/core/package.json
 });
 if (workspaceRootFile) {
     if (coreVersion.includes('workspace')) {
-        coreFilePath = path.join(path.dirname(resolvedCorePackageJsonPath), 'stylesheet.css');
+        coreFilePath = path_1.default.join(path_1.default.dirname(resolvedCorePackageJsonPath), 'stylesheet.css');
     }
     else {
-        const corePackageJson = JSON.parse(fs.readFileSync(resolvedCorePackageJsonPath, 'utf-8'));
+        const corePackageJson = JSON.parse(fs_1.default.readFileSync(resolvedCorePackageJsonPath, 'utf-8'));
         const exactCoreVersion = corePackageJson.version;
-        coreFilePath = path.join(projectRoot, 'node_modules', '.pnpm', `@plumeria+core@${exactCoreVersion}`, 'node_modules', '@plumeria', 'core', 'stylesheet.css');
+        coreFilePath = path_1.default.join(projectRoot, 'node_modules', '.pnpm', `@plumeria+core@${exactCoreVersion}`, 'node_modules', '@plumeria', 'core', 'stylesheet.css');
     }
 }
 else {
-    coreFilePath = path.join(path.dirname(resolvedCorePackageJsonPath), 'stylesheet.css');
+    coreFilePath = path_1.default.join(path_1.default.dirname(resolvedCorePackageJsonPath), 'stylesheet.css');
 }
 const cleanUp = async () => {
-    if (process.env.CI && existsSync(coreFilePath)) {
-        unlinkSync(coreFilePath);
+    if (process.env.CI && (0, fs_1.existsSync)(coreFilePath)) {
+        (0, fs_1.unlinkSync)(coreFilePath);
         console.log('File deleted successfully');
     }
     try {
-        await writeFile(coreFilePath, '', 'utf-8');
+        await (0, promises_1.writeFile)(coreFilePath, '', 'utf-8');
     }
     catch (err) {
         console.error('An error occurred:', err);
     }
 };
 function isCSS(filePath) {
-    if (statSync(filePath).isDirectory()) {
+    if ((0, fs_1.statSync)(filePath).isDirectory()) {
         return false;
     }
-    const code = readFileSync(filePath, 'utf8');
-    const ast = parseSync(code, {
+    const code = (0, fs_1.readFileSync)(filePath, 'utf8');
+    const ast = (0, core_1.parseSync)(code, {
         syntax: 'typescript',
         tsx: filePath.endsWith('.tsx'),
         decorators: false,
@@ -119,12 +154,12 @@ function isCSS(filePath) {
     return found;
 }
 async function optimizeCSS() {
-    const cssCode = await readFile(coreFilePath, 'utf8');
-    const merged = postcss([combineMediaQuery()]).process(cssCode, {
+    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 = lightningCSSTransform({
+    const light = (0, lightningcss_1.transform)({
         filename: coreFilePath,
         code: Buffer.from(merged.css),
         minify: process.env.NODE_ENV === 'production',
@@ -136,26 +171,25 @@ async function optimizeCSS() {
         },
     });
     const optimizedCss = Buffer.from(light.code).toString('utf-8');
-    await writeFile(coreFilePath, optimizedCss, 'utf-8');
+    await (0, promises_1.writeFile)(coreFilePath, optimizedCss, 'utf-8');
 }
 (async () => {
     await cleanUp();
     const scanRoot = process.cwd();
-    const files = await glob('**/*.{js,jsx,ts,tsx,vue,svelte}', {
+    const files = await (0, glob_1.glob)('**/*.{js,jsx,ts,tsx,vue,svelte}', {
         cwd: scanRoot,
-        absolute: true,
         exclude: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**'],
     });
-    const projectName = path.basename(projectRoot);
+    const projectName = path_1.default.basename(projectRoot);
     const filesSupportExtensions = [];
     for (const file of files) {
-        const ext = path.extname(file);
+        const ext = path_1.default.extname(file);
         if (ext === '.vue' || ext === '.svelte') {
-            const tsFile = await extractVueAndSvelte(file);
+            const tsFile = await (0, extract_1.extractVueAndSvelte)(file);
             filesSupportExtensions.push(tsFile);
         }
         else {
-            const tempFile = await extractTSFile(file);
+            const tempFile = await (0, extract_1.extractTSFile)(file);
             filesSupportExtensions.push(tempFile);
         }
     }
@@ -163,16 +197,16 @@ async function optimizeCSS() {
         .filter((file) => isCSS(file))
         .sort();
     for (let i = 0; i < styleFiles.length; i++) {
-        await execute(path.resolve(styleFiles[i]));
+        await (0, execute_1.execute)(path_1.default.resolve(styleFiles[i]));
         if (process.argv.includes('--paths'))
-            console.log(`✅: ${projectName}/${path.relative(projectRoot, styleFiles[i])}`);
+            console.log(`✅: ${projectName}/${path_1.default.relative(projectRoot, styleFiles[i])}`);
     }
     for (let i = 0; i < styleFiles.length; i++) {
-        await buildGlobal(coreFilePath);
+        await (0, processors_1.buildGlobal)(coreFilePath);
     }
     for (let i = 0; i < styleFiles.length; i++) {
-        await buildProps(coreFilePath);
+        await (0, processors_1.buildProps)(coreFilePath);
     }
     await optimizeCSS();
-    await restoreAllOriginals();
+    await (0, extract_1.restoreAllOriginals)();
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/compiler",
-  "version": "0.20.4",
+  "version": "0.21.0",
   "description": "Plumeria Rust-based compiler",
   "repository": {
     "type": "git",