@nlabs/lex 1.49.5 → 1.50.1

package/lib/utils/app.js

@@ -1,296 +1,297 @@
-import boxen from "boxen";
-import chalk from "chalk";
-import { copyFile, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
-import { sync as globSync } from "glob";
-import isEmpty from "lodash/isEmpty.js";
-import ora from "ora";
-import { basename as pathBasename, join as pathJoin, relative as pathRelative, resolve as pathResolve } from "path";
-import { rimrafSync } from "rimraf";
-import { log } from "./log.js";
-const cwd = process.cwd();
-const getFilenames = (props) => {
-  const { callback, cliName, name, quiet, type, useTypescript } = props;
-  let nameCaps;
-  const itemTypes = ["stores", "views"];
-  if (!name) {
-    if (itemTypes.includes(type)) {
-      log(`
-${cliName} Error: ${type} name is required. Please use 'lex -h' for options.`, "error", quiet);
-      return callback?.(1);
+/**
+ * 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 { copyFile, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs';
+import { sync as globSync } from 'glob';
+import isEmpty from 'lodash/isEmpty.js';
+import ora from 'ora';
+import { basename as pathBasename, join as pathJoin, relative as pathRelative, resolve as pathResolve } from 'path';
+import { rimrafSync } from 'rimraf';
+import { log } from './log.js';
+export const cwd = process.cwd();
+export const getFilenames = (props)=>{
+    const { callback, cliName, name, quiet, type, useTypescript } = props;
+    let nameCaps;
+    const itemTypes = [
+        'stores',
+        'views'
+    ];
+    if (!name) {
+        if (itemTypes.includes(type)) {
+            log(`\n${cliName} Error: ${type} name is required. Please use 'lex -h' for options.`, 'error', quiet);
+            return callback?.(1);
+        }
+    } else {
+        nameCaps = `${name.charAt(0).toUpperCase()}${name.substr(1)}`;
+    }
+    log(`${cliName} adding ${name} ${type}...`, 'info', quiet);
+    let templatePath;
+    let templateExt;
+    let templateReact;
+    if (useTypescript) {
+        templatePath = '../../templates/typescript';
+        templateExt = '.ts';
+        templateReact = '.tsx';
+    } else {
+        templatePath = '../../templates/flow';
+        templateExt = '.js';
+        templateReact = '.js';
     }
-  } else {
-    nameCaps = `${name.charAt(0).toUpperCase()}${name.substr(1)}`;
-  }
-  log(`${cliName} adding ${name} ${type}...`, "info", quiet);
-  let templatePath;
-  let templateExt;
-  let templateReact;
-  if (useTypescript) {
-    templatePath = "../../templates/typescript";
-    templateExt = ".ts";
-    templateReact = ".tsx";
-  } else {
-    templatePath = "../../templates/flow";
-    templateExt = ".js";
-    templateReact = ".js";
-  }
-  return {
-    nameCaps,
-    templateExt,
-    templatePath,
-    templateReact
-  };
-};
-const createSpinner = (quiet = false) => {
-  if (quiet) {
     return {
-      fail: () => {
-      },
-      start: () => {
-      },
-      succeed: () => {
-      }
+        nameCaps,
+        templateExt,
+        templatePath,
+        templateReact
     };
-  }
-  return ora({ color: "yellow" });
-};
-const createProgressBar = (percentage) => {
-  const width = 20;
-  const filled = Math.round(percentage / 100 * width);
-  const empty = width - filled;
-  const filledBar = chalk.cyan("\u2588").repeat(filled);
-  const emptyBar = chalk.gray("\u2591").repeat(empty);
-  return filledBar + emptyBar;
 };
-const handleWebpackProgress = (output, spinner, quiet, emoji, action) => {
-  if (quiet) {
-    return;
-  }
-  const progressMatch = output.match(/\[webpack\.Progress\] (\d+)%/);
-  if (progressMatch) {
-    const progress = parseInt(progressMatch[1], 10);
-    const progressBar = createProgressBar(progress);
-    spinner.text = `${emoji} ${action}: ${progressBar} ${progress}%`;
-  } else if (output.includes("[webpack.Progress]")) {
-    const generalProgressMatch = output.match(/(\d+)%/);
-    if (generalProgressMatch) {
-      const progress = parseInt(generalProgressMatch[1], 10);
-      const progressBar = createProgressBar(progress);
-      spinner.text = `${emoji} ${action}: ${progressBar} ${progress}%`;
+export const createSpinner = (quiet = false)=>{
+    if (quiet) {
+        return {
+            fail: ()=>{},
+            start: ()=>{},
+            succeed: ()=>{}
+        };
     }
-  }
+    return ora({
+        color: 'yellow'
+    });
 };
-const copyFiles = async (files, typeName, spinner, config) => {
-  const { outputFullPath, sourceFullPath } = config;
-  const items = files.map((fileName) => ({
-    from: fileName,
-    to: pathResolve(outputFullPath, pathRelative(sourceFullPath, fileName))
-  }));
-  try {
-    spinner.start(`Copying ${typeName} files...`);
-    await Promise.all(items.map(({ from, to }) => new Promise(
-      (resolve, reject) => {
-        mkdirSync(pathResolve(to, ".."), { recursive: true });
-        return copyFile(from, to, (copyError) => {
-          if (copyError) {
-            reject();
-          } else {
-            resolve(true);
-          }
-        });
-      }
-    )));
-    spinner.succeed(`Successfully copied ${files.length} ${typeName} files!`);
-  } catch (error) {
-    spinner.fail(`Copying of ${typeName} files failed.`);
-    log(`Error: ${error.message}`, "error");
-    log(error, "error");
-  }
+export const createProgressBar = (percentage)=>{
+    const width = 20;
+    const filled = Math.round(percentage / 100 * width);
+    const empty = width - filled;
+    const filledBar = chalk.cyan('█').repeat(filled);
+    const emptyBar = chalk.gray('░').repeat(empty);
+    return filledBar + emptyBar;
 };
-const copyConfiguredFiles = async (spinner, config, quiet) => {
-  const { copyFiles: copyFilesConfig, outputFullPath, sourceFullPath, sourcePath } = config;
-  if (!copyFilesConfig || copyFilesConfig.length === 0) {
-    return;
-  }
-  try {
-    spinner.start("Copying configured files...");
-    let totalCopied = 0;
-    const baseDir = sourceFullPath || (sourcePath ? pathResolve(cwd, sourcePath) : cwd);
-    for (const pattern of copyFilesConfig) {
-      const resolvedPattern = pathResolve(baseDir, pattern);
-      const matchingFiles = globSync(resolvedPattern, {
-        absolute: true,
-        nodir: true
-      });
-      if (matchingFiles.length === 0) {
-        if (!quiet) {
-          log(`Warning: No files found matching pattern: ${pattern}`, "warn", quiet);
+export const handleWebpackProgress = (output, spinner, quiet, emoji, action)=>{
+    if (quiet) {
+        return;
+    }
+    const progressMatch = output.match(/\[webpack\.Progress\] (\d+)%/);
+    if (progressMatch) {
+        const progress = parseInt(progressMatch[1], 10);
+        const progressBar = createProgressBar(progress);
+        spinner.text = `${emoji} ${action}: ${progressBar} ${progress}%`;
+    } else if (output.includes('[webpack.Progress]')) {
+        const generalProgressMatch = output.match(/(\d+)%/);
+        if (generalProgressMatch) {
+            const progress = parseInt(generalProgressMatch[1], 10);
+            const progressBar = createProgressBar(progress);
+            spinner.text = `${emoji} ${action}: ${progressBar} ${progress}%`;
         }
-        continue;
-      }
-      for (const sourceFile of matchingFiles) {
-        const relativePath = pathRelative(baseDir, sourceFile);
-        const destPath = pathResolve(outputFullPath, relativePath);
-        const destDir = pathResolve(destPath, "..");
-        mkdirSync(destDir, { recursive: true });
-        await new Promise((resolve, reject) => {
-          copyFile(sourceFile, destPath, (copyError) => {
-            if (copyError) {
-              reject(copyError);
-            } else {
-              resolve(true);
-            }
-          });
-        });
-        totalCopied++;
-      }
     }
-    if (totalCopied > 0) {
-      spinner.succeed(`Successfully copied ${totalCopied} configured files!`);
-    } else {
-      spinner.succeed("No configured files to copy");
+};
+export const copyFiles = async (files, typeName, spinner, config)=>{
+    const { outputFullPath, sourceFullPath } = config;
+    const items = files.map((fileName)=>({
+            from: fileName,
+            to: pathResolve(outputFullPath, pathRelative(sourceFullPath, fileName))
+        }));
+    try {
+        spinner.start(`Copying ${typeName} files...`);
+        await Promise.all(items.map(({ from, to })=>new Promise((resolve, reject)=>{
+                mkdirSync(pathResolve(to, '..'), {
+                    recursive: true
+                });
+                return copyFile(from, to, (copyError)=>{
+                    if (copyError) {
+                        reject();
+                    } else {
+                        resolve(true);
+                    }
+                });
+            })));
+        spinner.succeed(`Successfully copied ${files.length} ${typeName} files!`);
+    } catch (error) {
+        spinner.fail(`Copying of ${typeName} files failed.`);
+        log(`Error: ${error.message}`, 'error');
+        log(error, 'error');
     }
-  } catch (error) {
-    spinner.fail("Failed to copy configured files");
-    log(`Error copying configured files: ${error.message}`, "error", quiet);
-    throw error;
-  }
 };
-const copyFileSync = (source, target) => {
-  let targetFile = target;
-  if (existsSync(target)) {
-    if (lstatSync(target).isDirectory()) {
-      targetFile = pathJoin(target, pathBasename(source));
+export const copyConfiguredFiles = async (spinner, config, quiet)=>{
+    const { copyFiles: copyFilesConfig, outputFullPath, sourceFullPath, sourcePath } = config;
+    if (!copyFilesConfig || copyFilesConfig.length === 0) {
+        return;
+    }
+    try {
+        spinner.start('Copying configured files...');
+        let totalCopied = 0;
+        const baseDir = sourceFullPath || (sourcePath ? pathResolve(cwd, sourcePath) : cwd);
+        for (const pattern of copyFilesConfig){
+            const resolvedPattern = pathResolve(baseDir, pattern);
+            const matchingFiles = globSync(resolvedPattern, {
+                absolute: true,
+                nodir: true
+            });
+            if (matchingFiles.length === 0) {
+                if (!quiet) {
+                    log(`Warning: No files found matching pattern: ${pattern}`, 'warn', quiet);
+                }
+                continue;
+            }
+            for (const sourceFile of matchingFiles){
+                // Calculate relative path from source directory
+                const relativePath = pathRelative(baseDir, sourceFile);
+                // Determine destination path in output directory
+                const destPath = pathResolve(outputFullPath, relativePath);
+                // Create destination directory if it doesn't exist
+                const destDir = pathResolve(destPath, '..');
+                mkdirSync(destDir, {
+                    recursive: true
+                });
+                await new Promise((resolve, reject)=>{
+                    copyFile(sourceFile, destPath, (copyError)=>{
+                        if (copyError) {
+                            reject(copyError);
+                        } else {
+                            resolve(true);
+                        }
+                    });
+                });
+                totalCopied++;
+            }
+        }
+        if (totalCopied > 0) {
+            spinner.succeed(`Successfully copied ${totalCopied} configured files!`);
+        } else {
+            spinner.succeed('No configured files to copy');
+        }
+    } catch (error) {
+        spinner.fail('Failed to copy configured files');
+        log(`Error copying configured files: ${error.message}`, 'error', quiet);
+        throw error;
     }
-  }
-  writeFileSync(targetFile, readFileSync(source));
 };
-const copyFolderRecursiveSync = (source, target) => {
-  let files = [];
-  const targetFolder = pathJoin(target, pathBasename(source));
-  if (!existsSync(targetFolder)) {
-    mkdirSync(targetFolder);
-  }
-  if (lstatSync(source).isDirectory()) {
-    files = readdirSync(source);
-    files.forEach((file) => {
-      const curSource = pathJoin(source, file);
-      if (lstatSync(curSource).isDirectory()) {
-        copyFolderRecursiveSync(curSource, targetFolder);
-      } else {
-        copyFileSync(curSource, targetFolder);
-      }
-    });
-  }
+export const copyFileSync = (source, target)=>{
+    let targetFile = target;
+    if (existsSync(target)) {
+        if (lstatSync(target).isDirectory()) {
+            targetFile = pathJoin(target, pathBasename(source));
+        }
+    }
+    writeFileSync(targetFile, readFileSync(source));
 };
-const getPackageJson = (packagePath) => {
-  const formatPath = packagePath || `${process.cwd()}/package.json`;
-  const packageData = readFileSync(formatPath).toString();
-  return JSON.parse(packageData);
+export const copyFolderRecursiveSync = (source, target)=>{
+    let files = [];
+    const targetFolder = pathJoin(target, pathBasename(source));
+    if (!existsSync(targetFolder)) {
+        mkdirSync(targetFolder);
+    }
+    if (lstatSync(source).isDirectory()) {
+        files = readdirSync(source);
+        files.forEach((file)=>{
+            const curSource = pathJoin(source, file);
+            if (lstatSync(curSource).isDirectory()) {
+                copyFolderRecursiveSync(curSource, targetFolder);
+            } else {
+                copyFileSync(curSource, targetFolder);
+            }
+        });
+    }
 };
-const getFilesByExt = (ext, config) => {
-  const { sourceFullPath } = config;
-  return globSync(`${sourceFullPath}/**/**${ext}`);
+export const getPackageJson = (packagePath)=>{
+    const formatPath = packagePath || `${process.cwd()}/package.json`;
+    const packageData = readFileSync(formatPath).toString();
+    return JSON.parse(packageData);
 };
-const removeConflictModules = (moduleList) => {
-  const updatedList = { ...moduleList };
-  Object.keys(updatedList).forEach((moduleName) => {
-    const regex = new RegExp("^(?!@types/).*?(jest|webpack).*$", "gi");
-    if (regex.test(moduleName)) {
-      delete updatedList[moduleName];
-    }
-  });
-  return updatedList;
+export const getFilesByExt = (ext, config)=>{
+    const { sourceFullPath } = config;
+    return globSync(`${sourceFullPath}/**/**${ext}`);
 };
-const removeFiles = (fileName, isRelative = false) => new Promise((resolve, reject) => {
-  const filePath = isRelative ? pathResolve(cwd, fileName) : fileName;
-  try {
-    rimrafSync(filePath);
-    return resolve(null);
-  } catch (error) {
-    return reject(error);
-  }
-});
-const removeModules = () => new Promise(async (resolve, reject) => {
-  try {
-    await removeFiles("./node_modules", true);
-    await removeFiles("./yarn.lock", true);
-    await removeFiles("./package-lock.json", true);
-    resolve(null);
-  } catch (error) {
-    reject(error);
-  }
-});
-const setPackageJson = (json, packagePath) => {
-  if (!json) {
-    return;
-  }
-  const formatPath = packagePath || `${process.cwd()}/package.json`;
-  writeFileSync(formatPath, JSON.stringify(json, null, 2));
+export const removeConflictModules = (moduleList)=>{
+    const updatedList = {
+        ...moduleList
+    };
+    Object.keys(updatedList).forEach((moduleName)=>{
+        const regex = new RegExp('^(?!@types/).*?(jest|webpack).*$', 'gi');
+        if (regex.test(moduleName)) {
+            delete updatedList[moduleName];
+        }
+    });
+    return updatedList;
 };
-const linkedModules = (startPath) => {
-  const workingPath = startPath || process.cwd();
-  let modulePath;
-  let prefix;
-  if (workingPath.includes("@")) {
-    prefix = `@${workingPath.split("@").pop()}`;
-    modulePath = workingPath;
-  } else {
-    modulePath = pathJoin(workingPath, "node_modules");
-  }
-  const foundPaths = globSync(`${modulePath}/*`);
-  return foundPaths.reduce((list, foundPath) => {
-    try {
-      const stats = lstatSync(foundPath);
-      if (stats.isDirectory()) {
-        const deepList = linkedModules(foundPath);
-        list.push(...deepList);
-      } else if (stats.isSymbolicLink()) {
-        const moduleNames = [prefix, pathBasename(foundPath)].filter((item) => !isEmpty(item));
-        list.push({ name: `${moduleNames.join("/")}`, path: foundPath });
-      }
-      return list;
-    } catch {
-      return list;
+export const removeFiles = (fileName, isRelative = false)=>new Promise((resolve, reject)=>{
+        const filePath = isRelative ? pathResolve(cwd, fileName) : fileName;
+        try {
+            rimrafSync(filePath);
+            return resolve(null);
+        } catch (error) {
+            return reject(error);
+        }
+    });
+export const removeModules = ()=>new Promise(async (resolve, reject)=>{
+        try {
+            // Remove node_modules
+            await removeFiles('./node_modules', true);
+            // Remove yarn lock
+            await removeFiles('./yarn.lock', true);
+            // Remove npm lock
+            await removeFiles('./package-lock.json', true);
+            resolve(null);
+        } catch (error) {
+            reject(error);
+        }
+    });
+export const setPackageJson = (json, packagePath)=>{
+    if (!json) {
+        return;
     }
-  }, []);
+    const formatPath = packagePath || `${process.cwd()}/package.json`;
+    writeFileSync(formatPath, JSON.stringify(json, null, 2));
 };
-const checkLinkedModules = () => {
-  const linked = linkedModules();
-  if (linked.length) {
-    const msgModule = linked.length > 1 ? "Modules" : "Module";
-    const linkedMsg = linked.reduce(
-      (msg, linkedModule) => `${msg}
- * ${linkedModule.name}`,
-      `Linked ${msgModule}:`
-    );
-    log(boxen(linkedMsg, { dimBorder: true, padding: 1 }), "warn");
-  }
+export const linkedModules = (startPath)=>{
+    const workingPath = startPath || process.cwd();
+    let modulePath;
+    let prefix;
+    if (workingPath.includes('@')) {
+        prefix = `@${workingPath.split('@').pop()}`;
+        modulePath = workingPath;
+    } else {
+        modulePath = pathJoin(workingPath, 'node_modules');
+    }
+    const foundPaths = globSync(`${modulePath}/*`);
+    return foundPaths.reduce((list, foundPath)=>{
+        try {
+            const stats = lstatSync(foundPath);
+            if (stats.isDirectory()) {
+                const deepList = linkedModules(foundPath);
+                list.push(...deepList);
+            } else if (stats.isSymbolicLink()) {
+                const moduleNames = [
+                    prefix,
+                    pathBasename(foundPath)
+                ].filter((item)=>!isEmpty(item));
+                list.push({
+                    name: `${moduleNames.join('/')}`,
+                    path: foundPath
+                });
+            }
+            return list;
+        } catch  {
+            // Skip files that don't exist or can't be accessed
+            return list;
+        }
+    }, []);
 };
-const updateTemplateName = (filePath, replace, replaceCaps) => {
-  let data = readFileSync(filePath, "utf8");
-  data = data.replace(/sample/g, replace);
-  data = data.replace(/Sample/g, replaceCaps);
-  writeFileSync(filePath, data, "utf8");
+export const checkLinkedModules = ()=>{
+    const linked = linkedModules();
+    if (linked.length) {
+        const msgModule = linked.length > 1 ? 'Modules' : 'Module';
+        const linkedMsg = linked.reduce((msg, linkedModule)=>`${msg}\n * ${linkedModule.name}`, `Linked ${msgModule}:`);
+        log(boxen(linkedMsg, {
+            dimBorder: true,
+            padding: 1
+        }), 'warn');
+    }
 };
-export {
-  checkLinkedModules,
-  copyConfiguredFiles,
-  copyFileSync,
-  copyFiles,
-  copyFolderRecursiveSync,
-  createProgressBar,
-  createSpinner,
-  cwd,
-  getFilenames,
-  getFilesByExt,
-  getPackageJson,
-  handleWebpackProgress,
-  linkedModules,
-  removeConflictModules,
-  removeFiles,
-  removeModules,
-  setPackageJson,
-  updateTemplateName
+export const updateTemplateName = (filePath, replace, replaceCaps)=>{
+    let data = readFileSync(filePath, 'utf8');
+    data = data.replace(/sample/g, replace);
+    data = data.replace(/Sample/g, replaceCaps);
+    writeFileSync(filePath, data, 'utf8');
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/app.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 */\n\nimport boxen from 'boxen';\nimport chalk from 'chalk';\nimport {copyFile, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport isEmpty from 'lodash/isEmpty.js';\nimport ora from 'ora';\nimport {basename as pathBasename, join as pathJoin, relative as pathRelative, resolve as pathResolve} from 'path';\nimport {rimrafSync} from 'rimraf';\n\n\nimport {log} from './log.js';\n\nimport type {LexConfigType} from '../LexConfig.js';\n\n\nexport const cwd: string = process.cwd();\n\nexport interface GetFilenamesProps {\n  readonly callback?: (status: number) => void;\n  readonly cliName?: string;\n  readonly name?: string;\n  readonly quiet?: boolean;\n  readonly type?: string;\n  readonly useTypescript?: boolean;\n}\n\ninterface FilenamesResult {\n  nameCaps: string;\n  templateExt: string;\n  templatePath: string;\n  templateReact: string;\n}\n\nexport const getFilenames = (props: GetFilenamesProps): FilenamesResult | void => {\n  const {callback, cliName, name, quiet, type, useTypescript} = props;\n\n  let nameCaps: string;\n  const itemTypes: string[] = ['stores', 'views'];\n\n  if(!name) {\n    if(itemTypes.includes(type)) {\n      log(`\\n${cliName} Error: ${type} name is required. Please use 'lex -h' for options.`, 'error', quiet);\n      return callback?.(1);\n    }\n  } else {\n    nameCaps = `${name.charAt(0).toUpperCase()}${name.substr(1)}`;\n  }\n\n  log(`${cliName} adding ${name} ${type}...`, 'info', quiet);\n\n  let templatePath: string;\n  let templateExt: string;\n  let templateReact: string;\n\n  if(useTypescript) {\n    templatePath = '../../templates/typescript';\n    templateExt = '.ts';\n    templateReact = '.tsx';\n  } else {\n    templatePath = '../../templates/flow';\n    templateExt = '.js';\n    templateReact = '.js';\n  }\n\n  return {\n    nameCaps,\n    templateExt,\n    templatePath,\n    templateReact\n  };\n};\n\nexport interface Spinner {\n  fail: (text?: string) => void;\n  start: (text?: string) => void;\n  succeed: (text?: string) => void;\n  text?: string;\n}\n\nexport const createSpinner = (quiet = false): Spinner => {\n  if(quiet) {\n    return {\n      fail: () => {},\n      start: () => {},\n      succeed: () => {}\n    };\n  }\n\n  return ora({color: 'yellow'});\n};\n\nexport const createProgressBar = (percentage: number): string => {\n  const width = 20;\n  const filled = Math.round((percentage / 100) * width);\n  const empty = width - filled;\n\n  const filledBar = chalk.cyan('\u2588').repeat(filled);\n  const emptyBar = chalk.gray('\u2591').repeat(empty);\n\n  return filledBar + emptyBar;\n};\n\nexport const handleWebpackProgress = (output: string, spinner: Spinner, quiet: boolean, emoji: string, action: string): void => {\n  if(quiet) {\n    return;\n  }\n\n  const progressMatch = output.match(/\\[webpack\\.Progress\\] (\\d+)%/);\n  if(progressMatch) {\n    const progress = parseInt(progressMatch[1], 10);\n    const progressBar = createProgressBar(progress);\n    spinner.text = `${emoji} ${action}: ${progressBar} ${progress}%`;\n  } else if(output.includes('[webpack.Progress]')) {\n    const generalProgressMatch = output.match(/(\\d+)%/);\n    if(generalProgressMatch) {\n      const progress = parseInt(generalProgressMatch[1], 10);\n      const progressBar = createProgressBar(progress);\n      spinner.text = `${emoji} ${action}: ${progressBar} ${progress}%`;\n    }\n  }\n};\n\nexport const copyFiles = async (files: string[], typeName: string, spinner, config: LexConfigType) => {\n  const {outputFullPath, sourceFullPath} = config;\n  const items = files.map((fileName: string) => ({\n    from: fileName,\n    to: pathResolve(outputFullPath, pathRelative(sourceFullPath, fileName))\n  }));\n\n  try {\n    spinner.start(`Copying ${typeName} files...`);\n    await Promise.all(items.map(({from, to}) => new Promise(\n      (resolve, reject) => {\n        mkdirSync(pathResolve(to, '..'), {recursive: true});\n        return copyFile(from, to, (copyError) => {\n          if(copyError) {\n            reject();\n          } else {\n            resolve(true);\n          }\n        });\n      }\n    )));\n    spinner.succeed(`Successfully copied ${files.length} ${typeName} files!`);\n  } catch (error) {\n    spinner.fail(`Copying of ${typeName} files failed.`);\n    log(`Error: ${error.message}`, 'error');\n    log(error, 'error');\n  }\n};\n\nexport const copyConfiguredFiles = async (spinner, config: LexConfigType, quiet: boolean) => {\n  const {copyFiles: copyFilesConfig, outputFullPath, sourceFullPath, sourcePath} = config;\n  if(!copyFilesConfig || copyFilesConfig.length === 0) {\n    return;\n  }\n\n  try {\n    spinner.start('Copying configured files...');\n    let totalCopied = 0;\n\n    const baseDir = sourceFullPath || (sourcePath ? pathResolve(cwd, sourcePath) : cwd);\n\n    for(const pattern of copyFilesConfig) {\n      const resolvedPattern = pathResolve(baseDir, pattern);\n      const matchingFiles = globSync(resolvedPattern, {\n        absolute: true,\n        nodir: true\n      });\n      if(matchingFiles.length === 0) {\n        if(!quiet) {\n          log(`Warning: No files found matching pattern: ${pattern}`, 'warn', quiet);\n        }\n        continue;\n      }\n\n      for(const sourceFile of matchingFiles) {\n        // Calculate relative path from source directory\n        const relativePath = pathRelative(baseDir, sourceFile);\n        // Determine destination path in output directory\n        const destPath = pathResolve(outputFullPath, relativePath);\n        // Create destination directory if it doesn't exist\n        const destDir = pathResolve(destPath, '..');\n        mkdirSync(destDir, {recursive: true});\n\n        await new Promise((resolve, reject) => {\n          copyFile(sourceFile, destPath, (copyError) => {\n            if(copyError) {\n              reject(copyError);\n            } else {\n              resolve(true);\n            }\n          });\n        });\n        totalCopied++;\n      }\n    }\n    if(totalCopied > 0) {\n      spinner.succeed(`Successfully copied ${totalCopied} configured files!`);\n    } else {\n      spinner.succeed('No configured files to copy');\n    }\n  } catch (error) {\n    spinner.fail('Failed to copy configured files');\n    log(`Error copying configured files: ${error.message}`, 'error', quiet);\n    throw error;\n  }\n};\n\nexport const copyFileSync = (source: string, target: string) => {\n  let targetFile: string = target;\n\n  if(existsSync(target)) {\n    if(lstatSync(target).isDirectory()) {\n      targetFile = pathJoin(target, pathBasename(source));\n    }\n  }\n\n  writeFileSync(targetFile, readFileSync(source));\n};\n\nexport const copyFolderRecursiveSync = (source: string, target: string): void => {\n  let files: string[] = [];\n\n  const targetFolder: string = pathJoin(target, pathBasename(source));\n\n  if(!existsSync(targetFolder)) {\n    mkdirSync(targetFolder);\n  }\n\n  if(lstatSync(source).isDirectory()) {\n    files = readdirSync(source);\n    files.forEach((file: string) => {\n      const curSource: string = pathJoin(source, file);\n\n      if(lstatSync(curSource).isDirectory()) {\n        copyFolderRecursiveSync(curSource, targetFolder);\n      } else {\n        copyFileSync(curSource, targetFolder);\n      }\n    });\n  }\n};\n\nexport const getPackageJson = (packagePath?: string) => {\n  const formatPath: string = packagePath || `${process.cwd()}/package.json`;\n\n  const packageData: string = readFileSync(formatPath).toString();\n  return JSON.parse(packageData);\n};\n\nexport const getFilesByExt = (ext: string, config: LexConfigType): string[] => {\n  const {sourceFullPath} = config;\n  return globSync(`${sourceFullPath}/**/**${ext}`);\n};\n\nexport const removeConflictModules = (moduleList: object) => {\n  const updatedList: object = {...moduleList};\n\n  Object.keys(updatedList).forEach((moduleName: string) => {\n    const regex: RegExp = new RegExp('^(?!@types/).*?(jest|webpack).*$', 'gi');\n    if(regex.test(moduleName)) {\n      delete updatedList[moduleName];\n    }\n  });\n\n  return updatedList;\n};\n\nexport const removeFiles = (fileName: string, isRelative: boolean = false) => new Promise((resolve, reject) => {\n  const filePath: string = isRelative ? pathResolve(cwd, fileName) : fileName;\n  try {\n    rimrafSync(filePath);\n    return resolve(null);\n  } catch (error) {\n    return reject(error);\n  }\n});\n\nexport const removeModules = () => new Promise(async (resolve, reject) => {\n  try {\n    // Remove node_modules\n    await removeFiles('./node_modules', true);\n\n    // Remove yarn lock\n    await removeFiles('./yarn.lock', true);\n\n    // Remove npm lock\n    await removeFiles('./package-lock.json', true);\n\n    resolve(null);\n  } catch (error) {\n    reject(error);\n  }\n});\n\nexport const setPackageJson = (json, packagePath?: string) => {\n  if(!json) {\n    return;\n  }\n\n  const formatPath: string = packagePath || `${process.cwd()}/package.json`;\n\n  writeFileSync(formatPath, JSON.stringify(json, null, 2));\n};\n\nexport interface LinkedModuleType {\n  readonly name: string;\n  readonly path: string;\n}\n\nexport const linkedModules = (startPath?: string): LinkedModuleType[] => {\n  const workingPath: string = startPath || process.cwd();\n  let modulePath: string;\n  let prefix: string;\n\n  if(workingPath.includes('@')) {\n    prefix = `@${workingPath.split('@').pop()}`;\n    modulePath = workingPath;\n  } else {\n    modulePath = pathJoin(workingPath, 'node_modules');\n  }\n\n  const foundPaths: string[] = globSync(`${modulePath}/*`);\n  return foundPaths.reduce((list: LinkedModuleType[], foundPath: string) => {\n    try {\n      const stats = lstatSync(foundPath);\n\n      if(stats.isDirectory()) {\n        const deepList: LinkedModuleType[] = linkedModules(foundPath);\n        list.push(...deepList);\n      } else if(stats.isSymbolicLink()) {\n        const moduleNames: string[] = ([prefix, pathBasename(foundPath)]).filter((item: string) => !isEmpty(item));\n        list.push({name: `${moduleNames.join('/')}`, path: foundPath});\n      }\n\n      return list;\n    } catch {\n      // Skip files that don't exist or can't be accessed\n      return list;\n    }\n  }, []);\n};\n\nexport const checkLinkedModules = () => {\n  const linked = linkedModules();\n\n  if(linked.length) {\n    const msgModule: string = linked.length > 1 ? 'Modules' : 'Module';\n    const linkedMsg: string = linked.reduce(\n      (msg: string, linkedModule: LinkedModuleType) =>\n        `${msg}\\n * ${linkedModule.name}`,\n      `Linked ${msgModule}:`\n    );\n    log(boxen(linkedMsg, {dimBorder: true, padding: 1}), 'warn');\n  }\n};\n\nexport const updateTemplateName = (filePath: string, replace: string, replaceCaps: string) => {\n  let data: string = readFileSync(filePath, 'utf8');\n  data = data.replace(/sample/g, replace);\n  data = data.replace(/Sample/g, replaceCaps);\n  writeFileSync(filePath, data, 'utf8');\n};"],
  "mappings": "AAKA,OAAO,WAAW;AAClB,OAAO,WAAW;AAClB,SAAQ,UAAU,YAAY,WAAW,WAAW,aAAa,cAAc,qBAAoB;AACnG,SAAQ,QAAQ,gBAAe;AAC/B,OAAO,aAAa;AACpB,OAAO,SAAS;AAChB,SAAQ,YAAY,cAAc,QAAQ,UAAU,YAAY,cAAc,WAAW,mBAAkB;AAC3G,SAAQ,kBAAiB;AAGzB,SAAQ,WAAU;AAKX,MAAM,MAAc,QAAQ,IAAI;AAkBhC,MAAM,eAAe,CAAC,UAAqD;AAChF,QAAM,EAAC,UAAU,SAAS,MAAM,OAAO,MAAM,cAAa,IAAI;AAE9D,MAAI;AACJ,QAAM,YAAsB,CAAC,UAAU,OAAO;AAE9C,MAAG,CAAC,MAAM;AACR,QAAG,UAAU,SAAS,IAAI,GAAG;AAC3B,UAAI;AAAA,EAAK,OAAO,WAAW,IAAI,uDAAuD,SAAS,KAAK;AACpG,aAAO,WAAW,CAAC;AAAA,IACrB;AAAA,EACF,OAAO;AACL,eAAW,GAAG,KAAK,OAAO,CAAC,EAAE,YAAY,CAAC,GAAG,KAAK,OAAO,CAAC,CAAC;AAAA,EAC7D;AAEA,MAAI,GAAG,OAAO,WAAW,IAAI,IAAI,IAAI,OAAO,QAAQ,KAAK;AAEzD,MAAI;AACJ,MAAI;AACJ,MAAI;AAEJ,MAAG,eAAe;AAChB,mBAAe;AACf,kBAAc;AACd,oBAAgB;AAAA,EAClB,OAAO;AACL,mBAAe;AACf,kBAAc;AACd,oBAAgB;AAAA,EAClB;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AASO,MAAM,gBAAgB,CAAC,QAAQ,UAAmB;AACvD,MAAG,OAAO;AACR,WAAO;AAAA,MACL,MAAM,MAAM;AAAA,MAAC;AAAA,MACb,OAAO,MAAM;AAAA,MAAC;AAAA,MACd,SAAS,MAAM;AAAA,MAAC;AAAA,IAClB;AAAA,EACF;AAEA,SAAO,IAAI,EAAC,OAAO,SAAQ,CAAC;AAC9B;AAEO,MAAM,oBAAoB,CAAC,eAA+B;AAC/D,QAAM,QAAQ;AACd,QAAM,SAAS,KAAK,MAAO,aAAa,MAAO,KAAK;AACpD,QAAM,QAAQ,QAAQ;AAEtB,QAAM,YAAY,MAAM,KAAK,QAAG,EAAE,OAAO,MAAM;AAC/C,QAAM,WAAW,MAAM,KAAK,QAAG,EAAE,OAAO,KAAK;AAE7C,SAAO,YAAY;AACrB;AAEO,MAAM,wBAAwB,CAAC,QAAgB,SAAkB,OAAgB,OAAe,WAAyB;AAC9H,MAAG,OAAO;AACR;AAAA,EACF;AAEA,QAAM,gBAAgB,OAAO,MAAM,8BAA8B;AACjE,MAAG,eAAe;AAChB,UAAM,WAAW,SAAS,cAAc,CAAC,GAAG,EAAE;AAC9C,UAAM,cAAc,kBAAkB,QAAQ;AAC9C,YAAQ,OAAO,GAAG,KAAK,IAAI,MAAM,KAAK,WAAW,IAAI,QAAQ;AAAA,EAC/D,WAAU,OAAO,SAAS,oBAAoB,GAAG;AAC/C,UAAM,uBAAuB,OAAO,MAAM,QAAQ;AAClD,QAAG,sBAAsB;AACvB,YAAM,WAAW,SAAS,qBAAqB,CAAC,GAAG,EAAE;AACrD,YAAM,cAAc,kBAAkB,QAAQ;AAC9C,cAAQ,OAAO,GAAG,KAAK,IAAI,MAAM,KAAK,WAAW,IAAI,QAAQ;AAAA,IAC/D;AAAA,EACF;AACF;AAEO,MAAM,YAAY,OAAO,OAAiB,UAAkB,SAAS,WAA0B;AACpG,QAAM,EAAC,gBAAgB,eAAc,IAAI;AACzC,QAAM,QAAQ,MAAM,IAAI,CAAC,cAAsB;AAAA,IAC7C,MAAM;AAAA,IACN,IAAI,YAAY,gBAAgB,aAAa,gBAAgB,QAAQ,CAAC;AAAA,EACxE,EAAE;AAEF,MAAI;AACF,YAAQ,MAAM,WAAW,QAAQ,WAAW;AAC5C,UAAM,QAAQ,IAAI,MAAM,IAAI,CAAC,EAAC,MAAM,GAAE,MAAM,IAAI;AAAA,MAC9C,CAAC,SAAS,WAAW;AACnB,kBAAU,YAAY,IAAI,IAAI,GAAG,EAAC,WAAW,KAAI,CAAC;AAClD,eAAO,SAAS,MAAM,IAAI,CAAC,cAAc;AACvC,cAAG,WAAW;AACZ,mBAAO;AAAA,UACT,OAAO;AACL,oBAAQ,IAAI;AAAA,UACd;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF,CAAC,CAAC;AACF,YAAQ,QAAQ,uBAAuB,MAAM,MAAM,IAAI,QAAQ,SAAS;AAAA,EAC1E,SAAS,OAAO;AACd,YAAQ,KAAK,cAAc,QAAQ,gBAAgB;AACnD,QAAI,UAAU,MAAM,OAAO,IAAI,OAAO;AACtC,QAAI,OAAO,OAAO;AAAA,EACpB;AACF;AAEO,MAAM,sBAAsB,OAAO,SAAS,QAAuB,UAAmB;AAC3F,QAAM,EAAC,WAAW,iBAAiB,gBAAgB,gBAAgB,WAAU,IAAI;AACjF,MAAG,CAAC,mBAAmB,gBAAgB,WAAW,GAAG;AACnD;AAAA,EACF;AAEA,MAAI;AACF,YAAQ,MAAM,6BAA6B;AAC3C,QAAI,cAAc;AAElB,UAAM,UAAU,mBAAmB,aAAa,YAAY,KAAK,UAAU,IAAI;AAE/E,eAAU,WAAW,iBAAiB;AACpC,YAAM,kBAAkB,YAAY,SAAS,OAAO;AACpD,YAAM,gBAAgB,SAAS,iBAAiB;AAAA,QAC9C,UAAU;AAAA,QACV,OAAO;AAAA,MACT,CAAC;AACD,UAAG,cAAc,WAAW,GAAG;AAC7B,YAAG,CAAC,OAAO;AACT,cAAI,6CAA6C,OAAO,IAAI,QAAQ,KAAK;AAAA,QAC3E;AACA;AAAA,MACF;AAEA,iBAAU,cAAc,eAAe;AAErC,cAAM,eAAe,aAAa,SAAS,UAAU;AAErD,cAAM,WAAW,YAAY,gBAAgB,YAAY;AAEzD,cAAM,UAAU,YAAY,UAAU,IAAI;AAC1C,kBAAU,SAAS,EAAC,WAAW,KAAI,CAAC;AAEpC,cAAM,IAAI,QAAQ,CAAC,SAAS,WAAW;AACrC,mBAAS,YAAY,UAAU,CAAC,cAAc;AAC5C,gBAAG,WAAW;AACZ,qBAAO,SAAS;AAAA,YAClB,OAAO;AACL,sBAAQ,IAAI;AAAA,YACd;AAAA,UACF,CAAC;AAAA,QACH,CAAC;AACD;AAAA,MACF;AAAA,IACF;AACA,QAAG,cAAc,GAAG;AAClB,cAAQ,QAAQ,uBAAuB,WAAW,oBAAoB;AAAA,IACxE,OAAO;AACL,cAAQ,QAAQ,6BAA6B;AAAA,IAC/C;AAAA,EACF,SAAS,OAAO;AACd,YAAQ,KAAK,iCAAiC;AAC9C,QAAI,mCAAmC,MAAM,OAAO,IAAI,SAAS,KAAK;AACtE,UAAM;AAAA,EACR;AACF;AAEO,MAAM,eAAe,CAAC,QAAgB,WAAmB;AAC9D,MAAI,aAAqB;AAEzB,MAAG,WAAW,MAAM,GAAG;AACrB,QAAG,UAAU,MAAM,EAAE,YAAY,GAAG;AAClC,mBAAa,SAAS,QAAQ,aAAa,MAAM,CAAC;AAAA,IACpD;AAAA,EACF;AAEA,gBAAc,YAAY,aAAa,MAAM,CAAC;AAChD;AAEO,MAAM,0BAA0B,CAAC,QAAgB,WAAyB;AAC/E,MAAI,QAAkB,CAAC;AAEvB,QAAM,eAAuB,SAAS,QAAQ,aAAa,MAAM,CAAC;AAElE,MAAG,CAAC,WAAW,YAAY,GAAG;AAC5B,cAAU,YAAY;AAAA,EACxB;AAEA,MAAG,UAAU,MAAM,EAAE,YAAY,GAAG;AAClC,YAAQ,YAAY,MAAM;AAC1B,UAAM,QAAQ,CAAC,SAAiB;AAC9B,YAAM,YAAoB,SAAS,QAAQ,IAAI;AAE/C,UAAG,UAAU,SAAS,EAAE,YAAY,GAAG;AACrC,gCAAwB,WAAW,YAAY;AAAA,MACjD,OAAO;AACL,qBAAa,WAAW,YAAY;AAAA,MACtC;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAEO,MAAM,iBAAiB,CAAC,gBAAyB;AACtD,QAAM,aAAqB,eAAe,GAAG,QAAQ,IAAI,CAAC;AAE1D,QAAM,cAAsB,aAAa,UAAU,EAAE,SAAS;AAC9D,SAAO,KAAK,MAAM,WAAW;AAC/B;AAEO,MAAM,gBAAgB,CAAC,KAAa,WAAoC;AAC7E,QAAM,EAAC,eAAc,IAAI;AACzB,SAAO,SAAS,GAAG,cAAc,SAAS,GAAG,EAAE;AACjD;AAEO,MAAM,wBAAwB,CAAC,eAAuB;AAC3D,QAAM,cAAsB,EAAC,GAAG,WAAU;AAE1C,SAAO,KAAK,WAAW,EAAE,QAAQ,CAAC,eAAuB;AACvD,UAAM,QAAgB,IAAI,OAAO,oCAAoC,IAAI;AACzE,QAAG,MAAM,KAAK,UAAU,GAAG;AACzB,aAAO,YAAY,UAAU;AAAA,IAC/B;AAAA,EACF,CAAC;AAED,SAAO;AACT;AAEO,MAAM,cAAc,CAAC,UAAkB,aAAsB,UAAU,IAAI,QAAQ,CAAC,SAAS,WAAW;AAC7G,QAAM,WAAmB,aAAa,YAAY,KAAK,QAAQ,IAAI;AACnE,MAAI;AACF,eAAW,QAAQ;AACnB,WAAO,QAAQ,IAAI;AAAA,EACrB,SAAS,OAAO;AACd,WAAO,OAAO,KAAK;AAAA,EACrB;AACF,CAAC;AAEM,MAAM,gBAAgB,MAAM,IAAI,QAAQ,OAAO,SAAS,WAAW;AACxE,MAAI;AAEF,UAAM,YAAY,kBAAkB,IAAI;AAGxC,UAAM,YAAY,eAAe,IAAI;AAGrC,UAAM,YAAY,uBAAuB,IAAI;AAE7C,YAAQ,IAAI;AAAA,EACd,SAAS,OAAO;AACd,WAAO,KAAK;AAAA,EACd;AACF,CAAC;AAEM,MAAM,iBAAiB,CAAC,MAAM,gBAAyB;AAC5D,MAAG,CAAC,MAAM;AACR;AAAA,EACF;AAEA,QAAM,aAAqB,eAAe,GAAG,QAAQ,IAAI,CAAC;AAE1D,gBAAc,YAAY,KAAK,UAAU,MAAM,MAAM,CAAC,CAAC;AACzD;AAOO,MAAM,gBAAgB,CAAC,cAA2C;AACvE,QAAM,cAAsB,aAAa,QAAQ,IAAI;AACrD,MAAI;AACJ,MAAI;AAEJ,MAAG,YAAY,SAAS,GAAG,GAAG;AAC5B,aAAS,IAAI,YAAY,MAAM,GAAG,EAAE,IAAI,CAAC;AACzC,iBAAa;AAAA,EACf,OAAO;AACL,iBAAa,SAAS,aAAa,cAAc;AAAA,EACnD;AAEA,QAAM,aAAuB,SAAS,GAAG,UAAU,IAAI;AACvD,SAAO,WAAW,OAAO,CAAC,MAA0B,cAAsB;AACxE,QAAI;AACF,YAAM,QAAQ,UAAU,SAAS;AAEjC,UAAG,MAAM,YAAY,GAAG;AACtB,cAAM,WAA+B,cAAc,SAAS;AAC5D,aAAK,KAAK,GAAG,QAAQ;AAAA,MACvB,WAAU,MAAM,eAAe,GAAG;AAChC,cAAM,cAAyB,CAAC,QAAQ,aAAa,SAAS,CAAC,EAAG,OAAO,CAAC,SAAiB,CAAC,QAAQ,IAAI,CAAC;AACzG,aAAK,KAAK,EAAC,MAAM,GAAG,YAAY,KAAK,GAAG,CAAC,IAAI,MAAM,UAAS,CAAC;AAAA,MAC/D;AAEA,aAAO;AAAA,IACT,QAAQ;AAEN,aAAO;AAAA,IACT;AAAA,EACF,GAAG,CAAC,CAAC;AACP;AAEO,MAAM,qBAAqB,MAAM;AACtC,QAAM,SAAS,cAAc;AAE7B,MAAG,OAAO,QAAQ;AAChB,UAAM,YAAoB,OAAO,SAAS,IAAI,YAAY;AAC1D,UAAM,YAAoB,OAAO;AAAA,MAC/B,CAAC,KAAa,iBACZ,GAAG,GAAG;AAAA,KAAQ,aAAa,IAAI;AAAA,MACjC,UAAU,SAAS;AAAA,IACrB;AACA,QAAI,MAAM,WAAW,EAAC,WAAW,MAAM,SAAS,EAAC,CAAC,GAAG,MAAM;AAAA,EAC7D;AACF;AAEO,MAAM,qBAAqB,CAAC,UAAkB,SAAiB,gBAAwB;AAC5F,MAAI,OAAe,aAAa,UAAU,MAAM;AAChD,SAAO,KAAK,QAAQ,WAAW,OAAO;AACtC,SAAO,KAAK,QAAQ,WAAW,WAAW;AAC1C,gBAAc,UAAU,MAAM,MAAM;AACtC;",
  "names": []
}

+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utils/app.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 */\n\nimport boxen from 'boxen';\nimport chalk from 'chalk';\nimport {copyFile, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport isEmpty from 'lodash/isEmpty.js';\nimport ora from 'ora';\nimport {basename as pathBasename, join as pathJoin, relative as pathRelative, resolve as pathResolve} from 'path';\nimport {rimrafSync} from 'rimraf';\n\n\nimport {log} from './log.js';\n\nimport type {LexConfigType} from '../LexConfig.js';\n\n\nexport const cwd: string = process.cwd();\n\nexport interface GetFilenamesProps {\n  readonly callback?: (status: number) => void;\n  readonly cliName?: string;\n  readonly name?: string;\n  readonly quiet?: boolean;\n  readonly type?: string;\n  readonly useTypescript?: boolean;\n}\n\ninterface FilenamesResult {\n  nameCaps: string;\n  templateExt: string;\n  templatePath: string;\n  templateReact: string;\n}\n\nexport const getFilenames = (props: GetFilenamesProps): FilenamesResult | void => {\n  const {callback, cliName, name, quiet, type, useTypescript} = props;\n\n  let nameCaps: string;\n  const itemTypes: string[] = ['stores', 'views'];\n\n  if(!name) {\n    if(itemTypes.includes(type)) {\n      log(`\\n${cliName} Error: ${type} name is required. Please use 'lex -h' for options.`, 'error', quiet);\n      return callback?.(1);\n    }\n  } else {\n    nameCaps = `${name.charAt(0).toUpperCase()}${name.substr(1)}`;\n  }\n\n  log(`${cliName} adding ${name} ${type}...`, 'info', quiet);\n\n  let templatePath: string;\n  let templateExt: string;\n  let templateReact: string;\n\n  if(useTypescript) {\n    templatePath = '../../templates/typescript';\n    templateExt = '.ts';\n    templateReact = '.tsx';\n  } else {\n    templatePath = '../../templates/flow';\n    templateExt = '.js';\n    templateReact = '.js';\n  }\n\n  return {\n    nameCaps,\n    templateExt,\n    templatePath,\n    templateReact\n  };\n};\n\nexport interface Spinner {\n  fail: (text?: string) => void;\n  start: (text?: string) => void;\n  succeed: (text?: string) => void;\n  text?: string;\n}\n\nexport const createSpinner = (quiet = false): Spinner => {\n  if(quiet) {\n    return {\n      fail: () => {},\n      start: () => {},\n      succeed: () => {}\n    };\n  }\n\n  return ora({color: 'yellow'});\n};\n\nexport const createProgressBar = (percentage: number): string => {\n  const width = 20;\n  const filled = Math.round((percentage / 100) * width);\n  const empty = width - filled;\n\n  const filledBar = chalk.cyan('█').repeat(filled);\n  const emptyBar = chalk.gray('░').repeat(empty);\n\n  return filledBar + emptyBar;\n};\n\nexport const handleWebpackProgress = (output: string, spinner: Spinner, quiet: boolean, emoji: string, action: string): void => {\n  if(quiet) {\n    return;\n  }\n\n  const progressMatch = output.match(/\\[webpack\\.Progress\\] (\\d+)%/);\n  if(progressMatch) {\n    const progress = parseInt(progressMatch[1], 10);\n    const progressBar = createProgressBar(progress);\n    spinner.text = `${emoji} ${action}: ${progressBar} ${progress}%`;\n  } else if(output.includes('[webpack.Progress]')) {\n    const generalProgressMatch = output.match(/(\\d+)%/);\n    if(generalProgressMatch) {\n      const progress = parseInt(generalProgressMatch[1], 10);\n      const progressBar = createProgressBar(progress);\n      spinner.text = `${emoji} ${action}: ${progressBar} ${progress}%`;\n    }\n  }\n};\n\nexport const copyFiles = async (files: string[], typeName: string, spinner, config: LexConfigType) => {\n  const {outputFullPath, sourceFullPath} = config;\n  const items = files.map((fileName: string) => ({\n    from: fileName,\n    to: pathResolve(outputFullPath, pathRelative(sourceFullPath, fileName))\n  }));\n\n  try {\n    spinner.start(`Copying ${typeName} files...`);\n    await Promise.all(items.map(({from, to}) => new Promise(\n      (resolve, reject) => {\n        mkdirSync(pathResolve(to, '..'), {recursive: true});\n        return copyFile(from, to, (copyError) => {\n          if(copyError) {\n            reject();\n          } else {\n            resolve(true);\n          }\n        });\n      }\n    )));\n    spinner.succeed(`Successfully copied ${files.length} ${typeName} files!`);\n  } catch(error) {\n    spinner.fail(`Copying of ${typeName} files failed.`);\n    log(`Error: ${error.message}`, 'error');\n    log(error, 'error');\n  }\n};\n\nexport const copyConfiguredFiles = async (spinner, config: LexConfigType, quiet: boolean) => {\n  const {copyFiles: copyFilesConfig, outputFullPath, sourceFullPath, sourcePath} = config;\n  if(!copyFilesConfig || copyFilesConfig.length === 0) {\n    return;\n  }\n\n  try {\n    spinner.start('Copying configured files...');\n    let totalCopied = 0;\n\n    const baseDir = sourceFullPath || (sourcePath ? pathResolve(cwd, sourcePath) : cwd);\n\n    for(const pattern of copyFilesConfig) {\n      const resolvedPattern = pathResolve(baseDir, pattern);\n      const matchingFiles = globSync(resolvedPattern, {\n        absolute: true,\n        nodir: true\n      });\n      if(matchingFiles.length === 0) {\n        if(!quiet) {\n          log(`Warning: No files found matching pattern: ${pattern}`, 'warn', quiet);\n        }\n        continue;\n      }\n\n      for(const sourceFile of matchingFiles) {\n        // Calculate relative path from source directory\n        const relativePath = pathRelative(baseDir, sourceFile);\n        // Determine destination path in output directory\n        const destPath = pathResolve(outputFullPath, relativePath);\n        // Create destination directory if it doesn't exist\n        const destDir = pathResolve(destPath, '..');\n        mkdirSync(destDir, {recursive: true});\n\n        await new Promise((resolve, reject) => {\n          copyFile(sourceFile, destPath, (copyError) => {\n            if(copyError) {\n              reject(copyError);\n            } else {\n              resolve(true);\n            }\n          });\n        });\n        totalCopied++;\n      }\n    }\n    if(totalCopied > 0) {\n      spinner.succeed(`Successfully copied ${totalCopied} configured files!`);\n    } else {\n      spinner.succeed('No configured files to copy');\n    }\n  } catch(error) {\n    spinner.fail('Failed to copy configured files');\n    log(`Error copying configured files: ${error.message}`, 'error', quiet);\n    throw error;\n  }\n};\n\nexport const copyFileSync = (source: string, target: string) => {\n  let targetFile: string = target;\n\n  if(existsSync(target)) {\n    if(lstatSync(target).isDirectory()) {\n      targetFile = pathJoin(target, pathBasename(source));\n    }\n  }\n\n  writeFileSync(targetFile, readFileSync(source));\n};\n\nexport const copyFolderRecursiveSync = (source: string, target: string): void => {\n  let files: string[] = [];\n\n  const targetFolder: string = pathJoin(target, pathBasename(source));\n\n  if(!existsSync(targetFolder)) {\n    mkdirSync(targetFolder);\n  }\n\n  if(lstatSync(source).isDirectory()) {\n    files = readdirSync(source);\n    files.forEach((file: string) => {\n      const curSource: string = pathJoin(source, file);\n\n      if(lstatSync(curSource).isDirectory()) {\n        copyFolderRecursiveSync(curSource, targetFolder);\n      } else {\n        copyFileSync(curSource, targetFolder);\n      }\n    });\n  }\n};\n\nexport const getPackageJson = (packagePath?: string) => {\n  const formatPath: string = packagePath || `${process.cwd()}/package.json`;\n\n  const packageData: string = readFileSync(formatPath).toString();\n  return JSON.parse(packageData);\n};\n\nexport const getFilesByExt = (ext: string, config: LexConfigType): string[] => {\n  const {sourceFullPath} = config;\n  return globSync(`${sourceFullPath}/**/**${ext}`);\n};\n\nexport const removeConflictModules = (moduleList: object) => {\n  const updatedList: object = {...moduleList};\n\n  Object.keys(updatedList).forEach((moduleName: string) => {\n    const regex: RegExp = new RegExp('^(?!@types/).*?(jest|webpack).*$', 'gi');\n    if(regex.test(moduleName)) {\n      delete updatedList[moduleName];\n    }\n  });\n\n  return updatedList;\n};\n\nexport const removeFiles = (fileName: string, isRelative: boolean = false) => new Promise((resolve, reject) => {\n  const filePath: string = isRelative ? pathResolve(cwd, fileName) : fileName;\n  try {\n    rimrafSync(filePath);\n    return resolve(null);\n  } catch(error) {\n    return reject(error);\n  }\n});\n\nexport const removeModules = () => new Promise(async (resolve, reject) => {\n  try {\n    // Remove node_modules\n    await removeFiles('./node_modules', true);\n\n    // Remove yarn lock\n    await removeFiles('./yarn.lock', true);\n\n    // Remove npm lock\n    await removeFiles('./package-lock.json', true);\n\n    resolve(null);\n  } catch(error) {\n    reject(error);\n  }\n});\n\nexport const setPackageJson = (json, packagePath?: string) => {\n  if(!json) {\n    return;\n  }\n\n  const formatPath: string = packagePath || `${process.cwd()}/package.json`;\n\n  writeFileSync(formatPath, JSON.stringify(json, null, 2));\n};\n\nexport interface LinkedModuleType {\n  readonly name: string;\n  readonly path: string;\n}\n\nexport const linkedModules = (startPath?: string): LinkedModuleType[] => {\n  const workingPath: string = startPath || process.cwd();\n  let modulePath: string;\n  let prefix: string;\n\n  if(workingPath.includes('@')) {\n    prefix = `@${workingPath.split('@').pop()}`;\n    modulePath = workingPath;\n  } else {\n    modulePath = pathJoin(workingPath, 'node_modules');\n  }\n\n  const foundPaths: string[] = globSync(`${modulePath}/*`);\n  return foundPaths.reduce((list: LinkedModuleType[], foundPath: string) => {\n    try {\n      const stats = lstatSync(foundPath);\n\n      if(stats.isDirectory()) {\n        const deepList: LinkedModuleType[] = linkedModules(foundPath);\n        list.push(...deepList);\n      } else if(stats.isSymbolicLink()) {\n        const moduleNames: string[] = ([prefix, pathBasename(foundPath)]).filter((item: string) => !isEmpty(item));\n        list.push({name: `${moduleNames.join('/')}`, path: foundPath});\n      }\n\n      return list;\n    } catch{\n      // Skip files that don't exist or can't be accessed\n      return list;\n    }\n  }, []);\n};\n\nexport const checkLinkedModules = () => {\n  const linked = linkedModules();\n\n  if(linked.length) {\n    const msgModule: string = linked.length > 1 ? 'Modules' : 'Module';\n    const linkedMsg: string = linked.reduce(\n      (msg: string, linkedModule: LinkedModuleType) =>\n        `${msg}\\n * ${linkedModule.name}`,\n      `Linked ${msgModule}:`\n    );\n    log(boxen(linkedMsg, {dimBorder: true, padding: 1}), 'warn');\n  }\n};\n\nexport const updateTemplateName = (filePath: string, replace: string, replaceCaps: string) => {\n  let data: string = readFileSync(filePath, 'utf8');\n  data = data.replace(/sample/g, replace);\n  data = data.replace(/Sample/g, replaceCaps);\n  writeFileSync(filePath, data, 'utf8');\n};"],"names":["boxen","chalk","copyFile","existsSync","lstatSync","mkdirSync","readdirSync","readFileSync","writeFileSync","sync","globSync","isEmpty","ora","basename","pathBasename","join","pathJoin","relative","pathRelative","resolve","pathResolve","rimrafSync","log","cwd","process","getFilenames","props","callback","cliName","name","quiet","type","useTypescript","nameCaps","itemTypes","includes","charAt","toUpperCase","substr","templatePath","templateExt","templateReact","createSpinner","fail","start","succeed","color","createProgressBar","percentage","width","filled","Math","round","empty","filledBar","cyan","repeat","emptyBar","gray","handleWebpackProgress","output","spinner","emoji","action","progressMatch","match","progress","parseInt","progressBar","text","generalProgressMatch","copyFiles","files","typeName","config","outputFullPath","sourceFullPath","items","map","fileName","from","to","Promise","all","reject","recursive","copyError","length","error","message","copyConfiguredFiles","copyFilesConfig","sourcePath","totalCopied","baseDir","pattern","resolvedPattern","matchingFiles","absolute","nodir","sourceFile","relativePath","destPath","destDir","copyFileSync","source","target","targetFile","isDirectory","copyFolderRecursiveSync","targetFolder","forEach","file","curSource","getPackageJson","packagePath","formatPath","packageData","toString","JSON","parse","getFilesByExt","ext","removeConflictModules","moduleList","updatedList","Object","keys","moduleName","regex","RegExp","test","removeFiles","isRelative","filePath","removeModules","setPackageJson","json","stringify","linkedModules","startPath","workingPath","modulePath","prefix","split","pop","foundPaths","reduce","list","foundPath","stats","deepList","push","isSymbolicLink","moduleNames","filter","item","path","checkLinkedModules","linked","msgModule","linkedMsg","msg","linkedModule","dimBorder","padding","updateTemplateName","replace","replaceCaps","data"],"mappings":"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"}