@nlabs/lex 1.49.5 → 1.50.1

package/lib/commands/dev/dev.js

@@ -1,280 +1,282 @@
-import boxen from "boxen";
-import chalk from "chalk";
-import { execa } from "execa";
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import https from "https";
-import { networkInterfaces, homedir } from "os";
-import { dirname, resolve as pathResolve, join } from "path";
-import { LexConfig } from "../../LexConfig.js";
-import { createSpinner, handleWebpackProgress, removeFiles } from "../../utils/app.js";
-import { resolveWebpackPaths } from "../../utils/file.js";
-import { log } from "../../utils/log.js";
-import { processTranslations } from "../../utils/translations.js";
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import boxen from 'boxen';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import https from 'https';
+import { networkInterfaces, homedir } from 'os';
+import { dirname, resolve as pathResolve, join } from 'path';
+import { LexConfig } from '../../LexConfig.js';
+import { createSpinner, handleWebpackProgress, removeFiles } from '../../utils/app.js';
+import { resolveWebpackPaths } from '../../utils/file.js';
+import { log } from '../../utils/log.js';
+import { processTranslations } from '../../utils/translations.js';
 let currentFilename;
 let currentDirname;
 try {
-  currentFilename = eval('require("url").fileURLToPath(import.meta.url)');
-  currentDirname = dirname(currentFilename);
-} catch {
-  currentFilename = process.cwd();
-  currentDirname = process.cwd();
+    // eslint-disable-next-line no-eval
+    currentFilename = eval('require("url").fileURLToPath(import.meta.url)');
+    currentDirname = dirname(currentFilename);
+} catch  {
+    currentFilename = process.cwd();
+    currentDirname = process.cwd();
 }
-const getCacheDir = () => {
-  const cacheDir = join(homedir(), ".lex-cache");
-  if (!existsSync(cacheDir)) {
-    mkdirSync(cacheDir, { recursive: true });
-  }
-  return cacheDir;
+const getCacheDir = ()=>{
+    const cacheDir = join(homedir(), '.lex-cache');
+    if (!existsSync(cacheDir)) {
+        mkdirSync(cacheDir, {
+            recursive: true
+        });
+    }
+    return cacheDir;
 };
-const getCachePath = () => join(getCacheDir(), "public-ip.json");
-const readPublicIpCache = () => {
-  const cachePath = getCachePath();
-  if (!existsSync(cachePath)) {
-    return null;
-  }
-  try {
-    const cacheData = readFileSync(cachePath, "utf8");
-    const cache = JSON.parse(cacheData);
-    const oneWeekMs = 7 * 24 * 60 * 60 * 1e3;
-    if (Date.now() - cache.timestamp > oneWeekMs) {
-      return null;
+const getCachePath = ()=>join(getCacheDir(), 'public-ip.json');
+const readPublicIpCache = ()=>{
+    const cachePath = getCachePath();
+    if (!existsSync(cachePath)) {
+        return null;
+    }
+    try {
+        const cacheData = readFileSync(cachePath, 'utf8');
+        const cache = JSON.parse(cacheData);
+        const oneWeekMs = 7 * 24 * 60 * 60 * 1000;
+        if (Date.now() - cache.timestamp > oneWeekMs) {
+            return null;
+        }
+        return cache;
+    } catch  {
+        return null;
     }
-    return cache;
-  } catch {
-    return null;
-  }
 };
-const writePublicIpCache = (ip) => {
-  const cachePath = getCachePath();
-  const cache = {
-    ip,
-    timestamp: Date.now()
-  };
-  writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+const writePublicIpCache = (ip)=>{
+    const cachePath = getCachePath();
+    const cache = {
+        ip,
+        timestamp: Date.now()
+    };
+    writeFileSync(cachePath, JSON.stringify(cache, null, 2));
 };
-const fetchPublicIp = (forceRefresh = false) => new Promise((resolve) => {
-  if (!forceRefresh) {
-    const cached = readPublicIpCache();
-    if (cached) {
-      resolve(cached.ip);
-      return;
-    }
-  }
-  https.get("https://api.ipify.org", (res) => {
-    let data = "";
-    res.on("data", (chunk) => data += chunk);
-    res.on("end", () => {
-      const ip = data.trim();
-      if (ip) {
-        writePublicIpCache(ip);
-      }
-      resolve(ip);
+const fetchPublicIp = (forceRefresh = false)=>new Promise((resolve)=>{
+        if (!forceRefresh) {
+            const cached = readPublicIpCache();
+            if (cached) {
+                resolve(cached.ip);
+                return;
+            }
+        }
+        https.get('https://api.ipify.org', (res)=>{
+            let data = '';
+            res.on('data', (chunk)=>data += chunk);
+            res.on('end', ()=>{
+                const ip = data.trim();
+                if (ip) {
+                    writePublicIpCache(ip);
+                }
+                resolve(ip);
+            });
+        }).on('error', ()=>resolve(undefined));
     });
-  }).on("error", () => resolve(void 0));
-});
-const getNetworkAddresses = () => {
-  const interfaces = networkInterfaces();
-  const addresses = {
-    local: "localhost",
-    private: null,
-    public: null
-  };
-  for (const name of Object.keys(interfaces)) {
-    const networkInterface = interfaces[name];
-    if (!networkInterface) {
-      continue;
-    }
-    for (const iface of networkInterface) {
-      if (iface.family === "IPv4" && !iface.internal) {
-        const ip = iface.address;
-        if (ip.startsWith("10.") || ip.startsWith("192.168.") || ip.startsWith("172.")) {
-          if (!addresses.private) {
-            addresses.private = ip;
-          }
-        } else {
-          if (!addresses.public) {
-            addresses.public = ip;
-          }
+const getNetworkAddresses = ()=>{
+    const interfaces = networkInterfaces();
+    const addresses = {
+        local: 'localhost',
+        private: null,
+        public: null
+    };
+    for (const name of Object.keys(interfaces)){
+        const networkInterface = interfaces[name];
+        if (!networkInterface) {
+            continue;
+        }
+        for (const iface of networkInterface){
+            if (iface.family === 'IPv4' && !iface.internal) {
+                const ip = iface.address;
+                if (ip.startsWith('10.') || ip.startsWith('192.168.') || ip.startsWith('172.')) {
+                    if (!addresses.private) {
+                        addresses.private = ip;
+                    }
+                } else {
+                    if (!addresses.public) {
+                        addresses.public = ip;
+                    }
+                }
+            }
         }
-      }
     }
-  }
-  return addresses;
+    return addresses;
 };
-const displayServerStatus = (port = 7001, quiet, publicIp) => {
-  if (quiet) {
-    return;
-  }
-  const addresses = getNetworkAddresses();
-  const localUrl = `http://localhost:${port}`;
-  const privateUrl = addresses.private ? `http://${addresses.private}:${port}` : null;
-  let publicUrl = null;
-  if (publicIp) {
-    publicUrl = `http://${publicIp}:${port}`;
-  } else if (addresses.public) {
-    publicUrl = `http://${addresses.public}:${port}`;
-  }
-  let urlLines = `${chalk.green("Local:")}     ${chalk.underline(localUrl)}
-`;
-  if (privateUrl) {
-    urlLines += `${chalk.green("Private:")}   ${chalk.underline(privateUrl)}
-`;
-  }
-  if (publicUrl) {
-    urlLines += `${chalk.green("Public:")}    ${chalk.underline(publicUrl)}
-`;
-  }
-  const statusBox = boxen(
-    `${chalk.cyan.bold("\u{1F680} Development Server Running")}
-
-${urlLines}
-${chalk.yellow("Press Ctrl+C to stop the server")}`,
-    {
-      backgroundColor: "#1a1a1a",
-      borderColor: "cyan",
-      borderStyle: "round",
-      margin: 1,
-      padding: 1
+const displayServerStatus = (port = 3000, quiet, publicIp)=>{
+    if (quiet) {
+        return;
     }
-  );
-  console.log(`
-${statusBox}
-`);
-};
-const dev = async (cmd, callback = () => ({})) => {
-  const { bundleAnalyzer, cliName = "Lex", config, format = "esm", open = false, quiet, remove, translations = false, usePublicIp, variables } = cmd;
-  const spinner = createSpinner(quiet);
-  log(`${cliName} start development server...`, "info", quiet);
-  await LexConfig.parseConfig(cmd);
-  const { outputFullPath, useTypescript } = LexConfig.config;
-  let variablesObj = { NODE_ENV: "development" };
-  if (variables) {
-    try {
-      variablesObj = JSON.parse(variables);
-    } catch (_error) {
-      log(`
-${cliName} Error: Environment variables option is not a valid JSON object.`, "error", quiet);
-      callback(1);
-      return 1;
+    const addresses = getNetworkAddresses();
+    const localUrl = `http://localhost:${port}`;
+    const privateUrl = addresses.private ? `http://${addresses.private}:${port}` : null;
+    let publicUrl = null;
+    if (publicIp) {
+        publicUrl = `http://${publicIp}:${port}`;
+    } else if (addresses.public) {
+        publicUrl = `http://${addresses.public}:${port}`;
     }
-  }
-  process.env = { ...process.env, ...variablesObj };
-  if (useTypescript) {
-    LexConfig.checkTypescriptConfig();
-  }
-  if (remove) {
-    spinner.start("Cleaning output directory...");
-    await removeFiles(outputFullPath || "");
-    spinner.succeed("Successfully cleaned output directory!");
-  }
-  if (translations) {
-    spinner.start("Processing translations...");
-    try {
-      const sourcePath = LexConfig.config.sourceFullPath || process.cwd();
-      const outputPath = LexConfig.config.outputFullPath || "lib";
-      await processTranslations(sourcePath, outputPath, quiet);
-      spinner.succeed("Translations processed successfully!");
-    } catch (translationError) {
-      log(`
-${cliName} Error: Failed to process translations: ${translationError.message}`, "error", quiet);
-      spinner.fail("Failed to process translations.");
-      callback(1);
-      return 1;
+    let urlLines = `${chalk.green('Local:')}     ${chalk.underline(localUrl)}\n`;
+    if (privateUrl) {
+        urlLines += `${chalk.green('Private:')}   ${chalk.underline(privateUrl)}\n`;
+    }
+    if (publicUrl) {
+        urlLines += `${chalk.green('Public:')}    ${chalk.underline(publicUrl)}\n`;
     }
-  }
-  let webpackConfig;
-  if (config) {
-    const isRelativeConfig = config.substr(0, 2) === "./";
-    webpackConfig = isRelativeConfig ? pathResolve(process.cwd(), config) : config;
-  } else {
-    const { webpackConfig: resolvedConfig } = resolveWebpackPaths(currentDirname);
-    webpackConfig = resolvedConfig;
-  }
-  const { webpackPath } = resolveWebpackPaths(currentDirname);
-  const webpackOptions = [
-    "--color",
-    "--watch",
-    "--config",
-    webpackConfig
-  ];
-  if (bundleAnalyzer) {
-    webpackOptions.push("--bundleAnalyzer");
-  }
-  try {
-    const finalWebpackOptions = webpackPath === "npx" ? ["webpack", ...webpackOptions] : webpackOptions;
-    spinner.start("Starting development server...");
-    const childProcess = execa(webpackPath, finalWebpackOptions, {
-      encoding: "utf8",
-      env: {
-        LEX_QUIET: quiet,
-        WEBPACK_DEV_OPEN: open
-      },
-      stdio: "pipe"
+    const statusBox = boxen(`${chalk.cyan.bold('🚀 Development Server Running')}\n\n${urlLines}\n` + `${chalk.yellow('Press Ctrl+C to stop the server')}`, {
+        backgroundColor: '#1a1a1a',
+        borderColor: 'cyan',
+        borderStyle: 'round',
+        margin: 1,
+        padding: 1
     });
-    let serverStarted = false;
-    let statusShown = false;
-    const showStatusOnce = (portToShow) => {
-      if (statusShown) {
-        return;
-      }
-      statusShown = true;
-      if (usePublicIp) {
-        fetchPublicIp(usePublicIp).then((publicIp) => {
-          displayServerStatus(portToShow, quiet, publicIp);
-        });
-      } else {
-        displayServerStatus(portToShow, quiet);
-      }
+    // eslint-disable-next-line no-console
+    console.log(`\n${statusBox}\n`);
+};
+export const dev = async (cmd, callback = ()=>({}))=>{
+    const { bundleAnalyzer, cliName = 'Lex', config, format = 'esm', open = false, port = 3000, quiet, remove, translations = false, usePublicIp, variables } = cmd;
+    const spinner = createSpinner(quiet);
+    log(`${cliName} start development server...`, 'info', quiet);
+    await LexConfig.parseConfig(cmd);
+    const { outputFullPath, useTypescript } = LexConfig.config;
+    let variablesObj = {
+        NODE_ENV: 'development'
     };
-    let detectedPort = 7001;
-    childProcess.stdout?.on("data", (data) => {
-      const output = data.toString();
-      handleWebpackProgress(output, spinner, quiet, "\u{1F680}", "Webpack Building");
-      if (!serverStarted && (output.includes("Local:") || output.includes("webpack compiled") || output.includes("webpack-plugin-serve") || output.includes("http://localhost") || output.includes("listening on port"))) {
-        serverStarted = true;
-        spinner.succeed("Development server started.");
-        const portMatch = output.match(/Local:\s*http:\/\/[^:]+:(\d+)/) || output.match(/http:\/\/localhost:(\d+)/) || output.match(/port:\s*(\d+)/) || output.match(/listening on port (\d+)/) || output.match(/WebpackPluginServe listening on port (\d+)/);
-        if (portMatch) {
-          detectedPort = parseInt(portMatch[1]);
+    if (variables) {
+        try {
+            variablesObj = JSON.parse(variables);
+        } catch (_error) {
+            log(`\n${cliName} Error: Environment variables option is not a valid JSON object.`, 'error', quiet);
+            callback(1);
+            return 1;
         }
-        showStatusOnce(detectedPort);
-      }
-    });
-    childProcess.stderr?.on("data", (data) => {
-      const output = data.toString();
-      handleWebpackProgress(output, spinner, quiet, "\u{1F680}", "Webpack Building");
-      if (!serverStarted && (output.includes("Local:") || output.includes("webpack compiled") || output.includes("webpack-plugin-serve") || output.includes("http://localhost") || output.includes("listening on port"))) {
-        serverStarted = true;
-        spinner.succeed("Development server started.");
-        const portMatch = output.match(/Local:\s*http:\/\/[^:]+:(\d+)/) || output.match(/http:\/\/localhost:(\d+)/) || output.match(/port:\s*(\d+)/) || output.match(/listening on port (\d+)/) || output.match(/WebpackPluginServe listening on port (\d+)/);
-        if (portMatch) {
-          detectedPort = parseInt(portMatch[1]);
+    }
+    process.env = {
+        ...process.env,
+        ...variablesObj
+    };
+    if (useTypescript) {
+        LexConfig.checkTypescriptConfig();
+    }
+    if (remove) {
+        spinner.start('Cleaning output directory...');
+        await removeFiles(outputFullPath || '');
+        spinner.succeed('Successfully cleaned output directory!');
+    }
+    if (translations) {
+        spinner.start('Processing translations...');
+        try {
+            const sourcePath = LexConfig.config.sourceFullPath || process.cwd();
+            const outputPath = LexConfig.config.outputFullPath || 'lib';
+            await processTranslations(sourcePath, outputPath, quiet);
+            spinner.succeed('Translations processed successfully!');
+        } catch (translationError) {
+            log(`\n${cliName} Error: Failed to process translations: ${translationError.message}`, 'error', quiet);
+            spinner.fail('Failed to process translations.');
+            callback(1);
+            return 1;
         }
-        showStatusOnce(detectedPort);
-      }
-    });
-    setTimeout(() => {
-      if (!serverStarted) {
-        spinner.succeed("Development server started.");
-        showStatusOnce(detectedPort);
-      }
-    }, 5e3);
-    await childProcess;
-    if (!serverStarted) {
-      spinner.succeed("Development server started.");
-      showStatusOnce(detectedPort);
     }
-    callback(0);
-    return 0;
-  } catch (error) {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    spinner.fail("There was an error while running Webpack.");
-    callback(1);
-    return 1;
-  }
-};
-export {
-  dev
+    let webpackConfig;
+    if (config) {
+        const isRelativeConfig = config.substr(0, 2) === './';
+        webpackConfig = isRelativeConfig ? pathResolve(process.cwd(), config) : config;
+    } else {
+        const { webpackConfig: resolvedConfig } = resolveWebpackPaths(currentDirname);
+        webpackConfig = resolvedConfig;
+    }
+    const { webpackPath } = resolveWebpackPaths(currentDirname);
+    const webpackOptions = [
+        '--color',
+        '--watch',
+        '--config',
+        webpackConfig
+    ];
+    if (bundleAnalyzer) {
+        webpackOptions.push('--bundleAnalyzer');
+    }
+    if (port !== 3000) {
+        webpackOptions.push('--port', port.toString());
+    }
+    try {
+        const finalWebpackOptions = webpackPath === 'npx' ? [
+            'webpack',
+            ...webpackOptions
+        ] : webpackOptions;
+        spinner.start('Starting development server...');
+        const childProcess = execa(webpackPath, finalWebpackOptions, {
+            encoding: 'utf8',
+            env: {
+                LEX_QUIET: quiet,
+                WEBPACK_DEV_OPEN: open
+            },
+            stdio: 'pipe'
+        });
+        let serverStarted = false;
+        let statusShown = false;
+        const showStatusOnce = (portToShow)=>{
+            if (statusShown) {
+                return;
+            }
+            statusShown = true;
+            if (usePublicIp) {
+                fetchPublicIp(usePublicIp).then((publicIp)=>{
+                    displayServerStatus(portToShow, quiet, publicIp);
+                });
+            } else {
+                displayServerStatus(portToShow, quiet);
+            }
+        };
+        let detectedPort = 3000;
+        childProcess.stdout?.on('data', (data)=>{
+            const output = data.toString();
+            handleWebpackProgress(output, spinner, quiet, '🚀', 'Webpack Building');
+            if (!serverStarted && (output.includes('Local:') || output.includes('webpack compiled') || output.includes('webpack-plugin-serve') || output.includes('http://localhost') || output.includes('listening on port'))) {
+                serverStarted = true;
+                spinner.succeed('Development server started.');
+                const portMatch = output.match(/Local:\s*http:\/\/[^:]+:(\d+)/) || output.match(/http:\/\/localhost:(\d+)/) || output.match(/port:\s*(\d+)/) || output.match(/listening on port (\d+)/) || output.match(/WebpackPluginServe listening on port (\d+)/);
+                if (portMatch) {
+                    detectedPort = parseInt(portMatch[1]);
+                }
+                showStatusOnce(detectedPort);
+            }
+        });
+        childProcess.stderr?.on('data', (data)=>{
+            const output = data.toString();
+            handleWebpackProgress(output, spinner, quiet, '🚀', 'Webpack Building');
+            if (!serverStarted && (output.includes('Local:') || output.includes('webpack compiled') || output.includes('webpack-plugin-serve') || output.includes('http://localhost') || output.includes('listening on port'))) {
+                serverStarted = true;
+                spinner.succeed('Development server started.');
+                const portMatch = output.match(/Local:\s*http:\/\/[^:]+:(\d+)/) || output.match(/http:\/\/localhost:(\d+)/) || output.match(/port:\s*(\d+)/) || output.match(/listening on port (\d+)/) || output.match(/WebpackPluginServe listening on port (\d+)/);
+                if (portMatch) {
+                    detectedPort = parseInt(portMatch[1]);
+                }
+                showStatusOnce(detectedPort);
+            }
+        });
+        setTimeout(()=>{
+            if (!serverStarted) {
+                spinner.succeed('Development server started.');
+                showStatusOnce(detectedPort);
+            }
+        }, 5000);
+        await childProcess;
+        if (!serverStarted) {
+            spinner.succeed('Development server started.');
+            showStatusOnce(detectedPort);
+        }
+        callback(0);
+        return 0;
+    } catch (error) {
+        log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+        spinner.fail('There was an error while running Webpack.');
+        callback(1);
+        return 1;
+    }
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/dev/dev.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 boxen from 'boxen';\nimport chalk from 'chalk';\nimport {execa} from 'execa';\nimport {existsSync, readFileSync, writeFileSync, mkdirSync} from 'fs';\nimport https from 'https';\nimport {networkInterfaces, homedir} from 'os';\nimport {dirname, resolve as pathResolve, join} from 'path';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner, handleWebpackProgress, removeFiles} from '../../utils/app.js';\nimport {resolveWebpackPaths} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\nimport {processTranslations} from '../../utils/translations.js';\n\nlet currentFilename: string;\nlet currentDirname: string;\n\ntry {\n  // eslint-disable-next-line no-eval\n  currentFilename = eval('require(\"url\").fileURLToPath(import.meta.url)');\n  currentDirname = dirname(currentFilename);\n} catch {\n  currentFilename = process.cwd();\n  currentDirname = process.cwd();\n}\n\nexport interface DevOptions {\n  readonly bundleAnalyzer?: boolean;\n  readonly cliName?: string;\n  readonly config?: string;\n  readonly format?: string;\n  readonly open?: boolean;\n  readonly quiet?: boolean;\n  readonly remove?: boolean;\n  readonly translations?: boolean;\n  readonly usePublicIp?: boolean;\n  readonly variables?: string;\n}\n\nexport type DevCallback = (status: number) => void;\n\ninterface PublicIpCache {\n  ip: string;\n  timestamp: number;\n}\n\nconst getCacheDir = (): string => {\n  const cacheDir = join(homedir(), '.lex-cache');\n  if(!existsSync(cacheDir)) {\n    mkdirSync(cacheDir, {recursive: true});\n  }\n  return cacheDir;\n};\n\nconst getCachePath = (): string => join(getCacheDir(), 'public-ip.json');\n\nconst readPublicIpCache = (): PublicIpCache | null => {\n  const cachePath = getCachePath();\n  if(!existsSync(cachePath)) {\n    return null;\n  }\n\n  try {\n    const cacheData = readFileSync(cachePath, 'utf8');\n    const cache: PublicIpCache = JSON.parse(cacheData);\n    const oneWeekMs = 7 * 24 * 60 * 60 * 1000;\n\n    if(Date.now() - cache.timestamp > oneWeekMs) {\n      return null;\n    }\n\n    return cache;\n  } catch {\n    return null;\n  }\n};\n\nconst writePublicIpCache = (ip: string): void => {\n  const cachePath = getCachePath();\n  const cache: PublicIpCache = {\n    ip,\n    timestamp: Date.now()\n  };\n  writeFileSync(cachePath, JSON.stringify(cache, null, 2));\n};\n\nconst fetchPublicIp = (forceRefresh: boolean = false): Promise<string | undefined> => new Promise((resolve) => {\n  if(!forceRefresh) {\n    const cached = readPublicIpCache();\n    if(cached) {\n      resolve(cached.ip);\n      return;\n    }\n  }\n\n  https.get('https://api.ipify.org', (res) => {\n    let data = '';\n    res.on('data', (chunk) => (data += chunk));\n    res.on('end', () => {\n      const ip = data.trim();\n      if(ip) {\n        writePublicIpCache(ip);\n      }\n      resolve(ip);\n    });\n  }).on('error', () => resolve(undefined));\n});\n\nconst getNetworkAddresses = () => {\n  const interfaces = networkInterfaces();\n  const addresses = {\n    local: 'localhost',\n    private: null,\n    public: null\n  };\n\n  for(const name of Object.keys(interfaces)) {\n    const networkInterface = interfaces[name];\n    if(!networkInterface) {\n      continue;\n    }\n\n    for(const iface of networkInterface) {\n      if(iface.family === 'IPv4' && !iface.internal) {\n        const ip = iface.address;\n\n        if(ip.startsWith('10.') || ip.startsWith('192.168.') || ip.startsWith('172.')) {\n          if(!addresses.private) {\n            addresses.private = ip;\n          }\n        } else {\n          if(!addresses.public) {\n            addresses.public = ip;\n          }\n        }\n      }\n    }\n  }\n\n  return addresses;\n};\n\nconst displayServerStatus = (port: number = 7001, quiet: boolean, publicIp?: string) => {\n  if(quiet) {\n    return;\n  }\n\n  const addresses = getNetworkAddresses();\n  const localUrl = `http://localhost:${port}`;\n  const privateUrl = addresses.private ? `http://${addresses.private}:${port}` : null;\n  let publicUrl = null;\n  if(publicIp) {\n    publicUrl = `http://${publicIp}:${port}`;\n  } else if(addresses.public) {\n    publicUrl = `http://${addresses.public}:${port}`;\n  }\n\n  let urlLines = `${chalk.green('Local:')}     ${chalk.underline(localUrl)}\\n`;\n\n  if(privateUrl) {\n    urlLines += `${chalk.green('Private:')}   ${chalk.underline(privateUrl)}\\n`;\n  }\n\n  if(publicUrl) {\n    urlLines += `${chalk.green('Public:')}    ${chalk.underline(publicUrl)}\\n`;\n  }\n\n  const statusBox = boxen(\n    `${chalk.cyan.bold('\uD83D\uDE80 Development Server Running')}\\n\\n${urlLines}\\n` +\n    `${chalk.yellow('Press Ctrl+C to stop the server')}`,\n    {\n      backgroundColor: '#1a1a1a',\n      borderColor: 'cyan',\n      borderStyle: 'round',\n      margin: 1,\n      padding: 1\n    }\n  );\n\n  // eslint-disable-next-line no-console\n  console.log(`\\n${statusBox}\\n`);\n};\n\nexport const dev = async (cmd: DevOptions, callback: DevCallback = () => ({})): Promise<number> => {\n  const {bundleAnalyzer, cliName = 'Lex', config, format = 'esm', open = false, quiet, remove, translations = false, usePublicIp, variables} = cmd;\n\n  const spinner = createSpinner(quiet);\n\n  log(`${cliName} start development server...`, 'info', quiet);\n\n  await LexConfig.parseConfig(cmd);\n\n  const {outputFullPath, useTypescript} = LexConfig.config;\n\n  let variablesObj: object = {NODE_ENV: 'development'};\n\n  if(variables) {\n    try {\n      variablesObj = JSON.parse(variables);\n    } catch (_error) {\n      log(`\\n${cliName} Error: Environment variables option is not a valid JSON object.`, 'error', quiet);\n      callback(1);\n      return 1;\n    }\n  }\n\n  process.env = {...process.env, ...variablesObj};\n\n  if(useTypescript) {\n    LexConfig.checkTypescriptConfig();\n  }\n\n  if(remove) {\n    spinner.start('Cleaning output directory...');\n\n    await removeFiles(outputFullPath || '');\n\n    spinner.succeed('Successfully cleaned output directory!');\n  }\n\n  if(translations) {\n    spinner.start('Processing translations...');\n\n    try {\n      const sourcePath = LexConfig.config.sourceFullPath || process.cwd();\n      const outputPath = LexConfig.config.outputFullPath || 'lib';\n\n      await processTranslations(sourcePath, outputPath, quiet);\n      spinner.succeed('Translations processed successfully!');\n    } catch (translationError) {\n      log(`\\n${cliName} Error: Failed to process translations: ${translationError.message}`, 'error', quiet);\n      spinner.fail('Failed to process translations.');\n      callback(1);\n      return 1;\n    }\n  }\n\n  let webpackConfig: string;\n\n  if(config) {\n    const isRelativeConfig: boolean = config.substr(0, 2) === './';\n    webpackConfig = isRelativeConfig ? pathResolve(process.cwd(), config) : config;\n  } else {\n    const {webpackConfig: resolvedConfig} = resolveWebpackPaths(currentDirname);\n    webpackConfig = resolvedConfig;\n  }\n\n  const {webpackPath} = resolveWebpackPaths(currentDirname);\n\n  const webpackOptions: string[] = [\n    '--color',\n    '--watch',\n    '--config', webpackConfig\n  ];\n\n  if(bundleAnalyzer) {\n    webpackOptions.push('--bundleAnalyzer');\n  }\n\n  try {\n    const finalWebpackOptions = webpackPath === 'npx' ? ['webpack', ...webpackOptions] : webpackOptions;\n\n    spinner.start('Starting development server...');\n\n    const childProcess = execa(webpackPath, finalWebpackOptions, {\n      encoding: 'utf8',\n      env: {\n        LEX_QUIET: quiet,\n        WEBPACK_DEV_OPEN: open\n      },\n      stdio: 'pipe'\n    } as any);\n\n    let serverStarted = false;\n    let statusShown = false;\n    const showStatusOnce = (portToShow: number) => {\n      if(statusShown) {\n        return;\n      }\n      statusShown = true;\n      if(usePublicIp) {\n        fetchPublicIp(usePublicIp).then((publicIp) => {\n          displayServerStatus(portToShow, quiet, publicIp);\n        });\n      } else {\n        displayServerStatus(portToShow, quiet);\n      }\n    };\n    let detectedPort = 7001;\n\n    childProcess.stdout?.on('data', (data: Buffer) => {\n      const output = data.toString();\n\n      handleWebpackProgress(output, spinner, quiet, '\uD83D\uDE80', 'Webpack Building');\n\n      if(!serverStarted && (output.includes('Local:') || output.includes('webpack compiled') || output.includes('webpack-plugin-serve') || output.includes('http://localhost') || output.includes('listening on port'))) {\n        serverStarted = true;\n        spinner.succeed('Development server started.');\n\n        const portMatch = output.match(/Local:\\s*http:\\/\\/[^:]+:(\\d+)/) ||\n          output.match(/http:\\/\\/localhost:(\\d+)/) ||\n          output.match(/port:\\s*(\\d+)/) ||\n          output.match(/listening on port (\\d+)/) ||\n          output.match(/WebpackPluginServe listening on port (\\d+)/);\n        if(portMatch) {\n          detectedPort = parseInt(portMatch[1]);\n        }\n\n        showStatusOnce(detectedPort);\n      }\n    });\n\n    childProcess.stderr?.on('data', (data: Buffer) => {\n      const output = data.toString();\n\n      handleWebpackProgress(output, spinner, quiet, '\uD83D\uDE80', 'Webpack Building');\n\n      if(!serverStarted && (output.includes('Local:') || output.includes('webpack compiled') || output.includes('webpack-plugin-serve') || output.includes('http://localhost') || output.includes('listening on port'))) {\n        serverStarted = true;\n        spinner.succeed('Development server started.');\n\n        const portMatch = output.match(/Local:\\s*http:\\/\\/[^:]+:(\\d+)/) ||\n          output.match(/http:\\/\\/localhost:(\\d+)/) ||\n          output.match(/port:\\s*(\\d+)/) ||\n          output.match(/listening on port (\\d+)/) ||\n          output.match(/WebpackPluginServe listening on port (\\d+)/);\n        if(portMatch) {\n          detectedPort = parseInt(portMatch[1]);\n        }\n\n        showStatusOnce(detectedPort);\n      }\n    });\n\n    setTimeout(() => {\n      if(!serverStarted) {\n        spinner.succeed('Development server started.');\n        showStatusOnce(detectedPort);\n      }\n    }, 5000);\n\n    await childProcess;\n\n    if(!serverStarted) {\n      spinner.succeed('Development server started.');\n      showStatusOnce(detectedPort);\n    }\n\n    callback(0);\n    return 0;\n  } catch (error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n    spinner.fail('There was an error while running Webpack.');\n\n    callback(1);\n    return 1;\n  }\n};"],
  "mappings": "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",
  "names": []
}

+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/dev/dev.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 boxen from 'boxen';\nimport chalk from 'chalk';\nimport {execa} from 'execa';\nimport {existsSync, readFileSync, writeFileSync, mkdirSync} from 'fs';\nimport https from 'https';\nimport {networkInterfaces, homedir} from 'os';\nimport {dirname, resolve as pathResolve, join} from 'path';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner, handleWebpackProgress, removeFiles} from '../../utils/app.js';\nimport {resolveWebpackPaths} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\nimport {processTranslations} from '../../utils/translations.js';\n\nlet currentFilename: string;\nlet currentDirname: string;\n\ntry {\n  // eslint-disable-next-line no-eval\n  currentFilename = eval('require(\"url\").fileURLToPath(import.meta.url)');\n  currentDirname = dirname(currentFilename);\n} catch{\n  currentFilename = process.cwd();\n  currentDirname = process.cwd();\n}\n\nexport interface DevOptions {\n  readonly bundleAnalyzer?: boolean;\n  readonly cliName?: string;\n  readonly config?: string;\n  readonly format?: string;\n  readonly open?: boolean;\n  readonly port?: number;\n  readonly quiet?: boolean;\n  readonly remove?: boolean;\n  readonly translations?: boolean;\n  readonly usePublicIp?: boolean;\n  readonly variables?: string;\n}\n\nexport type DevCallback = (status: number) => void;\n\ninterface PublicIpCache {\n  ip: string;\n  timestamp: number;\n}\n\nconst getCacheDir = (): string => {\n  const cacheDir = join(homedir(), '.lex-cache');\n  if(!existsSync(cacheDir)) {\n    mkdirSync(cacheDir, {recursive: true});\n  }\n  return cacheDir;\n};\n\nconst getCachePath = (): string => join(getCacheDir(), 'public-ip.json');\n\nconst readPublicIpCache = (): PublicIpCache | null => {\n  const cachePath = getCachePath();\n  if(!existsSync(cachePath)) {\n    return null;\n  }\n\n  try {\n    const cacheData = readFileSync(cachePath, 'utf8');\n    const cache: PublicIpCache = JSON.parse(cacheData);\n    const oneWeekMs = 7 * 24 * 60 * 60 * 1000;\n\n    if(Date.now() - cache.timestamp > oneWeekMs) {\n      return null;\n    }\n\n    return cache;\n  } catch{\n    return null;\n  }\n};\n\nconst writePublicIpCache = (ip: string): void => {\n  const cachePath = getCachePath();\n  const cache: PublicIpCache = {\n    ip,\n    timestamp: Date.now()\n  };\n  writeFileSync(cachePath, JSON.stringify(cache, null, 2));\n};\n\nconst fetchPublicIp = (forceRefresh: boolean = false): Promise<string | undefined> => new Promise((resolve) => {\n  if(!forceRefresh) {\n    const cached = readPublicIpCache();\n    if(cached) {\n      resolve(cached.ip);\n      return;\n    }\n  }\n\n  https.get('https://api.ipify.org', (res) => {\n    let data = '';\n    res.on('data', (chunk) => (data += chunk));\n    res.on('end', () => {\n      const ip = data.trim();\n      if(ip) {\n        writePublicIpCache(ip);\n      }\n      resolve(ip);\n    });\n  }).on('error', () => resolve(undefined));\n});\n\nconst getNetworkAddresses = () => {\n  const interfaces = networkInterfaces();\n  const addresses = {\n    local: 'localhost',\n    private: null,\n    public: null\n  };\n\n  for(const name of Object.keys(interfaces)) {\n    const networkInterface = interfaces[name];\n    if(!networkInterface) {\n      continue;\n    }\n\n    for(const iface of networkInterface) {\n      if(iface.family === 'IPv4' && !iface.internal) {\n        const ip = iface.address;\n\n        if(ip.startsWith('10.') || ip.startsWith('192.168.') || ip.startsWith('172.')) {\n          if(!addresses.private) {\n            addresses.private = ip;\n          }\n        } else {\n          if(!addresses.public) {\n            addresses.public = ip;\n          }\n        }\n      }\n    }\n  }\n\n  return addresses;\n};\n\nconst displayServerStatus = (port: number = 3000, quiet: boolean, publicIp?: string) => {\n  if(quiet) {\n    return;\n  }\n\n  const addresses = getNetworkAddresses();\n  const localUrl = `http://localhost:${port}`;\n  const privateUrl = addresses.private ? `http://${addresses.private}:${port}` : null;\n  let publicUrl = null;\n  if(publicIp) {\n    publicUrl = `http://${publicIp}:${port}`;\n  } else if(addresses.public) {\n    publicUrl = `http://${addresses.public}:${port}`;\n  }\n\n  let urlLines = `${chalk.green('Local:')}     ${chalk.underline(localUrl)}\\n`;\n\n  if(privateUrl) {\n    urlLines += `${chalk.green('Private:')}   ${chalk.underline(privateUrl)}\\n`;\n  }\n\n  if(publicUrl) {\n    urlLines += `${chalk.green('Public:')}    ${chalk.underline(publicUrl)}\\n`;\n  }\n\n  const statusBox = boxen(\n    `${chalk.cyan.bold('🚀 Development Server Running')}\\n\\n${urlLines}\\n` +\n    `${chalk.yellow('Press Ctrl+C to stop the server')}`,\n    {\n      backgroundColor: '#1a1a1a',\n      borderColor: 'cyan',\n      borderStyle: 'round',\n      margin: 1,\n      padding: 1\n    }\n  );\n\n  // eslint-disable-next-line no-console\n  console.log(`\\n${statusBox}\\n`);\n};\n\nexport const dev = async (cmd: DevOptions, callback: DevCallback = () => ({})): Promise<number> => {\n  const {bundleAnalyzer, cliName = 'Lex', config, format = 'esm', open = false, port = 3000, quiet, remove, translations = false, usePublicIp, variables} = cmd;\n\n  const spinner = createSpinner(quiet);\n\n  log(`${cliName} start development server...`, 'info', quiet);\n\n  await LexConfig.parseConfig(cmd);\n\n  const {outputFullPath, useTypescript} = LexConfig.config;\n\n  let variablesObj: object = {NODE_ENV: 'development'};\n\n  if(variables) {\n    try {\n      variablesObj = JSON.parse(variables);\n    } catch(_error) {\n      log(`\\n${cliName} Error: Environment variables option is not a valid JSON object.`, 'error', quiet);\n      callback(1);\n      return 1;\n    }\n  }\n\n  process.env = {...process.env, ...variablesObj};\n\n  if(useTypescript) {\n    LexConfig.checkTypescriptConfig();\n  }\n\n  if(remove) {\n    spinner.start('Cleaning output directory...');\n\n    await removeFiles(outputFullPath || '');\n\n    spinner.succeed('Successfully cleaned output directory!');\n  }\n\n  if(translations) {\n    spinner.start('Processing translations...');\n\n    try {\n      const sourcePath = LexConfig.config.sourceFullPath || process.cwd();\n      const outputPath = LexConfig.config.outputFullPath || 'lib';\n\n      await processTranslations(sourcePath, outputPath, quiet);\n      spinner.succeed('Translations processed successfully!');\n    } catch(translationError) {\n      log(`\\n${cliName} Error: Failed to process translations: ${translationError.message}`, 'error', quiet);\n      spinner.fail('Failed to process translations.');\n      callback(1);\n      return 1;\n    }\n  }\n\n  let webpackConfig: string;\n\n  if(config) {\n    const isRelativeConfig: boolean = config.substr(0, 2) === './';\n    webpackConfig = isRelativeConfig ? pathResolve(process.cwd(), config) : config;\n  } else {\n    const {webpackConfig: resolvedConfig} = resolveWebpackPaths(currentDirname);\n    webpackConfig = resolvedConfig;\n  }\n\n  const {webpackPath} = resolveWebpackPaths(currentDirname);\n\n  const webpackOptions: string[] = [\n    '--color',\n    '--watch',\n    '--config', webpackConfig\n  ];\n\n  if(bundleAnalyzer) {\n    webpackOptions.push('--bundleAnalyzer');\n  }\n\n  if(port !== 3000) {\n    webpackOptions.push('--port', port.toString());\n  }\n\n  try {\n    const finalWebpackOptions = webpackPath === 'npx' ? ['webpack', ...webpackOptions] : webpackOptions;\n\n    spinner.start('Starting development server...');\n\n    const childProcess = execa(webpackPath, finalWebpackOptions, {\n      encoding: 'utf8',\n      env: {\n        LEX_QUIET: quiet,\n        WEBPACK_DEV_OPEN: open\n      },\n      stdio: 'pipe'\n    } as any);\n\n    let serverStarted = false;\n    let statusShown = false;\n    const showStatusOnce = (portToShow: number) => {\n      if(statusShown) {\n        return;\n      }\n      statusShown = true;\n      if(usePublicIp) {\n        fetchPublicIp(usePublicIp).then((publicIp) => {\n          displayServerStatus(portToShow, quiet, publicIp);\n        });\n      } else {\n        displayServerStatus(portToShow, quiet);\n      }\n    };\n    let detectedPort = 3000;\n\n    childProcess.stdout?.on('data', (data: Buffer) => {\n      const output = data.toString();\n\n      handleWebpackProgress(output, spinner, quiet, '🚀', 'Webpack Building');\n\n      if(!serverStarted && (output.includes('Local:') || output.includes('webpack compiled') || output.includes('webpack-plugin-serve') || output.includes('http://localhost') || output.includes('listening on port'))) {\n        serverStarted = true;\n        spinner.succeed('Development server started.');\n\n        const portMatch = output.match(/Local:\\s*http:\\/\\/[^:]+:(\\d+)/) ||\n          output.match(/http:\\/\\/localhost:(\\d+)/) ||\n          output.match(/port:\\s*(\\d+)/) ||\n          output.match(/listening on port (\\d+)/) ||\n          output.match(/WebpackPluginServe listening on port (\\d+)/);\n        if(portMatch) {\n          detectedPort = parseInt(portMatch[1]);\n        }\n\n        showStatusOnce(detectedPort);\n      }\n    });\n\n    childProcess.stderr?.on('data', (data: Buffer) => {\n      const output = data.toString();\n\n      handleWebpackProgress(output, spinner, quiet, '🚀', 'Webpack Building');\n\n      if(!serverStarted && (output.includes('Local:') || output.includes('webpack compiled') || output.includes('webpack-plugin-serve') || output.includes('http://localhost') || output.includes('listening on port'))) {\n        serverStarted = true;\n        spinner.succeed('Development server started.');\n\n        const portMatch = output.match(/Local:\\s*http:\\/\\/[^:]+:(\\d+)/) ||\n          output.match(/http:\\/\\/localhost:(\\d+)/) ||\n          output.match(/port:\\s*(\\d+)/) ||\n          output.match(/listening on port (\\d+)/) ||\n          output.match(/WebpackPluginServe listening on port (\\d+)/);\n        if(portMatch) {\n          detectedPort = parseInt(portMatch[1]);\n        }\n\n        showStatusOnce(detectedPort);\n      }\n    });\n\n    setTimeout(() => {\n      if(!serverStarted) {\n        spinner.succeed('Development server started.');\n        showStatusOnce(detectedPort);\n      }\n    }, 5000);\n\n    await childProcess;\n\n    if(!serverStarted) {\n      spinner.succeed('Development server started.');\n      showStatusOnce(detectedPort);\n    }\n\n    callback(0);\n    return 0;\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n    spinner.fail('There was an error while running Webpack.');\n\n    callback(1);\n    return 1;\n  }\n};"],"names":["boxen","chalk","execa","existsSync","readFileSync","writeFileSync","mkdirSync","https","networkInterfaces","homedir","dirname","resolve","pathResolve","join","LexConfig","createSpinner","handleWebpackProgress","removeFiles","resolveWebpackPaths","log","processTranslations","currentFilename","currentDirname","eval","process","cwd","getCacheDir","cacheDir","recursive","getCachePath","readPublicIpCache","cachePath","cacheData","cache","JSON","parse","oneWeekMs","Date","now","timestamp","writePublicIpCache","ip","stringify","fetchPublicIp","forceRefresh","Promise","cached","get","res","data","on","chunk","trim","undefined","getNetworkAddresses","interfaces","addresses","local","private","public","name","Object","keys","networkInterface","iface","family","internal","address","startsWith","displayServerStatus","port","quiet","publicIp","localUrl","privateUrl","publicUrl","urlLines","green","underline","statusBox","cyan","bold","yellow","backgroundColor","borderColor","borderStyle","margin","padding","console","dev","cmd","callback","bundleAnalyzer","cliName","config","format","open","remove","translations","usePublicIp","variables","spinner","parseConfig","outputFullPath","useTypescript","variablesObj","NODE_ENV","_error","env","checkTypescriptConfig","start","succeed","sourcePath","sourceFullPath","outputPath","translationError","message","fail","webpackConfig","isRelativeConfig","substr","resolvedConfig","webpackPath","webpackOptions","push","toString","finalWebpackOptions","childProcess","encoding","LEX_QUIET","WEBPACK_DEV_OPEN","stdio","serverStarted","statusShown","showStatusOnce","portToShow","then","detectedPort","stdout","output","includes","portMatch","match","parseInt","stderr","setTimeout","error"],"mappings":"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"}