@darkobits/chex - npm Package Compare versions

Comparing version 2.0.7 to 2.0.8

dist/index.js

 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
-var chex_1 = require("./lib/chex");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(chex_1).default; } });
+const chex = require("./lib/chex.js");
+module.exports = chex;
+//# sourceMappingURL=index.js.map

dist/lib/chex.d.ts

 import { type ExecaChildProcess, type ExecaSyncReturnValue, type Options, type SyncOptions } from 'execa';
+/**
+ * Value returned by Chex.
+ */
 export interface ExecaWrapper {
+    /**
+     * Call the bound executable asynchronously.
+     */
     (command: string | ReadonlyArray<string>, options?: Options): ExecaChildProcess;
+    /**
+     * Call the bound executable synchronously.
+     */
     sync(command: string | ReadonlyArray<string>, options?: SyncOptions): ExecaSyncReturnValue;
+    /**
+     * Parsed semver version of the executable.
+     */
     version: string;
+    /**
+     * Raw version reported by the executable.
+     */
     rawVersion: string;
 }
+/**
+ * Asynchronous version of Chex.
+ */
 declare const chex: {
     (dependencyExpression: string, execaOpts?: Options): Promise<ExecaWrapper>;
+    /**
+     * Synchronous version of Chex.
+     */
     sync(dependencyExpression: string, execaOpts?: SyncOptions): ExecaWrapper;
 };
 export default chex;

dist/lib/chex.js

 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const execa_1 = __importDefault(require("execa"));
-const semver_1 = __importDefault(require("semver"));
-const get_executable_version_1 = __importDefault(require("../lib/get-executable-version"));
+const execa = require("execa");
+const semver = require("semver");
+const getExecutableVersion = require("./get-executable-version.js");
 function parseDependencyExpression(versionExpression) {
-    const [rawName, versionRange] = versionExpression.split(' ');
-    const name = rawName.toLowerCase();
-    if (versionRange) {
-        if (semver_1.default.validRange(versionRange)) {
-            return { name, versionRange };
-        }
-        throw new Error(`Invalid semver range: ${versionRange}`);
+  const [rawName, versionRange] = versionExpression.split(" ");
+  const name = rawName.toLowerCase();
+  if (versionRange) {
+    if (semver.validRange(versionRange)) {
+      return { name, versionRange };
     }
-    return { name, versionRange: '' };
+    throw new Error(`Invalid semver range: ${versionRange}`);
+  }
+  return { name, versionRange: "" };
 }
 function chexCommon(name, versionRange, version, rawVersion) {
-    if (versionRange && version === 'unknown') {
-        throw new Error(`Unable to determine version of "${name}"`);
+  if (versionRange && version === "unknown") {
+    throw new Error(`Unable to determine version of "${name}"`);
+  }
+  if (versionRange && !semver.valid(version)) {
+    throw new Error(`Version "${version}" of "${name}" is not a valid semver version.`);
+  }
+  if (versionRange && !semver.satisfies(version, versionRange)) {
+    throw new Error(`Version "${version}" of "${name}" does not satisfy criteria "${versionRange}".`);
+  }
+  const execaWrapper = (commandStringOrArgumentsArray, execaOpts) => {
+    if (typeof commandStringOrArgumentsArray === "string") {
+      return execa.command(`${name} ${commandStringOrArgumentsArray}`, execaOpts);
     }
-    if (versionRange && !semver_1.default.valid(version)) {
-        throw new Error(`Version "${version}" of "${name}" is not a valid semver version.`);
+    return execa(name, commandStringOrArgumentsArray, execaOpts);
+  };
+  execaWrapper.sync = (commandStringOrArgumentsArray, execaOpts) => {
+    if (typeof commandStringOrArgumentsArray === "string") {
+      return execa.commandSync(`${name} ${commandStringOrArgumentsArray}`, execaOpts);
     }
-    if (versionRange && !semver_1.default.satisfies(version, versionRange)) {
-        throw new Error(`Version "${version}" of "${name}" does not satisfy criteria "${versionRange}".`);
-    }
-    const execaWrapper = (commandStringOrArgumentsArray, execaOpts) => {
-        if (typeof commandStringOrArgumentsArray === 'string') {
-            return execa_1.default.command(`${name} ${commandStringOrArgumentsArray}`, execaOpts);
-        }
-        return (0, execa_1.default)(name, commandStringOrArgumentsArray, execaOpts);
-    };
-    execaWrapper.sync = (commandStringOrArgumentsArray, execaOpts) => {
-        if (typeof commandStringOrArgumentsArray === 'string') {
-            return execa_1.default.commandSync(`${name} ${commandStringOrArgumentsArray}`, execaOpts);
-        }
-        return execa_1.default.sync(name, commandStringOrArgumentsArray, execaOpts);
-    };
-    execaWrapper.version = version;
-    execaWrapper.rawVersion = rawVersion;
-    return execaWrapper;
+    return execa.sync(name, commandStringOrArgumentsArray, execaOpts);
+  };
+  execaWrapper.version = version;
+  execaWrapper.rawVersion = rawVersion;
+  return execaWrapper;
 }
 const chex = async (dependencyExpression, execaOpts) => {
-    const { name, versionRange } = parseDependencyExpression(dependencyExpression);
-    const { version, rawVersion } = await (0, get_executable_version_1.default)(name, execaOpts);
-    return chexCommon(name, versionRange, version, rawVersion);
+  const { name, versionRange } = parseDependencyExpression(dependencyExpression);
+  const { version, rawVersion } = await getExecutableVersion(name, execaOpts);
+  return chexCommon(name, versionRange, version, rawVersion);
 };
 chex.sync = (dependencyExpression, execaOpts) => {
-    const { name, versionRange } = parseDependencyExpression(dependencyExpression);
-    const { version, rawVersion } = get_executable_version_1.default.sync(name, execaOpts);
-    return chexCommon(name, versionRange, version, rawVersion);
+  const { name, versionRange } = parseDependencyExpression(dependencyExpression);
+  const { version, rawVersion } = getExecutableVersion.sync(name, execaOpts);
+  return chexCommon(name, versionRange, version, rawVersion);
 };
-exports.default = chex;
+module.exports = chex;
+//# sourceMappingURL=chex.js.map

dist/lib/get-executable-version.d.ts

 import execa, { type Options } from 'execa';
+/**
+ * Provided an executable name, uses various techniques to determine its
+ * version. If successful, resolves with the version of the executable. If the
+ * version could not be determined, resolves with the string 'unknown'. If the
+ * executable does not exist on the system, an error will be thrown.
+ */
 declare function getExecutableVersion(name: string, execaOpts?: Options): Promise<{
@@ -3,0 +9,0 @@ version: string;

dist/lib/get-executable-version.js

 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const execa_1 = __importDefault(require("execa"));
-const find_versions_1 = __importDefault(require("find-versions"));
-const semver_1 = __importDefault(require("semver"));
-const versionFlags = ['--version', '-v', 'version'];
-const unknownVersionResult = { version: 'unknown', rawVersion: 'unknown' };
+const execa = require("execa");
+const findVersions = require("find-versions");
+const semver = require("semver");
+const versionFlags = ["--version", "-v", "version"];
+const unknownVersionResult = { version: "unknown", rawVersion: "unknown" };
 function normalizeName(name) {
-    return name.toLocaleLowerCase();
+  return name.toLocaleLowerCase();
 }
 function parseVersionResult(result) {
-    for (const stream of ['stdout', 'stderr']) {
-        const rawVersion = result[stream];
-        if (!rawVersion) {
-            continue;
-        }
-        const strictVersion = (0, find_versions_1.default)(rawVersion)[0];
-        if (strictVersion) {
-            return { version: strictVersion, rawVersion };
-        }
-        const looseVersion = semver_1.default.clean((0, find_versions_1.default)(rawVersion, { loose: true })[0], { loose: true });
-        if (looseVersion) {
-            return { version: looseVersion, rawVersion };
-        }
+  for (const stream of ["stdout", "stderr"]) {
+    const rawVersion = result[stream];
+    if (!rawVersion) {
+      continue;
     }
+    const strictVersion = findVersions(rawVersion)[0];
+    if (strictVersion) {
+      return { version: strictVersion, rawVersion };
+    }
+    const looseVersion = semver.clean(findVersions(rawVersion, { loose: true })[0], { loose: true });
+    if (looseVersion) {
+      return { version: looseVersion, rawVersion };
+    }
+  }
 }
 function handleError(name, err) {
-    if (err && err.errno === 'ENOENT') {
-        throw new Error(`Executable "${name}" could not be found.`);
-    }
+  if (err && err.errno === "ENOENT") {
+    throw new Error(`Executable "${name}" could not be found.`);
+  }
 }
 async function getExecutableVersion(name, execaOpts) {
-    for (const flag of versionFlags) {
-        try {
-            const version = parseVersionResult(await (0, execa_1.default)(normalizeName(name), [flag], execaOpts));
-            if (version) {
-                return version;
-            }
-        }
-        catch (err) {
-            handleError(name, err);
-        }
+  for (const flag of versionFlags) {
+    try {
+      const version = parseVersionResult(await execa(normalizeName(name), [flag], execaOpts));
+      if (version) {
+        return version;
+      }
+    } catch (err) {
+      handleError(name, err);
     }
-    return unknownVersionResult;
+  }
+  return unknownVersionResult;
 }
 getExecutableVersion.sync = (name, execaOpts) => {
-    for (const flag of versionFlags) {
-        try {
-            const version = parseVersionResult(execa_1.default.sync(normalizeName(name), [flag], execaOpts));
-            if (version) {
-                return version;
-            }
-        }
-        catch (err) {
-            handleError(name, err);
-        }
+  for (const flag of versionFlags) {
+    try {
+      const version = parseVersionResult(execa.sync(normalizeName(name), [flag], execaOpts));
+      if (version) {
+        return version;
+      }
+    } catch (err) {
+      handleError(name, err);
     }
-    return unknownVersionResult;
+  }
+  return unknownVersionResult;
 };
-exports.default = getExecutableVersion;
+module.exports = getExecutableVersion;
+//# sourceMappingURL=get-executable-version.js.map

package.json

 {
   "name": "@darkobits/chex",
-  "version": "2.0.7",
+  "version": "2.0.8",
   "description": "Check that an executable is installed and verify its version.",
@@ -24,4 +24,4 @@ "author": "darkobits",
   "devDependencies": {
-    "@darkobits/eslint-plugin": "^0.2.10",
-    "@darkobits/ts": "^0.13.3",
+    "@darkobits/eslint-plugin": "^0.3.2",
+    "@darkobits/ts": "~0.14.0",
     "@types/semver": "^7.3.13",
@@ -28,0 +28,0 @@ "@types/uuid": "^9.0.0",

No alert changes

Improved metrics

Total package byte prevSize

15269

increased by16.52%

Number of package files

12

increased by33.33%

Lines of code

167

increased by9.87%

No dependency changes