@nlabs/lex 1.48.7 → 1.49.1

package/lib/utils/app.js

@@ -0,0 +1,296 @@
+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);
+    }
+  } 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: () => {
+      }
+    };
+  }
+  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}%`;
+    }
+  }
+};
+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");
+  }
+};
+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) {
+        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");
+    }
+  } 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));
+    }
+  }
+  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);
+      }
+    });
+  }
+};
+const getPackageJson = (packagePath) => {
+  const formatPath = packagePath || `${process.cwd()}/package.json`;
+  const packageData = readFileSync(formatPath).toString();
+  return JSON.parse(packageData);
+};
+const getFilesByExt = (ext, config) => {
+  const { sourceFullPath } = config;
+  return globSync(`${sourceFullPath}/**/**${ext}`);
+};
+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 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));
+};
+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;
+    }
+  }, []);
+};
+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");
+  }
+};
+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 {
+  checkLinkedModules,
+  copyConfiguredFiles,
+  copyFileSync,
+  copyFiles,
+  copyFolderRecursiveSync,
+  createProgressBar,
+  createSpinner,
+  cwd,
+  getFilenames,
+  getFilesByExt,
+  getPackageJson,
+  handleWebpackProgress,
+  linkedModules,
+  removeConflictModules,
+  removeFiles,
+  removeModules,
+  setPackageJson,
+  updateTemplateName
+};
+//# 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": "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",
  "names": []
}


package/{dist → lib}/utils/file.d.ts

@@ -1,8 +1,12 @@
-export declare function getDirName(): string;
-export declare function getFilePath(relativePath: string): string;
-export declare function getLexPackageJsonPath(): string;
+export declare const getDirName: () => string;
+export declare const getFilePath: (relativePath: string) => string;
+export declare const getLexPackageJsonPath: () => string;
 export declare const relativeFilePath: (filename: string, dirPath?: string, backUp?: number) => string;
 export declare const relativeNodePath: (filename: string, dirPath?: string, backUp?: number) => string;
 export declare const getNodePath: (moduleName: string) => string;
 export declare const resolveBinaryPath: (binaryName: string, packageName?: string) => string;
 export declare const findTailwindCssPath: () => string;
+export declare const resolveWebpackPaths: (currentDirname: string) => {
+    webpackPath: string;
+    webpackConfig: string;
+};

package/lib/utils/file.js

@@ -0,0 +1,229 @@
+import findFileUp from "find-file-up";
+import { existsSync, readFileSync } from "fs";
+import { sync as globSync } from "glob";
+import { resolve as pathResolve, dirname } from "path";
+import { LexConfig } from "../LexConfig.js";
+const getDirName = () => {
+  try {
+    return eval('new URL(".", import.meta.url).pathname');
+  } catch {
+    return process.cwd();
+  }
+};
+const getFilePath = (relativePath) => {
+  try {
+    return eval('require("url").fileURLToPath(new URL(relativePath, import.meta.url))');
+  } catch {
+    if (relativePath === "../../../package.json") {
+      return pathResolve(process.cwd(), "package.json");
+    }
+    return pathResolve(process.cwd(), relativePath);
+  }
+};
+const getLexPackageJsonPath = () => {
+  const LEX_PACKAGE_NAME = "@nlabs/lex";
+  const lexInNodeModules = pathResolve(process.cwd(), "node_modules/@nlabs/lex/package.json");
+  if (existsSync(lexInNodeModules)) {
+    return lexInNodeModules;
+  }
+  let startDir;
+  if (process.env.LEX_ROOT) {
+    startDir = process.env.LEX_ROOT;
+  } else {
+    try {
+      startDir = eval('new URL(".", import.meta.url).pathname');
+    } catch {
+      try {
+        startDir = eval('__filename ? require("path").dirname(__filename) : null');
+        if (!startDir) {
+          throw new Error("__filename not available");
+        }
+      } catch {
+        try {
+          if (process.argv[1] && !process.argv[1].includes("node")) {
+            startDir = dirname(process.argv[1]);
+          } else {
+            throw new Error("process.argv[1] not suitable");
+          }
+        } catch {
+          startDir = process.cwd();
+        }
+      }
+    }
+  }
+  let dir = startDir;
+  for (let i = 0; i < 8; i++) {
+    const pkgPath = pathResolve(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.name === LEX_PACKAGE_NAME) {
+          return pkgPath;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return pathResolve(process.cwd(), "package.json");
+};
+const relativeFilePath = (filename, dirPath = "./", backUp = 0) => {
+  const nestDepth = 10;
+  if (backUp) {
+    const filePath = findFileUp.sync(filename, dirPath, nestDepth);
+    const previousPath = Array(backUp).fill(null).map(() => "../").join("");
+    return pathResolve(filePath, previousPath);
+  }
+  return findFileUp.sync(filename, dirPath, nestDepth);
+};
+const relativeNodePath = (filename, dirPath = "./", backUp = 0) => {
+  const nestDepth = 10;
+  const modulePath = `node_modules/${filename}`;
+  if (dirPath !== "./") {
+    const lexModulePath = pathResolve(dirPath, modulePath);
+    if (existsSync(lexModulePath)) {
+      return lexModulePath;
+    }
+  }
+  const projectPath = pathResolve(process.cwd(), modulePath);
+  if (existsSync(projectPath)) {
+    return projectPath;
+  }
+  if (backUp) {
+    const filePath = findFileUp.sync(modulePath, dirPath, nestDepth);
+    const previousPath = Array(nestDepth).fill(null).map(() => "../").join("");
+    return pathResolve(filePath, previousPath);
+  }
+  return findFileUp.sync(modulePath, dirPath, nestDepth) || `/node_modules/${filename}`;
+};
+const getNodePath = (moduleName) => {
+  const dirName = getDirName();
+  const modulePath = `node_modules/${moduleName}`;
+  const projectPath = pathResolve(process.cwd(), modulePath);
+  if (existsSync(projectPath)) {
+    return projectPath;
+  }
+  const repoPath = findFileUp.sync(modulePath, dirName);
+  if (repoPath && existsSync(repoPath)) {
+    return repoPath;
+  }
+  const localPath = findFileUp.sync(modulePath, "./", 10) || `./${modulePath}`;
+  return localPath;
+};
+const resolveBinaryPath = (binaryName, packageName) => {
+  const lexDir = LexConfig.getLexDir();
+  const lexBinPath = pathResolve(lexDir, `node_modules/.bin/${binaryName}`);
+  if (existsSync(lexBinPath)) {
+    return lexBinPath;
+  }
+  if (packageName) {
+    const lexPackageBinPath = pathResolve(lexDir, `node_modules/${packageName}/bin/${binaryName}`);
+    if (existsSync(lexPackageBinPath)) {
+      return lexPackageBinPath;
+    }
+    const lexPackageBinJsPath = pathResolve(lexDir, `node_modules/${packageName}/bin/${binaryName}.js`);
+    if (existsSync(lexPackageBinJsPath)) {
+      return lexPackageBinJsPath;
+    }
+    const lexPackageBinCjsPath = pathResolve(lexDir, `node_modules/${packageName}/bin/${binaryName}.cjs`);
+    if (existsSync(lexPackageBinCjsPath)) {
+      return lexPackageBinCjsPath;
+    }
+  }
+  const checkBinUp = (startDir2) => {
+    let checkDir = startDir2;
+    for (let i = 0; i < 5; i++) {
+      const monorepoBinPath = pathResolve(checkDir, `node_modules/.bin/${binaryName}`);
+      if (existsSync(monorepoBinPath)) {
+        return monorepoBinPath;
+      }
+      const parentDir = pathResolve(checkDir, "..");
+      if (parentDir === checkDir) {
+        break;
+      }
+      checkDir = parentDir;
+    }
+    return "";
+  };
+  const fromCwd = checkBinUp(process.cwd());
+  if (fromCwd) {
+    return fromCwd;
+  }
+  const fromLex = checkBinUp(lexDir);
+  if (fromLex) {
+    return fromLex;
+  }
+  return "";
+};
+const findTailwindCssPath = () => {
+  const tailwindPatterns = ["**/tailwind.css"];
+  for (const pattern of tailwindPatterns) {
+    const files = globSync(pattern, {
+      cwd: process.cwd(),
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.storybook/**"]
+    });
+    if (files.length > 0) {
+      return pathResolve(process.cwd(), files[0]);
+    }
+  }
+  return "";
+};
+const resolveWebpackPaths = (currentDirname) => {
+  const possibleWebpackPaths = [
+    pathResolve(process.cwd(), "node_modules/webpack-cli/bin/cli.js"),
+    pathResolve(process.cwd(), "node_modules/.bin/webpack"),
+    pathResolve(process.cwd(), "node_modules/@nlabs/lex", "node_modules/webpack-cli/bin/cli.js"),
+    pathResolve(process.cwd(), "node_modules/@nlabs/lex", "node_modules/.bin/webpack"),
+    pathResolve(currentDirname, "node_modules/@nlabs/lex/node_modules/webpack-cli/bin/cli.js"),
+    pathResolve(currentDirname, "node_modules/@nlabs/lex/node_modules/.bin/webpack"),
+    pathResolve(process.env.LEX_HOME || "/node_modules/@nlabs/lex", "node_modules/webpack-cli/bin/cli.js"),
+    pathResolve(process.env.LEX_HOME || "/node_modules/@nlabs/lex", "node_modules/.bin/webpack")
+  ];
+  let webpackPath = "";
+  for (const path of possibleWebpackPaths) {
+    if (existsSync(path)) {
+      webpackPath = path;
+      break;
+    }
+  }
+  if (!webpackPath) {
+    webpackPath = "npx";
+  }
+  const possibleWebpackConfigPaths = [
+    pathResolve(process.cwd(), "webpack.config.js"),
+    pathResolve(process.cwd(), "webpack.config.ts"),
+    pathResolve(process.cwd(), "node_modules/@nlabs/lex/webpack.config.js"),
+    pathResolve(process.cwd(), "node_modules/@nlabs/lex/webpack.config.ts"),
+    pathResolve(currentDirname, "node_modules/@nlabs/lex/webpack.config.js"),
+    pathResolve(currentDirname, "node_modules/@nlabs/lex/webpack.config.ts"),
+    pathResolve(process.env.LEX_HOME || "/node_modules/@nlabs/lex", "webpack.config.js"),
+    pathResolve(process.env.LEX_HOME || "/node_modules/@nlabs/lex", "webpack.config.ts")
+  ];
+  let webpackConfig = "";
+  for (const path of possibleWebpackConfigPaths) {
+    if (existsSync(path)) {
+      webpackConfig = path;
+      break;
+    }
+  }
+  if (!webpackConfig) {
+    webpackConfig = pathResolve(currentDirname, "../../webpack.config.js");
+  }
+  return { webpackConfig, webpackPath };
+};
+export {
+  findTailwindCssPath,
+  getDirName,
+  getFilePath,
+  getLexPackageJsonPath,
+  getNodePath,
+  relativeFilePath,
+  relativeNodePath,
+  resolveBinaryPath,
+  resolveWebpackPaths
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/file.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 findFileUp from 'find-file-up';\nimport {existsSync, readFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {resolve as pathResolve, dirname} from 'path';\n\nimport {LexConfig} from '../LexConfig.js';\n\nexport const getDirName = (): string => {\n  try {\n    return eval('new URL(\".\", import.meta.url).pathname');\n  } catch {\n    return process.cwd();\n  }\n};\n\nexport const getFilePath = (relativePath: string): string => {\n  try {\n    return eval('require(\"url\").fileURLToPath(new URL(relativePath, import.meta.url))');\n  } catch {\n    if(relativePath === '../../../package.json') {\n      return pathResolve(process.cwd(), 'package.json');\n    }\n    return pathResolve(process.cwd(), relativePath);\n  }\n};\n\nexport const getLexPackageJsonPath = (): string => {\n  const LEX_PACKAGE_NAME = '@nlabs/lex';\n\n  const lexInNodeModules = pathResolve(process.cwd(), 'node_modules/@nlabs/lex/package.json');\n\n  if(existsSync(lexInNodeModules)) {\n    return lexInNodeModules;\n  }\n\n  let startDir: string;\n\n  if(process.env.LEX_ROOT) {\n    startDir = process.env.LEX_ROOT;\n  } else {\n    try {\n      startDir = eval('new URL(\".\", import.meta.url).pathname');\n    } catch {\n      try {\n        startDir = eval('__filename ? require(\"path\").dirname(__filename) : null');\n        if(!startDir) {\n          throw new Error('__filename not available');\n        }\n      } catch {\n        try {\n          if(process.argv[1] && !process.argv[1].includes('node')) {\n            startDir = dirname(process.argv[1]);\n          } else {\n            throw new Error('process.argv[1] not suitable');\n          }\n        } catch {\n          startDir = process.cwd();\n        }\n      }\n    }\n  }\n\n  let dir = startDir;\n  for(let i = 0; i < 8; i++) {\n    const pkgPath = pathResolve(dir, 'package.json');\n    if(existsSync(pkgPath)) {\n      try {\n        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));\n        if(pkg.name === LEX_PACKAGE_NAME) {\n          return pkgPath;\n        }\n      } catch {\n      }\n    }\n    const parent = dirname(dir);\n    if(parent === dir) {\n      break;\n    }\n    dir = parent;\n  }\n\n  return pathResolve(process.cwd(), 'package.json');\n};\n\nexport const relativeFilePath = (filename: string, dirPath: string = './', backUp: number = 0): string => {\n  const nestDepth: number = 10;\n\n  if(backUp) {\n    const filePath: string = findFileUp.sync(filename, dirPath, nestDepth);\n    const previousPath: string = Array(backUp).fill(null).map(() => '../').join('');\n    return pathResolve(filePath, previousPath);\n  }\n\n  return findFileUp.sync(filename, dirPath, nestDepth);\n};\n\nexport const relativeNodePath = (filename: string, dirPath: string = './', backUp: number = 0): string => {\n  const nestDepth: number = 10;\n  const modulePath = `node_modules/${filename}`;\n\n  if(dirPath !== './') {\n    const lexModulePath = pathResolve(dirPath, modulePath);\n    if(existsSync(lexModulePath)) {\n      return lexModulePath;\n    }\n  }\n\n  const projectPath = pathResolve(process.cwd(), modulePath);\n  if(existsSync(projectPath)) {\n    return projectPath;\n  }\n\n  if(backUp) {\n    const filePath: string = findFileUp.sync(modulePath, dirPath, nestDepth);\n    const previousPath: string = Array(nestDepth).fill(null).map(() => '../').join('');\n    return pathResolve(filePath, previousPath);\n  }\n\n  return findFileUp.sync(modulePath, dirPath, nestDepth) || `/node_modules/${filename}`;\n};\n\nexport const getNodePath = (moduleName: string): string => {\n  const dirName = getDirName();\n  const modulePath: string = `node_modules/${moduleName}`;\n\n  const projectPath = pathResolve(process.cwd(), modulePath);\n  if(existsSync(projectPath)) {\n    return projectPath;\n  }\n\n  const repoPath: string = findFileUp.sync(modulePath, dirName);\n  if(repoPath && existsSync(repoPath)) {\n    return repoPath;\n  }\n\n  const localPath: string = findFileUp.sync(modulePath, './', 10) || `./${modulePath}`;\n  return localPath;\n};\n\nexport const resolveBinaryPath = (binaryName: string, packageName?: string): string => {\n  const lexDir = LexConfig.getLexDir();\n\n  const lexBinPath = pathResolve(lexDir, `node_modules/.bin/${binaryName}`);\n  if(existsSync(lexBinPath)) {\n    return lexBinPath;\n  }\n\n  if(packageName) {\n    const lexPackageBinPath = pathResolve(lexDir, `node_modules/${packageName}/bin/${binaryName}`);\n    if(existsSync(lexPackageBinPath)) {\n      return lexPackageBinPath;\n    }\n\n    const lexPackageBinJsPath = pathResolve(lexDir, `node_modules/${packageName}/bin/${binaryName}.js`);\n    if(existsSync(lexPackageBinJsPath)) {\n      return lexPackageBinJsPath;\n    }\n\n    const lexPackageBinCjsPath = pathResolve(lexDir, `node_modules/${packageName}/bin/${binaryName}.cjs`);\n    if(existsSync(lexPackageBinCjsPath)) {\n      return lexPackageBinCjsPath;\n    }\n  }\n\n  const checkBinUp = (startDir: string) => {\n    let checkDir = startDir;\n    for(let i = 0; i < 5; i++) {\n      const monorepoBinPath = pathResolve(checkDir, `node_modules/.bin/${binaryName}`);\n      if(existsSync(monorepoBinPath)) {\n        return monorepoBinPath;\n      }\n      const parentDir = pathResolve(checkDir, '..');\n      if(parentDir === checkDir) {\n        break;\n      }\n      checkDir = parentDir;\n    }\n    return '';\n  };\n\n  const fromCwd = checkBinUp(process.cwd());\n  if(fromCwd) {\n    return fromCwd;\n  }\n\n  const fromLex = checkBinUp(lexDir);\n  if(fromLex) {\n    return fromLex;\n  }\n\n  return '';\n};\n\nexport const findTailwindCssPath = (): string => {\n  const tailwindPatterns = ['**/tailwind.css'];\n\n  for(const pattern of tailwindPatterns) {\n    const files = globSync(pattern, {\n      cwd: process.cwd(),\n      ignore: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.storybook/**']\n    });\n\n    if(files.length > 0) {\n      return pathResolve(process.cwd(), files[0]);\n    }\n  }\n\n  return '';\n};\n\nexport const resolveWebpackPaths = (currentDirname: string): {webpackPath: string; webpackConfig: string} => {\n  const possibleWebpackPaths = [\n    pathResolve(process.cwd(), 'node_modules/webpack-cli/bin/cli.js'),\n    pathResolve(process.cwd(), 'node_modules/.bin/webpack'),\n    pathResolve(process.cwd(), 'node_modules/@nlabs/lex', 'node_modules/webpack-cli/bin/cli.js'),\n    pathResolve(process.cwd(), 'node_modules/@nlabs/lex', 'node_modules/.bin/webpack'),\n    pathResolve(currentDirname, 'node_modules/@nlabs/lex/node_modules/webpack-cli/bin/cli.js'),\n    pathResolve(currentDirname, 'node_modules/@nlabs/lex/node_modules/.bin/webpack'),\n    pathResolve(process.env.LEX_HOME || '/node_modules/@nlabs/lex', 'node_modules/webpack-cli/bin/cli.js'),\n    pathResolve(process.env.LEX_HOME || '/node_modules/@nlabs/lex', 'node_modules/.bin/webpack')\n  ];\n\n  let webpackPath = '';\n\n  for(const path of possibleWebpackPaths) {\n    if(existsSync(path)) {\n      webpackPath = path;\n      break;\n    }\n  }\n\n  if(!webpackPath) {\n    webpackPath = 'npx';\n  }\n\n  const possibleWebpackConfigPaths = [\n    pathResolve(process.cwd(), 'webpack.config.js'),\n    pathResolve(process.cwd(), 'webpack.config.ts'),\n    pathResolve(process.cwd(), 'node_modules/@nlabs/lex/webpack.config.js'),\n    pathResolve(process.cwd(), 'node_modules/@nlabs/lex/webpack.config.ts'),\n    pathResolve(currentDirname, 'node_modules/@nlabs/lex/webpack.config.js'),\n    pathResolve(currentDirname, 'node_modules/@nlabs/lex/webpack.config.ts'),\n    pathResolve(process.env.LEX_HOME || '/node_modules/@nlabs/lex', 'webpack.config.js'),\n    pathResolve(process.env.LEX_HOME || '/node_modules/@nlabs/lex', 'webpack.config.ts')\n  ];\n\n  let webpackConfig = '';\n\n  for(const path of possibleWebpackConfigPaths) {\n    if(existsSync(path)) {\n      webpackConfig = path;\n      break;\n    }\n  }\n\n  if(!webpackConfig) {\n    webpackConfig = pathResolve(currentDirname, '../../webpack.config.js');\n  }\n\n  return {webpackConfig, webpackPath};\n};"],
  "mappings": "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",
  "names": ["startDir"]
}


package/lib/utils/translations.d.ts

@@ -0,0 +1 @@
+export declare const processTranslations: (sourcePath: string, outputPath: string, quiet?: boolean) => Promise<void>;