@nlabs/lex 1.49.4 → 1.50.0

package/lib/commands/migrate/migrate.js

@@ -1,37 +1,50 @@
-import { execa } from "execa";
-import { LexConfig } from "../../LexConfig.js";
-import { createSpinner, getPackageJson, removeConflictModules, removeModules } from "../../utils/app.js";
-import { log } from "../../utils/log.js";
-const migrate = async (cmd, callback = process.exit) => {
-  const { cliName = "Lex", packageManager: cmdPackageManager, quiet } = cmd;
-  const cwd = process.cwd();
-  const spinner = createSpinner(quiet);
-  spinner.start("Removing node modules...");
-  await removeModules();
-  const { packageManager: configPackageManager } = LexConfig.config;
-  const packageManager = cmdPackageManager || configPackageManager || "";
-  const packagePath = `${cwd}/package.json`;
-  const appPackage = getPackageJson(packagePath);
-  const { dependencies = {}, devDependencies = {} } = appPackage;
-  appPackage.dependencies = removeConflictModules(dependencies);
-  appPackage.devDependencies = removeConflictModules(devDependencies);
-  try {
-    await execa(packageManager, ["install"], {
-      encoding: "utf8",
-      stdio: "inherit"
-    });
-    spinner.succeed("Successfully migrated app!");
-    callback(0);
-    return 0;
-  } catch (error) {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    spinner.fail("Failed to remove modules.");
-    callback(1);
-    return 1;
-  }
+/**
+ * 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, getPackageJson, removeConflictModules, removeModules } from '../../utils/app.js';
+import { log } from '../../utils/log.js';
+export const migrate = async (cmd, callback = process.exit)=>{
+    const { cliName = 'Lex', packageManager: cmdPackageManager, quiet } = cmd;
+    const cwd = process.cwd();
+    // // Display message
+    // log(`${cliName} copying "${to}"...`, 'info', quiet);
+    // Spinner
+    const spinner = createSpinner(quiet);
+    spinner.start('Removing node modules...');
+    // Remove node_modules
+    await removeModules();
+    const { packageManager: configPackageManager } = LexConfig.config;
+    const packageManager = cmdPackageManager || configPackageManager || '';
+    const packagePath = `${cwd}/package.json`;
+    const appPackage = getPackageJson(packagePath);
+    const { dependencies = {}, devDependencies = {} } = appPackage;
+    // Remove ESBuild, Jest and Webpack from app since it will conflict
+    appPackage.dependencies = removeConflictModules(dependencies);
+    appPackage.devDependencies = removeConflictModules(devDependencies);
+    // Install new list of packages
+    try {
+        await execa(packageManager, [
+            'install'
+        ], {
+            encoding: 'utf8',
+            stdio: 'inherit'
+        });
+        // Stop loader
+        spinner.succeed('Successfully migrated app!');
+        // Kill process
+        callback(0);
+        return 0;
+    } catch (error) {
+        // Display error message
+        log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+        // Stop spinner
+        spinner.fail('Failed to remove modules.');
+        // Kill process
+        callback(1);
+        return 1;
+    }
 };
-export {
-  migrate
-};
-//# sourceMappingURL=data:application/json;base64,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
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/commands/publish/publish.js

@@ -1,104 +1,124 @@
-import { execa } from "execa";
-import semver from "semver";
-import { LexConfig } from "../../LexConfig.js";
-import { createSpinner, getPackageJson, setPackageJson } from "../../utils/app.js";
-import { log } from "../../utils/log.js";
-const publish = async (cmd, callback = process.exit) => {
-  const { bump, cliName = "Lex", newVersion, otp, packageManager: cmdPackageManager, private: accessPrivate, tag, quiet } = cmd;
-  log(`${cliName} publishing npm module...`, "info", quiet);
-  const spinner = createSpinner(quiet);
-  await LexConfig.parseConfig(cmd);
-  const { packageManager: configPackageManager } = LexConfig.config;
-  const packageManager = cmdPackageManager || configPackageManager;
-  const publishOptions = ["publish"];
-  if (accessPrivate) {
-    publishOptions.push("--access", "restricted");
-  }
-  if (otp) {
-    publishOptions.push("--otp", otp);
-  }
-  if (tag) {
-    publishOptions.push("--tag", tag);
-  }
-  let nextVersion;
-  const packagePath = `${process.cwd()}/package.json`;
-  let packageJson;
-  let packageName;
-  let prevVersion;
-  try {
-    packageJson = getPackageJson(packagePath);
-    packageName = packageJson.name;
-    prevVersion = packageJson.version;
-  } catch (error) {
-    log(`
-${cliName} Error: The file, ${packagePath}, was not found or is malformed.
-`, "error", quiet);
-    log(error.message, "error");
-    callback(1);
-    return 1;
-  }
-  if (newVersion) {
-    nextVersion = newVersion;
-  } else if (bump) {
-    const formatBump = bump.toString().trim().toLowerCase();
-    if (formatBump) {
-      const validReleases = ["major", "minor", "patch"];
-      const validPreReleases = ["alpha", "beta", "rc"];
-      const packageVersion = semver.coerce(prevVersion);
-      if (!semver.valid(packageVersion)) {
-        log(`
-${cliName} Error: Version is invalid in package.json`, "error", quiet);
-        callback(1);
-        return 1;
-      }
-      if (validReleases.includes(formatBump)) {
-        nextVersion = semver.inc(packageVersion, formatBump);
-      } else if (validPreReleases.includes(formatBump)) {
-        nextVersion = semver.inc(packageVersion, "prerelease", formatBump);
-      } else {
-        log(`
-${cliName} Error: Bump type is invalid. please make sure it is one of the following: ${validReleases.join(", ")}, ${validPreReleases.join(", ")}`, "error", quiet);
+/**
+ * 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 semver from 'semver';
+import { LexConfig } from '../../LexConfig.js';
+import { createSpinner, getPackageJson, setPackageJson } from '../../utils/app.js';
+import { log } from '../../utils/log.js';
+export const publish = async (cmd, callback = process.exit)=>{
+    const { bump, cliName = 'Lex', newVersion, otp, packageManager: cmdPackageManager, private: accessPrivate, tag, quiet } = cmd;
+    log(`${cliName} publishing npm module...`, 'info', quiet);
+    // Spinner
+    const spinner = createSpinner(quiet);
+    // Get custom configuration
+    await LexConfig.parseConfig(cmd);
+    const { packageManager: configPackageManager } = LexConfig.config;
+    const packageManager = cmdPackageManager || configPackageManager;
+    const publishOptions = [
+        'publish'
+    ];
+    if (accessPrivate) {
+        publishOptions.push('--access', 'restricted');
+    }
+    if (otp) {
+        publishOptions.push('--otp', otp);
+    }
+    if (tag) {
+        publishOptions.push('--tag', tag);
+    }
+    // Get next version number
+    let nextVersion;
+    const packagePath = `${process.cwd()}/package.json`;
+    let packageJson;
+    let packageName;
+    let prevVersion;
+    // If not using yarn, we'll use npm and manually update the version number
+    try {
+        packageJson = getPackageJson(packagePath);
+        packageName = packageJson.name;
+        prevVersion = packageJson.version;
+    } catch (error) {
+        log(`\n${cliName} Error: The file, ${packagePath}, was not found or is malformed.\n`, 'error', quiet);
+        log(error.message, 'error');
         callback(1);
         return 1;
-      }
+    }
+    // Update package.json with the latest version
+    if (newVersion) {
+        // If using a specific version, we don't need to determine the next bump
+        nextVersion = newVersion;
+    } else if (bump) {
+        // Determine next version
+        const formatBump = bump.toString().trim().toLowerCase();
+        if (formatBump) {
+            const validReleases = [
+                'major',
+                'minor',
+                'patch'
+            ];
+            const validPreReleases = [
+                'alpha',
+                'beta',
+                'rc'
+            ];
+            // Make sure the version in package.json is valid
+            const packageVersion = semver.coerce(prevVersion);
+            if (!semver.valid(packageVersion)) {
+                log(`\n${cliName} Error: Version is invalid in package.json`, 'error', quiet);
+                callback(1);
+                return 1;
+            }
+            if (validReleases.includes(formatBump)) {
+                nextVersion = semver.inc(packageVersion, formatBump);
+            } else if (validPreReleases.includes(formatBump)) {
+                nextVersion = semver.inc(packageVersion, 'prerelease', formatBump);
+            } else {
+                log(`\n${cliName} Error: Bump type is invalid. please make sure it is one of the following: ${validReleases.join(', ')}, ${validPreReleases.join(', ')}`, 'error', quiet);
+                callback(1);
+                return 1;
+            }
+        } else {
+            log(`\n${cliName} Error: Bump type is missing.`, 'error', quiet);
+            callback(1);
+            return 1;
+        }
+    }
+    if (nextVersion && packageManager === 'yarn') {
+        publishOptions.push('--new-version', nextVersion);
+    } else if (nextVersion && packageJson) {
+        try {
+            // Save updated version
+            setPackageJson({
+                ...packageJson,
+                version: nextVersion
+            }, packagePath);
+        } catch (error) {
+            log(`\n${cliName} Error: The file, ${packagePath}, was not found or is malformed. ${error.message}`, 'error', quiet);
+            callback(1);
+            return 1;
+        }
     } else {
-      log(`
-${cliName} Error: Bump type is missing.`, "error", quiet);
-      callback(1);
-      return 1;
+        nextVersion = prevVersion;
     }
-  }
-  if (nextVersion && packageManager === "yarn") {
-    publishOptions.push("--new-version", nextVersion);
-  } else if (nextVersion && packageJson) {
     try {
-      setPackageJson({ ...packageJson, version: nextVersion }, packagePath);
+        await execa(packageManager, publishOptions, {
+            encoding: 'utf8',
+            stdio: 'inherit'
+        });
+        spinner.succeed(`Successfully published npm package: ${packageName}!`);
+        // Kill process
+        callback(0);
+        return 0;
     } catch (error) {
-      log(`
-${cliName} Error: The file, ${packagePath}, was not found or is malformed. ${error.message}`, "error", quiet);
-      callback(1);
-      return 1;
+        // Display error message
+        log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+        // Stop spinner
+        spinner.fail('Publishing to npm has failed.');
+        // Kill process
+        callback(1);
+        return 1;
     }
-  } else {
-    nextVersion = prevVersion;
-  }
-  try {
-    await execa(packageManager, publishOptions, {
-      encoding: "utf8",
-      stdio: "inherit"
-    });
-    spinner.succeed(`Successfully published npm package: ${packageName}!`);
-    callback(0);
-    return 0;
-  } catch (error) {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    spinner.fail("Publishing to npm has failed.");
-    callback(1);
-    return 1;
-  }
-};
-export {
-  publish
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/publish/publish.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {execa} from 'execa';\nimport semver, {ReleaseType} from 'semver';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner, getPackageJson, setPackageJson} from '../../utils/app.js';\nimport {log} from '../../utils/log.js';\n\nexport interface PublishOptions {\n  readonly bump?: string;\n  readonly cliName?: string;\n  readonly newVersion?: string;\n  readonly otp?: string;\n  readonly packageManager?: string;\n  readonly private?: boolean;\n  readonly quiet?: boolean;\n  readonly tag?: string;\n}\n\nexport type PublishCallback = typeof process.exit;\n\nexport const publish = async (cmd: PublishOptions, callback: PublishCallback = process.exit): Promise<number> => {\n  const {bump, cliName = 'Lex', newVersion, otp, packageManager: cmdPackageManager, private: accessPrivate, tag, quiet} = cmd;\n  log(`${cliName} publishing npm module...`, 'info', quiet);\n\n  // Spinner\n  const spinner = createSpinner(quiet);\n\n  // Get custom configuration\n  await LexConfig.parseConfig(cmd);\n\n  const {packageManager: configPackageManager} = LexConfig.config;\n  const packageManager: string = cmdPackageManager || configPackageManager;\n  const publishOptions: string[] = ['publish'];\n\n  if(accessPrivate) {\n    publishOptions.push('--access', 'restricted');\n  }\n\n  if(otp) {\n    publishOptions.push('--otp', otp);\n  }\n\n  if(tag) {\n    publishOptions.push('--tag', tag);\n  }\n\n  // Get next version number\n  let nextVersion: string;\n  const packagePath: string = `${process.cwd()}/package.json`;\n  let packageJson;\n  let packageName: string;\n  let prevVersion: string;\n\n  // If not using yarn, we'll use npm and manually update the version number\n  try {\n    packageJson = getPackageJson(packagePath);\n    packageName = packageJson.name;\n    prevVersion = packageJson.version;\n  } catch (error) {\n    log(`\\n${cliName} Error: The file, ${packagePath}, was not found or is malformed.\\n`, 'error', quiet);\n    log(error.message, 'error');\n    callback(1);\n    return 1;\n  }\n\n  // Update package.json with the latest version\n  if(newVersion) {\n    // If using a specific version, we don't need to determine the next bump\n    nextVersion = newVersion;\n  } else if(bump) {\n    // Determine next version\n    const formatBump = bump.toString()\n      .trim()\n      .toLowerCase();\n\n    if(formatBump) {\n      const validReleases: string[] = ['major', 'minor', 'patch'];\n      const validPreReleases: string[] = ['alpha', 'beta', 'rc'];\n\n      // Make sure the version in package.json is valid\n      const packageVersion = semver.coerce(prevVersion);\n\n      if(!semver.valid(packageVersion)) {\n        log(`\\n${cliName} Error: Version is invalid in package.json`, 'error', quiet);\n        callback(1);\n        return 1;\n      }\n\n      if(validReleases.includes(formatBump)) {\n        nextVersion = semver.inc(packageVersion, formatBump as ReleaseType);\n      } else if(validPreReleases.includes(formatBump)) {\n        nextVersion = semver.inc(packageVersion, 'prerelease', formatBump);\n      } else {\n        log(`\\n${cliName} Error: Bump type is invalid. please make sure it is one of the following: ${validReleases.join(', ')}, ${validPreReleases.join(', ')}`, 'error', quiet);\n        callback(1);\n        return 1;\n      }\n    } else {\n      log(`\\n${cliName} Error: Bump type is missing.`, 'error', quiet);\n      callback(1);\n      return 1;\n    }\n  }\n\n  if(nextVersion && packageManager === 'yarn') {\n    publishOptions.push('--new-version', nextVersion);\n  } else if(nextVersion && packageJson) {\n    try {\n      // Save updated version\n      setPackageJson({...packageJson, version: nextVersion}, packagePath);\n    } catch (error) {\n      log(`\\n${cliName} Error: The file, ${packagePath}, was not found or is malformed. ${error.message}`, 'error', quiet);\n      callback(1);\n      return 1;\n    }\n  } else {\n    nextVersion = prevVersion;\n  }\n\n  try {\n    await execa(packageManager, publishOptions, {\n      encoding: 'utf8',\n      stdio: 'inherit'\n    });\n\n    spinner.succeed(`Successfully published npm package: ${packageName}!`);\n\n    // Kill 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('Publishing to npm has failed.');\n\n    // Kill process\n    callback(1);\n    return 1;\n  }\n};"],
  "mappings": "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",
  "names": []
}

+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/publish/publish.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {execa} from 'execa';\nimport semver, {ReleaseType} from 'semver';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner, getPackageJson, setPackageJson} from '../../utils/app.js';\nimport {log} from '../../utils/log.js';\n\nexport interface PublishOptions {\n  readonly bump?: string;\n  readonly cliName?: string;\n  readonly newVersion?: string;\n  readonly otp?: string;\n  readonly packageManager?: string;\n  readonly private?: boolean;\n  readonly quiet?: boolean;\n  readonly tag?: string;\n}\n\nexport type PublishCallback = typeof process.exit;\n\nexport const publish = async (cmd: PublishOptions, callback: PublishCallback = process.exit): Promise<number> => {\n  const {bump, cliName = 'Lex', newVersion, otp, packageManager: cmdPackageManager, private: accessPrivate, tag, quiet} = cmd;\n  log(`${cliName} publishing npm module...`, 'info', quiet);\n\n  // Spinner\n  const spinner = createSpinner(quiet);\n\n  // Get custom configuration\n  await LexConfig.parseConfig(cmd);\n\n  const {packageManager: configPackageManager} = LexConfig.config;\n  const packageManager: string = cmdPackageManager || configPackageManager;\n  const publishOptions: string[] = ['publish'];\n\n  if(accessPrivate) {\n    publishOptions.push('--access', 'restricted');\n  }\n\n  if(otp) {\n    publishOptions.push('--otp', otp);\n  }\n\n  if(tag) {\n    publishOptions.push('--tag', tag);\n  }\n\n  // Get next version number\n  let nextVersion: string;\n  const packagePath: string = `${process.cwd()}/package.json`;\n  let packageJson;\n  let packageName: string;\n  let prevVersion: string;\n\n  // If not using yarn, we'll use npm and manually update the version number\n  try {\n    packageJson = getPackageJson(packagePath);\n    packageName = packageJson.name;\n    prevVersion = packageJson.version;\n  } catch(error) {\n    log(`\\n${cliName} Error: The file, ${packagePath}, was not found or is malformed.\\n`, 'error', quiet);\n    log(error.message, 'error');\n    callback(1);\n    return 1;\n  }\n\n  // Update package.json with the latest version\n  if(newVersion) {\n    // If using a specific version, we don't need to determine the next bump\n    nextVersion = newVersion;\n  } else if(bump) {\n    // Determine next version\n    const formatBump = bump.toString()\n      .trim()\n      .toLowerCase();\n\n    if(formatBump) {\n      const validReleases: string[] = ['major', 'minor', 'patch'];\n      const validPreReleases: string[] = ['alpha', 'beta', 'rc'];\n\n      // Make sure the version in package.json is valid\n      const packageVersion = semver.coerce(prevVersion);\n\n      if(!semver.valid(packageVersion)) {\n        log(`\\n${cliName} Error: Version is invalid in package.json`, 'error', quiet);\n        callback(1);\n        return 1;\n      }\n\n      if(validReleases.includes(formatBump)) {\n        nextVersion = semver.inc(packageVersion, formatBump as ReleaseType);\n      } else if(validPreReleases.includes(formatBump)) {\n        nextVersion = semver.inc(packageVersion, 'prerelease', formatBump);\n      } else {\n        log(`\\n${cliName} Error: Bump type is invalid. please make sure it is one of the following: ${validReleases.join(', ')}, ${validPreReleases.join(', ')}`, 'error', quiet);\n        callback(1);\n        return 1;\n      }\n    } else {\n      log(`\\n${cliName} Error: Bump type is missing.`, 'error', quiet);\n      callback(1);\n      return 1;\n    }\n  }\n\n  if(nextVersion && packageManager === 'yarn') {\n    publishOptions.push('--new-version', nextVersion);\n  } else if(nextVersion && packageJson) {\n    try {\n      // Save updated version\n      setPackageJson({...packageJson, version: nextVersion}, packagePath);\n    } catch(error) {\n      log(`\\n${cliName} Error: The file, ${packagePath}, was not found or is malformed. ${error.message}`, 'error', quiet);\n      callback(1);\n      return 1;\n    }\n  } else {\n    nextVersion = prevVersion;\n  }\n\n  try {\n    await execa(packageManager, publishOptions, {\n      encoding: 'utf8',\n      stdio: 'inherit'\n    });\n\n    spinner.succeed(`Successfully published npm package: ${packageName}!`);\n\n    // Kill 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('Publishing to npm has failed.');\n\n    // Kill process\n    callback(1);\n    return 1;\n  }\n};"],"names":["execa","semver","LexConfig","createSpinner","getPackageJson","setPackageJson","log","publish","cmd","callback","process","exit","bump","cliName","newVersion","otp","packageManager","cmdPackageManager","private","accessPrivate","tag","quiet","spinner","parseConfig","configPackageManager","config","publishOptions","push","nextVersion","packagePath","cwd","packageJson","packageName","prevVersion","name","version","error","message","formatBump","toString","trim","toLowerCase","validReleases","validPreReleases","packageVersion","coerce","valid","includes","inc","join","encoding","stdio","succeed","fail"],"mappings":"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"}