@nlabs/lex 1.49.4 → 1.50.0

package/lib/commands/compile/compile.js

@@ -1,241 +1,228 @@
-import { execa } from "execa";
-import { existsSync, lstatSync, readdirSync } from "fs";
-import { sync as globSync } from "glob";
-import { extname as pathExtname, join as pathJoin, resolve as pathResolve } from "path";
-import { LexConfig, getTypeScriptConfigPath } from "../../LexConfig.js";
-import { checkLinkedModules, copyConfiguredFiles, copyFiles, createSpinner, getFilesByExt, removeFiles } from "../../utils/app.js";
-import { getDirName, resolveBinaryPath } from "../../utils/file.js";
-import { log } from "../../utils/log.js";
-const hasFileType = (startPath, ext) => {
-  if (!existsSync(startPath)) {
-    return false;
-  }
-  const files = readdirSync(startPath);
-  return files.some((file) => {
-    const filename = pathJoin(startPath, file);
-    const fileExt = pathExtname(filename);
-    const stat = lstatSync(filename);
-    if (stat.isDirectory()) {
-      return hasFileType(filename, ext);
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { transform } from '@swc/core';
+import { execa } from 'execa';
+import { existsSync, lstatSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { sync as globSync } from 'glob';
+import { extname as pathExtname, join as pathJoin, resolve as pathResolve, dirname } from 'path';
+import { LexConfig, getTypeScriptConfigPath } from '../../LexConfig.js';
+import { checkLinkedModules, copyConfiguredFiles, copyFiles, createSpinner, getFilesByExt, removeFiles } from '../../utils/app.js';
+import { getDirName, resolveBinaryPath } from '../../utils/file.js';
+import { log } from '../../utils/log.js';
+export const hasFileType = (startPath, ext)=>{
+    if (!existsSync(startPath)) {
+        return false;
     }
-    return ext.includes(fileExt);
-  });
+    const files = readdirSync(startPath);
+    return files.some((file)=>{
+        const filename = pathJoin(startPath, file);
+        const fileExt = pathExtname(filename);
+        const stat = lstatSync(filename);
+        if (stat.isDirectory()) {
+            return hasFileType(filename, ext);
+        }
+        return ext.includes(fileExt);
+    });
 };
-const compile = async (cmd, callback = () => ({})) => {
-  const {
-    cliName = "Lex",
-    config,
-    outputPath,
-    quiet,
-    remove,
-    sourcePath,
-    watch
-  } = cmd;
-  const spinner = createSpinner(quiet);
-  log(`${cliName} compiling...`, "info", quiet);
-  await LexConfig.parseConfig(cmd);
-  const { outputFullPath, sourceFullPath, useTypescript } = LexConfig.config;
-  const outputDir = outputPath || outputFullPath;
-  const sourceDir = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath || "";
-  const dirName = getDirName();
-  const dirPath = pathResolve(dirName, "../..");
-  checkLinkedModules();
-  if (remove) {
-    await removeFiles(outputDir);
-  }
-  if (useTypescript) {
-    LexConfig.checkCompileTypescriptConfig();
-    const typescriptPath = resolveBinaryPath("tsc", "typescript");
-    if (!typescriptPath) {
-      log(`
-${cliName} Error: TypeScript binary not found in Lex's node_modules or monorepo root`, "error", quiet);
-      log("Please reinstall Lex or check your installation.", "info", quiet);
-      return 1;
+export const compile = async (cmd, callback = ()=>({}))=>{
+    const { cliName = 'Lex', config, format = 'esm', outputPath, quiet, remove, sourcePath, watch } = cmd;
+    const spinner = createSpinner(quiet);
+    log(`${cliName} compiling...`, 'info', quiet);
+    await LexConfig.parseConfig(cmd);
+    const { outputFullPath, sourceFullPath, swc: swcConfig, useTypescript } = LexConfig.config;
+    const outputDir = outputPath || outputFullPath;
+    const sourceDir = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath || '';
+    const dirName = getDirName();
+    const dirPath = pathResolve(dirName, '../..');
+    checkLinkedModules();
+    if (remove) {
+        await removeFiles(outputDir);
     }
-    const typescriptOptions = config ? ["-p", config] : ["-p", getTypeScriptConfigPath("tsconfig.build.json")];
-    spinner.start("Static type checking with Typescript...");
-    try {
-      await execa(typescriptPath, typescriptOptions, { encoding: "utf8" });
-      spinner.succeed("Successfully completed type checking!");
-    } catch (error) {
-      log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-      spinner.fail("Type checking failed.");
-      callback(1);
-      return 1;
+    if (useTypescript) {
+        LexConfig.checkCompileTypescriptConfig();
+        const typescriptPath = resolveBinaryPath('tsc', 'typescript');
+        if (!typescriptPath) {
+            log(`\n${cliName} Error: TypeScript binary not found in Lex's node_modules or monorepo root`, 'error', quiet);
+            log('Please reinstall Lex or check your installation.', 'info', quiet);
+            return 1;
+        }
+        const typescriptOptions = config ? [
+            '-p',
+            config
+        ] : [
+            '-p',
+            getTypeScriptConfigPath('tsconfig.build.json')
+        ];
+        spinner.start('Static type checking with Typescript...');
+        try {
+            await execa(typescriptPath, typescriptOptions, {
+                encoding: 'utf8'
+            });
+            spinner.succeed('Successfully completed type checking!');
+        } catch (error) {
+            log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+            spinner.fail('Type checking failed.');
+            callback(1);
+            return 1;
+        }
     }
-  }
-  const globOptions = {
-    cwd: sourceDir,
-    dot: false,
-    nodir: true,
-    nosort: true
-  };
-  const tsFiles = globSync(`${sourceDir}/**/!(*.spec|*.test|*.integration).ts*`, globOptions);
-  const jsFiles = globSync(`${sourceDir}/**/!(*.spec|*.test|*.integration).js`, globOptions);
-  const sourceFiles = [...tsFiles, ...jsFiles];
-  const esbuildConfig = LexConfig.config.esbuild || {};
-  const isProduction = process.env.NODE_ENV === "production";
-  let shouldMinify;
-  if (typeof esbuildConfig.minify === "boolean") {
-    shouldMinify = esbuildConfig.minify;
-  } else {
-    shouldMinify = isProduction;
-  }
-  const esbuildPath = resolveBinaryPath("esbuild", "esbuild");
-  if (!esbuildPath) {
-    log(`
-${cliName} Error: esbuild binary not found in Lex's node_modules or monorepo root`, "error", quiet);
-    log("Please reinstall Lex or check your installation.", "info", quiet);
-    return 1;
-  }
-  const esbuildOptions = [
-    ...sourceFiles,
-    "--color=true",
-    `--format=${esbuildConfig.format || "esm"}`,
-    `--outdir=${outputDir}`,
-    `--platform=${esbuildConfig.platform || "node"}`,
-    `--sourcemap=${esbuildConfig.sourcemap || "inline"}`,
-    `--target=${esbuildConfig.target || "node20"}`
-  ];
-  if (shouldMinify) {
-    esbuildOptions.push("--minify");
-  }
-  if (esbuildConfig.treeShaking !== false) {
-    esbuildOptions.push("--tree-shaking=true");
-  }
-  if (esbuildConfig.drop && esbuildConfig.drop.length > 0) {
-    esbuildConfig.drop.forEach((item) => {
-      esbuildOptions.push(`--drop:${item}`);
-    });
-  }
-  if (esbuildConfig.pure && esbuildConfig.pure.length > 0) {
-    esbuildConfig.pure.forEach((item) => {
-      esbuildOptions.push(`--pure:${item}`);
-    });
-  }
-  if (esbuildConfig.legalComments) {
-    esbuildOptions.push(`--legal-comments=${esbuildConfig.legalComments}`);
-  }
-  if (esbuildConfig.banner) {
-    Object.entries(esbuildConfig.banner).forEach(([type, content]) => {
-      esbuildOptions.push(`--banner:${type}=${content}`);
-    });
-  }
-  if (esbuildConfig.footer) {
-    Object.entries(esbuildConfig.footer).forEach(([type, content]) => {
-      esbuildOptions.push(`--footer:${type}=${content}`);
-    });
-  }
-  if (esbuildConfig.define) {
-    Object.entries(esbuildConfig.define).forEach(([key, value]) => {
-      esbuildOptions.push(`--define:${key}=${value}`);
-    });
-  }
-  if (watch) {
-    esbuildOptions.push("--watch");
-  }
-  const cssFiles = getFilesByExt(".css", LexConfig.config);
-  if (cssFiles.length) {
-    const postcssPath = resolveBinaryPath("postcss", "postcss-cli");
-    if (!postcssPath) {
-      log(`
-${cliName} Error: PostCSS binary not found in Lex's node_modules or monorepo root`, "error", quiet);
-      log("Please reinstall Lex or check your installation.", "info", quiet);
-      return 1;
+    const globOptions = {
+        cwd: sourceDir,
+        dot: false,
+        nodir: true,
+        nosort: true
+    };
+    const tsFiles = globSync(`${sourceDir}/**/!(*.spec|*.test|*.integration).ts*`, globOptions);
+    const jsFiles = globSync(`${sourceDir}/**/!(*.spec|*.test|*.integration).js`, globOptions);
+    const sourceFiles = [
+        ...tsFiles,
+        ...jsFiles
+    ];
+    const cssFiles = getFilesByExt('.css', LexConfig.config);
+    if (cssFiles.length) {
+        const postcssPath = resolveBinaryPath('postcss', 'postcss-cli');
+        if (!postcssPath) {
+            log(`\n${cliName} Error: PostCSS binary not found in Lex's node_modules or monorepo root`, 'error', quiet);
+            log('Please reinstall Lex or check your installation.', 'info', quiet);
+            return 1;
+        }
+        const postcssOptions = [
+            `${sourceDir}/**/**.css`,
+            '--base',
+            sourceDir,
+            '--dir',
+            outputDir,
+            '--config',
+            pathResolve(dirName, '../../postcss.config.js')
+        ];
+        try {
+            await execa(postcssPath, postcssOptions, {
+                encoding: 'utf8'
+            });
+            spinner.succeed(`Successfully formatted ${cssFiles.length} css files!`);
+        } catch (error) {
+            log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+            spinner.fail('Failed formatting css.');
+            callback(1);
+            return 1;
+        }
     }
-    const postcssOptions = [
-      `${sourceDir}/**/**.css`,
-      "--base",
-      sourceDir,
-      "--dir",
-      outputDir,
-      "--config",
-      pathResolve(dirName, "../../postcss.config.js")
+    const gifFiles = getFilesByExt('.gif', LexConfig.config);
+    const jpgFiles = getFilesByExt('.jpg', LexConfig.config);
+    const pngFiles = getFilesByExt('.png', LexConfig.config);
+    const svgFiles = getFilesByExt('.svg', LexConfig.config);
+    const imageFiles = [
+        ...gifFiles,
+        ...jpgFiles,
+        ...pngFiles,
+        ...svgFiles
     ];
-    try {
-      await execa(postcssPath, postcssOptions, { encoding: "utf8" });
-      spinner.succeed(`Successfully formatted ${cssFiles.length} css files!`);
-    } catch (error) {
-      log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-      spinner.fail("Failed formatting css.");
-      callback(1);
-      return 1;
+    if (imageFiles.length) {
+        try {
+            await copyFiles(imageFiles, 'image', spinner, LexConfig.config);
+        } catch (error) {
+            log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+            spinner.fail('Failed to move images to output directory.');
+            callback(1);
+            return 1;
+        }
     }
-  }
-  const gifFiles = getFilesByExt(".gif", LexConfig.config);
-  const jpgFiles = getFilesByExt(".jpg", LexConfig.config);
-  const pngFiles = getFilesByExt(".png", LexConfig.config);
-  const svgFiles = getFilesByExt(".svg", LexConfig.config);
-  const imageFiles = [...gifFiles, ...jpgFiles, ...pngFiles, ...svgFiles];
-  if (imageFiles.length) {
-    try {
-      await copyFiles(imageFiles, "image", spinner, LexConfig.config);
-    } catch (error) {
-      log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-      spinner.fail("Failed to move images to output directory.");
-      callback(1);
-      return 1;
+    const ttfFiles = getFilesByExt('.ttf', LexConfig.config);
+    const otfFiles = getFilesByExt('.otf', LexConfig.config);
+    const woffFiles = getFilesByExt('.woff', LexConfig.config);
+    const woff2Files = getFilesByExt('.woff2', LexConfig.config);
+    const fontFiles = [
+        ...ttfFiles,
+        ...otfFiles,
+        ...woffFiles,
+        ...woff2Files
+    ];
+    if (fontFiles.length) {
+        try {
+            await copyFiles(fontFiles, 'font', spinner, LexConfig.config);
+        } catch (error) {
+            log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+            spinner.fail('Failed to move fonts to output directory.');
+            callback(1);
+            return 1;
+        }
     }
-  }
-  const ttfFiles = getFilesByExt(".ttf", LexConfig.config);
-  const otfFiles = getFilesByExt(".otf", LexConfig.config);
-  const woffFiles = getFilesByExt(".woff", LexConfig.config);
-  const woff2Files = getFilesByExt(".woff2", LexConfig.config);
-  const fontFiles = [...ttfFiles, ...otfFiles, ...woffFiles, ...woff2Files];
-  if (fontFiles.length) {
-    try {
-      await copyFiles(fontFiles, "font", spinner, LexConfig.config);
-    } catch (error) {
-      log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-      spinner.fail("Failed to move fonts to output directory.");
-      callback(1);
-      return 1;
+    const mdFiles = getFilesByExt('.md', LexConfig.config);
+    if (mdFiles.length) {
+        try {
+            await copyFiles(mdFiles, 'documents', spinner, LexConfig.config);
+        } catch (error) {
+            log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+            spinner.fail('Failed to move docs to output directory.');
+            callback(1);
+            return 1;
+        }
     }
-  }
-  const mdFiles = getFilesByExt(".md", LexConfig.config);
-  if (mdFiles.length) {
+    spinner.start(watch ? 'Watching for changes...' : 'Compiling with SWC...');
     try {
-      await copyFiles(mdFiles, "documents", spinner, LexConfig.config);
+        // Compile each file with SWC
+        for (const file of sourceFiles){
+            const sourcePath = pathResolve(sourceDir, file);
+            const outputPath = pathResolve(outputDir, file.replace(/\.(ts|tsx)$/, '.js'));
+            // Ensure output directory exists
+            const outputDirPath = dirname(outputPath);
+            if (!existsSync(outputDirPath)) {
+                mkdirSync(outputDirPath, {
+                    recursive: true
+                });
+            }
+            const sourceCode = readFileSync(sourcePath, 'utf8');
+            const isTSX = file.endsWith('.tsx');
+            // Merge SWC config with command-specific overrides
+            const swcOptions = {
+                filename: file,
+                ...swcConfig,
+                jsc: {
+                    ...swcConfig?.jsc,
+                    parser: {
+                        decorators: swcConfig?.jsc?.parser?.decorators ?? true,
+                        dynamicImport: swcConfig?.jsc?.parser?.dynamicImport ?? true,
+                        syntax: 'typescript',
+                        tsx: isTSX
+                    },
+                    target: swcConfig?.jsc?.target ?? 'es2020',
+                    transform: isTSX ? {
+                        ...swcConfig?.jsc?.transform,
+                        react: {
+                            runtime: 'automatic',
+                            ...swcConfig?.jsc?.transform?.react
+                        }
+                    } : swcConfig?.jsc?.transform
+                },
+                module: {
+                    ...swcConfig?.module,
+                    type: format === 'cjs' ? 'commonjs' : swcConfig?.module?.type || 'es6'
+                }
+            };
+            const result = await transform(sourceCode, swcOptions);
+            writeFileSync(outputPath, result.code);
+        }
+        spinner.succeed('Compile completed successfully!');
     } catch (error) {
-      log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-      spinner.fail("Failed to move docs to output directory.");
-      callback(1);
-      return 1;
+        log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+        if (!quiet) {
+            console.error(error);
+        }
+        spinner.fail('Code compiling failed.');
+        callback(1);
+        return 1;
     }
-  }
-  spinner.start(watch ? "Watching for changes..." : "Compiling with ESBuild...");
-  try {
-    await execa(esbuildPath, esbuildOptions, { encoding: "utf8" });
-    spinner.succeed("Compile completed successfully!");
-  } catch (error) {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    if (!quiet) {
-      console.error(error);
+    try {
+        await copyConfiguredFiles(spinner, LexConfig.config, quiet);
+    } catch (copyError) {
+        log(`\n${cliName} Error: Failed to copy configured files: ${copyError.message}`, 'error', quiet);
+        spinner.fail('Failed to copy configured files.');
+        callback(1);
+        return 1;
     }
-    spinner.fail("Code compiling failed.");
-    callback(1);
-    return 1;
-  }
-  try {
-    await copyConfiguredFiles(spinner, LexConfig.config, quiet);
-  } catch (copyError) {
-    log(`
-${cliName} Error: Failed to copy configured files: ${copyError.message}`, "error", quiet);
-    spinner.fail("Failed to copy configured files.");
-    callback(1);
-    return 1;
-  }
-  callback(0);
-  return 0;
-};
-export {
-  compile,
-  hasFileType
+    callback(0);
+    return 0;
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/compile/compile.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {execa} from 'execa';\nimport {existsSync, lstatSync, readdirSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {extname as pathExtname, join as pathJoin, resolve as pathResolve} from 'path';\n\nimport {LexConfig, getTypeScriptConfigPath} from '../../LexConfig.js';\nimport {checkLinkedModules, copyConfiguredFiles, copyFiles, createSpinner, getFilesByExt, removeFiles} from '../../utils/app.js';\nimport {getDirName, resolveBinaryPath} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nexport const hasFileType = (startPath: string, ext: string[]): boolean => {\n  if(!existsSync(startPath)) {\n    return false;\n  }\n\n  const files: string[] = readdirSync(startPath);\n\n  return files.some((file: string) => {\n    const filename: string = pathJoin(startPath, file);\n    const fileExt: string = pathExtname(filename);\n    const stat = lstatSync(filename);\n\n    if(stat.isDirectory()) {\n      return hasFileType(filename, ext);\n    }\n\n    return ext.includes(fileExt);\n  });\n};\n\nexport const compile = async (cmd: any, callback: any = () => ({})): Promise<number> => {\n  const {\n    cliName = 'Lex',\n    config,\n    outputPath,\n    quiet,\n    remove,\n    sourcePath,\n    watch\n  } = cmd;\n\n  const spinner = createSpinner(quiet);\n\n  log(`${cliName} compiling...`, 'info', quiet);\n\n  await LexConfig.parseConfig(cmd);\n\n  const {outputFullPath, sourceFullPath, useTypescript} = LexConfig.config;\n  const outputDir: string = outputPath || outputFullPath;\n  const sourceDir: string = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath || '';\n  const dirName = getDirName();\n  const dirPath: string = pathResolve(dirName, '../..');\n\n  checkLinkedModules();\n\n  if(remove) {\n    await removeFiles(outputDir);\n  }\n\n  if(useTypescript) {\n    LexConfig.checkCompileTypescriptConfig();\n\n    const typescriptPath: string = resolveBinaryPath('tsc', 'typescript');\n\n    if(!typescriptPath) {\n      log(`\\n${cliName} Error: TypeScript binary not found in Lex's node_modules or monorepo root`, 'error', quiet);\n      log('Please reinstall Lex or check your installation.', 'info', quiet);\n      return 1;\n    }\n\n    const typescriptOptions: string[] = config ?\n      ['-p', config] :\n      ['-p', getTypeScriptConfigPath('tsconfig.build.json')];\n\n    spinner.start('Static type checking with Typescript...');\n\n    try {\n      await execa(typescriptPath, typescriptOptions, {encoding: 'utf8'});\n\n      spinner.succeed('Successfully completed type checking!');\n    } catch (error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Type checking failed.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const globOptions = {\n    cwd: sourceDir,\n    dot: false,\n    nodir: true,\n    nosort: true\n  };\n  const tsFiles: string[] = globSync(`${sourceDir}/**/!(*.spec|*.test|*.integration).ts*`, globOptions);\n  const jsFiles: string[] = globSync(`${sourceDir}/**/!(*.spec|*.test|*.integration).js`, globOptions);\n  const sourceFiles: string[] = [...tsFiles, ...jsFiles];\n  const esbuildConfig = LexConfig.config.esbuild || {};\n  const isProduction = process.env.NODE_ENV === 'production';\n  let shouldMinify: boolean;\n\n  if(typeof esbuildConfig.minify === 'boolean') {\n    shouldMinify = esbuildConfig.minify;\n  } else {\n    shouldMinify = isProduction;\n  }\n\n  const esbuildPath: string = resolveBinaryPath('esbuild', 'esbuild');\n\n  if(!esbuildPath) {\n    log(`\\n${cliName} Error: esbuild binary not found in Lex's node_modules or monorepo root`, 'error', quiet);\n    log('Please reinstall Lex or check your installation.', 'info', quiet);\n    return 1;\n  }\n\n  const esbuildOptions: string[] = [\n    ...sourceFiles,\n    '--color=true',\n    `--format=${esbuildConfig.format || 'esm'}`,\n    `--outdir=${outputDir}`,\n    `--platform=${esbuildConfig.platform || 'node'}`,\n    `--sourcemap=${esbuildConfig.sourcemap || 'inline'}`,\n    `--target=${esbuildConfig.target || 'node20'}`\n  ];\n\n  if(shouldMinify) {\n    esbuildOptions.push('--minify');\n  }\n\n  if(esbuildConfig.treeShaking !== false) {\n    esbuildOptions.push('--tree-shaking=true');\n  }\n\n  if(esbuildConfig.drop && esbuildConfig.drop.length > 0) {\n    esbuildConfig.drop.forEach((item) => {\n      esbuildOptions.push(`--drop:${item}`);\n    });\n  }\n\n  if(esbuildConfig.pure && esbuildConfig.pure.length > 0) {\n    esbuildConfig.pure.forEach((item) => {\n      esbuildOptions.push(`--pure:${item}`);\n    });\n  }\n\n  if(esbuildConfig.legalComments) {\n    esbuildOptions.push(`--legal-comments=${esbuildConfig.legalComments}`);\n  }\n\n  if(esbuildConfig.banner) {\n    Object.entries(esbuildConfig.banner).forEach(([type, content]) => {\n      esbuildOptions.push(`--banner:${type}=${content}`);\n    });\n  }\n\n  if(esbuildConfig.footer) {\n    Object.entries(esbuildConfig.footer).forEach(([type, content]) => {\n      esbuildOptions.push(`--footer:${type}=${content}`);\n    });\n  }\n\n  if(esbuildConfig.define) {\n    Object.entries(esbuildConfig.define).forEach(([key, value]) => {\n      esbuildOptions.push(`--define:${key}=${value}`);\n    });\n  }\n\n  if(watch) {\n    esbuildOptions.push('--watch');\n  }\n\n  const cssFiles: string[] = getFilesByExt('.css', LexConfig.config);\n\n  if(cssFiles.length) {\n    const postcssPath: string = resolveBinaryPath('postcss', 'postcss-cli');\n\n    if(!postcssPath) {\n      log(`\\n${cliName} Error: PostCSS binary not found in Lex's node_modules or monorepo root`, 'error', quiet);\n      log('Please reinstall Lex or check your installation.', 'info', quiet);\n      return 1;\n    }\n\n    const postcssOptions: string[] = [\n      `${sourceDir}/**/**.css`,\n      '--base',\n      sourceDir,\n      '--dir',\n      outputDir,\n      '--config',\n      pathResolve(dirName, '../../postcss.config.js')\n    ];\n\n    try {\n      await execa(postcssPath, postcssOptions, {encoding: 'utf8'});\n      spinner.succeed(`Successfully formatted ${cssFiles.length} css files!`);\n    } catch (error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed formatting css.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const gifFiles: string[] = getFilesByExt('.gif', LexConfig.config);\n  const jpgFiles: string[] = getFilesByExt('.jpg', LexConfig.config);\n  const pngFiles: string[] = getFilesByExt('.png', LexConfig.config);\n  const svgFiles: string[] = getFilesByExt('.svg', LexConfig.config);\n  const imageFiles: string[] = [...gifFiles, ...jpgFiles, ...pngFiles, ...svgFiles];\n\n  if(imageFiles.length) {\n    try {\n      await copyFiles(imageFiles, 'image', spinner, LexConfig.config);\n    } catch (error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed to move images to output directory.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const ttfFiles: string[] = getFilesByExt('.ttf', LexConfig.config);\n  const otfFiles: string[] = getFilesByExt('.otf', LexConfig.config);\n  const woffFiles: string[] = getFilesByExt('.woff', LexConfig.config);\n  const woff2Files: string[] = getFilesByExt('.woff2', LexConfig.config);\n  const fontFiles: string[] = [...ttfFiles, ...otfFiles, ...woffFiles, ...woff2Files];\n\n  if(fontFiles.length) {\n    try {\n      await copyFiles(fontFiles, 'font', spinner, LexConfig.config);\n    } catch (error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed to move fonts to output directory.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const mdFiles: string[] = getFilesByExt('.md', LexConfig.config);\n\n  if(mdFiles.length) {\n    try {\n      await copyFiles(mdFiles, 'documents', spinner, LexConfig.config);\n    } catch (error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed to move docs to output directory.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  spinner.start(watch ? 'Watching for changes...' : 'Compiling with ESBuild...');\n\n  try {\n    await execa(esbuildPath, esbuildOptions, {encoding: 'utf8'});\n\n    spinner.succeed('Compile completed successfully!');\n  } catch (error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n    if(!quiet) {\n      console.error(error);\n    }\n\n    spinner.fail('Code compiling failed.');\n\n    callback(1);\n    return 1;\n  }\n\n  try {\n    await copyConfiguredFiles(spinner, LexConfig.config, quiet);\n  } catch (copyError) {\n    log(`\\n${cliName} Error: Failed to copy configured files: ${copyError.message}`, 'error', quiet);\n\n    spinner.fail('Failed to copy configured files.');\n\n    callback(1);\n    return 1;\n  }\n\n  callback(0);\n  return 0;\n};"],
  "mappings": "AAIA,SAAQ,aAAY;AACpB,SAAQ,YAAY,WAAW,mBAAkB;AACjD,SAAQ,QAAQ,gBAAe;AAC/B,SAAQ,WAAW,aAAa,QAAQ,UAAU,WAAW,mBAAkB;AAE/E,SAAQ,WAAW,+BAA8B;AACjD,SAAQ,oBAAoB,qBAAqB,WAAW,eAAe,eAAe,mBAAkB;AAC5G,SAAQ,YAAY,yBAAwB;AAC5C,SAAQ,WAAU;AAEX,MAAM,cAAc,CAAC,WAAmB,QAA2B;AACxE,MAAG,CAAC,WAAW,SAAS,GAAG;AACzB,WAAO;AAAA,EACT;AAEA,QAAM,QAAkB,YAAY,SAAS;AAE7C,SAAO,MAAM,KAAK,CAAC,SAAiB;AAClC,UAAM,WAAmB,SAAS,WAAW,IAAI;AACjD,UAAM,UAAkB,YAAY,QAAQ;AAC5C,UAAM,OAAO,UAAU,QAAQ;AAE/B,QAAG,KAAK,YAAY,GAAG;AACrB,aAAO,YAAY,UAAU,GAAG;AAAA,IAClC;AAEA,WAAO,IAAI,SAAS,OAAO;AAAA,EAC7B,CAAC;AACH;AAEO,MAAM,UAAU,OAAO,KAAU,WAAgB,OAAO,CAAC,OAAwB;AACtF,QAAM;AAAA,IACJ,UAAU;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,UAAU,cAAc,KAAK;AAEnC,MAAI,GAAG,OAAO,iBAAiB,QAAQ,KAAK;AAE5C,QAAM,UAAU,YAAY,GAAG;AAE/B,QAAM,EAAC,gBAAgB,gBAAgB,cAAa,IAAI,UAAU;AAClE,QAAM,YAAoB,cAAc;AACxC,QAAM,YAAoB,aAAa,YAAY,QAAQ,IAAI,GAAG,KAAK,UAAU,EAAE,IAAI,kBAAkB;AACzG,QAAM,UAAU,WAAW;AAC3B,QAAM,UAAkB,YAAY,SAAS,OAAO;AAEpD,qBAAmB;AAEnB,MAAG,QAAQ;AACT,UAAM,YAAY,SAAS;AAAA,EAC7B;AAEA,MAAG,eAAe;AAChB,cAAU,6BAA6B;AAEvC,UAAM,iBAAyB,kBAAkB,OAAO,YAAY;AAEpE,QAAG,CAAC,gBAAgB;AAClB,UAAI;AAAA,EAAK,OAAO,8EAA8E,SAAS,KAAK;AAC5G,UAAI,oDAAoD,QAAQ,KAAK;AACrE,aAAO;AAAA,IACT;AAEA,UAAM,oBAA8B,SAClC,CAAC,MAAM,MAAM,IACb,CAAC,MAAM,wBAAwB,qBAAqB,CAAC;AAEvD,YAAQ,MAAM,yCAAyC;AAEvD,QAAI;AACF,YAAM,MAAM,gBAAgB,mBAAmB,EAAC,UAAU,OAAM,CAAC;AAEjE,cAAQ,QAAQ,uCAAuC;AAAA,IACzD,SAAS,OAAO;AACd,UAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAE1D,cAAQ,KAAK,uBAAuB;AAEpC,eAAS,CAAC;AACV,aAAO;AAAA,IACT;AAAA,EACF;AAEA,QAAM,cAAc;AAAA,IAClB,KAAK;AAAA,IACL,KAAK;AAAA,IACL,OAAO;AAAA,IACP,QAAQ;AAAA,EACV;AACA,QAAM,UAAoB,SAAS,GAAG,SAAS,0CAA0C,WAAW;AACpG,QAAM,UAAoB,SAAS,GAAG,SAAS,yCAAyC,WAAW;AACnG,QAAM,cAAwB,CAAC,GAAG,SAAS,GAAG,OAAO;AACrD,QAAM,gBAAgB,UAAU,OAAO,WAAW,CAAC;AACnD,QAAM,eAAe,QAAQ,IAAI,aAAa;AAC9C,MAAI;AAEJ,MAAG,OAAO,cAAc,WAAW,WAAW;AAC5C,mBAAe,cAAc;AAAA,EAC/B,OAAO;AACL,mBAAe;AAAA,EACjB;AAEA,QAAM,cAAsB,kBAAkB,WAAW,SAAS;AAElE,MAAG,CAAC,aAAa;AACf,QAAI;AAAA,EAAK,OAAO,2EAA2E,SAAS,KAAK;AACzG,QAAI,oDAAoD,QAAQ,KAAK;AACrE,WAAO;AAAA,EACT;AAEA,QAAM,iBAA2B;AAAA,IAC/B,GAAG;AAAA,IACH;AAAA,IACA,YAAY,cAAc,UAAU,KAAK;AAAA,IACzC,YAAY,SAAS;AAAA,IACrB,cAAc,cAAc,YAAY,MAAM;AAAA,IAC9C,eAAe,cAAc,aAAa,QAAQ;AAAA,IAClD,YAAY,cAAc,UAAU,QAAQ;AAAA,EAC9C;AAEA,MAAG,cAAc;AACf,mBAAe,KAAK,UAAU;AAAA,EAChC;AAEA,MAAG,cAAc,gBAAgB,OAAO;AACtC,mBAAe,KAAK,qBAAqB;AAAA,EAC3C;AAEA,MAAG,cAAc,QAAQ,cAAc,KAAK,SAAS,GAAG;AACtD,kBAAc,KAAK,QAAQ,CAAC,SAAS;AACnC,qBAAe,KAAK,UAAU,IAAI,EAAE;AAAA,IACtC,CAAC;AAAA,EACH;AAEA,MAAG,cAAc,QAAQ,cAAc,KAAK,SAAS,GAAG;AACtD,kBAAc,KAAK,QAAQ,CAAC,SAAS;AACnC,qBAAe,KAAK,UAAU,IAAI,EAAE;AAAA,IACtC,CAAC;AAAA,EACH;AAEA,MAAG,cAAc,eAAe;AAC9B,mBAAe,KAAK,oBAAoB,cAAc,aAAa,EAAE;AAAA,EACvE;AAEA,MAAG,cAAc,QAAQ;AACvB,WAAO,QAAQ,cAAc,MAAM,EAAE,QAAQ,CAAC,CAAC,MAAM,OAAO,MAAM;AAChE,qBAAe,KAAK,YAAY,IAAI,IAAI,OAAO,EAAE;AAAA,IACnD,CAAC;AAAA,EACH;AAEA,MAAG,cAAc,QAAQ;AACvB,WAAO,QAAQ,cAAc,MAAM,EAAE,QAAQ,CAAC,CAAC,MAAM,OAAO,MAAM;AAChE,qBAAe,KAAK,YAAY,IAAI,IAAI,OAAO,EAAE;AAAA,IACnD,CAAC;AAAA,EACH;AAEA,MAAG,cAAc,QAAQ;AACvB,WAAO,QAAQ,cAAc,MAAM,EAAE,QAAQ,CAAC,CAAC,KAAK,KAAK,MAAM;AAC7D,qBAAe,KAAK,YAAY,GAAG,IAAI,KAAK,EAAE;AAAA,IAChD,CAAC;AAAA,EACH;AAEA,MAAG,OAAO;AACR,mBAAe,KAAK,SAAS;AAAA,EAC/B;AAEA,QAAM,WAAqB,cAAc,QAAQ,UAAU,MAAM;AAEjE,MAAG,SAAS,QAAQ;AAClB,UAAM,cAAsB,kBAAkB,WAAW,aAAa;AAEtE,QAAG,CAAC,aAAa;AACf,UAAI;AAAA,EAAK,OAAO,2EAA2E,SAAS,KAAK;AACzG,UAAI,oDAAoD,QAAQ,KAAK;AACrE,aAAO;AAAA,IACT;AAEA,UAAM,iBAA2B;AAAA,MAC/B,GAAG,SAAS;AAAA,MACZ;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,YAAY,SAAS,yBAAyB;AAAA,IAChD;AAEA,QAAI;AACF,YAAM,MAAM,aAAa,gBAAgB,EAAC,UAAU,OAAM,CAAC;AAC3D,cAAQ,QAAQ,0BAA0B,SAAS,MAAM,aAAa;AAAA,IACxE,SAAS,OAAO;AACd,UAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAE1D,cAAQ,KAAK,wBAAwB;AAErC,eAAS,CAAC;AACV,aAAO;AAAA,IACT;AAAA,EACF;AAEA,QAAM,WAAqB,cAAc,QAAQ,UAAU,MAAM;AACjE,QAAM,WAAqB,cAAc,QAAQ,UAAU,MAAM;AACjE,QAAM,WAAqB,cAAc,QAAQ,UAAU,MAAM;AACjE,QAAM,WAAqB,cAAc,QAAQ,UAAU,MAAM;AACjE,QAAM,aAAuB,CAAC,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,QAAQ;AAEhF,MAAG,WAAW,QAAQ;AACpB,QAAI;AACF,YAAM,UAAU,YAAY,SAAS,SAAS,UAAU,MAAM;AAAA,IAChE,SAAS,OAAO;AACd,UAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAE1D,cAAQ,KAAK,4CAA4C;AAEzD,eAAS,CAAC;AACV,aAAO;AAAA,IACT;AAAA,EACF;AAEA,QAAM,WAAqB,cAAc,QAAQ,UAAU,MAAM;AACjE,QAAM,WAAqB,cAAc,QAAQ,UAAU,MAAM;AACjE,QAAM,YAAsB,cAAc,SAAS,UAAU,MAAM;AACnE,QAAM,aAAuB,cAAc,UAAU,UAAU,MAAM;AACrE,QAAM,YAAsB,CAAC,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU;AAElF,MAAG,UAAU,QAAQ;AACnB,QAAI;AACF,YAAM,UAAU,WAAW,QAAQ,SAAS,UAAU,MAAM;AAAA,IAC9D,SAAS,OAAO;AACd,UAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAE1D,cAAQ,KAAK,2CAA2C;AAExD,eAAS,CAAC;AACV,aAAO;AAAA,IACT;AAAA,EACF;AAEA,QAAM,UAAoB,cAAc,OAAO,UAAU,MAAM;AAE/D,MAAG,QAAQ,QAAQ;AACjB,QAAI;AACF,YAAM,UAAU,SAAS,aAAa,SAAS,UAAU,MAAM;AAAA,IACjE,SAAS,OAAO;AACd,UAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAE1D,cAAQ,KAAK,0CAA0C;AAEvD,eAAS,CAAC;AACV,aAAO;AAAA,IACT;AAAA,EACF;AAEA,UAAQ,MAAM,QAAQ,4BAA4B,2BAA2B;AAE7E,MAAI;AACF,UAAM,MAAM,aAAa,gBAAgB,EAAC,UAAU,OAAM,CAAC;AAE3D,YAAQ,QAAQ,iCAAiC;AAAA,EACnD,SAAS,OAAO;AACd,QAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAE1D,QAAG,CAAC,OAAO;AACT,cAAQ,MAAM,KAAK;AAAA,IACrB;AAEA,YAAQ,KAAK,wBAAwB;AAErC,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAEA,MAAI;AACF,UAAM,oBAAoB,SAAS,UAAU,QAAQ,KAAK;AAAA,EAC5D,SAAS,WAAW;AAClB,QAAI;AAAA,EAAK,OAAO,4CAA4C,UAAU,OAAO,IAAI,SAAS,KAAK;AAE/F,YAAQ,KAAK,kCAAkC;AAE/C,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAEA,WAAS,CAAC;AACV,SAAO;AACT;",
  "names": []
}

+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/compile/compile.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {transform} from '@swc/core';\nimport {execa} from 'execa';\nimport {existsSync, lstatSync, readdirSync, readFileSync, writeFileSync, mkdirSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {extname as pathExtname, join as pathJoin, resolve as pathResolve, dirname} from 'path';\n\nimport {LexConfig, getTypeScriptConfigPath} from '../../LexConfig.js';\nimport {checkLinkedModules, copyConfiguredFiles, copyFiles, createSpinner, getFilesByExt, removeFiles} from '../../utils/app.js';\nimport {getDirName, resolveBinaryPath} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nexport const hasFileType = (startPath: string, ext: string[]): boolean => {\n  if(!existsSync(startPath)) {\n    return false;\n  }\n\n  const files: string[] = readdirSync(startPath);\n\n  return files.some((file: string) => {\n    const filename: string = pathJoin(startPath, file);\n    const fileExt: string = pathExtname(filename);\n    const stat = lstatSync(filename);\n\n    if(stat.isDirectory()) {\n      return hasFileType(filename, ext);\n    }\n\n    return ext.includes(fileExt);\n  });\n};\n\nexport const compile = async (cmd: any, callback: any = () => ({})): Promise<number> => {\n  const {\n    cliName = 'Lex',\n    config,\n    format = 'esm',\n    outputPath,\n    quiet,\n    remove,\n    sourcePath,\n    watch\n  } = cmd;\n\n  const spinner = createSpinner(quiet);\n\n  log(`${cliName} compiling...`, 'info', quiet);\n\n  await LexConfig.parseConfig(cmd);\n\n  const {outputFullPath, sourceFullPath, swc: swcConfig, useTypescript} = LexConfig.config;\n  const outputDir: string = outputPath || outputFullPath;\n  const sourceDir: string = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath || '';\n  const dirName = getDirName();\n  const dirPath: string = pathResolve(dirName, '../..');\n\n  checkLinkedModules();\n\n  if(remove) {\n    await removeFiles(outputDir);\n  }\n\n  if(useTypescript) {\n    LexConfig.checkCompileTypescriptConfig();\n\n    const typescriptPath: string = resolveBinaryPath('tsc', 'typescript');\n\n    if(!typescriptPath) {\n      log(`\\n${cliName} Error: TypeScript binary not found in Lex's node_modules or monorepo root`, 'error', quiet);\n      log('Please reinstall Lex or check your installation.', 'info', quiet);\n      return 1;\n    }\n\n    const typescriptOptions: string[] = config ?\n      ['-p', config] :\n      ['-p', getTypeScriptConfigPath('tsconfig.build.json')];\n\n    spinner.start('Static type checking with Typescript...');\n\n    try {\n      await execa(typescriptPath, typescriptOptions, {encoding: 'utf8'});\n\n      spinner.succeed('Successfully completed type checking!');\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Type checking failed.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const globOptions = {\n    cwd: sourceDir,\n    dot: false,\n    nodir: true,\n    nosort: true\n  };\n  const tsFiles: string[] = globSync(`${sourceDir}/**/!(*.spec|*.test|*.integration).ts*`, globOptions);\n  const jsFiles: string[] = globSync(`${sourceDir}/**/!(*.spec|*.test|*.integration).js`, globOptions);\n  const sourceFiles: string[] = [...tsFiles, ...jsFiles];\n\n  const cssFiles: string[] = getFilesByExt('.css', LexConfig.config);\n\n  if(cssFiles.length) {\n    const postcssPath: string = resolveBinaryPath('postcss', 'postcss-cli');\n\n    if(!postcssPath) {\n      log(`\\n${cliName} Error: PostCSS binary not found in Lex's node_modules or monorepo root`, 'error', quiet);\n      log('Please reinstall Lex or check your installation.', 'info', quiet);\n      return 1;\n    }\n\n    const postcssOptions: string[] = [\n      `${sourceDir}/**/**.css`,\n      '--base',\n      sourceDir,\n      '--dir',\n      outputDir,\n      '--config',\n      pathResolve(dirName, '../../postcss.config.js')\n    ];\n\n    try {\n      await execa(postcssPath, postcssOptions, {encoding: 'utf8'});\n      spinner.succeed(`Successfully formatted ${cssFiles.length} css files!`);\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed formatting css.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const gifFiles: string[] = getFilesByExt('.gif', LexConfig.config);\n  const jpgFiles: string[] = getFilesByExt('.jpg', LexConfig.config);\n  const pngFiles: string[] = getFilesByExt('.png', LexConfig.config);\n  const svgFiles: string[] = getFilesByExt('.svg', LexConfig.config);\n  const imageFiles: string[] = [...gifFiles, ...jpgFiles, ...pngFiles, ...svgFiles];\n\n  if(imageFiles.length) {\n    try {\n      await copyFiles(imageFiles, 'image', spinner, LexConfig.config);\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed to move images to output directory.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const ttfFiles: string[] = getFilesByExt('.ttf', LexConfig.config);\n  const otfFiles: string[] = getFilesByExt('.otf', LexConfig.config);\n  const woffFiles: string[] = getFilesByExt('.woff', LexConfig.config);\n  const woff2Files: string[] = getFilesByExt('.woff2', LexConfig.config);\n  const fontFiles: string[] = [...ttfFiles, ...otfFiles, ...woffFiles, ...woff2Files];\n\n  if(fontFiles.length) {\n    try {\n      await copyFiles(fontFiles, 'font', spinner, LexConfig.config);\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed to move fonts to output directory.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  const mdFiles: string[] = getFilesByExt('.md', LexConfig.config);\n\n  if(mdFiles.length) {\n    try {\n      await copyFiles(mdFiles, 'documents', spinner, LexConfig.config);\n    } catch(error) {\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      spinner.fail('Failed to move docs to output directory.');\n\n      callback(1);\n      return 1;\n    }\n  }\n\n  spinner.start(watch ? 'Watching for changes...' : 'Compiling with SWC...');\n\n  try {\n    // Compile each file with SWC\n    for(const file of sourceFiles) {\n      const sourcePath = pathResolve(sourceDir, file);\n      const outputPath = pathResolve(outputDir, file.replace(/\\.(ts|tsx)$/, '.js'));\n\n      // Ensure output directory exists\n      const outputDirPath = dirname(outputPath);\n      if(!existsSync(outputDirPath)) {\n        mkdirSync(outputDirPath, {recursive: true});\n      }\n\n      const sourceCode = readFileSync(sourcePath, 'utf8');\n\n      const isTSX = file.endsWith('.tsx');\n\n      // Merge SWC config with command-specific overrides\n      const swcOptions = {\n        filename: file,\n        ...swcConfig,\n        jsc: {\n          ...swcConfig?.jsc,\n          parser: {\n            decorators: swcConfig?.jsc?.parser?.decorators ?? true,\n            dynamicImport: swcConfig?.jsc?.parser?.dynamicImport ?? true,\n            syntax: 'typescript' as const,\n            tsx: isTSX\n          },\n          target: swcConfig?.jsc?.target ?? 'es2020',\n          transform: isTSX ? {\n            ...swcConfig?.jsc?.transform,\n            react: {\n              runtime: 'automatic' as const,\n              ...swcConfig?.jsc?.transform?.react\n            }\n          } : swcConfig?.jsc?.transform\n        },\n        module: {\n          ...swcConfig?.module,\n          type: format === 'cjs' ? 'commonjs' as const : (swcConfig?.module?.type as 'es6' || 'es6')\n        }\n      };\n\n      const result = await transform(sourceCode, swcOptions);\n\n      writeFileSync(outputPath, result.code);\n    }\n\n    spinner.succeed('Compile completed successfully!');\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n    if(!quiet) {\n      console.error(error);\n    }\n\n    spinner.fail('Code compiling failed.');\n\n    callback(1);\n    return 1;\n  }\n\n  try {\n    await copyConfiguredFiles(spinner, LexConfig.config, quiet);\n  } catch(copyError) {\n    log(`\\n${cliName} Error: Failed to copy configured files: ${copyError.message}`, 'error', quiet);\n\n    spinner.fail('Failed to copy configured files.');\n\n    callback(1);\n    return 1;\n  }\n\n  callback(0);\n  return 0;\n};"],"names":["transform","execa","existsSync","lstatSync","readdirSync","readFileSync","writeFileSync","mkdirSync","sync","globSync","extname","pathExtname","join","pathJoin","resolve","pathResolve","dirname","LexConfig","getTypeScriptConfigPath","checkLinkedModules","copyConfiguredFiles","copyFiles","createSpinner","getFilesByExt","removeFiles","getDirName","resolveBinaryPath","log","hasFileType","startPath","ext","files","some","file","filename","fileExt","stat","isDirectory","includes","compile","cmd","callback","cliName","config","format","outputPath","quiet","remove","sourcePath","watch","spinner","parseConfig","outputFullPath","sourceFullPath","swc","swcConfig","useTypescript","outputDir","sourceDir","process","cwd","dirName","dirPath","checkCompileTypescriptConfig","typescriptPath","typescriptOptions","start","encoding","succeed","error","message","fail","globOptions","dot","nodir","nosort","tsFiles","jsFiles","sourceFiles","cssFiles","length","postcssPath","postcssOptions","gifFiles","jpgFiles","pngFiles","svgFiles","imageFiles","ttfFiles","otfFiles","woffFiles","woff2Files","fontFiles","mdFiles","replace","outputDirPath","recursive","sourceCode","isTSX","endsWith","swcOptions","jsc","parser","decorators","dynamicImport","syntax","tsx","target","react","runtime","module","type","result","code","console","copyError"],"mappings":"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"}