@nlabs/lex 1.48.7 → 1.49.0

package/lib/commands/dev/dev.js

@@ -0,0 +1,286 @@
+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();
+}
+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;
+    }
+    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 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(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;
+          }
+        }
+      }
+    }
+  }
+  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
+    }
+  );
+  console.log(`
+${statusBox}
+`);
+};
+const dev = async (cmd, callback = () => ({})) => {
+  const { bundleAnalyzer, cliName = "Lex", config, 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;
+    }
+  }
+  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 || "dist";
+      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 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"
+    });
+    let serverStarted = false;
+    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]);
+        }
+        displayServerStatus(detectedPort, quiet);
+        fetchPublicIp(usePublicIp).then((publicIp) => {
+          if (publicIp) {
+            displayServerStatus(detectedPort, quiet, publicIp);
+          }
+        });
+      }
+    });
+    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]);
+        }
+        displayServerStatus(detectedPort, quiet);
+        fetchPublicIp(usePublicIp).then((publicIp) => {
+          if (publicIp) {
+            displayServerStatus(detectedPort, quiet, publicIp);
+          }
+        });
+      }
+    });
+    setTimeout(() => {
+      if (!serverStarted) {
+        spinner.succeed("Development server started.");
+        displayServerStatus(detectedPort, quiet);
+        fetchPublicIp(usePublicIp).then((publicIp) => {
+          if (publicIp) {
+            displayServerStatus(detectedPort, quiet, publicIp);
+          }
+        });
+      }
+    }, 5e3);
+    await childProcess;
+    if (!serverStarted) {
+      spinner.succeed("Development server started.");
+      displayServerStatus(detectedPort, quiet);
+      fetchPublicIp(usePublicIp).then((publicIp) => {
+        if (publicIp) {
+          displayServerStatus(detectedPort, quiet, publicIp);
+        }
+      });
+    }
+    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
+};
+//# 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 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\n    // Check if cache is older than 1 week (7 days * 24 hours * 60 minutes * 60 seconds * 1000 milliseconds)\n    const oneWeekMs = 7 * 24 * 60 * 60 * 1000;\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  // Check cache first unless force refresh is requested\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        // Private IP ranges\n        if(ip.startsWith('10.') || ip.startsWith('192.168.') || ip.startsWith('172.')) {\n          if(!addresses.private) {\n            addresses.private = ip;\n          }\n        } else {\n          // Public IP (not in private ranges)\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, 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  // Process translations if flag is enabled (before starting dev server)\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 || 'dist';\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 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        // Try multiple patterns to detect the port\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        displayServerStatus(detectedPort, quiet);\n        fetchPublicIp(usePublicIp).then((publicIp) => {\n          if(publicIp) {\n            displayServerStatus(detectedPort, quiet, publicIp);\n          }\n        });\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        // Try multiple patterns to detect the port\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        displayServerStatus(detectedPort, quiet);\n        fetchPublicIp(usePublicIp).then((publicIp) => {\n          if(publicIp) {\n            displayServerStatus(detectedPort, quiet, publicIp);\n          }\n        });\n      }\n    });\n\n    setTimeout(() => {\n      if(!serverStarted) {\n        spinner.succeed('Development server started.');\n        displayServerStatus(detectedPort, quiet);\n        fetchPublicIp(usePublicIp).then((publicIp) => {\n          if(publicIp) {\n            displayServerStatus(detectedPort, quiet, publicIp);\n          }\n        });\n      }\n    }, 5000);\n\n    await childProcess;\n\n    if(!serverStarted) {\n      spinner.succeed('Development server started.');\n      displayServerStatus(detectedPort, quiet);\n      fetchPublicIp(usePublicIp).then((publicIp) => {\n        if(publicIp) {\n          displayServerStatus(detectedPort, quiet, publicIp);\n        }\n      });\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": []
}


package/{dist → lib}/commands/init/init.js

@@ -90,4 +90,4 @@ ${cliName} Error: ${error.message}`, "error", quiet);
 export {
   init
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/init/init.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 {renameSync, writeFileSync} from 'fs';\nimport {resolve as pathResolve} from 'path';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner, getPackageJson, setPackageJson} from '../../utils/app.js';\nimport {getDirName} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nexport interface InitOptions {\n  readonly cliName?: string;\n  readonly install?: boolean;\n  readonly packageManager?: string;\n  readonly quiet?: boolean;\n  readonly typescript?: boolean;\n}\n\nexport type InitCallback = (status: number) => void;\n\nexport const init = async (\n  appName: string,\n  packageName: string,\n  cmd: InitOptions,\n  callback: InitCallback = () => ({})\n): Promise<number> => {\n  const {cliName = 'Lex', install, packageManager: cmdPackageManager, quiet, typescript} = cmd;\n  const cwd: string = process.cwd();\n\n  // Spinner\n  const spinner = createSpinner(quiet);\n\n  // Download app module into temporary directory\n  log(`${cliName} is downloading the app module...`, 'info', quiet);\n  spinner.start('Downloading app...');\n  const tmpPath: string = pathResolve(cwd, './.lexTmp');\n  const appPath: string = pathResolve(cwd, `./${appName}`);\n  const dirName = getDirName();\n  const dnpPath: string = pathResolve(dirName, '../../../node_modules/download-npm-package/bin/cli.js');\n\n  // Get custom configuration\n  await LexConfig.parseConfig(cmd);\n  const {packageManager: configPackageManager, useTypescript: configTypescript} = LexConfig.config;\n  const packageManager: string = cmdPackageManager || configPackageManager || '';\n  const useTypescript: boolean = typescript !== undefined ? typescript : configTypescript || false;\n\n  let appModule: string = packageName;\n\n  // Use base app module based on config\n  if(!appModule) {\n    if(useTypescript) {\n      appModule = '@nlabs/arkhamjs-example-ts-react';\n    } else {\n      appModule = '@nlabs/arkhamjs-example-flow-react';\n    }\n  }\n\n  try {\n    await execa(dnpPath, [appModule, tmpPath], {});\n\n    // Stop spinner and update status\n    spinner.succeed('Successfully downloaded app!');\n  } catch(error) {\n    console.log('error', error);\n    log(`\\n${cliName} Error: There was an error downloading ${appModule}. Make sure the package exists and there is a network connection.`, 'error', quiet);\n\n    // Stop spinner and kill process\n    spinner.fail('Downloaded of app failed.');\n\n    // Kill process\n    callback(1);\n    return 1;\n  }\n\n  // Move into configured directory\n  try {\n    renameSync(`${tmpPath}/${appModule}`, appPath);\n  } catch(_error) {\n    log(`\\n${cliName} Error: There was an error copying ${appModule} to the current working directory.`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n\n  // Configure package.json\n  const packagePath: string = `${appPath}/package.json`;\n  const packageJson = getPackageJson(packagePath);\n  packageJson.name = appName;\n  packageJson.description = `${cliName} created app`;\n  packageJson.version = '0.1.0';\n  delete packageJson.keywords;\n  delete packageJson.author;\n  delete packageJson.contributors;\n  delete packageJson.repository;\n  delete packageJson.homepage;\n  delete packageJson.bugs;\n\n  try {\n    // Update package.json\n    setPackageJson(packageJson, packagePath);\n\n    // Update README\n    const readmePath: string = `${appPath}/README.md`;\n    writeFileSync(readmePath, `# ${appName}`);\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n\n  if(install) {\n    spinner.start('Installing dependencies...');\n\n    // Change to the app directory\n    process.chdir(appPath);\n\n    // Install dependencies\n    try {\n      await execa(packageManager, ['install'], {\n        encoding: 'utf8',\n        stdio: 'inherit'\n      });\n\n      // Stop spinner\n      spinner.succeed('Successfully installed dependencies!');\n    } catch(error) {\n      // Display error message\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      // Stop spinner\n      spinner.fail('Failed to install dependencies.');\n\n      // Kill process\n      callback(1);\n      return 1;\n    }\n  }\n\n  // Kill process\n  callback(0);\n  return 0;\n};"],
  "mappings": "AAIA,SAAQ,aAAY;AACpB,SAAQ,YAAY,qBAAoB;AACxC,SAAQ,WAAW,mBAAkB;AAErC,SAAQ,iBAAgB;AACxB,SAAQ,eAAe,gBAAgB,sBAAqB;AAC5D,SAAQ,kBAAiB;AACzB,SAAQ,WAAU;AAYX,MAAM,OAAO,OAClB,SACA,aACA,KACA,WAAyB,OAAO,CAAC,OACb;AACpB,QAAM,EAAC,UAAU,OAAO,SAAS,gBAAgB,mBAAmB,OAAO,WAAU,IAAI;AACzF,QAAM,MAAc,QAAQ,IAAI;AAGhC,QAAM,UAAU,cAAc,KAAK;AAGnC,MAAI,GAAG,OAAO,qCAAqC,QAAQ,KAAK;AAChE,UAAQ,MAAM,oBAAoB;AAClC,QAAM,UAAkB,YAAY,KAAK,WAAW;AACpD,QAAM,UAAkB,YAAY,KAAK,KAAK,OAAO,EAAE;AACvD,QAAM,UAAU,WAAW;AAC3B,QAAM,UAAkB,YAAY,SAAS,uDAAuD;AAGpG,QAAM,UAAU,YAAY,GAAG;AAC/B,QAAM,EAAC,gBAAgB,sBAAsB,eAAe,iBAAgB,IAAI,UAAU;AAC1F,QAAM,iBAAyB,qBAAqB,wBAAwB;AAC5E,QAAM,gBAAyB,eAAe,SAAY,aAAa,oBAAoB;AAE3F,MAAI,YAAoB;AAGxB,MAAG,CAAC,WAAW;AACb,QAAG,eAAe;AAChB,kBAAY;AAAA,IACd,OAAO;AACL,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,MAAI;AACF,UAAM,MAAM,SAAS,CAAC,WAAW,OAAO,GAAG,CAAC,CAAC;AAG7C,YAAQ,QAAQ,8BAA8B;AAAA,EAChD,SAAQ,OAAO;AACb,YAAQ,IAAI,SAAS,KAAK;AAC1B,QAAI;AAAA,EAAK,OAAO,0CAA0C,SAAS,qEAAqE,SAAS,KAAK;AAGtJ,YAAQ,KAAK,2BAA2B;AAGxC,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAGA,MAAI;AACF,eAAW,GAAG,OAAO,IAAI,SAAS,IAAI,OAAO;AAAA,EAC/C,SAAQ,QAAQ;AACd,QAAI;AAAA,EAAK,OAAO,sCAAsC,SAAS,sCAAsC,SAAS,KAAK;AACnH,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAGA,QAAM,cAAsB,GAAG,OAAO;AACtC,QAAM,cAAc,eAAe,WAAW;AAC9C,cAAY,OAAO;AACnB,cAAY,cAAc,GAAG,OAAO;AACpC,cAAY,UAAU;AACtB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AAEnB,MAAI;AAEF,mBAAe,aAAa,WAAW;AAGvC,UAAM,aAAqB,GAAG,OAAO;AACrC,kBAAc,YAAY,KAAK,OAAO,EAAE;AAAA,EAC1C,SAAQ,OAAO;AACb,QAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAC1D,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAEA,MAAG,SAAS;AACV,YAAQ,MAAM,4BAA4B;AAG1C,YAAQ,MAAM,OAAO;AAGrB,QAAI;AACF,YAAM,MAAM,gBAAgB,CAAC,SAAS,GAAG;AAAA,QACvC,UAAU;AAAA,QACV,OAAO;AAAA,MACT,CAAC;AAGD,cAAQ,QAAQ,sCAAsC;AAAA,IACxD,SAAQ,OAAO;AAEb,UAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAG1D,cAAQ,KAAK,iCAAiC;AAG9C,eAAS,CAAC;AACV,aAAO;AAAA,IACT;AAAA,EACF;AAGA,WAAS,CAAC;AACV,SAAO;AACT;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/init/init.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 {renameSync, writeFileSync} from 'fs';\nimport {resolve as pathResolve} from 'path';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner, getPackageJson, setPackageJson} from '../../utils/app.js';\nimport {getDirName} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nexport interface InitOptions {\n  readonly cliName?: string;\n  readonly install?: boolean;\n  readonly packageManager?: string;\n  readonly quiet?: boolean;\n  readonly typescript?: boolean;\n}\n\nexport type InitCallback = (status: number) => void;\n\nexport const init = async (\n  appName: string,\n  packageName: string,\n  cmd: InitOptions,\n  callback: InitCallback = () => ({})\n): Promise<number> => {\n  const {cliName = 'Lex', install, packageManager: cmdPackageManager, quiet, typescript} = cmd;\n  const cwd: string = process.cwd();\n\n  // Spinner\n  const spinner = createSpinner(quiet);\n\n  // Download app module into temporary directory\n  log(`${cliName} is downloading the app module...`, 'info', quiet);\n  spinner.start('Downloading app...');\n  const tmpPath: string = pathResolve(cwd, './.lexTmp');\n  const appPath: string = pathResolve(cwd, `./${appName}`);\n  const dirName = getDirName();\n  const dnpPath: string = pathResolve(dirName, '../../../node_modules/download-npm-package/bin/cli.js');\n\n  // Get custom configuration\n  await LexConfig.parseConfig(cmd);\n  const {packageManager: configPackageManager, useTypescript: configTypescript} = LexConfig.config;\n  const packageManager: string = cmdPackageManager || configPackageManager || '';\n  const useTypescript: boolean = typescript !== undefined ? typescript : configTypescript || false;\n\n  let appModule: string = packageName;\n\n  // Use base app module based on config\n  if(!appModule) {\n    if(useTypescript) {\n      appModule = '@nlabs/arkhamjs-example-ts-react';\n    } else {\n      appModule = '@nlabs/arkhamjs-example-flow-react';\n    }\n  }\n\n  try {\n    await execa(dnpPath, [appModule, tmpPath], {});\n\n    // Stop spinner and update status\n    spinner.succeed('Successfully downloaded app!');\n  } catch (error) {\n    console.log('error', error);\n    log(`\\n${cliName} Error: There was an error downloading ${appModule}. Make sure the package exists and there is a network connection.`, 'error', quiet);\n\n    // Stop spinner and kill process\n    spinner.fail('Downloaded of app failed.');\n\n    // Kill process\n    callback(1);\n    return 1;\n  }\n\n  // Move into configured directory\n  try {\n    renameSync(`${tmpPath}/${appModule}`, appPath);\n  } catch (_error) {\n    log(`\\n${cliName} Error: There was an error copying ${appModule} to the current working directory.`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n\n  // Configure package.json\n  const packagePath: string = `${appPath}/package.json`;\n  const packageJson = getPackageJson(packagePath);\n  packageJson.name = appName;\n  packageJson.description = `${cliName} created app`;\n  packageJson.version = '0.1.0';\n  delete packageJson.keywords;\n  delete packageJson.author;\n  delete packageJson.contributors;\n  delete packageJson.repository;\n  delete packageJson.homepage;\n  delete packageJson.bugs;\n\n  try {\n    // Update package.json\n    setPackageJson(packageJson, packagePath);\n\n    // Update README\n    const readmePath: string = `${appPath}/README.md`;\n    writeFileSync(readmePath, `# ${appName}`);\n  } catch (error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n\n  if(install) {\n    spinner.start('Installing dependencies...');\n\n    // Change to the app directory\n    process.chdir(appPath);\n\n    // Install dependencies\n    try {\n      await execa(packageManager, ['install'], {\n        encoding: 'utf8',\n        stdio: 'inherit'\n      });\n\n      // Stop spinner\n      spinner.succeed('Successfully installed dependencies!');\n    } catch (error) {\n      // Display error message\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      // Stop spinner\n      spinner.fail('Failed to install dependencies.');\n\n      // Kill process\n      callback(1);\n      return 1;\n    }\n  }\n\n  // Kill process\n  callback(0);\n  return 0;\n};"],
  "mappings": "AAIA,SAAQ,aAAY;AACpB,SAAQ,YAAY,qBAAoB;AACxC,SAAQ,WAAW,mBAAkB;AAErC,SAAQ,iBAAgB;AACxB,SAAQ,eAAe,gBAAgB,sBAAqB;AAC5D,SAAQ,kBAAiB;AACzB,SAAQ,WAAU;AAYX,MAAM,OAAO,OAClB,SACA,aACA,KACA,WAAyB,OAAO,CAAC,OACb;AACpB,QAAM,EAAC,UAAU,OAAO,SAAS,gBAAgB,mBAAmB,OAAO,WAAU,IAAI;AACzF,QAAM,MAAc,QAAQ,IAAI;AAGhC,QAAM,UAAU,cAAc,KAAK;AAGnC,MAAI,GAAG,OAAO,qCAAqC,QAAQ,KAAK;AAChE,UAAQ,MAAM,oBAAoB;AAClC,QAAM,UAAkB,YAAY,KAAK,WAAW;AACpD,QAAM,UAAkB,YAAY,KAAK,KAAK,OAAO,EAAE;AACvD,QAAM,UAAU,WAAW;AAC3B,QAAM,UAAkB,YAAY,SAAS,uDAAuD;AAGpG,QAAM,UAAU,YAAY,GAAG;AAC/B,QAAM,EAAC,gBAAgB,sBAAsB,eAAe,iBAAgB,IAAI,UAAU;AAC1F,QAAM,iBAAyB,qBAAqB,wBAAwB;AAC5E,QAAM,gBAAyB,eAAe,SAAY,aAAa,oBAAoB;AAE3F,MAAI,YAAoB;AAGxB,MAAG,CAAC,WAAW;AACb,QAAG,eAAe;AAChB,kBAAY;AAAA,IACd,OAAO;AACL,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,MAAI;AACF,UAAM,MAAM,SAAS,CAAC,WAAW,OAAO,GAAG,CAAC,CAAC;AAG7C,YAAQ,QAAQ,8BAA8B;AAAA,EAChD,SAAS,OAAO;AACd,YAAQ,IAAI,SAAS,KAAK;AAC1B,QAAI;AAAA,EAAK,OAAO,0CAA0C,SAAS,qEAAqE,SAAS,KAAK;AAGtJ,YAAQ,KAAK,2BAA2B;AAGxC,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAGA,MAAI;AACF,eAAW,GAAG,OAAO,IAAI,SAAS,IAAI,OAAO;AAAA,EAC/C,SAAS,QAAQ;AACf,QAAI;AAAA,EAAK,OAAO,sCAAsC,SAAS,sCAAsC,SAAS,KAAK;AACnH,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAGA,QAAM,cAAsB,GAAG,OAAO;AACtC,QAAM,cAAc,eAAe,WAAW;AAC9C,cAAY,OAAO;AACnB,cAAY,cAAc,GAAG,OAAO;AACpC,cAAY,UAAU;AACtB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AAEnB,MAAI;AAEF,mBAAe,aAAa,WAAW;AAGvC,UAAM,aAAqB,GAAG,OAAO;AACrC,kBAAc,YAAY,KAAK,OAAO,EAAE;AAAA,EAC1C,SAAS,OAAO;AACd,QAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAC1D,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAEA,MAAG,SAAS;AACV,YAAQ,MAAM,4BAA4B;AAG1C,YAAQ,MAAM,OAAO;AAGrB,QAAI;AACF,YAAM,MAAM,gBAAgB,CAAC,SAAS,GAAG;AAAA,QACvC,UAAU;AAAA,QACV,OAAO;AAAA,MACT,CAAC;AAGD,cAAQ,QAAQ,sCAAsC;AAAA,IACxD,SAAS,OAAO;AAEd,UAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAG1D,cAAQ,KAAK,iCAAiC;AAG9C,eAAS,CAAC;AACV,aAAO;AAAA,IACT;AAAA,EACF;AAGA,WAAS,CAAC;AACV,SAAO;AACT;",
  "names": []
}
