@nlabs/lex 1.49.4 → 1.50.0

package/lib/commands/update/update.js

@@ -1,128 +1,149 @@
-import { execa } from "execa";
-import { LexConfig } from "../../LexConfig.js";
-import { createSpinner } from "../../utils/app.js";
-import { log } from "../../utils/log.js";
-const update = async (cmd, callback = process.exit) => {
-  const { cliName = "Lex", packageManager: cmdPackageManager, quiet, registry } = cmd;
-  log(`${cliName} updating packages...`, "info", quiet);
-  const spinner = createSpinner(quiet);
-  await LexConfig.parseConfig(cmd);
-  const { packageManager: configPackageManager } = LexConfig.config;
-  const packageManager = cmdPackageManager || configPackageManager || "npm";
-  const isNpm = packageManager === "npm";
-  try {
-    if (isNpm) {
-      let ncuCommand;
-      let ncuArgs;
-      try {
-        ncuCommand = "npx";
-        ncuArgs = [
-          "npm-check-updates",
-          "--concurrency",
-          "10",
-          "--packageManager",
-          packageManager,
-          "--pre",
-          "0",
-          "--target",
-          "latest",
-          ...cmd.interactive ? ["--interactive"] : [],
-          "--upgrade"
-        ];
-        if (registry) {
-          ncuArgs.push("--registry", registry);
-        }
-        await execa(ncuCommand, ncuArgs, {
-          encoding: "utf8",
-          stdio: "inherit"
-        });
-      } catch {
-        try {
-          ncuCommand = "npm-check-updates";
-          ncuArgs = [
-            "--concurrency",
-            "10",
-            "--packageManager",
-            packageManager,
-            "--pre",
-            "0",
-            "--target",
-            "latest",
-            ...cmd.interactive ? ["--interactive"] : [],
-            "--upgrade"
-          ];
-          if (registry) {
-            ncuArgs.push("--registry", registry);
-          }
-          await execa(ncuCommand, ncuArgs, {
-            encoding: "utf8",
-            stdio: "inherit"
-          });
-        } catch {
-          log("npm-check-updates not found. Installing it globally...", "info", quiet);
-          try {
-            await execa("npm", ["install", "-g", "npm-check-updates"], {
-              encoding: "utf8",
-              stdio: "inherit"
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { execa } from 'execa';
+import { LexConfig } from '../../LexConfig.js';
+import { createSpinner } from '../../utils/app.js';
+import { log } from '../../utils/log.js';
+export const update = async (cmd, callback = process.exit)=>{
+    const { cliName = 'Lex', packageManager: cmdPackageManager, quiet, registry } = cmd;
+    log(`${cliName} updating packages...`, 'info', quiet);
+    const spinner = createSpinner(quiet);
+    await LexConfig.parseConfig(cmd);
+    const { packageManager: configPackageManager } = LexConfig.config;
+    const packageManager = cmdPackageManager || configPackageManager || 'npm';
+    const isNpm = packageManager === 'npm';
+    try {
+        if (isNpm) {
+            let ncuCommand;
+            let ncuArgs;
+            try {
+                ncuCommand = 'npx';
+                ncuArgs = [
+                    'npm-check-updates',
+                    '--concurrency',
+                    '10',
+                    '--packageManager',
+                    packageManager,
+                    '--pre',
+                    '0',
+                    '--target',
+                    'latest',
+                    ...cmd.interactive ? [
+                        '--interactive'
+                    ] : [],
+                    '--upgrade'
+                ];
+                if (registry) {
+                    ncuArgs.push('--registry', registry);
+                }
+                await execa(ncuCommand, ncuArgs, {
+                    encoding: 'utf8',
+                    stdio: 'inherit'
+                });
+            } catch  {
+                try {
+                    ncuCommand = 'npm-check-updates';
+                    ncuArgs = [
+                        '--concurrency',
+                        '10',
+                        '--packageManager',
+                        packageManager,
+                        '--pre',
+                        '0',
+                        '--target',
+                        'latest',
+                        ...cmd.interactive ? [
+                            '--interactive'
+                        ] : [],
+                        '--upgrade'
+                    ];
+                    if (registry) {
+                        ncuArgs.push('--registry', registry);
+                    }
+                    await execa(ncuCommand, ncuArgs, {
+                        encoding: 'utf8',
+                        stdio: 'inherit'
+                    });
+                } catch  {
+                    log('npm-check-updates not found. Installing it globally...', 'info', quiet);
+                    try {
+                        await execa('npm', [
+                            'install',
+                            '-g',
+                            'npm-check-updates'
+                        ], {
+                            encoding: 'utf8',
+                            stdio: 'inherit'
+                        });
+                        ncuCommand = 'npm-check-updates';
+                        ncuArgs = [
+                            '--concurrency',
+                            '10',
+                            '--packageManager',
+                            packageManager,
+                            '--pre',
+                            '0',
+                            '--target',
+                            'latest',
+                            ...cmd.interactive ? [
+                                '--interactive'
+                            ] : [],
+                            '--upgrade'
+                        ];
+                        if (registry) {
+                            ncuArgs.push('--registry', registry);
+                        }
+                        await execa(ncuCommand, ncuArgs, {
+                            encoding: 'utf8',
+                            stdio: 'inherit'
+                        });
+                    } catch (installError) {
+                        log(`Failed to install or use npm-check-updates: ${installError.message}`, 'error', quiet);
+                        log('Please install npm-check-updates manually: npm install -g npm-check-updates', 'info', quiet);
+                        throw installError;
+                    }
+                }
+            }
+            // After successful update, run npm install and audit fix
+            await execa('npm', [
+                'i',
+                '--force'
+            ], {
+                encoding: 'utf8',
+                stdio: 'inherit'
             });
-            ncuCommand = "npm-check-updates";
-            ncuArgs = [
-              "--concurrency",
-              "10",
-              "--packageManager",
-              packageManager,
-              "--pre",
-              "0",
-              "--target",
-              "latest",
-              ...cmd.interactive ? ["--interactive"] : [],
-              "--upgrade"
+            await execa('npm', [
+                'audit',
+                'fix'
+            ], {
+                encoding: 'utf8',
+                stdio: 'inherit'
+            });
+        } else {
+            // Use yarn
+            const updateApp = 'yarn';
+            const updateOptions = [
+                cmd.interactive ? 'upgrade-interactive' : 'upgrade',
+                '--latest'
             ];
             if (registry) {
-              ncuArgs.push("--registry", registry);
+                updateOptions.push('--registry', registry);
             }
-            await execa(ncuCommand, ncuArgs, {
-              encoding: "utf8",
-              stdio: "inherit"
+            await execa(updateApp, updateOptions, {
+                encoding: 'utf8',
+                stdio: 'inherit'
             });
-          } catch (installError) {
-            log(`Failed to install or use npm-check-updates: ${installError.message}`, "error", quiet);
-            log("Please install npm-check-updates manually: npm install -g npm-check-updates", "info", quiet);
-            throw installError;
-          }
         }
-      }
-      await execa("npm", ["i", "--force"], {
-        encoding: "utf8",
-        stdio: "inherit"
-      });
-      await execa("npm", ["audit", "fix"], {
-        encoding: "utf8",
-        stdio: "inherit"
-      });
-    } else {
-      const updateApp = "yarn";
-      const updateOptions = [cmd.interactive ? "upgrade-interactive" : "upgrade", "--latest"];
-      if (registry) {
-        updateOptions.push("--registry", registry);
-      }
-      await execa(updateApp, updateOptions, {
-        encoding: "utf8",
-        stdio: "inherit"
-      });
+        spinner.succeed('Successfully updated packages!');
+        callback(0);
+        return 0;
+    } catch (error) {
+        log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+        spinner.fail('Failed to update packages.');
+        callback(1);
+        return 1;
     }
-    spinner.succeed("Successfully updated packages!");
-    callback(0);
-    return 0;
-  } catch (error) {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    spinner.fail("Failed to update packages.");
-    callback(1);
-    return 1;
-  }
-};
-export {
-  update
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/update/update.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {execa} from 'execa';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner} from '../../utils/app.js';\nimport {log} from '../../utils/log.js';\n\nexport interface UpdateOptions {\n  readonly cliName?: string;\n  readonly interactive?: boolean;\n  readonly packageManager?: string;\n  readonly quiet?: boolean;\n  readonly registry?: string;\n}\n\nexport type UpdateCallback = typeof process.exit;\n\nexport const update = async (cmd: UpdateOptions, callback: UpdateCallback = process.exit): Promise<number> => {\n  const {cliName = 'Lex', packageManager: cmdPackageManager, quiet, registry} = cmd;\n\n  log(`${cliName} updating packages...`, 'info', quiet);\n\n  const spinner = createSpinner(quiet);\n\n  await LexConfig.parseConfig(cmd);\n\n  const {packageManager: configPackageManager} = LexConfig.config;\n  const packageManager: string = cmdPackageManager || configPackageManager || 'npm';\n  const isNpm: boolean = packageManager === 'npm';\n\n  try {\n    if(isNpm) {\n      let ncuCommand: string;\n      let ncuArgs: string[];\n\n      try {\n        ncuCommand = 'npx';\n        ncuArgs = [\n          'npm-check-updates',\n          '--concurrency', '10',\n          '--packageManager', packageManager,\n          '--pre', '0',\n          '--target', 'latest',\n          ...(cmd.interactive ? ['--interactive'] : []),\n          '--upgrade'\n        ];\n\n        if(registry) {\n          ncuArgs.push('--registry', registry);\n        }\n\n        await execa(ncuCommand, ncuArgs, {\n          encoding: 'utf8',\n          stdio: 'inherit'\n        });\n      } catch {\n        try {\n          ncuCommand = 'npm-check-updates';\n          ncuArgs = [\n            '--concurrency', '10',\n            '--packageManager', packageManager,\n            '--pre', '0',\n            '--target', 'latest',\n            ...(cmd.interactive ? ['--interactive'] : []),\n            '--upgrade'\n          ];\n\n          if(registry) {\n            ncuArgs.push('--registry', registry);\n          }\n\n          await execa(ncuCommand, ncuArgs, {\n            encoding: 'utf8',\n            stdio: 'inherit'\n          });\n        } catch {\n          log('npm-check-updates not found. Installing it globally...', 'info', quiet);\n\n          try {\n            await execa('npm', ['install', '-g', 'npm-check-updates'], {\n              encoding: 'utf8',\n              stdio: 'inherit'\n            });\n\n            ncuCommand = 'npm-check-updates';\n            ncuArgs = [\n              '--concurrency', '10',\n              '--packageManager', packageManager,\n              '--pre', '0',\n              '--target', 'latest',\n              ...(cmd.interactive ? ['--interactive'] : []),\n              '--upgrade'\n            ];\n\n            if(registry) {\n              ncuArgs.push('--registry', registry);\n            }\n\n            await execa(ncuCommand, ncuArgs, {\n              encoding: 'utf8',\n              stdio: 'inherit'\n            });\n          } catch (installError) {\n            log(`Failed to install or use npm-check-updates: ${installError.message}`, 'error', quiet);\n            log('Please install npm-check-updates manually: npm install -g npm-check-updates', 'info', quiet);\n            throw installError;\n          }\n        }\n      }\n\n      // After successful update, run npm install and audit fix\n      await execa('npm', ['i', '--force'], {\n        encoding: 'utf8',\n        stdio: 'inherit'\n      });\n\n      await execa('npm', ['audit', 'fix'], {\n        encoding: 'utf8',\n        stdio: 'inherit'\n      });\n    } else {\n      // Use yarn\n      const updateApp = 'yarn';\n      const updateOptions: string[] = [cmd.interactive ? 'upgrade-interactive' : 'upgrade', '--latest'];\n\n      if(registry) {\n        updateOptions.push('--registry', registry);\n      }\n\n      await execa(updateApp, updateOptions, {\n        encoding: 'utf8',\n        stdio: 'inherit'\n      });\n    }\n\n    spinner.succeed('Successfully updated packages!');\n\n    callback(0);\n    return 0;\n  } catch (error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n    spinner.fail('Failed to update packages.');\n\n    callback(1);\n    return 1;\n  }\n};"],
  "mappings": "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",
  "names": []
}

+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/update/update.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {execa} from 'execa';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner} from '../../utils/app.js';\nimport {log} from '../../utils/log.js';\n\nexport interface UpdateOptions {\n  readonly cliName?: string;\n  readonly interactive?: boolean;\n  readonly packageManager?: string;\n  readonly quiet?: boolean;\n  readonly registry?: string;\n}\n\nexport type UpdateCallback = typeof process.exit;\n\nexport const update = async (cmd: UpdateOptions, callback: UpdateCallback = process.exit): Promise<number> => {\n  const {cliName = 'Lex', packageManager: cmdPackageManager, quiet, registry} = cmd;\n\n  log(`${cliName} updating packages...`, 'info', quiet);\n\n  const spinner = createSpinner(quiet);\n\n  await LexConfig.parseConfig(cmd);\n\n  const {packageManager: configPackageManager} = LexConfig.config;\n  const packageManager: string = cmdPackageManager || configPackageManager || 'npm';\n  const isNpm: boolean = packageManager === 'npm';\n\n  try {\n    if(isNpm) {\n      let ncuCommand: string;\n      let ncuArgs: string[];\n\n      try {\n        ncuCommand = 'npx';\n        ncuArgs = [\n          'npm-check-updates',\n          '--concurrency', '10',\n          '--packageManager', packageManager,\n          '--pre', '0',\n          '--target', 'latest',\n          ...(cmd.interactive ? ['--interactive'] : []),\n          '--upgrade'\n        ];\n\n        if(registry) {\n          ncuArgs.push('--registry', registry);\n        }\n\n        await execa(ncuCommand, ncuArgs, {\n          encoding: 'utf8',\n          stdio: 'inherit'\n        });\n      } catch{\n        try {\n          ncuCommand = 'npm-check-updates';\n          ncuArgs = [\n            '--concurrency', '10',\n            '--packageManager', packageManager,\n            '--pre', '0',\n            '--target', 'latest',\n            ...(cmd.interactive ? ['--interactive'] : []),\n            '--upgrade'\n          ];\n\n          if(registry) {\n            ncuArgs.push('--registry', registry);\n          }\n\n          await execa(ncuCommand, ncuArgs, {\n            encoding: 'utf8',\n            stdio: 'inherit'\n          });\n        } catch{\n          log('npm-check-updates not found. Installing it globally...', 'info', quiet);\n\n          try {\n            await execa('npm', ['install', '-g', 'npm-check-updates'], {\n              encoding: 'utf8',\n              stdio: 'inherit'\n            });\n\n            ncuCommand = 'npm-check-updates';\n            ncuArgs = [\n              '--concurrency', '10',\n              '--packageManager', packageManager,\n              '--pre', '0',\n              '--target', 'latest',\n              ...(cmd.interactive ? ['--interactive'] : []),\n              '--upgrade'\n            ];\n\n            if(registry) {\n              ncuArgs.push('--registry', registry);\n            }\n\n            await execa(ncuCommand, ncuArgs, {\n              encoding: 'utf8',\n              stdio: 'inherit'\n            });\n          } catch(installError) {\n            log(`Failed to install or use npm-check-updates: ${installError.message}`, 'error', quiet);\n            log('Please install npm-check-updates manually: npm install -g npm-check-updates', 'info', quiet);\n            throw installError;\n          }\n        }\n      }\n\n      // After successful update, run npm install and audit fix\n      await execa('npm', ['i', '--force'], {\n        encoding: 'utf8',\n        stdio: 'inherit'\n      });\n\n      await execa('npm', ['audit', 'fix'], {\n        encoding: 'utf8',\n        stdio: 'inherit'\n      });\n    } else {\n      // Use yarn\n      const updateApp = 'yarn';\n      const updateOptions: string[] = [cmd.interactive ? 'upgrade-interactive' : 'upgrade', '--latest'];\n\n      if(registry) {\n        updateOptions.push('--registry', registry);\n      }\n\n      await execa(updateApp, updateOptions, {\n        encoding: 'utf8',\n        stdio: 'inherit'\n      });\n    }\n\n    spinner.succeed('Successfully updated packages!');\n\n    callback(0);\n    return 0;\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n    spinner.fail('Failed to update packages.');\n\n    callback(1);\n    return 1;\n  }\n};"],"names":["execa","LexConfig","createSpinner","log","update","cmd","callback","process","exit","cliName","packageManager","cmdPackageManager","quiet","registry","spinner","parseConfig","configPackageManager","config","isNpm","ncuCommand","ncuArgs","interactive","push","encoding","stdio","installError","message","updateApp","updateOptions","succeed","error","fail"],"mappings":"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"}

package/lib/commands/upgrade/upgrade.js

@@ -1,47 +1,54 @@
-import { compareVersions } from "compare-versions";
-import { execa } from "execa";
-import { readFileSync } from "fs";
-import latestVersion from "latest-version";
-import { LexConfig } from "../../LexConfig.js";
-import { createSpinner } from "../../utils/app.js";
-import { getLexPackageJsonPath } from "../../utils/file.js";
-import { log } from "../../utils/log.js";
-import { parseVersion } from "../versions/versions.js";
+import { compareVersions } from 'compare-versions';
+import { execa } from 'execa';
+import { readFileSync } from 'fs';
+import latestVersion from 'latest-version';
+import { LexConfig } from '../../LexConfig.js';
+import { createSpinner } from '../../utils/app.js';
+import { getLexPackageJsonPath } from '../../utils/file.js';
+import { log } from '../../utils/log.js';
+import { parseVersion } from '../versions/versions.js';
 const packagePath = getLexPackageJsonPath();
-const packageJson = JSON.parse(readFileSync(packagePath, "utf8"));
-const upgrade = async (cmd, callback = process.exit) => {
-  const { cliName = "Lex", cliPackage = "@nlabs/lex", quiet } = cmd;
-  log(`Upgrading ${cliName}...`, "info", quiet);
-  const spinner = createSpinner(quiet);
-  await LexConfig.parseConfig(cmd);
-  return latestVersion("@nlabs/lex").then(async (latest) => {
-    const current = parseVersion(packageJson.version);
-    const versionDiff = compareVersions(latest, current);
-    if (versionDiff === 0) {
-      log(`
-Currently up-to-date. Version ${latest} is the latest.`, "note", quiet);
-      callback(0);
-      return 0;
-    }
-    log(`
-Currently out of date. Upgrading from version ${current} to ${latest}...`, "note", quiet);
-    const upgradeOptions = ["install", "-g", `${cliPackage}@latest`];
-    await execa("npm", upgradeOptions, {
-      encoding: "utf8",
-      stdio: "inherit"
+const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+export const upgrade = async (cmd, callback = process.exit)=>{
+    const { cliName = 'Lex', cliPackage = '@nlabs/lex', quiet } = cmd;
+    // Display status
+    log(`Upgrading ${cliName}...`, 'info', quiet);
+    // Spinner
+    const spinner = createSpinner(quiet);
+    // Get custom configuration
+    await LexConfig.parseConfig(cmd);
+    return latestVersion('@nlabs/lex').then(async (latest)=>{
+        const current = parseVersion(packageJson.version);
+        const versionDiff = compareVersions(latest, current);
+        if (versionDiff === 0) {
+            log(`\nCurrently up-to-date. Version ${latest} is the latest.`, 'note', quiet);
+            callback(0);
+            return 0;
+        }
+        log(`\nCurrently out of date. Upgrading from version ${current} to ${latest}...`, 'note', quiet);
+        const upgradeOptions = [
+            'install',
+            '-g',
+            `${cliPackage}@latest`
+        ];
+        await execa('npm', upgradeOptions, {
+            encoding: 'utf8',
+            stdio: 'inherit'
+        });
+        // Stop loader
+        spinner.succeed(`Successfully updated ${cliName}!`);
+        // Stop process
+        callback(0);
+        return 0;
+    }).catch((error)=>{
+        // Display error message
+        log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+        // Stop spinner
+        spinner.fail('Failed to updated packages.');
+        // Kill process
+        callback(1);
+        return 1;
     });
-    spinner.succeed(`Successfully updated ${cliName}!`);
-    callback(0);
-    return 0;
-  }).catch((error) => {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    spinner.fail("Failed to updated packages.");
-    callback(1);
-    return 1;
-  });
 };
-export {
-  upgrade
-};
-//# sourceMappingURL=data:application/json;base64,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
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21tYW5kcy91cGdyYWRlL3VwZ3JhZGUudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtjb21wYXJlVmVyc2lvbnN9IGZyb20gJ2NvbXBhcmUtdmVyc2lvbnMnO1xuaW1wb3J0IHtleGVjYX0gZnJvbSAnZXhlY2EnO1xuaW1wb3J0IHtyZWFkRmlsZVN5bmN9IGZyb20gJ2ZzJztcbmltcG9ydCBsYXRlc3RWZXJzaW9uIGZyb20gJ2xhdGVzdC12ZXJzaW9uJztcblxuaW1wb3J0IHtMZXhDb25maWd9IGZyb20gJy4uLy4uL0xleENvbmZpZy5qcyc7XG5pbXBvcnQge2NyZWF0ZVNwaW5uZXJ9IGZyb20gJy4uLy4uL3V0aWxzL2FwcC5qcyc7XG5pbXBvcnQge2dldExleFBhY2thZ2VKc29uUGF0aH0gZnJvbSAnLi4vLi4vdXRpbHMvZmlsZS5qcyc7XG5pbXBvcnQge2xvZ30gZnJvbSAnLi4vLi4vdXRpbHMvbG9nLmpzJztcbmltcG9ydCB7cGFyc2VWZXJzaW9ufSBmcm9tICcuLi92ZXJzaW9ucy92ZXJzaW9ucy5qcyc7XG5cbmNvbnN0IHBhY2thZ2VQYXRoID0gZ2V0TGV4UGFja2FnZUpzb25QYXRoKCk7XG5jb25zdCBwYWNrYWdlSnNvbiA9IEpTT04ucGFyc2UocmVhZEZpbGVTeW5jKHBhY2thZ2VQYXRoLCAndXRmOCcpKTtcblxuZXhwb3J0IGludGVyZmFjZSBVcGdyYWRlT3B0aW9ucyB7XG4gIHJlYWRvbmx5IGNsaU5hbWU/OiBzdHJpbmc7XG4gIHJlYWRvbmx5IGNsaVBhY2thZ2U/OiBzdHJpbmc7XG4gIHJlYWRvbmx5IHF1aWV0PzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IHR5cGUgVXBncmFkZUNhbGxiYWNrID0gdHlwZW9mIHByb2Nlc3MuZXhpdDtcblxuZXhwb3J0IGNvbnN0IHVwZ3JhZGUgPSBhc3luYyAoY21kOiBVcGdyYWRlT3B0aW9ucywgY2FsbGJhY2s6IFVwZ3JhZGVDYWxsYmFjayA9IHByb2Nlc3MuZXhpdCk6IFByb21pc2U8bnVtYmVyPiA9PiB7XG4gIGNvbnN0IHtjbGlOYW1lID0gJ0xleCcsIGNsaVBhY2thZ2UgPSAnQG5sYWJzL2xleCcsIHF1aWV0fSA9IGNtZDtcblxuICAvLyBEaXNwbGF5IHN0YXR1c1xuICBsb2coYFVwZ3JhZGluZyAke2NsaU5hbWV9Li4uYCwgJ2luZm8nLCBxdWlldCk7XG5cbiAgLy8gU3Bpbm5lclxuICBjb25zdCBzcGlubmVyID0gY3JlYXRlU3Bpbm5lcihxdWlldCk7XG5cbiAgLy8gR2V0IGN1c3RvbSBjb25maWd1cmF0aW9uXG4gIGF3YWl0IExleENvbmZpZy5wYXJzZUNvbmZpZyhjbWQpO1xuXG4gIHJldHVybiBsYXRlc3RWZXJzaW9uKCdAbmxhYnMvbGV4JylcbiAgICAudGhlbihhc3luYyAobGF0ZXN0OiBzdHJpbmcpID0+IHtcbiAgICAgIGNvbnN0IGN1cnJlbnQ6IHN0cmluZyA9IHBhcnNlVmVyc2lvbihwYWNrYWdlSnNvbi52ZXJzaW9uKTtcbiAgICAgIGNvbnN0IHZlcnNpb25EaWZmOiBudW1iZXIgPSBjb21wYXJlVmVyc2lvbnMobGF0ZXN0LCBjdXJyZW50KTtcblxuICAgICAgaWYodmVyc2lvbkRpZmYgPT09IDApIHtcbiAgICAgICAgbG9nKGBcXG5DdXJyZW50bHkgdXAtdG8tZGF0ZS4gVmVyc2lvbiAke2xhdGVzdH0gaXMgdGhlIGxhdGVzdC5gLCAnbm90ZScsIHF1aWV0KTtcbiAgICAgICAgY2FsbGJhY2soMCk7XG4gICAgICAgIHJldHVybiAwO1xuICAgICAgfVxuXG4gICAgICBsb2coYFxcbkN1cnJlbnRseSBvdXQgb2YgZGF0ZS4gVXBncmFkaW5nIGZyb20gdmVyc2lvbiAke2N1cnJlbnR9IHRvICR7bGF0ZXN0fS4uLmAsICdub3RlJywgcXVpZXQpO1xuXG4gICAgICBjb25zdCB1cGdyYWRlT3B0aW9uczogc3RyaW5nW10gPSBbJ2luc3RhbGwnLCAnLWcnLCBgJHtjbGlQYWNrYWdlfUBsYXRlc3RgXTtcblxuICAgICAgYXdhaXQgZXhlY2EoJ25wbScsIHVwZ3JhZGVPcHRpb25zLCB7XG4gICAgICAgIGVuY29kaW5nOiAndXRmOCcsXG4gICAgICAgIHN0ZGlvOiAnaW5oZXJpdCdcbiAgICAgIH0pO1xuXG4gICAgICAvLyBTdG9wIGxvYWRlclxuICAgICAgc3Bpbm5lci5zdWNjZWVkKGBTdWNjZXNzZnVsbHkgdXBkYXRlZCAke2NsaU5hbWV9IWApO1xuXG4gICAgICAvLyBTdG9wIHByb2Nlc3NcbiAgICAgIGNhbGxiYWNrKDApO1xuICAgICAgcmV0dXJuIDA7XG4gICAgfSlcbiAgICAuY2F0Y2goKGVycm9yKSA9PiB7XG4gICAgICAvLyBEaXNwbGF5IGVycm9yIG1lc3NhZ2VcbiAgICAgIGxvZyhgXFxuJHtjbGlOYW1lfSBFcnJvcjogJHtlcnJvci5tZXNzYWdlfWAsICdlcnJvcicsIHF1aWV0KTtcblxuICAgICAgLy8gU3RvcCBzcGlubmVyXG4gICAgICBzcGlubmVyLmZhaWwoJ0ZhaWxlZCB0byB1cGRhdGVkIHBhY2thZ2VzLicpO1xuXG4gICAgICAvLyBLaWxsIHByb2Nlc3NcbiAgICAgIGNhbGxiYWNrKDEpO1xuICAgICAgcmV0dXJuIDE7XG4gICAgfSk7XG59OyJdLCJuYW1lcyI6WyJjb21wYXJlVmVyc2lvbnMiLCJleGVjYSIsInJlYWRGaWxlU3luYyIsImxhdGVzdFZlcnNpb24iLCJMZXhDb25maWciLCJjcmVhdGVTcGlubmVyIiwiZ2V0TGV4UGFja2FnZUpzb25QYXRoIiwibG9nIiwicGFyc2VWZXJzaW9uIiwicGFja2FnZVBhdGgiLCJwYWNrYWdlSnNvbiIsIkpTT04iLCJwYXJzZSIsInVwZ3JhZGUiLCJjbWQiLCJjYWxsYmFjayIsInByb2Nlc3MiLCJleGl0IiwiY2xpTmFtZSIsImNsaVBhY2thZ2UiLCJxdWlldCIsInNwaW5uZXIiLCJwYXJzZUNvbmZpZyIsInRoZW4iLCJsYXRlc3QiLCJjdXJyZW50IiwidmVyc2lvbiIsInZlcnNpb25EaWZmIiwidXBncmFkZU9wdGlvbnMiLCJlbmNvZGluZyIsInN0ZGlvIiwic3VjY2VlZCIsImNhdGNoIiwiZXJyb3IiLCJtZXNzYWdlIiwiZmFpbCJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBUUEsZUFBZSxRQUFPLG1CQUFtQjtBQUNqRCxTQUFRQyxLQUFLLFFBQU8sUUFBUTtBQUM1QixTQUFRQyxZQUFZLFFBQU8sS0FBSztBQUNoQyxPQUFPQyxtQkFBbUIsaUJBQWlCO0FBRTNDLFNBQVFDLFNBQVMsUUFBTyxxQkFBcUI7QUFDN0MsU0FBUUMsYUFBYSxRQUFPLHFCQUFxQjtBQUNqRCxTQUFRQyxxQkFBcUIsUUFBTyxzQkFBc0I7QUFDMUQsU0FBUUMsR0FBRyxRQUFPLHFCQUFxQjtBQUN2QyxTQUFRQyxZQUFZLFFBQU8sMEJBQTBCO0FBRXJELE1BQU1DLGNBQWNIO0FBQ3BCLE1BQU1JLGNBQWNDLEtBQUtDLEtBQUssQ0FBQ1YsYUFBYU8sYUFBYTtBQVV6RCxPQUFPLE1BQU1JLFVBQVUsT0FBT0MsS0FBcUJDLFdBQTRCQyxRQUFRQyxJQUFJO0lBQ3pGLE1BQU0sRUFBQ0MsVUFBVSxLQUFLLEVBQUVDLGFBQWEsWUFBWSxFQUFFQyxLQUFLLEVBQUMsR0FBR047SUFFNUQsaUJBQWlCO0lBQ2pCUCxJQUFJLENBQUMsVUFBVSxFQUFFVyxRQUFRLEdBQUcsQ0FBQyxFQUFFLFFBQVFFO0lBRXZDLFVBQVU7SUFDVixNQUFNQyxVQUFVaEIsY0FBY2U7SUFFOUIsMkJBQTJCO0lBQzNCLE1BQU1oQixVQUFVa0IsV0FBVyxDQUFDUjtJQUU1QixPQUFPWCxjQUFjLGNBQ2xCb0IsSUFBSSxDQUFDLE9BQU9DO1FBQ1gsTUFBTUMsVUFBa0JqQixhQUFhRSxZQUFZZ0IsT0FBTztRQUN4RCxNQUFNQyxjQUFzQjNCLGdCQUFnQndCLFFBQVFDO1FBRXBELElBQUdFLGdCQUFnQixHQUFHO1lBQ3BCcEIsSUFBSSxDQUFDLGdDQUFnQyxFQUFFaUIsT0FBTyxlQUFlLENBQUMsRUFBRSxRQUFRSjtZQUN4RUwsU0FBUztZQUNULE9BQU87UUFDVDtRQUVBUixJQUFJLENBQUMsZ0RBQWdELEVBQUVrQixRQUFRLElBQUksRUFBRUQsT0FBTyxHQUFHLENBQUMsRUFBRSxRQUFRSjtRQUUxRixNQUFNUSxpQkFBMkI7WUFBQztZQUFXO1lBQU0sR0FBR1QsV0FBVyxPQUFPLENBQUM7U0FBQztRQUUxRSxNQUFNbEIsTUFBTSxPQUFPMkIsZ0JBQWdCO1lBQ2pDQyxVQUFVO1lBQ1ZDLE9BQU87UUFDVDtRQUVBLGNBQWM7UUFDZFQsUUFBUVUsT0FBTyxDQUFDLENBQUMscUJBQXFCLEVBQUViLFFBQVEsQ0FBQyxDQUFDO1FBRWxELGVBQWU7UUFDZkgsU0FBUztRQUNULE9BQU87SUFDVCxHQUNDaUIsS0FBSyxDQUFDLENBQUNDO1FBQ04sd0JBQXdCO1FBQ3hCMUIsSUFBSSxDQUFDLEVBQUUsRUFBRVcsUUFBUSxRQUFRLEVBQUVlLE1BQU1DLE9BQU8sRUFBRSxFQUFFLFNBQVNkO1FBRXJELGVBQWU7UUFDZkMsUUFBUWMsSUFBSSxDQUFDO1FBRWIsZUFBZTtRQUNmcEIsU0FBUztRQUNULE9BQU87SUFDVDtBQUNKLEVBQUUifQ==

package/lib/commands/versions/versions.d.ts

@@ -1,8 +1,8 @@
 export declare const parseVersion: (packageVersion: string) => string;
 export declare const packages: {
-    esbuild: string;
     jest: string;
     lex: any;
+    swc: string;
     typescript: string;
     webpack: string;
 };

package/lib/commands/versions/versions.js

@@ -1,41 +1,39 @@
-import { readFileSync } from "fs";
-import { getLexPackageJsonPath } from "../../utils/file.js";
-import { log } from "../../utils/log.js";
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { readFileSync } from 'fs';
+import { getLexPackageJsonPath } from '../../utils/file.js';
+import { log } from '../../utils/log.js';
 const packagePath = getLexPackageJsonPath();
-const packageJson = JSON.parse(readFileSync(packagePath, "utf8"));
-const parseVersion = (packageVersion) => packageVersion?.replace(/\^/g, "") || "N/A";
-const packages = {
-  esbuild: parseVersion(packageJson?.dependencies?.esbuild),
-  jest: parseVersion(packageJson?.dependencies?.jest),
-  lex: packageJson.version,
-  typescript: parseVersion(packageJson?.dependencies?.typescript),
-  webpack: parseVersion(packageJson?.dependencies?.webpack)
+const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+export const parseVersion = (packageVersion)=>packageVersion?.replace(/\^/g, '') || 'N/A';
+export const packages = {
+    jest: parseVersion(packageJson?.dependencies?.jest),
+    lex: packageJson.version,
+    swc: parseVersion(packageJson?.dependencies?.['@swc/core']),
+    typescript: parseVersion(packageJson?.dependencies?.typescript),
+    webpack: parseVersion(packageJson?.dependencies?.webpack)
 };
-const jsonVersions = (lexPackages) => Object.keys(lexPackages).reduce((list, key) => {
-  list[key] = packages[key];
-  return list;
-}, {});
-const versions = (cmd, callback) => {
-  if (cmd.json) {
-    console.log(JSON.stringify(jsonVersions(packages)));
-  } else {
-    log("Versions:", "info", false);
-    log(`  Lex: ${packages.lex}`, "info", false);
-    log("  ----------", "note", false);
-    log(`  ESBuild: ${packages.esbuild}`, "info", false);
-    log(`  Jest: ${packages.jest}`, "info", false);
-    log(`  Typescript: ${packages.typescript}`, "info", false);
-    log(`  Webpack: ${packages.webpack}`, "info", false);
-  }
-  if (callback) {
-    callback(0);
-  }
-  return Promise.resolve(0);
+export const jsonVersions = (lexPackages)=>Object.keys(lexPackages).reduce((list, key)=>{
+        list[key] = packages[key];
+        return list;
+    }, {});
+export const versions = (cmd, callback)=>{
+    if (cmd.json) {
+        console.log(JSON.stringify(jsonVersions(packages)));
+    } else {
+        log('Versions:', 'info', false);
+        log(`  Lex: ${packages.lex}`, 'info', false);
+        log('  ----------', 'note', false);
+        log(`  SWC: ${packages.swc}`, 'info', false);
+        log(`  Jest: ${packages.jest}`, 'info', false);
+        log(`  Typescript: ${packages.typescript}`, 'info', false);
+        log(`  Webpack: ${packages.webpack}`, 'info', false);
+    }
+    if (callback) {
+        callback(0);
+    }
+    return Promise.resolve(0);
 };
-export {
-  jsonVersions,
-  packages,
-  parseVersion,
-  versions
-};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2NvbW1hbmRzL3ZlcnNpb25zL3ZlcnNpb25zLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAxOC1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBDb3B5cmlnaHRzIGxpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS4gU2VlIHRoZSBhY2NvbXBhbnlpbmcgTElDRU5TRSBmaWxlIGZvciB0ZXJtcy5cbiAqL1xuaW1wb3J0IHtyZWFkRmlsZVN5bmN9IGZyb20gJ2ZzJztcblxuaW1wb3J0IHtnZXRMZXhQYWNrYWdlSnNvblBhdGh9IGZyb20gJy4uLy4uL3V0aWxzL2ZpbGUuanMnO1xuaW1wb3J0IHtsb2d9IGZyb20gJy4uLy4uL3V0aWxzL2xvZy5qcyc7XG5cbmNvbnN0IHBhY2thZ2VQYXRoID0gZ2V0TGV4UGFja2FnZUpzb25QYXRoKCk7XG5jb25zdCBwYWNrYWdlSnNvbiA9IEpTT04ucGFyc2UocmVhZEZpbGVTeW5jKHBhY2thZ2VQYXRoLCAndXRmOCcpKTtcblxuZXhwb3J0IGNvbnN0IHBhcnNlVmVyc2lvbiA9IChwYWNrYWdlVmVyc2lvbjogc3RyaW5nKTogc3RyaW5nID0+IHBhY2thZ2VWZXJzaW9uPy5yZXBsYWNlKC9cXF4vZywgJycpIHx8ICdOL0EnO1xuXG5leHBvcnQgY29uc3QgcGFja2FnZXMgPSB7XG4gIGVzYnVpbGQ6IHBhcnNlVmVyc2lvbihwYWNrYWdlSnNvbj8uZGVwZW5kZW5jaWVzPy5lc2J1aWxkKSxcbiAgamVzdDogcGFyc2VWZXJzaW9uKHBhY2thZ2VKc29uPy5kZXBlbmRlbmNpZXM/Lmplc3QpLFxuICBsZXg6IHBhY2thZ2VKc29uLnZlcnNpb24sXG4gIHR5cGVzY3JpcHQ6IHBhcnNlVmVyc2lvbihwYWNrYWdlSnNvbj8uZGVwZW5kZW5jaWVzPy50eXBlc2NyaXB0KSxcbiAgd2VicGFjazogcGFyc2VWZXJzaW9uKHBhY2thZ2VKc29uPy5kZXBlbmRlbmNpZXM/LndlYnBhY2spXG59O1xuXG5leHBvcnQgY29uc3QganNvblZlcnNpb25zID0gKGxleFBhY2thZ2VzKSA9PiBPYmplY3Qua2V5cyhsZXhQYWNrYWdlcykucmVkdWNlKChsaXN0LCBrZXkpID0+IHtcbiAgbGlzdFtrZXldID0gcGFja2FnZXNba2V5XTtcbiAgcmV0dXJuIGxpc3Q7XG59LCB7fSk7XG5cbmV4cG9ydCBpbnRlcmZhY2UgVmVyc2lvbnNDbWQge1xuICByZWFkb25seSBqc29uPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGNvbnN0IHZlcnNpb25zID0gKGNtZDogVmVyc2lvbnNDbWQsIGNhbGxiYWNrOiAoc3RhdHVzOiBudW1iZXIpID0+IHZvaWQpOiBQcm9taXNlPG51bWJlcj4gPT4ge1xuICBpZihjbWQuanNvbikge1xuICAgIGNvbnNvbGUubG9nKEpTT04uc3RyaW5naWZ5KGpzb25WZXJzaW9ucyhwYWNrYWdlcykpKTtcbiAgfSBlbHNlIHtcbiAgICBsb2coJ1ZlcnNpb25zOicsICdpbmZvJywgZmFsc2UpO1xuICAgIGxvZyhgICBMZXg6ICR7cGFja2FnZXMubGV4fWAsICdpbmZvJywgZmFsc2UpO1xuICAgIGxvZygnICAtLS0tLS0tLS0tJywgJ25vdGUnLCBmYWxzZSk7XG4gICAgbG9nKGAgIEVTQnVpbGQ6ICR7cGFja2FnZXMuZXNidWlsZH1gLCAnaW5mbycsIGZhbHNlKTtcbiAgICBsb2coYCAgSmVzdDogJHtwYWNrYWdlcy5qZXN0fWAsICdpbmZvJywgZmFsc2UpO1xuICAgIGxvZyhgICBUeXBlc2NyaXB0OiAke3BhY2thZ2VzLnR5cGVzY3JpcHR9YCwgJ2luZm8nLCBmYWxzZSk7XG4gICAgbG9nKGAgIFdlYnBhY2s6ICR7cGFja2FnZXMud2VicGFja31gLCAnaW5mbycsIGZhbHNlKTtcbiAgfVxuXG4gIGlmKGNhbGxiYWNrKSB7XG4gICAgY2FsbGJhY2soMCk7XG4gIH1cblxuICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKDApO1xufTsiXSwKICAibWFwcGluZ3MiOiAiQUFJQSxTQUFRLG9CQUFtQjtBQUUzQixTQUFRLDZCQUE0QjtBQUNwQyxTQUFRLFdBQVU7QUFFbEIsTUFBTSxjQUFjLHNCQUFzQjtBQUMxQyxNQUFNLGNBQWMsS0FBSyxNQUFNLGFBQWEsYUFBYSxNQUFNLENBQUM7QUFFekQsTUFBTSxlQUFlLENBQUMsbUJBQW1DLGdCQUFnQixRQUFRLE9BQU8sRUFBRSxLQUFLO0FBRS9GLE1BQU0sV0FBVztBQUFBLEVBQ3RCLFNBQVMsYUFBYSxhQUFhLGNBQWMsT0FBTztBQUFBLEVBQ3hELE1BQU0sYUFBYSxhQUFhLGNBQWMsSUFBSTtBQUFBLEVBQ2xELEtBQUssWUFBWTtBQUFBLEVBQ2pCLFlBQVksYUFBYSxhQUFhLGNBQWMsVUFBVTtBQUFBLEVBQzlELFNBQVMsYUFBYSxhQUFhLGNBQWMsT0FBTztBQUMxRDtBQUVPLE1BQU0sZUFBZSxDQUFDLGdCQUFnQixPQUFPLEtBQUssV0FBVyxFQUFFLE9BQU8sQ0FBQyxNQUFNLFFBQVE7QUFDMUYsT0FBSyxHQUFHLElBQUksU0FBUyxHQUFHO0FBQ3hCLFNBQU87QUFDVCxHQUFHLENBQUMsQ0FBQztBQU1FLE1BQU0sV0FBVyxDQUFDLEtBQWtCLGFBQXdEO0FBQ2pHLE1BQUcsSUFBSSxNQUFNO0FBQ1gsWUFBUSxJQUFJLEtBQUssVUFBVSxhQUFhLFFBQVEsQ0FBQyxDQUFDO0FBQUEsRUFDcEQsT0FBTztBQUNMLFFBQUksYUFBYSxRQUFRLEtBQUs7QUFDOUIsUUFBSSxVQUFVLFNBQVMsR0FBRyxJQUFJLFFBQVEsS0FBSztBQUMzQyxRQUFJLGdCQUFnQixRQUFRLEtBQUs7QUFDakMsUUFBSSxjQUFjLFNBQVMsT0FBTyxJQUFJLFFBQVEsS0FBSztBQUNuRCxRQUFJLFdBQVcsU0FBUyxJQUFJLElBQUksUUFBUSxLQUFLO0FBQzdDLFFBQUksaUJBQWlCLFNBQVMsVUFBVSxJQUFJLFFBQVEsS0FBSztBQUN6RCxRQUFJLGNBQWMsU0FBUyxPQUFPLElBQUksUUFBUSxLQUFLO0FBQUEsRUFDckQ7QUFFQSxNQUFHLFVBQVU7QUFDWCxhQUFTLENBQUM7QUFBQSxFQUNaO0FBRUEsU0FBTyxRQUFRLFFBQVEsQ0FBQztBQUMxQjsiLAogICJuYW1lcyI6IFtdCn0K
+
+//# sourceMappingURL=data:application/json;base64,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