@nlabs/lex 1.46.2 → 1.47.1

package/resolver.cjs

@@ -6,6 +6,66 @@ const {existsSync} = require('fs');
 const {extname: pathExtname, resolve: pathResolve} = require('path');
 const resolveSync = require('resolve/sync');
 
+// Simple fallback for Jest's internal module resolution
+const resolveJestInternal = (moduleName) => {
+  // For Jest's internal requests, be more permissive
+  if (moduleName === 'index') {
+    // Jest might be looking for an index file in the current context
+    const possibleIndexFiles = [
+      pathResolve(process.cwd(), 'index.js'),
+      pathResolve(process.cwd(), 'index.ts'),
+      pathResolve(process.cwd(), 'index.cjs'),
+      pathResolve(__dirname, '../index.js'),
+      pathResolve(__dirname, '../index.ts'),
+      pathResolve(__dirname, '../index.cjs')
+    ];
+
+    for (const indexFile of possibleIndexFiles) {
+      if (existsSync(indexFile)) {
+        return indexFile;
+      }
+    }
+  }
+
+  // For other bare module names, try Node.js resolution
+  try {
+    return require.resolve(moduleName);
+  } catch (e) {
+    // If that fails, try to find it in node_modules
+    const possiblePaths = [
+      pathResolve(process.cwd(), 'node_modules', moduleName),
+      pathResolve(__dirname, '../node_modules', moduleName),
+      pathResolve(__dirname, '../../node_modules', moduleName)
+    ];
+
+    for (const possiblePath of possiblePaths) {
+      if (existsSync(possiblePath)) {
+        // Check for package.json to get the main entry point
+        const packageJsonPath = pathResolve(possiblePath, 'package.json');
+        if (existsSync(packageJsonPath)) {
+          try {
+            const packageJson = require(packageJsonPath);
+            const mainFile = packageJson.main || 'index.js';
+            const mainPath = pathResolve(possiblePath, mainFile);
+            if (existsSync(mainPath)) {
+              return mainPath;
+            }
+          } catch (e) {
+            // Continue to next path
+          }
+        }
+        // If no package.json or main file, try index.js
+        const indexPath = pathResolve(possiblePath, 'index.js');
+        if (existsSync(indexPath)) {
+          return indexPath;
+        }
+      }
+    }
+  }
+
+  return null;
+};
+
 const getFullPath = (basedir, name, extensions) => {
   let fileName = name;
 
@@ -42,45 +102,96 @@ module.exports = (value, options) => {
   }
 
   const isSequencer = fileName.startsWith('jest-sequencer-');
-
   if(isSequencer) {
     fileName = fileName.replace('jest-sequencer-', '');
   }
 
-  const {basedir, extensions = ['.js', '.ts']} = options;
+  const {basedir, extensions = ['.js', '.ts', '.tsx', '.cjs']} = options;
   const existingExt = pathExtname(fileName) || '';
   const hasExtension = existingExt !== '' && extensions.includes(existingExt);
   const isAbsolute = fileName.indexOf('/') === 0;
 
+  // For Jest's internal modules and transformers, use lex node_modules
+  if (fileName.includes('babel-jest') ||
+      fileName.includes('ts-jest') ||
+      fileName.includes('jest-transform-graphql') ||
+      fileName.includes('core-js') ||
+      fileName.includes('regenerator-runtime') ||
+      fileName.includes('jest-circus') ||
+      fileName.includes('@jest/') ||
+      fileName.includes('jest-sequencer-')) {
+    try {
+      const result = resolveSync(fileName, {basedir: pathResolve(__dirname, '../'), extensions});
+      return result;
+    } catch(error) {
+      return null;
+    }
+  }
+
+  // For internal node_modules imports (like core-js internal imports), use default resolution
+  if (basedir && basedir.includes('node_modules') && (fileName.startsWith('./') || fileName.startsWith('../'))) {
+    try {
+      const result = resolveSync(fileName, {basedir, extensions});
+      return result;
+    } catch(error) {
+      return null;
+    }
+  }
+
   if(isAbsolute) {
     if(hasExtension) {
-      return existsSync(fileName) ? fileName : null;
+      const result = existsSync(fileName) ? fileName : null;
+      return result;
     }
-
-    return getFullPath(fileName, 'index', extensions);
+    const result = pathResolve(fileName, 'index');
+    return result;
   }
 
   if(fileName === '..') {
-    return getFullPath(basedir, '..', extensions);
+    const result = pathResolve(basedir, '..');
+    return result;
   }
 
   const hasBase = fileName.indexOf('./') >= 0 || fileName.indexOf('../') >= 0;
-
   if(hasBase) {
     if(hasExtension) {
-      return pathResolve(`${basedir}/${fileName}`);
+      const result = pathResolve(basedir, fileName);
+      return result;
     }
 
-    return getFullPath(basedir, fileName, extensions);
+    // For relative paths without extension, try to resolve with extensions
+    try {
+      const result = resolveSync(fileName, {basedir, extensions});
+      return result;
+    } catch(error) {
+      // If resolveSync fails, try the old method
+      const result = pathResolve(basedir, fileName);
+
+      // Check if the result is a directory and append index.js if needed
+      if (existsSync(result) && !existsSync(result + '.js') && !existsSync(result + '.ts') && !existsSync(result + '.cjs')) {
+        const stats = require('fs').statSync(result);
+        if (stats.isDirectory()) {
+          const indexResult = pathResolve(result, 'index.js');
+          return indexResult;
+        }
+      }
+
+      return result;
+    }
   }
 
+  // For bare module names (like @nlabs/utils), try our custom resolution
   try {
-    return resolveSync(fileName, {basedir: `${__dirname}/../`, extensions});
-  } catch(error) {
+    const result = resolveSync(fileName, {basedir: process.cwd(), extensions});
+    return result;
+  } catch(projectError) {
+    // If not found, try to resolve from the Lex package's directory
     try {
-      return resolveSync(fileName, {basedir: process.cwd(), extensions});
-    } catch(error) {
-      return null;
+      const result = resolveSync(fileName, {basedir: pathResolve(__dirname, '../'), extensions});
+      return result;
+    } catch(lexError) {
+      // If still not found, throw the original error
+      throw projectError;
     }
   }
 };

package/tsconfig.json

@@ -6,6 +6,7 @@
   ],
   "extends": "../../tsconfig.base.json",
   "include": [
-    "./src"
+    "./src",
+    "./jest.setup.ts"
   ]
 }

package/webpack.config.d.ts

@@ -0,0 +1,2 @@
+declare function _default(webpackEnv: any, webpackOptions: any): any;
+export default _default;

package/webpack.config.js

@@ -2,11 +2,8 @@
  * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
  * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
  */
-import {existsSync} from 'fs';
-import {resolve as pathResolve} from 'path';
-import {URL} from 'url';
-
 import {StaticSitePlugin} from '@nlabs/webpack-plugin-static-site';
+import tailwindcss from '@tailwindcss/postcss';
 import autoprefixer from 'autoprefixer';
 import CompressionWebpackPlugin from 'compression-webpack-plugin';
 import CopyWebpackPlugin from 'copy-webpack-plugin';
@@ -14,9 +11,11 @@ import cssnano from 'cssnano';
 import DotenvPlugin from 'dotenv-webpack';
 import {EsbuildPlugin} from 'esbuild-loader';
 import FaviconsWebpackPlugin from 'favicons-webpack-plugin';
+import {existsSync} from 'fs';
 import {sync as globSync} from 'glob';
 import HtmlWebPackPlugin from 'html-webpack-plugin';
 import isEmpty from 'lodash/isEmpty.js';
+import {resolve as pathResolve} from 'path';
 import postcssBrowserReporter from 'postcss-browser-reporter';
 import postcssCustomProperties from 'postcss-custom-properties';
 import postcssFlexbugsFixes from 'postcss-flexbugs-fixes';
@@ -27,6 +26,8 @@ import postcssPercentage from 'postcss-percentage';
 import postcssPresetEnv from 'postcss-preset-env';
 import postcssUrl from 'postcss-url';
 import SVGSpriteMapPlugin from 'svg-spritemap-webpack-plugin';
+import TsconfigPathsPlugin from 'tsconfig-paths-webpack-plugin';
+import {URL} from 'url';
 import {default as webpack} from 'webpack';
 import {BundleAnalyzerPlugin} from 'webpack-bundle-analyzer';
 import {merge} from 'webpack-merge';
@@ -158,6 +159,13 @@ if(outputFile) {
   outputFilename = '[name].js';
 }
 
+const resolvePlugins = [];
+if(existsSync(`${sourceFullPath}/tsconfig.json`)) {
+  resolvePlugins.push(new TsconfigPathsPlugin({
+    configFile: `${sourceFullPath}/../tsconfig.json`
+  }));
+}
+
 // Loader paths
 const esbuildLoaderPath = relativeNodePath('esbuild-loader', dirName);
 const cssLoaderPath = relativeNodePath('css-loader', dirName);
@@ -266,26 +274,32 @@ export default (webpackEnv, webpackOptions) => {
                 postcssOptions: {
                   plugins: [
                     postcssImport({addDependencyTo: webpack}),
-                    postcssUrl,
-                    postcssFor,
+                    postcssUrl(),
+                    postcssFor(),
                     postcssPercentage({
                       floor: true,
                       precision: 9,
                       trimTrailingZero: true
                     }),
                     postcssCustomProperties({
+                      extensions: ['.css'],
+                      inject: {
+                        insertAt: 'top'
+                      },
+                      minimize: true,
                       preserve: false,
                       strict: false,
                       warnings: false
                     }),
-                    autoprefixer,
-                    postcssNesting,
-                    postcssFlexbugsFixes,
+                    tailwindcss(),
+                    autoprefixer(),
+                    postcssNesting(),
+                    postcssFlexbugsFixes(),
                     postcssPresetEnv({
                       stage: 0
                     }),
                     cssnano({autoprefixer: false}),
-                    postcssBrowserReporter
+                    postcssBrowserReporter()
                   ]
                 }
               }
@@ -374,10 +388,12 @@ export default (webpackEnv, webpackOptions) => {
         path: relativeNodePath('path-browserify', dirName),
         process: relativeNodePath('process/browser.js', dirName),
         stream: relativeNodePath('stream-browserify', dirName),
-        util: relativeNodePath('util', dirName)
+        util: relativeNodePath('util', dirName),
+        vm: relativeNodePath('vm-browserify', dirName)
       },
       mainFiles: ['index'],
       modules: [sourceFullPath, 'node_modules', relativeNodePath('', dirName)],
+      plugins: resolvePlugins,
       unsafeCache: {
         node_modules: true
       }

package/dist/commands/build.js

@@ -1,265 +0,0 @@
-import GraphqlLoaderPlugin from "@luckycatfactory/esbuild-graphql-loader";
-import { execa } from "execa";
-import { readFileSync } from "fs";
-import { sync as globSync } from "glob";
-import { resolve as pathResolve } from "path";
-import { URL } from "url";
-import { LexConfig } from "../LexConfig.js";
-import { checkLinkedModules, createSpinner, removeFiles } from "../utils/app.js";
-import { relativeNodePath } from "../utils/file.js";
-import { log } from "../utils/log.js";
-const buildWithEsBuild = async (spinner, commandOptions, callback) => {
-  const {
-    cliName = "Lex",
-    format = "cjs",
-    outputPath,
-    quiet,
-    sourcePath,
-    watch
-  } = commandOptions;
-  const {
-    outputFullPath,
-    sourceFullPath,
-    targetEnvironment,
-    useGraphQl,
-    useTypescript
-  } = LexConfig.config;
-  const sourceDir = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath;
-  const loader = {
-    ".js": "js"
-  };
-  if (useTypescript) {
-    loader[".ts"] = "ts";
-    loader[".tsx"] = "tsx";
-  }
-  const plugins = [];
-  if (useGraphQl) {
-    plugins.push(GraphqlLoaderPlugin());
-  }
-  const globOptions = {
-    cwd: sourceDir,
-    dot: false,
-    nodir: true,
-    nosort: true
-  };
-  const tsFiles = globSync(`${sourceDir}/**/!(*.spec|*.test).ts*`, globOptions);
-  const jsFiles = globSync(`${sourceDir}/**/!(*.spec|*.test).js`, globOptions);
-  const sourceFiles = [...tsFiles, ...jsFiles];
-  const packageJsonData = readFileSync(pathResolve(process.cwd(), "./package.json"));
-  const packageJson = JSON.parse(packageJsonData.toString());
-  const external = [
-    ...Object.keys(packageJson.dependencies || {}),
-    ...Object.keys(packageJson.peerDependencies || {})
-  ];
-  const dirName = new URL(".", import.meta.url).pathname;
-  const dirPath = pathResolve(dirName, "../..");
-  const outputDir = outputPath || outputFullPath;
-  const esbuildPath = relativeNodePath("esbuild/bin/esbuild", dirPath);
-  const esbuildOptions = [
-    ...sourceFiles,
-    "--bundle",
-    "--color=true",
-    `--format=${format}`,
-    `--outdir=${outputDir}`,
-    "--platform=node",
-    "--format=cjs",
-    "--sourcemap=inline",
-    `--target=${targetEnvironment === "node" ? "node20" : "es2018"}`
-  ];
-  if (external.length) {
-    esbuildOptions.push(`--external:${external.join(",")}`);
-  }
-  if (plugins.length) {
-    esbuildOptions.push(`--plugins=${plugins.join(",")}`);
-  }
-  if (watch) {
-    esbuildOptions.push("--watch");
-  }
-  try {
-    await execa(esbuildPath, esbuildOptions, { encoding: "utf8" });
-    spinner.succeed("Build completed successfully!");
-  } catch (error) {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    if (!quiet) {
-      console.error(error);
-    }
-    spinner.fail("Code build failed.");
-    callback(1);
-    return 1;
-  }
-  callback(0);
-  return 0;
-};
-const buildWithWebpack = async (spinner, cmd, callback) => {
-  const {
-    analyze,
-    cliName = "Lex",
-    config,
-    configName,
-    defineProcessEnvNodeEnv,
-    devtool,
-    disableInterpret,
-    entry,
-    env,
-    failOnWarnings,
-    json,
-    merge,
-    mode,
-    name,
-    nodeEnv,
-    noDevtool,
-    noStats,
-    noTarget,
-    noWatch,
-    noWatchOptionsStdin,
-    outputPath,
-    quiet = false,
-    stats,
-    target,
-    watch,
-    watchOptionsStdin
-  } = cmd;
-  let webpackConfig;
-  const dirName = new URL(".", import.meta.url).pathname;
-  if (config) {
-    const isRelativeConfig = config.substr(0, 2) === "./";
-    webpackConfig = isRelativeConfig ? pathResolve(process.cwd(), config) : config;
-  } else {
-    webpackConfig = pathResolve(dirName, "../../webpack.config.js");
-  }
-  const webpackOptions = [
-    "--color",
-    "--progress",
-    "--config",
-    webpackConfig
-  ];
-  if (analyze) {
-    webpackOptions.push("--analyze");
-  }
-  if (configName) {
-    webpackOptions.push("--configName", configName);
-  }
-  if (defineProcessEnvNodeEnv) {
-    webpackOptions.push("--defineProcessEnvNodeEnv", defineProcessEnvNodeEnv);
-  }
-  if (devtool) {
-    webpackOptions.push("--devtool", devtool);
-  }
-  if (disableInterpret) {
-    webpackOptions.push("--disableInterpret");
-  }
-  if (entry) {
-    webpackOptions.push("--entry", entry);
-  }
-  if (env) {
-    webpackOptions.push("--env", env);
-  }
-  if (failOnWarnings) {
-    webpackOptions.push("--failOnWarnings");
-  }
-  if (json) {
-    webpackOptions.push("--json", json);
-  }
-  if (mode) {
-    webpackOptions.push("--mode", mode);
-  }
-  if (merge) {
-    webpackOptions.push("--merge");
-  }
-  if (name) {
-    webpackOptions.push("--name", name);
-  }
-  if (noDevtool) {
-    webpackOptions.push("--noDevtool");
-  }
-  if (noStats) {
-    webpackOptions.push("--noStats");
-  }
-  if (noTarget) {
-    webpackOptions.push("--noTarget");
-  }
-  if (noWatch) {
-    webpackOptions.push("--noWatch");
-  }
-  if (noWatchOptionsStdin) {
-    webpackOptions.push("--noWatchOptionsStdin");
-  }
-  if (nodeEnv) {
-    webpackOptions.push("--nodeEnv", nodeEnv);
-  }
-  if (outputPath) {
-    webpackOptions.push("--outputPath", outputPath);
-  }
-  if (stats) {
-    webpackOptions.push("--stats", stats);
-  }
-  if (target) {
-    webpackOptions.push("--target", target);
-  }
-  if (watch) {
-    webpackOptions.push("--watch");
-  }
-  if (watchOptionsStdin) {
-    webpackOptions.push("--watchOptionsStdin");
-  }
-  const dirPath = pathResolve(dirName, "../..");
-  try {
-    const webpackPath = relativeNodePath("webpack-cli/bin/cli.js", dirPath);
-    await execa(webpackPath, webpackOptions, { encoding: "utf8", stdio: "inherit" });
-    spinner.succeed("Build completed successfully!");
-    callback(0);
-    return 0;
-  } catch (error) {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    spinner.fail("Build failed.");
-    callback(1);
-    return 1;
-  }
-};
-const build = async (cmd, callback = () => ({})) => {
-  const {
-    bundler = "webpack",
-    cliName = "Lex",
-    quiet = false,
-    remove = false,
-    variables = "{}"
-  } = cmd;
-  const spinner = createSpinner(quiet);
-  log(`${cliName} building...`, "info", quiet);
-  await LexConfig.parseConfig(cmd);
-  const { outputFullPath, useTypescript } = LexConfig.config;
-  checkLinkedModules();
-  let variablesObj = { NODE_ENV: "production" };
-  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 };
-  spinner.start("Building code...");
-  if (remove) {
-    await removeFiles(outputFullPath);
-  }
-  if (useTypescript) {
-    LexConfig.checkTypescriptConfig();
-  }
-  if (bundler === "esbuild") {
-    return buildWithEsBuild(spinner, cmd, callback);
-  }
-  return buildWithWebpack(spinner, cmd, callback);
-};
-var build_default = build;
-export {
-  build,
-  buildWithEsBuild,
-  buildWithWebpack,
-  build_default as default
-};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/commands/build.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 GraphqlLoaderPlugin from '@luckycatfactory/esbuild-graphql-loader';\nimport {execa} from 'execa';\nimport {readFileSync} from 'fs';\nimport {sync as globSync} from 'glob';\nimport {resolve as pathResolve} from 'path';\nimport {URL} from 'url';\n\nimport {LexConfig} from '../LexConfig.js';\nimport {checkLinkedModules, createSpinner, removeFiles} from '../utils/app.js';\nimport {relativeNodePath} from '../utils/file.js';\nimport {log} from '../utils/log.js';\n\nexport interface BuildOptions {\n  readonly bundler?: 'webpack' | 'esbuild';\n  readonly cliName?: string;\n  readonly format?: string;\n  readonly outputPath?: string;\n  readonly quiet?: boolean;\n  readonly remove?: boolean;\n  readonly sourcePath?: string;\n  readonly variables?: string;\n  readonly watch?: boolean;\n}\n\nexport type BuildCallback = (status: number) => void;\n\nexport const buildWithEsBuild = async (spinner, commandOptions: BuildOptions, callback: BuildCallback) => {\n  const {\n    cliName = 'Lex',\n    format = 'cjs',\n    outputPath,\n    quiet,\n    sourcePath,\n    watch\n  } = commandOptions;\n  const {\n    outputFullPath,\n    sourceFullPath,\n    targetEnvironment,\n    useGraphQl,\n    useTypescript\n  } = LexConfig.config;\n  const sourceDir: string = sourcePath ? pathResolve(process.cwd(), `./${sourcePath}`) : sourceFullPath;\n  const loader = {\n    '.js': 'js'\n  };\n\n  if(useTypescript) {\n    loader['.ts'] = 'ts';\n    loader['.tsx'] = 'tsx';\n  }\n\n  const plugins = [];\n\n  if(useGraphQl) {\n    plugins.push((GraphqlLoaderPlugin as unknown as () => void)());\n  }\n\n  // Source files\n  const globOptions = {\n    cwd: sourceDir,\n    dot: false,\n    nodir: true,\n    nosort: true\n  };\n  const tsFiles: string[] = globSync(`${sourceDir}/**/!(*.spec|*.test).ts*`, globOptions);\n  const jsFiles: string[] = globSync(`${sourceDir}/**/!(*.spec|*.test).js`, globOptions);\n  const sourceFiles: string[] = [...tsFiles, ...jsFiles];\n\n  // NPM Packages\n  const packageJsonData = readFileSync(pathResolve(process.cwd(), './package.json'));\n  const packageJson = JSON.parse(packageJsonData.toString());\n  const external = [\n    ...Object.keys(packageJson.dependencies || {}),\n    ...Object.keys(packageJson.peerDependencies || {})\n  ];\n\n  // ESBuild options\n  const dirName = new URL('.', import.meta.url).pathname;\n  const dirPath: string = pathResolve(dirName, '../..');\n  const outputDir: string = outputPath || outputFullPath;\n  const esbuildPath: string = relativeNodePath('esbuild/bin/esbuild', dirPath);\n  const esbuildOptions: string[] = [\n    ...sourceFiles,\n    '--bundle',\n    '--color=true',\n    `--format=${format}`,\n    `--outdir=${outputDir}`,\n    '--platform=node',\n    '--format=cjs',\n    '--sourcemap=inline',\n    `--target=${targetEnvironment === 'node' ? 'node20' : 'es2018'}`\n  ];\n\n  if(external.length) {\n    esbuildOptions.push(`--external:${external.join(',')}`);\n  }\n\n  if(plugins.length) {\n    esbuildOptions.push(`--plugins=${plugins.join(',')}`);\n  }\n  if(watch) {\n    esbuildOptions.push('--watch');\n  }\n\n  try {\n    await execa(esbuildPath, esbuildOptions, {encoding: 'utf8'});\n\n    spinner.succeed('Build completed successfully!');\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n    if(!quiet) {\n      console.error(error);\n    }\n\n    spinner.fail('Code build failed.');\n\n    callback(1);\n    return 1;\n  }\n\n  callback(0);\n  return 0;\n};\n\nexport const buildWithWebpack = async (spinner, cmd, callback) => {\n  const {\n    analyze,\n    cliName = 'Lex',\n    config,\n    configName,\n    defineProcessEnvNodeEnv,\n    devtool,\n    disableInterpret,\n    entry,\n    env,\n    failOnWarnings,\n    json,\n    merge,\n    mode,\n    name,\n    nodeEnv,\n    noDevtool,\n    noStats,\n    noTarget,\n    noWatch,\n    noWatchOptionsStdin,\n    outputPath,\n    quiet = false,\n    stats,\n    target,\n    watch,\n    watchOptionsStdin\n  } = cmd;\n\n  // Get custom webpack configuration\n  let webpackConfig: string;\n  const dirName = new URL('.', import.meta.url).pathname;\n\n  if(config) {\n    const isRelativeConfig: boolean = config.substr(0, 2) === './';\n    webpackConfig = isRelativeConfig ? pathResolve(process.cwd(), config) : config;\n  } else {\n    webpackConfig = pathResolve(dirName, '../../webpack.config.js');\n  }\n\n  const webpackOptions: string[] = [\n    '--color',\n    '--progress',\n    '--config', webpackConfig\n  ];\n\n  if(analyze) {\n    webpackOptions.push('--analyze');\n  }\n\n  if(configName) {\n    webpackOptions.push('--configName', configName);\n  }\n\n  if(defineProcessEnvNodeEnv) {\n    webpackOptions.push('--defineProcessEnvNodeEnv', defineProcessEnvNodeEnv);\n  }\n\n  if(devtool) {\n    webpackOptions.push('--devtool', devtool);\n  }\n\n  if(disableInterpret) {\n    webpackOptions.push('--disableInterpret');\n  }\n\n  if(entry) {\n    webpackOptions.push('--entry', entry);\n  }\n\n  if(env) {\n    webpackOptions.push('--env', env);\n  }\n\n  if(failOnWarnings) {\n    webpackOptions.push('--failOnWarnings');\n  }\n\n  if(json) {\n    webpackOptions.push('--json', json);\n  }\n\n  if(mode) {\n    webpackOptions.push('--mode', mode);\n  }\n\n  if(merge) {\n    webpackOptions.push('--merge');\n  }\n\n  if(name) {\n    webpackOptions.push('--name', name);\n  }\n\n  if(noDevtool) {\n    webpackOptions.push('--noDevtool');\n  }\n\n  if(noStats) {\n    webpackOptions.push('--noStats');\n  }\n\n  if(noTarget) {\n    webpackOptions.push('--noTarget');\n  }\n\n  if(noWatch) {\n    webpackOptions.push('--noWatch');\n  }\n\n  if(noWatchOptionsStdin) {\n    webpackOptions.push('--noWatchOptionsStdin');\n  }\n\n  if(nodeEnv) {\n    webpackOptions.push('--nodeEnv', nodeEnv);\n  }\n\n  if(outputPath) {\n    webpackOptions.push('--outputPath', outputPath);\n  }\n\n  if(stats) {\n    webpackOptions.push('--stats', stats);\n  }\n\n  if(target) {\n    webpackOptions.push('--target', target);\n  }\n\n  if(watch) {\n    webpackOptions.push('--watch');\n  }\n\n  if(watchOptionsStdin) {\n    webpackOptions.push('--watchOptionsStdin');\n  }\n\n  // Compile using webpack\n  const dirPath: string = pathResolve(dirName, '../..');\n\n  try {\n    const webpackPath: string = relativeNodePath('webpack-cli/bin/cli.js', dirPath);\n    await execa(webpackPath, webpackOptions, {encoding: 'utf8', stdio: 'inherit'});\n\n    // Stop spinner\n    spinner.succeed('Build completed successfully!');\n\n    // Stop process\n    callback(0);\n    return 0;\n  } catch(error) {\n    // Display error message\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n    // Stop spinner\n    spinner.fail('Build failed.');\n\n    // Kill process\n    callback(1);\n    return 1;\n  }\n};\n\nexport const build = async (cmd: BuildOptions, callback: BuildCallback = () => ({})): Promise<number> => {\n  const {\n    bundler = 'webpack',\n    cliName = 'Lex',\n    quiet = false,\n    remove = false,\n    variables = '{}'\n  } = cmd;\n\n  // Spinner\n  const spinner = createSpinner(quiet);\n\n  // Display status\n  log(`${cliName} building...`, 'info', quiet);\n\n  // Get custom configuration\n  await LexConfig.parseConfig(cmd);\n\n  const {outputFullPath, useTypescript} = LexConfig.config;\n\n  // Check for linked modules\n  checkLinkedModules();\n\n  // Set node environment variables\n  let variablesObj: object = {NODE_ENV: 'production'};\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\n      // Kill process\n      callback(1);\n      return 1;\n    }\n  }\n\n  process.env = {...process.env, ...variablesObj};\n\n  // Start build spinner\n  spinner.start('Building code...');\n\n  // Clean output directory before we start adding in new files\n  if(remove) {\n    await removeFiles(outputFullPath);\n  }\n\n  // Add tsconfig file if none exists\n  if(useTypescript) {\n    // Make sure tsconfig.json exists\n    LexConfig.checkTypescriptConfig();\n  }\n\n  if(bundler === 'esbuild') {\n    return buildWithEsBuild(spinner, cmd, callback);\n  }\n\n  return buildWithWebpack(spinner, cmd, callback);\n};\n\nexport default build;\n"],
  "mappings": "AAIA,OAAO,yBAAyB;AAChC,SAAQ,aAAY;AACpB,SAAQ,oBAAmB;AAC3B,SAAQ,QAAQ,gBAAe;AAC/B,SAAQ,WAAW,mBAAkB;AACrC,SAAQ,WAAU;AAElB,SAAQ,iBAAgB;AACxB,SAAQ,oBAAoB,eAAe,mBAAkB;AAC7D,SAAQ,wBAAuB;AAC/B,SAAQ,WAAU;AAgBX,MAAM,mBAAmB,OAAO,SAAS,gBAA8B,aAA4B;AACxG,QAAM;AAAA,IACJ,UAAU;AAAA,IACV,SAAS;AAAA,IACT;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI,UAAU;AACd,QAAM,YAAoB,aAAa,YAAY,QAAQ,IAAI,GAAG,KAAK,UAAU,EAAE,IAAI;AACvF,QAAM,SAAS;AAAA,IACb,OAAO;AAAA,EACT;AAEA,MAAG,eAAe;AAChB,WAAO,KAAK,IAAI;AAChB,WAAO,MAAM,IAAI;AAAA,EACnB;AAEA,QAAM,UAAU,CAAC;AAEjB,MAAG,YAAY;AACb,YAAQ,KAAM,oBAA8C,CAAC;AAAA,EAC/D;AAGA,QAAM,cAAc;AAAA,IAClB,KAAK;AAAA,IACL,KAAK;AAAA,IACL,OAAO;AAAA,IACP,QAAQ;AAAA,EACV;AACA,QAAM,UAAoB,SAAS,GAAG,SAAS,4BAA4B,WAAW;AACtF,QAAM,UAAoB,SAAS,GAAG,SAAS,2BAA2B,WAAW;AACrF,QAAM,cAAwB,CAAC,GAAG,SAAS,GAAG,OAAO;AAGrD,QAAM,kBAAkB,aAAa,YAAY,QAAQ,IAAI,GAAG,gBAAgB,CAAC;AACjF,QAAM,cAAc,KAAK,MAAM,gBAAgB,SAAS,CAAC;AACzD,QAAM,WAAW;AAAA,IACf,GAAG,OAAO,KAAK,YAAY,gBAAgB,CAAC,CAAC;AAAA,IAC7C,GAAG,OAAO,KAAK,YAAY,oBAAoB,CAAC,CAAC;AAAA,EACnD;AAGA,QAAM,UAAU,IAAI,IAAI,KAAK,YAAY,GAAG,EAAE;AAC9C,QAAM,UAAkB,YAAY,SAAS,OAAO;AACpD,QAAM,YAAoB,cAAc;AACxC,QAAM,cAAsB,iBAAiB,uBAAuB,OAAO;AAC3E,QAAM,iBAA2B;AAAA,IAC/B,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA,YAAY,MAAM;AAAA,IAClB,YAAY,SAAS;AAAA,IACrB;AAAA,IACA;AAAA,IACA;AAAA,IACA,YAAY,sBAAsB,SAAS,WAAW,QAAQ;AAAA,EAChE;AAEA,MAAG,SAAS,QAAQ;AAClB,mBAAe,KAAK,cAAc,SAAS,KAAK,GAAG,CAAC,EAAE;AAAA,EACxD;AAEA,MAAG,QAAQ,QAAQ;AACjB,mBAAe,KAAK,aAAa,QAAQ,KAAK,GAAG,CAAC,EAAE;AAAA,EACtD;AACA,MAAG,OAAO;AACR,mBAAe,KAAK,SAAS;AAAA,EAC/B;AAEA,MAAI;AACF,UAAM,MAAM,aAAa,gBAAgB,EAAC,UAAU,OAAM,CAAC;AAE3D,YAAQ,QAAQ,+BAA+B;AAAA,EACjD,SAAQ,OAAO;AACb,QAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAE1D,QAAG,CAAC,OAAO;AACT,cAAQ,MAAM,KAAK;AAAA,IACrB;AAEA,YAAQ,KAAK,oBAAoB;AAEjC,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAEA,WAAS,CAAC;AACV,SAAO;AACT;AAEO,MAAM,mBAAmB,OAAO,SAAS,KAAK,aAAa;AAChE,QAAM;AAAA,IACJ;AAAA,IACA,UAAU;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAGJ,MAAI;AACJ,QAAM,UAAU,IAAI,IAAI,KAAK,YAAY,GAAG,EAAE;AAE9C,MAAG,QAAQ;AACT,UAAM,mBAA4B,OAAO,OAAO,GAAG,CAAC,MAAM;AAC1D,oBAAgB,mBAAmB,YAAY,QAAQ,IAAI,GAAG,MAAM,IAAI;AAAA,EAC1E,OAAO;AACL,oBAAgB,YAAY,SAAS,yBAAyB;AAAA,EAChE;AAEA,QAAM,iBAA2B;AAAA,IAC/B;AAAA,IACA;AAAA,IACA;AAAA,IAAY;AAAA,EACd;AAEA,MAAG,SAAS;AACV,mBAAe,KAAK,WAAW;AAAA,EACjC;AAEA,MAAG,YAAY;AACb,mBAAe,KAAK,gBAAgB,UAAU;AAAA,EAChD;AAEA,MAAG,yBAAyB;AAC1B,mBAAe,KAAK,6BAA6B,uBAAuB;AAAA,EAC1E;AAEA,MAAG,SAAS;AACV,mBAAe,KAAK,aAAa,OAAO;AAAA,EAC1C;AAEA,MAAG,kBAAkB;AACnB,mBAAe,KAAK,oBAAoB;AAAA,EAC1C;AAEA,MAAG,OAAO;AACR,mBAAe,KAAK,WAAW,KAAK;AAAA,EACtC;AAEA,MAAG,KAAK;AACN,mBAAe,KAAK,SAAS,GAAG;AAAA,EAClC;AAEA,MAAG,gBAAgB;AACjB,mBAAe,KAAK,kBAAkB;AAAA,EACxC;AAEA,MAAG,MAAM;AACP,mBAAe,KAAK,UAAU,IAAI;AAAA,EACpC;AAEA,MAAG,MAAM;AACP,mBAAe,KAAK,UAAU,IAAI;AAAA,EACpC;AAEA,MAAG,OAAO;AACR,mBAAe,KAAK,SAAS;AAAA,EAC/B;AAEA,MAAG,MAAM;AACP,mBAAe,KAAK,UAAU,IAAI;AAAA,EACpC;AAEA,MAAG,WAAW;AACZ,mBAAe,KAAK,aAAa;AAAA,EACnC;AAEA,MAAG,SAAS;AACV,mBAAe,KAAK,WAAW;AAAA,EACjC;AAEA,MAAG,UAAU;AACX,mBAAe,KAAK,YAAY;AAAA,EAClC;AAEA,MAAG,SAAS;AACV,mBAAe,KAAK,WAAW;AAAA,EACjC;AAEA,MAAG,qBAAqB;AACtB,mBAAe,KAAK,uBAAuB;AAAA,EAC7C;AAEA,MAAG,SAAS;AACV,mBAAe,KAAK,aAAa,OAAO;AAAA,EAC1C;AAEA,MAAG,YAAY;AACb,mBAAe,KAAK,gBAAgB,UAAU;AAAA,EAChD;AAEA,MAAG,OAAO;AACR,mBAAe,KAAK,WAAW,KAAK;AAAA,EACtC;AAEA,MAAG,QAAQ;AACT,mBAAe,KAAK,YAAY,MAAM;AAAA,EACxC;AAEA,MAAG,OAAO;AACR,mBAAe,KAAK,SAAS;AAAA,EAC/B;AAEA,MAAG,mBAAmB;AACpB,mBAAe,KAAK,qBAAqB;AAAA,EAC3C;AAGA,QAAM,UAAkB,YAAY,SAAS,OAAO;AAEpD,MAAI;AACF,UAAM,cAAsB,iBAAiB,0BAA0B,OAAO;AAC9E,UAAM,MAAM,aAAa,gBAAgB,EAAC,UAAU,QAAQ,OAAO,UAAS,CAAC;AAG7E,YAAQ,QAAQ,+BAA+B;AAG/C,aAAS,CAAC;AACV,WAAO;AAAA,EACT,SAAQ,OAAO;AAEb,QAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAG1D,YAAQ,KAAK,eAAe;AAG5B,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AACF;AAEO,MAAM,QAAQ,OAAO,KAAmB,WAA0B,OAAO,CAAC,OAAwB;AACvG,QAAM;AAAA,IACJ,UAAU;AAAA,IACV,UAAU;AAAA,IACV,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,YAAY;AAAA,EACd,IAAI;AAGJ,QAAM,UAAU,cAAc,KAAK;AAGnC,MAAI,GAAG,OAAO,gBAAgB,QAAQ,KAAK;AAG3C,QAAM,UAAU,YAAY,GAAG;AAE/B,QAAM,EAAC,gBAAgB,cAAa,IAAI,UAAU;AAGlD,qBAAmB;AAGnB,MAAI,eAAuB,EAAC,UAAU,aAAY;AAElD,MAAG,WAAW;AACZ,QAAI;AACF,qBAAe,KAAK,MAAM,SAAS;AAAA,IACrC,SAAQ,OAAO;AACb,UAAI;AAAA,EAAK,OAAO,oEAAoE,SAAS,KAAK;AAGlG,eAAS,CAAC;AACV,aAAO;AAAA,IACT;AAAA,EACF;AAEA,UAAQ,MAAM,EAAC,GAAG,QAAQ,KAAK,GAAG,aAAY;AAG9C,UAAQ,MAAM,kBAAkB;AAGhC,MAAG,QAAQ;AACT,UAAM,YAAY,cAAc;AAAA,EAClC;AAGA,MAAG,eAAe;AAEhB,cAAU,sBAAsB;AAAA,EAClC;AAEA,MAAG,YAAY,WAAW;AACxB,WAAO,iBAAiB,SAAS,KAAK,QAAQ;AAAA,EAChD;AAEA,SAAO,iBAAiB,SAAS,KAAK,QAAQ;AAChD;AAEA,IAAO,gBAAQ;",
  "names": []
}
