@jsdevtools/npm-publish 1.4.3 → 2.1.0

package/src/npm/call-npm-cli.ts

@@ -0,0 +1,140 @@
+import childProcess from "node:child_process";
+import os from "node:os";
+
+import * as errors from "../errors.js";
+import type { Logger } from "../options.js";
+import type { NpmCliEnvironment } from "./use-npm-environment.js";
+
+export interface NpmCliOptions {
+  environment: NpmCliEnvironment;
+  logger?: Logger | undefined;
+}
+
+export interface NpmCallResult<CommandT extends Command> {
+  successData: SuccessData<CommandT> | undefined;
+  errorCode: string | undefined;
+  error: Error | undefined;
+}
+
+type SuccessData<T extends Command> = T extends typeof VIEW
+  ? NpmViewData
+  : T extends typeof PUBLISH
+  ? NpmPublishData
+  : unknown;
+
+export interface NpmViewData {
+  "dist-tags": Record<string, string>;
+  versions: string[];
+}
+export interface NpmPublishData {
+  id: string;
+  files: { path: string; size: number }[];
+}
+
+export type Command = typeof VIEW | typeof PUBLISH | string;
+export const VIEW = "view";
+export const PUBLISH = "publish";
+
+export const E404 = "E404";
+export const EPUBLISHCONFLICT = "EPUBLISHCONFLICT";
+
+const NPM = os.platform() === "win32" ? "npm.cmd" : "npm";
+const JSON_MATCH_RE = /(\{[\s\S]*\})/mu;
+
+/**
+ * Call the NPM CLI in JSON mode.
+ *
+ * @param command The command of the NPM CLI to call
+ * @param cliArguments Any arguments to send to the command
+ * @param options Customize environment variables or add an error handler.
+ * @returns The parsed JSON, or stdout if unparsable.
+ */
+export async function callNpmCli<CommandT extends Command>(
+  command: CommandT,
+  cliArguments: string[],
+  options: NpmCliOptions
+): Promise<NpmCallResult<CommandT>> {
+  const { stdout, stderr, exitCode } = await execNpm(
+    [command, "--ignore-scripts", "--json", ...cliArguments],
+    options.environment,
+    options.logger
+  );
+
+  let successData;
+  let errorCode;
+  let error;
+
+  if (exitCode === 0) {
+    successData = parseJson<SuccessData<CommandT>>(stdout);
+  } else {
+    const errorPayload = parseJson<{ error?: { code?: string | null } }>(
+      stdout,
+      stderr
+    );
+
+    errorCode = errorPayload?.error?.code?.toUpperCase();
+    error = new errors.NpmCallError(command, exitCode, stderr);
+  }
+
+  return { successData, errorCode, error };
+}
+
+/**
+ * Execute the npm CLI.
+ *
+ * @param commandArguments Npm subcommand and arguments.
+ * @param environment Environment variables.
+ * @param logger Optional logger.
+ * @returns Stdout, stderr, and the exit code.
+ */
+async function execNpm(
+  commandArguments: string[],
+  environment: Record<string, string>,
+  logger?: Logger
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  logger?.debug?.(`Running command: ${NPM} ${commandArguments.join(" ")}`);
+
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+
+    const npm = childProcess.spawn(NPM, commandArguments, {
+      env: { ...process.env, ...environment },
+    });
+
+    npm.stdout.on("data", (data) => (stdout += data));
+    npm.stderr.on("data", (data) => (stderr += data));
+    npm.on("close", (code) => {
+      resolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code ?? 0,
+      });
+    });
+  });
+}
+
+/**
+ * Parse CLI outputs for JSON data.
+ *
+ * Certain versions of the npm CLI may intersperse JSON with human-readable
+ * output, which this function accounts for.
+ *
+ * @param values CLI outputs to check
+ * @returns Parsed JSON, if able to parse.
+ */
+function parseJson<TParsed>(...values: string[]): TParsed | undefined {
+  for (const value of values) {
+    const jsonValue = JSON_MATCH_RE.exec(value)?.[1];
+
+    if (jsonValue) {
+      try {
+        return JSON.parse(jsonValue) as TParsed;
+      } catch {
+        return undefined;
+      }
+    }
+  }
+
+  return undefined;
+}

package/src/npm/index.ts

@@ -0,0 +1,2 @@
+export * from "./call-npm-cli.js";
+export * from "./use-npm-environment.js";

package/src/npm/use-npm-environment.ts

@@ -0,0 +1,57 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import type { PackageManifest } from "../read-manifest.js";
+import type { NormalizedOptions } from "../normalize-options.js";
+
+export type NpmCliEnvironment = Record<string, string>;
+
+export type NpmCliTask<TReturn> = (
+  manifest: PackageManifest,
+  options: NormalizedOptions,
+  environment: NpmCliEnvironment
+) => Promise<TReturn>;
+
+/**
+ * Create a temporary .npmrc file with the given auth token, and call a task
+ * with env vars set to use that .npmrc.
+ *
+ * @param manifest Pacakge metadata.
+ * @param options Configuration options.
+ * @param task A function called with the configured environment. After the
+ *   function resolves, the temporary .npmrc file will be removed.
+ * @returns The resolved value of `task`
+ */
+export async function useNpmEnvironment<TReturn>(
+  manifest: PackageManifest,
+  options: NormalizedOptions,
+  task: NpmCliTask<TReturn>
+): Promise<TReturn> {
+  const { registry, token, logger, temporaryDirectory } = options;
+  const npmrcDirectory = await fs.mkdtemp(
+    path.join(temporaryDirectory, "npm-publish-")
+  );
+  const npmrc = path.join(npmrcDirectory, ".npmrc");
+  const environment = {
+    NODE_AUTH_TOKEN: token,
+    npm_config_userconfig: npmrc,
+  };
+
+  const config = [
+    "; created by jsdevtools/npm-publish",
+    `//${registry.host}/:_authToken=\${NODE_AUTH_TOKEN}`,
+    `registry=${registry.href}`,
+    "",
+  ].join(os.EOL);
+
+  await fs.writeFile(npmrc, config, "utf8");
+
+  logger?.debug?.(`Temporary .npmrc created at ${npmrc}\n${config}`);
+
+  try {
+    return await task(manifest, options, environment);
+  } finally {
+    await fs.rm(npmrcDirectory, { force: true, recursive: true });
+  }
+}

package/src/npm-publish.ts

@@ -0,0 +1,40 @@
+import { readManifest } from "./read-manifest.js";
+import { normalizeOptions } from "./normalize-options.js";
+import { useNpmEnvironment } from "./npm/index.js";
+import { compareAndPublish } from "./compare-and-publish/index.js";
+import { formatPublishResult } from "./format-publish-result.js";
+import type { Options } from "./options.js";
+import type { Results } from "./results.js";
+
+/**
+ * Publishes a package to NPM, if its version has changed.
+ *
+ * @param options Publish options.
+ * @returns Release metadata.
+ */
+export async function npmPublish(options: Options): Promise<Results> {
+  const manifest = await readManifest(options.package);
+  const normalizedOptions = normalizeOptions(manifest, options);
+  const publishResult = await useNpmEnvironment(
+    manifest,
+    normalizedOptions,
+    compareAndPublish
+  );
+
+  normalizedOptions.logger?.info?.(
+    formatPublishResult(manifest, normalizedOptions, publishResult)
+  );
+
+  return {
+    id: publishResult.id,
+    type: publishResult.type,
+    oldVersion: publishResult.oldVersion,
+    name: manifest.name,
+    version: manifest.version,
+    registry: normalizedOptions.registry,
+    tag: normalizedOptions.tag.value,
+    access: normalizedOptions.access.value,
+    strategy: normalizedOptions.strategy.value,
+    dryRun: normalizedOptions.dryRun.value,
+  };
+}

package/src/options.ts

@@ -0,0 +1,108 @@
+/** The possible access levels for an NPM package */
+export type Access = typeof ACCESS_PUBLIC | typeof ACCESS_RESTRICTED;
+export const ACCESS_PUBLIC = "public";
+export const ACCESS_RESTRICTED = "restricted";
+
+/**
+ * Version check strategy.
+ *
+ * - `upgrade`: the package will only be published if its version is higher than
+ *   the existing version on the configured tag.
+ * - `all`: the package will be published if its version is not yet published,
+ *   even if its lower that the existing tag.
+ */
+export type Strategy = typeof STRATEGY_UPGRADE | typeof STRATEGY_ALL;
+export const STRATEGY_UPGRADE = "upgrade";
+export const STRATEGY_ALL = "all";
+
+/** An interface that can be used to log messages. */
+export interface Logger {
+  error: (message: string | Error) => void;
+  info?: undefined | ((message: string) => void);
+  debug?: undefined | ((message: string) => void);
+}
+
+/** Options that determine how/whether the package is published. */
+export interface Options {
+  /** The NPM access token to use when publishing. */
+  token: string;
+
+  /**
+   * The absolute or relative path of your package.
+   *
+   * Defaults to the package in the current working directory.
+   */
+  package?: string | undefined;
+
+  /**
+   * The NPM registry URL to use.
+   *
+   * Defaults to "https://registry.npmjs.org/".
+   *
+   * Can be set by the package.json's `publishConfig` field.
+   */
+  registry?: string | URL | undefined;
+
+  /**
+   * The tag to publish to.
+   *
+   * Defaults to "latest".
+   *
+   * Can be set by the package.json's `publishConfig` field.
+   */
+  tag?: string | undefined;
+
+  /**
+   * Package access.
+   *
+   * Determines whether the published package should be publicly visible, or
+   * restricted to members of your NPM organization. This only applies to scoped
+   * packages.
+   *
+   * Defaults to "restricted" for scoped packages, unless that package has been
+   * previously published as `public`
+   *
+   * Can be set by the package.json's `publishConfig` field.
+   */
+  access?: Access | undefined;
+
+  /**
+   * Generate provenance statements.
+   *
+   * Publish must be run from a supported CI provider to succeed. When run from
+   * GitHub Actions, requires `id-token: write` permission.
+   *
+   * Defaults to `false`.
+   *
+   * Can be set by the package.json's `publishConfig` field.
+   */
+  provenance?: boolean | undefined;
+
+  /**
+   * Version check strategy.
+   *
+   * If "upgrade" (default), the package will only be published if its version
+   * is higher than the existing version on the configured tag. If "always", the
+   * package will be published if its version is simply not yet published.
+   *
+   * Defaults to `upgrade`.
+   */
+  strategy?: Strategy | undefined;
+
+  /**
+   * Pretend to publish, but don't actually upload to the registry.
+   *
+   * Defaults to `false`.
+   */
+  dryRun?: boolean | undefined;
+
+  /** Optional logger. */
+  logger?: Logger | undefined;
+
+  /**
+   * Temporary directory.
+   *
+   * Defaults to os.tmpdir()
+   */
+  temporaryDirectory?: string | undefined;
+}

package/src/read-manifest.ts

@@ -0,0 +1,142 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { valid as semverValid } from "semver";
+import { list as tarList, type ReadEntry } from "tar";
+
+import * as errors from "./errors.js";
+
+/** A package manifest (package.json) and associated details. */
+export interface PackageManifest {
+  packageSpec: string;
+  name: string;
+  version: string;
+  scope: string | undefined;
+  publishConfig: PackagePublishConfig | undefined;
+}
+
+/** Any publish configuration defined in package.json. */
+export interface PackagePublishConfig {
+  tag?: string;
+  access?: string;
+  registry?: string;
+  provenance?: boolean;
+}
+
+const SCOPE_RE = /^(@.+)\/.+$/u;
+
+const MANIFEST_BASENAME = "package.json";
+const TARBALL_EXTNAME = ".tgz";
+
+const isManifest = (file: unknown): file is string => {
+  return typeof file === "string" && path.basename(file) === MANIFEST_BASENAME;
+};
+
+const isDirectory = (file: unknown): file is string => {
+  return typeof file === "string" && path.extname(file) === "";
+};
+
+const isTarball = (file: unknown): file is string => {
+  return typeof file === "string" && path.extname(file) === TARBALL_EXTNAME;
+};
+
+const isVersion = (version: unknown): version is string => {
+  return semverValid(version as string) !== null;
+};
+
+const readPackageJson = async (...pathSegments: string[]): Promise<string> => {
+  const file = path.resolve(...pathSegments);
+
+  try {
+    return await fs.readFile(file, "utf8");
+  } catch (error) {
+    throw new errors.PackageJsonReadError(file, error);
+  }
+};
+
+const readTarballPackageJson = async (file: string): Promise<string> => {
+  const data: Buffer[] = [];
+  const onentry = (entry: ReadEntry) => {
+    if (entry.path === "package/package.json") {
+      entry.on("data", (chunk) => data.push(chunk));
+    }
+  };
+
+  try {
+    await tarList({ file, onentry });
+
+    if (data.length === 0) {
+      throw new Error("package.json not found inside archive");
+    }
+  } catch (error) {
+    throw new errors.PackageTarballReadError(file, error);
+  }
+
+  return Buffer.concat(data).toString();
+};
+
+/**
+ * Reads the package manifest (package.json) and returns its parsed contents.
+ *
+ * @param packagePath The path to the package being published.
+ * @returns The parsed package metadata.
+ */
+export async function readManifest(
+  packagePath: unknown
+): Promise<PackageManifest> {
+  let packageSpec: string | undefined;
+  let manifestContents: string;
+
+  if (!packagePath) {
+    packageSpec = "";
+    manifestContents = await readPackageJson(MANIFEST_BASENAME);
+  } else if (isManifest(packagePath)) {
+    packageSpec = path.resolve(path.dirname(packagePath));
+    manifestContents = await readPackageJson(packagePath);
+  } else if (isDirectory(packagePath)) {
+    packageSpec = path.resolve(packagePath);
+    manifestContents = await readPackageJson(packagePath, MANIFEST_BASENAME);
+  } else if (isTarball(packagePath)) {
+    packageSpec = path.resolve(packagePath);
+    manifestContents = await readTarballPackageJson(packageSpec);
+  } else {
+    throw new errors.InvalidPackageError(packagePath);
+  }
+
+  let manifestJson: Record<string, unknown>;
+  let name: unknown;
+  let version: unknown;
+  let publishConfig: unknown;
+
+  try {
+    manifestJson = JSON.parse(manifestContents) as Record<string, unknown>;
+    name = manifestJson["name"];
+    version = manifestJson["version"];
+    publishConfig = manifestJson["publishConfig"] ?? {};
+  } catch (error) {
+    throw new errors.PackageJsonParseError(packageSpec, error);
+  }
+
+  if (typeof name !== "string" || name.length === 0) {
+    throw new errors.InvalidPackageNameError(name);
+  }
+
+  if (!isVersion(version)) {
+    throw new errors.InvalidPackageVersionError(version);
+  }
+
+  if (
+    typeof publishConfig !== "object" ||
+    Array.isArray(publishConfig) ||
+    !publishConfig
+  ) {
+    throw new errors.InvalidPackagePublishConfigError(publishConfig);
+  }
+
+  return {
+    packageSpec,
+    name,
+    version,
+    publishConfig,
+    scope: SCOPE_RE.exec(name)?.[1],
+  };
+}

package/src/results.ts

@@ -0,0 +1,50 @@
+import type { Access, Strategy } from "./options.js";
+import type { ReleaseType as SemverReleaseType } from "semver";
+
+/** Release type */
+export type ReleaseType = SemverReleaseType | typeof INITIAL | typeof DIFFERENT;
+export const INITIAL = "initial";
+export const DIFFERENT = "different";
+
+/** Results of the publish */
+export interface Results {
+  /**
+   * The identifier of the published package, if published. Format is
+   * `${packageName}@${version}`
+   */
+  id: string | undefined;
+
+  /** The name of the NPM package that was published */
+  name: string;
+
+  /** The version that was published */
+  version: string;
+
+  /** The type of version change that occurred, if any. */
+  type: ReleaseType | undefined;
+
+  /** The version number that was previously published to NPM, if any. */
+  oldVersion: string | undefined;
+
+  /** The registry where the package was published */
+  registry: URL;
+
+  /** The tag that the package was published to. */
+  tag: string;
+
+  /**
+   * Indicates whether the published package is publicly visible or restricted
+   * to members of your NPM organization.
+   *
+   * If package is scoped, undefined means npm's scoped package defaults. If a
+   * scoped package has previously been published as public, the default is
+   * public. Otherwise, it is restricted.
+   */
+  access: Access | undefined;
+
+  /** Version check strategy used. */
+  strategy: Strategy;
+
+  /** Whether this was a dry run (not published to NPM) */
+  dryRun: boolean;
+}

package/CHANGELOG.md

@@ -1,49 +0,0 @@
-Change Log
-====================================================================================================
-All notable changes will be documented in this file.
-NPM Publish adheres to [Semantic Versioning](http://semver.org/).
-
-
-
-[v1.4.0](https://github.com/JS-DevTools/npm-publish/tree/v1.4.0) (2020-10-02)
-----------------------------------------------------------------------------------------------------
-
-- Added support NPM's `--tag` argument, which allows packages to be published to a named tag that can then be installed using `npm install <package-name>@<tag>`
-
-- Added support for NPM's `--access` argument, which controls whether scoped packages are publicly accessible, or restricted to members of your NPM organization
-
-[Full Changelog](https://github.com/JS-DevTools/npm-publish/compare/v1.3.0...v1.4.0)
-
-
-
-[v1.3.0](https://github.com/JS-DevTools/npm-publish/tree/v1.3.0) (2020-10-01)
-----------------------------------------------------------------------------------------------------
-
-- NPM-Publish can now successfully publish a brand-new package to NPM. Previously it failed because it couldn't determine the previous package version. ([PR #12](https://github.com/JS-DevTools/npm-publish/pull/12) from [@ZitRos](https://github.com/ZitRos))
-
-[Full Changelog](https://github.com/JS-DevTools/npm-publish/compare/v1.2.0...v1.3.0)
-
-
-
-[v1.2.0](https://github.com/JS-DevTools/npm-publish/tree/v1.2.0) (2020-07-23)
-----------------------------------------------------------------------------------------------------
-
-- Added support for running NPM in "dry run" mode, which doesn't actually publish, but reports details of what _would_ have been published.
-
-[Full Changelog](https://github.com/JS-DevTools/npm-publish/compare/v1.1.2...v1.2.0)
-
-
-
-[v1.1.0](https://github.com/JS-DevTools/npm-publish/tree/v1.1.0) (2020-03-29)
-----------------------------------------------------------------------------------------------------
-
-- FIX: The configured NPM registry and token are now used _all_ NPM commands, not just for publishing. This ensures that npm-publish works with private packages and custom registries
-
-[Full Changelog](https://github.com/JS-DevTools/npm-publish/compare/v1.0.13...v1.1.0)
-
-
-
-[v1.0.0](https://github.com/JS-DevTools/npm-publish/tree/v1.0.0) (2020-01-21)
-----------------------------------------------------------------------------------------------------
-
-Initial release 🎉

package/lib/action/index.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@actions/core");
-const npm_publish_1 = require("../npm-publish");
-/**
- * The main entry point of the GitHub Action
- * @internal
- */
-async function main() {
-    try {
-        // Setup global error handlers
-        process.on("uncaughtException", errorHandler);
-        process.on("unhandledRejection", errorHandler);
-        // Get the GitHub Actions input options
-        const options = {
-            token: core_1.getInput("token", { required: true }),
-            registry: core_1.getInput("registry", { required: true }),
-            package: core_1.getInput("package", { required: true }),
-            checkVersion: core_1.getInput("check-version", { required: true }).toLowerCase() === "true",
-            tag: core_1.getInput("tag"),
-            access: core_1.getInput("access"),
-            dryRun: core_1.getInput("dry-run").toLowerCase() === "true",
-            debug: debugHandler,
-        };
-        // Publish to NPM
-        let results = await npm_publish_1.npmPublish(options);
-        if (results.type === "none") {
-            console.log(`\n📦 ${results.package} v${results.version} is already published to NPM`);
-        }
-        else if (results.dryRun) {
-            console.log(`\n📦 ${results.package} v${results.version} was NOT actually published to NPM (dry run)`);
-        }
-        else {
-            console.log(`\n📦 Successfully published ${results.package} v${results.version} to NPM`);
-        }
-        // Set the GitHub Actions output variables
-        core_1.setOutput("type", results.type);
-        core_1.setOutput("version", results.version);
-        core_1.setOutput("old-version", results.oldVersion);
-        core_1.setOutput("tag", results.tag);
-        core_1.setOutput("access", results.access);
-        core_1.setOutput("dry-run", results.dryRun);
-    }
-    catch (error) {
-        errorHandler(error);
-    }
-}
-/**
- * Prints errors to the GitHub Actions console
- */
-function errorHandler(error) {
-    let message = error.stack || error.message || String(error);
-    core_1.setFailed(message);
-    process.exit();
-}
-/**
- * Prints debug logs to the GitHub Actions console
- */
-function debugHandler(message, data) {
-    if (data) {
-        message += "\n" + JSON.stringify(data, undefined, 2);
-    }
-    core_1.debug(message);
-}
-// eslint-disable-next-line @typescript-eslint/no-floating-promises
-main();
-//# sourceMappingURL=index.js.map

package/lib/action/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/action/index.ts"],"names":[],"mappings":";;AAAA,wCAAsE;AACtE,gDAA4C;AAG5C;;;GAGG;AACH,KAAK,UAAU,IAAI;IACjB,IAAI;QACF,8BAA8B;QAC9B,OAAO,CAAC,EAAE,CAAC,mBAAmB,EAAE,YAAY,CAAC,CAAC;QAC9C,OAAO,CAAC,EAAE,CAAC,oBAAoB,EAAE,YAAY,CAAC,CAAC;QAE/C,uCAAuC;QACvC,MAAM,OAAO,GAAY;YACvB,KAAK,EAAE,eAAQ,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;YAC5C,QAAQ,EAAE,eAAQ,CAAC,UAAU,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;YAClD,OAAO,EAAE,eAAQ,CAAC,SAAS,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;YAChD,YAAY,EAAE,eAAQ,CAAC,eAAe,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,KAAK,MAAM;YACpF,GAAG,EAAE,eAAQ,CAAC,KAAK,CAAC;YACpB,MAAM,EAAE,eAAQ,CAAC,QAAQ,CAAW;YACpC,MAAM,EAAE,eAAQ,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,KAAK,MAAM;YACpD,KAAK,EAAE,YAAY;SACpB,CAAC;QAEF,iBAAiB;QACjB,IAAI,OAAO,GAAG,MAAM,wBAAU,CAAC,OAAO,CAAC,CAAC;QAExC,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE;YAC3B,OAAO,CAAC,GAAG,CAAC,QAAQ,OAAO,CAAC,OAAO,KAAK,OAAO,CAAC,OAAO,8BAA8B,CAAC,CAAC;SACxF;aACI,IAAI,OAAO,CAAC,MAAM,EAAE;YACvB,OAAO,CAAC,GAAG,CAAC,QAAQ,OAAO,CAAC,OAAO,KAAK,OAAO,CAAC,OAAO,8CAA8C,CAAC,CAAC;SACxG;aACI;YACH,OAAO,CAAC,GAAG,CAAC,+BAA+B,OAAO,CAAC,OAAO,KAAK,OAAO,CAAC,OAAO,SAAS,CAAC,CAAC;SAC1F;QAED,0CAA0C;QAC1C,gBAAS,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QAChC,gBAAS,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QACtC,gBAAS,CAAC,aAAa,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;QAC7C,gBAAS,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;QAC9B,gBAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QACpC,gBAAS,CAAC,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;KACtC;IACD,OAAO,KAAK,EAAE;QACZ,YAAY,CAAC,KAAc,CAAC,CAAC;KAC9B;AACH,CAAC;AAED;;GAEG;AACH,SAAS,YAAY,CAAC,KAAY;IAChC,IAAI,OAAO,GAAG,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;IAC5D,gBAAS,CAAC,OAAO,CAAC,CAAC;IACnB,OAAO,CAAC,IAAI,EAAE,CAAC;AACjB,CAAC;AAED;;GAEG;AACH,SAAS,YAAY,CAAC,OAAe,EAAE,IAAa;IAClD,IAAI,IAAI,EAAE;QACR,OAAO,IAAI,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;KACtD;IAED,YAAK,CAAC,OAAO,CAAC,CAAC;AACjB,CAAC;AAED,mEAAmE;AACnE,IAAI,EAAE,CAAC"}

package/lib/cli/exit-code.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/cli/exit-code.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExitCode = void 0;
-/**
- * CLI exit codes.
- *
- * @see https://nodejs.org/api/process.html#process_exit_codes
- * @internal
- */
-var ExitCode;
-(function (ExitCode) {
-    ExitCode[ExitCode["Success"] = 0] = "Success";
-    ExitCode[ExitCode["FatalError"] = 1] = "FatalError";
-    ExitCode[ExitCode["InvalidArgument"] = 9] = "InvalidArgument";
-})(ExitCode = exports.ExitCode || (exports.ExitCode = {}));
-//# sourceMappingURL=exit-code.js.map

package/lib/cli/exit-code.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"exit-code.js","sourceRoot":"","sources":["../../src/cli/exit-code.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACH,IAAY,QAIX;AAJD,WAAY,QAAQ;IAClB,6CAAW,CAAA;IACX,mDAAc,CAAA;IACd,6DAAmB,CAAA;AACrB,CAAC,EAJW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAInB"}