syncpack 8.4.11 → 9.0.0

package/dist/get-context/get-package-json-files/get-patterns/props.js

@@ -0,0 +1,48 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+exports.__esModule = true;
+exports.props = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var isWalkable = function (value) {
+    return value !== null && typeof value !== 'undefined';
+};
+/**
+ * Safely read nested properties of any value.
+ * @param keys 'child.grandChild.greatGrandChild'
+ */
+function props(keys, predicate) {
+    return function getNestedProp(obj) {
+        var e_1, _a;
+        var next = obj;
+        try {
+            for (var _b = __values(keys.split('.')), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                if (isWalkable(next) && key in next) {
+                    next = next[key];
+                }
+                else {
+                    return ts_belt_1.O.None;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return ts_belt_1.O.fromPredicate(next, predicate);
+    };
+}
+exports.props = props;

package/dist/get-context/get-package-json-files/get-patterns/read-json-safe.d.ts

@@ -0,0 +1,12 @@
+import { R } from '@mobily/ts-belt';
+import type { Disk } from '../../../lib/disk';
+import { BaseError } from '../../../lib/error';
+export interface JsonFile<T> {
+    /** absolute path on disk to this file */
+    readonly filePath: string;
+    /** parsed JSON contents of the file */
+    contents: T;
+    /** raw file contents of the file */
+    readonly json: string;
+}
+export declare function readJsonSafe<T>(disk: Disk): (filePath: string) => R.Result<JsonFile<T>, BaseError>;

package/dist/get-context/get-package-json-files/get-patterns/read-json-safe.js

@@ -0,0 +1,20 @@
+"use strict";
+exports.__esModule = true;
+exports.readJsonSafe = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var error_1 = require("../../../lib/error");
+function readJsonSafe(disk) {
+    return function readJsonSafe(filePath) {
+        return (0, ts_belt_1.pipe)(readFileSafe(filePath), ts_belt_1.R.flatMap((0, ts_belt_1.flow)((parseJsonSafe), ts_belt_1.R.mapError(error_1.BaseError.map("Failed to parse JSON file at ".concat(filePath))), ts_belt_1.R.map(function (_a) {
+            var contents = _a.contents, json = _a.json;
+            return ({ contents: contents, filePath: filePath, json: json });
+        }))));
+    };
+    function readFileSafe(filePath) {
+        return (0, ts_belt_1.pipe)(ts_belt_1.R.fromExecution(function () { return disk.readFileSync(filePath); }), ts_belt_1.R.mapError(error_1.BaseError.map("Failed to read JSON file at ".concat(filePath))));
+    }
+}
+exports.readJsonSafe = readJsonSafe;
+function parseJsonSafe(json) {
+    return (0, ts_belt_1.pipe)(ts_belt_1.R.fromExecution(function () { return JSON.parse(json); }), ts_belt_1.R.mapError(error_1.BaseError.map('Failed to parse JSON')), ts_belt_1.R.map(function (contents) { return ({ contents: contents, json: json }); }));
+}

package/dist/get-context/get-package-json-files/get-patterns/read-yaml-safe.d.ts

@@ -0,0 +1,4 @@
+import { R } from '@mobily/ts-belt';
+import type { Disk } from '../../../lib/disk';
+import { BaseError } from '../../../lib/error';
+export declare function readYamlSafe<T = unknown>(disk: Disk): (filePath: string) => R.Result<T, BaseError>;

package/dist/get-context/get-package-json-files/get-patterns/read-yaml-safe.js

@@ -0,0 +1,11 @@
+"use strict";
+exports.__esModule = true;
+exports.readYamlSafe = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var error_1 = require("../../../lib/error");
+function readYamlSafe(disk) {
+    return function readYamlSafe(filePath) {
+        return (0, ts_belt_1.pipe)(ts_belt_1.R.fromExecution(function () { return disk.readYamlFileSync(filePath); }), ts_belt_1.R.mapError(error_1.BaseError.map("Failed to read YAML file at ".concat(filePath))));
+    };
+}
+exports.readYamlSafe = readYamlSafe;

package/dist/get-context/get-package-json-files/index.d.ts

@@ -0,0 +1,5 @@
+import type { Disk } from '../../lib/disk';
+import type { Syncpack } from '../../types';
+import { PackageJsonFile } from './package-json-file';
+/** Create an API for every package.json file needed. */
+export declare function getPackageJsonFiles(disk: Disk, config: Syncpack.Config.Private): PackageJsonFile[];

package/dist/get-context/get-package-json-files/index.js

@@ -0,0 +1,16 @@
+"use strict";
+exports.__esModule = true;
+exports.getPackageJsonFiles = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var _R_1 = require("../$R");
+var get_file_paths_1 = require("./get-file-paths");
+var read_json_safe_1 = require("./get-patterns/read-json-safe");
+var package_json_file_1 = require("./package-json-file");
+/** Create an API for every package.json file needed. */
+function getPackageJsonFiles(disk, config) {
+    return (0, ts_belt_1.pipe)((0, get_file_paths_1.getFilePaths)(disk, config), ts_belt_1.R.flatMap(_R_1.$R.onlyOk(resolvePackageJson(disk))), ts_belt_1.R.getWithDefault([]));
+    function resolvePackageJson(disk) {
+        return (0, ts_belt_1.flow)((0, read_json_safe_1.readJsonSafe)(disk), ts_belt_1.R.map(function (jsonFile) { return new package_json_file_1.PackageJsonFile(jsonFile, config, disk); }));
+    }
+}
+exports.getPackageJsonFiles = getPackageJsonFiles;

package/dist/get-context/get-package-json-files/package-json-file/index.d.ts

@@ -0,0 +1,51 @@
+import type { Disk } from '../../../lib/disk';
+import type { Syncpack } from '../../../types';
+import type { JsonFile } from '../get-patterns/read-json-safe';
+import { Instance } from './instance';
+export interface PackageJson {
+    bugs?: {
+        url: string;
+    } | string;
+    dependencies?: Record<string, string>;
+    description?: string;
+    devDependencies?: Record<string, string>;
+    keywords?: string[];
+    name?: string;
+    overrides?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    pnpm?: {
+        overrides?: Record<string, string>;
+    };
+    repository?: {
+        directory?: string;
+        type: string;
+        url: string;
+    } | string;
+    resolutions?: Record<string, string>;
+    scripts?: Record<string, string>;
+    version?: string;
+    workspaces?: Record<string, string[]> | string[];
+    [otherProps: string]: Record<string, string | string[] | Record<string, string | string[]>> | string | string[] | undefined;
+}
+type Entry = [string, string];
+export declare class PackageJsonFile {
+    /** parsed JSON contents of the file */
+    contents: PackageJson;
+    /** api for writing to disk */
+    readonly disk: Disk;
+    /** absolute path on disk to this file */
+    readonly filePath: string;
+    /** raw file contents of the file */
+    readonly json: string;
+    /** resolved configuration */
+    readonly config: Syncpack.Config.Private;
+    /** relative path on disk to this file */
+    readonly shortPath: string;
+    constructor(jsonFile: JsonFile<PackageJson>, config: Syncpack.Config.Private, disk: Disk);
+    hasChanged(): boolean;
+    write(): void;
+    getSource(): string;
+    getInstances(): Instance[];
+    getPathEntries(pathDef: Syncpack.PathDefinition, file: PackageJsonFile): Entry[];
+}
+export {};

package/dist/get-context/get-package-json-files/package-json-file/index.js

@@ -0,0 +1,85 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+exports.__esModule = true;
+exports.PackageJsonFile = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var path_1 = require("path");
+var constants_1 = require("../../../constants");
+var log_1 = require("../../../lib/log");
+var newlines_1 = require("../../../lib/newlines");
+var path_strategy_1 = require("../../get-config/path-strategy");
+var instance_1 = require("./instance");
+var PackageJsonFile = /** @class */ (function () {
+    function PackageJsonFile(jsonFile, config, disk) {
+        this.contents = jsonFile.contents;
+        this.disk = disk;
+        this.filePath = jsonFile.filePath;
+        this.json = jsonFile.json;
+        this.config = config;
+        this.shortPath = (0, path_1.relative)(constants_1.CWD, jsonFile.filePath);
+    }
+    PackageJsonFile.prototype.hasChanged = function () {
+        return this.json !== this.getSource();
+    };
+    PackageJsonFile.prototype.write = function () {
+        this.disk.writeFileSync(this.filePath, this.getSource());
+    };
+    PackageJsonFile.prototype.getSource = function () {
+        var contents = this.contents;
+        var indent = this.config.indent;
+        var EOL = newlines_1.newlines.detect(this.json);
+        var source = "".concat(JSON.stringify(contents, null, indent)).concat(EOL);
+        return newlines_1.newlines.fix(source, EOL);
+    };
+    PackageJsonFile.prototype.getInstances = function () {
+        var _this = this;
+        return this.config.enabledTypes
+            .flatMap(function (pathDef) {
+            return _this.getPathEntries(pathDef, _this).map(function (_a) {
+                var _b = __read(_a, 2), name = _b[0], version = _b[1];
+                return new instance_1.Instance(pathDef, name, _this, version);
+            });
+        })
+            .filter(function (instance) {
+            var pathDef = instance.pathDef, name = instance.name, version = instance.version;
+            if (name.search(new RegExp(_this.config.filter)) === -1) {
+                (0, log_1.verbose)('skip instance, name does not match filter', instance);
+                return false;
+            }
+            (0, log_1.verbose)("add ".concat(name, "@").concat(version, " to ").concat(pathDef.name, ":").concat(pathDef.strategy, " ").concat(_this.shortPath));
+            return true;
+        });
+    };
+    PackageJsonFile.prototype.getPathEntries = function (pathDef, file) {
+        var strategyName = pathDef.strategy;
+        switch (strategyName) {
+            case 'name@version':
+                return (0, ts_belt_1.pipe)(path_strategy_1.strategyByName[strategyName].read(file, pathDef), ts_belt_1.R.getWithDefault([]));
+            case 'name~version':
+                return (0, ts_belt_1.pipe)(path_strategy_1.strategyByName[strategyName].read(file, pathDef), ts_belt_1.R.getWithDefault([]));
+            case 'version':
+                return (0, ts_belt_1.pipe)(path_strategy_1.strategyByName[strategyName].read(file, pathDef), ts_belt_1.R.getWithDefault([]));
+            case 'versionsByName':
+                return (0, ts_belt_1.pipe)(path_strategy_1.strategyByName[strategyName].read(file, pathDef), ts_belt_1.R.getWithDefault([]));
+            default:
+                return (0, path_strategy_1.exhaustiveCheck)(strategyName);
+        }
+    };
+    return PackageJsonFile;
+}());
+exports.PackageJsonFile = PackageJsonFile;

package/dist/get-context/get-package-json-files/package-json-file/instance.d.ts

@@ -0,0 +1,25 @@
+import type { PackageJsonFile } from '.';
+import type { Syncpack } from '../../../types';
+import type { SemverGroup } from '../../get-groups/semver-group';
+import type { VersionGroup } from '../../get-groups/version-group';
+export declare class Instance {
+    /** the name of this dependency */
+    name: string;
+    /** The package this dependency is installed in this specific time */
+    packageJsonFile: PackageJsonFile;
+    /** where this dependency is installed */
+    pathDef: Syncpack.PathDefinition;
+    /** The .name property of the package.json file of this instance */
+    pkgName: string;
+    /** the version of this dependency */
+    version: string;
+    constructor(pathDef: Syncpack.PathDefinition, name: string, packageJsonFile: PackageJsonFile, version: string);
+    hasRange(range: Syncpack.Config.SemverRange.Value): boolean;
+    setRange(range: Syncpack.Config.SemverRange.Value): void;
+    /**
+     * In the case of banned dependencies, their version is set to `undefined`,
+     * which causes them to be removed by `JSON.stringify`.
+     */
+    setVersion(version: string | undefined): void;
+    matchesGroup(group: SemverGroup | VersionGroup): boolean;
+}

package/dist/get-context/get-package-json-files/package-json-file/instance.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.Instance = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var expect_more_1 = require("expect-more");
+var minimatch_1 = __importDefault(require("minimatch"));
+var _R_1 = require("../../$R");
+var set_semver_range_1 = require("../../../lib/set-semver-range");
+var path_strategy_1 = require("../../get-config/path-strategy");
+var Instance = /** @class */ (function () {
+    function Instance(pathDef, name, packageJsonFile, version) {
+        this.pathDef = pathDef;
+        this.name = name;
+        this.packageJsonFile = packageJsonFile;
+        this.pkgName = packageJsonFile.contents.name || 'PACKAGE_JSON_HAS_NO_NAME';
+        this.version = version;
+    }
+    Instance.prototype.hasRange = function (range) {
+        return (this.pathDef.name !== 'workspace' &&
+            this.version === (0, set_semver_range_1.setSemverRange)(range, this.version));
+    };
+    Instance.prototype.setRange = function (range) {
+        this.setVersion((0, set_semver_range_1.setSemverRange)(range, this.version));
+    };
+    /**
+     * In the case of banned dependencies, their version is set to `undefined`,
+     * which causes them to be removed by `JSON.stringify`.
+     */
+    Instance.prototype.setVersion = function (version) {
+        var strategyName = this.pathDef.strategy;
+        var entry = [this.name, version];
+        var file = this.packageJsonFile;
+        switch (strategyName) {
+            case 'name@version':
+                (0, ts_belt_1.pipe)(path_strategy_1.strategyByName[strategyName].write(file, this.pathDef, entry), _R_1.$R.tapErrVerbose);
+                break;
+            case 'name~version':
+                (0, ts_belt_1.pipe)(path_strategy_1.strategyByName[strategyName].write(file, this.pathDef, entry), _R_1.$R.tapErrVerbose);
+                break;
+            case 'version':
+                (0, ts_belt_1.pipe)(path_strategy_1.strategyByName[strategyName].write(file, this.pathDef, entry), _R_1.$R.tapErrVerbose);
+                break;
+            case 'versionsByName':
+                (0, ts_belt_1.pipe)(path_strategy_1.strategyByName[strategyName].write(file, this.pathDef, entry), _R_1.$R.tapErrVerbose);
+                break;
+            default:
+                return (0, path_strategy_1.exhaustiveCheck)(strategyName);
+        }
+    };
+    Instance.prototype.matchesGroup = function (group) {
+        var _this = this;
+        return (group.packages.some(function (pattern) { return (0, minimatch_1["default"])(_this.pkgName, pattern); }) &&
+            group.dependencies.some(function (pattern) { return (0, minimatch_1["default"])(_this.name, pattern); }) &&
+            (!(0, expect_more_1.isNonEmptyArray)(group.dependencyTypes) ||
+                group.dependencyTypes.includes(this.pathDef.name)));
+    };
+    return Instance;
+}());
+exports.Instance = Instance;

package/dist/get-context/index.d.ts

@@ -0,0 +1,21 @@
+import type { Disk } from '../lib/disk';
+import type { Syncpack } from '../types';
+import type { SemverGroup } from './get-groups/semver-group';
+import type { VersionGroup } from './get-groups/version-group';
+import type { PackageJsonFile } from './get-package-json-files/package-json-file';
+export type Context = Omit<Syncpack.Config.Private, 'semverGroups' | 'versionGroups'> & {
+    disk: Disk;
+    isInvalid: boolean;
+    packageJsonFiles: PackageJsonFile[];
+    semverGroups: SemverGroup[];
+    versionGroups: VersionGroup[];
+};
+/**
+ * Every command in syncpack should accept the return value of this function as
+ * its input.
+ *
+ * The aim here is to move all disk activity to a single place, so
+ * that the majority of syncpack and its tests don't have to deal with the file
+ * system and can focus solely on transformation logic.
+ */
+export declare function getContext(program: Partial<Syncpack.Config.Cli>, disk?: Disk): Context;

package/dist/get-context/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+exports.getContext = void 0;
+var disk_1 = require("../lib/disk");
+var get_all_instances_1 = require("./get-all-instances");
+var get_config_1 = require("./get-config");
+var get_semver_groups_1 = require("./get-groups/get-semver-groups");
+var get_version_groups_1 = require("./get-groups/get-version-groups");
+var get_package_json_files_1 = require("./get-package-json-files");
+/**
+ * Every command in syncpack should accept the return value of this function as
+ * its input.
+ *
+ * The aim here is to move all disk activity to a single place, so
+ * that the majority of syncpack and its tests don't have to deal with the file
+ * system and can focus solely on transformation logic.
+ */
+function getContext(program, disk) {
+    if (disk === void 0) { disk = disk_1.disk; }
+    var config = (0, get_config_1.getConfig)(disk, program);
+    var packageJsonFiles = (0, get_package_json_files_1.getPackageJsonFiles)(disk, config);
+    var instances = (0, get_all_instances_1.getAllInstances)(packageJsonFiles);
+    var semverGroups = (0, get_semver_groups_1.getSemverGroups)(config, instances);
+    var versionGroups = (0, get_version_groups_1.getVersionGroups)(config, instances);
+    return __assign(__assign({}, config), { disk: disk, isInvalid: false, packageJsonFiles: packageJsonFiles, semverGroups: semverGroups, versionGroups: versionGroups });
+}
+exports.getContext = getContext;

package/dist/lib/disk.d.ts

@@ -1,13 +1,13 @@
-import type { SyncpackConfig } from '../types';
-export declare type Disk = typeof disk;
-export declare const disk: {
-    readonly process: {
-        readonly exit: (code: number) => void;
+import type { Syncpack } from '../types';
+export type Disk = {
+    process: {
+        exit: (code: number) => void;
     };
-    readonly globSync: (pattern: string) => string[];
-    readonly readConfigFileSync: (configPath?: string) => Partial<SyncpackConfig>;
-    readonly readFileSync: (filePath: string) => string;
-    readonly readYamlFileSync: <T = unknown>(filePath: string) => T;
-    readonly removeSync: (filePath: string) => void;
-    readonly writeFileSync: (filePath: string, contents: string) => void;
+    globSync: (pattern: string) => string[];
+    readConfigFileSync: (configPath?: string) => Partial<Syncpack.Config.SyncpackRc>;
+    readFileSync: (filePath: string) => string;
+    readYamlFileSync: <T = unknown>(filePath: string) => T;
+    removeSync: (filePath: string) => void;
+    writeFileSync: (filePath: string, contents: string) => void;
 };
+export declare const disk: Disk;

package/dist/lib/disk.js

@@ -34,7 +34,6 @@ exports.disk = {
                 var rcPath_1 = (0, path_1.join)(constants_1.CWD, 'package.json');
                 var pjson = (0, fs_extra_1.readJsonSync)(rcPath_1, { throws: false });
                 var rcConfig_1 = (_a = pjson === null || pjson === void 0 ? void 0 : pjson.config) === null || _a === void 0 ? void 0 : _a.syncpack;
-                console.log(rcConfig_1);
                 if ((0, expect_more_1.isNonEmptyObject)(rcConfig_1))
                     return rcConfig_1;
                 (0, log_1.verbose)('no config file found');

package/dist/lib/error.d.ts

@@ -0,0 +1,12 @@
+export declare class BaseError extends Error {
+    name: 'SyncpackError';
+    cause?: BaseError | Error | null;
+    constructor(message: string, options?: {
+        cause?: unknown;
+        props?: {
+            args: any[];
+        };
+    });
+    static normalize(value: unknown): BaseError | Error | null;
+    static map(message: string): (cause: unknown) => BaseError;
+}

package/dist/lib/error.js

@@ -0,0 +1,43 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.BaseError = void 0;
+var BaseError = /** @class */ (function (_super) {
+    __extends(BaseError, _super);
+    function BaseError(message, options) {
+        var _this = _super.call(this, message) || this;
+        _this.name = 'SyncpackError';
+        _this.cause = BaseError.normalize(options === null || options === void 0 ? void 0 : options.cause);
+        return _this;
+    }
+    BaseError.normalize = function (value) {
+        if (value instanceof BaseError)
+            return value;
+        if (value instanceof Error)
+            return value;
+        if (typeof value === 'string')
+            return new Error(value);
+        return null;
+    };
+    BaseError.map = function (message) {
+        return function (cause) {
+            return new BaseError(message, { cause: cause });
+        };
+    };
+    return BaseError;
+}(Error));
+exports.BaseError = BaseError;

package/dist/lib/exit-if-invalid.d.ts

@@ -0,0 +1,2 @@
+import type { Syncpack } from '../types';
+export declare function exitIfInvalid(ctx: Syncpack.Ctx): Syncpack.Ctx;

package/dist/lib/exit-if-invalid.js

@@ -0,0 +1,10 @@
+"use strict";
+exports.__esModule = true;
+exports.exitIfInvalid = void 0;
+function exitIfInvalid(ctx) {
+    if (ctx.isInvalid) {
+        ctx.disk.process.exit(1);
+    }
+    return ctx;
+}
+exports.exitIfInvalid = exitIfInvalid;

package/dist/lib/is-semver.d.ts

@@ -1,4 +1,4 @@
-import type { ValidRange } from '../types';
-export declare function isValidSemverRange(value: unknown): value is ValidRange;
+import type { Syncpack } from '../types';
+export declare function isValidSemverRange(value: unknown): value is Syncpack.Config.SemverRange.Value;
 export declare function isSemver(version: unknown): boolean;
 export declare function isLooseSemver(version: unknown): boolean;

package/dist/lib/is-semver.js

@@ -4,15 +4,15 @@ exports.isLooseSemver = exports.isSemver = exports.isValidSemverRange = void 0;
 var expect_more_1 = require("expect-more");
 var constants_1 = require("../constants");
 function isValidSemverRange(value) {
-    return (value === constants_1.RANGE_ANY ||
-        value === constants_1.RANGE_EXACT ||
-        value === constants_1.RANGE_GT ||
-        value === constants_1.RANGE_GTE ||
-        value === constants_1.RANGE_LOOSE ||
-        value === constants_1.RANGE_LT ||
-        value === constants_1.RANGE_LTE ||
-        value === constants_1.RANGE_MINOR ||
-        value === constants_1.RANGE_PATCH);
+    return (value === constants_1.RANGE.ANY ||
+        value === constants_1.RANGE.EXACT ||
+        value === constants_1.RANGE.GT ||
+        value === constants_1.RANGE.GTE ||
+        value === constants_1.RANGE.LOOSE ||
+        value === constants_1.RANGE.LT ||
+        value === constants_1.RANGE.LTE ||
+        value === constants_1.RANGE.MINOR ||
+        value === constants_1.RANGE.PATCH);
 }
 exports.isValidSemverRange = isValidSemverRange;
 function isSemver(version) {

package/dist/lib/log.d.ts

@@ -1 +1,7 @@
 export declare function verbose(...values: unknown[]): void;
+export declare function fixed(message: string): void;
+export declare function skip(message: string): void;
+export declare function semverGroupHeader(order: number): void;
+export declare function versionGroupHeader(order: number): void;
+export declare function valid(message: string, comment?: string): void;
+export declare function invalid(message: string, comment?: string): void;

package/dist/lib/log.js

@@ -1,4 +1,8 @@
 "use strict";
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -28,7 +32,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 exports.__esModule = true;
-exports.verbose = void 0;
+exports.invalid = exports.valid = exports.versionGroupHeader = exports.semverGroupHeader = exports.skip = exports.fixed = exports.verbose = void 0;
 var chalk_1 = __importDefault(require("chalk"));
 var expect_more_1 = require("expect-more");
 var util_1 = require("util");
@@ -47,3 +51,38 @@ function verbose() {
     }
 }
 exports.verbose = verbose;
+function fixed(message) {
+    console.log((0, chalk_1["default"])(templateObject_1 || (templateObject_1 = __makeTemplateObject(["{green ", "}"], ["{green ", "}"])), constants_1.ICON.tick), message);
+}
+exports.fixed = fixed;
+function skip(message) {
+    console.log(chalk_1["default"].dim(constants_1.ICON.skip), chalk_1["default"].dim(message));
+}
+exports.skip = skip;
+function semverGroupHeader(order) {
+    console.log((0, chalk_1["default"])(templateObject_2 || (templateObject_2 = __makeTemplateObject(["{dim = Semver Group ", " ", "}"], ["{dim = Semver Group ", " ", "}"])), order, '='.repeat(63)));
+}
+exports.semverGroupHeader = semverGroupHeader;
+function versionGroupHeader(order) {
+    console.log((0, chalk_1["default"])(templateObject_3 || (templateObject_3 = __makeTemplateObject(["{dim = Version Group ", " ", "}"], ["{dim = Version Group ", " ", "}"])), order, '='.repeat(63)));
+}
+exports.versionGroupHeader = versionGroupHeader;
+function valid(message, comment) {
+    if (comment) {
+        console.log((0, chalk_1["default"])(templateObject_4 || (templateObject_4 = __makeTemplateObject(["{dim ", "} ", " {dim ", "}"], ["{dim ", "} ", " {dim ", "}"])), constants_1.ICON.skip, message, comment));
+    }
+    else {
+        console.log((0, chalk_1["default"])(templateObject_5 || (templateObject_5 = __makeTemplateObject(["{dim ", "} ", ""], ["{dim ", "} ", ""])), constants_1.ICON.skip, message));
+    }
+}
+exports.valid = valid;
+function invalid(message, comment) {
+    if (comment) {
+        console.log((0, chalk_1["default"])(templateObject_6 || (templateObject_6 = __makeTemplateObject(["{red ", "} ", " {dim ", "}"], ["{red ", "} ", " {dim ", "}"])), constants_1.ICON.cross, message, comment));
+    }
+    else {
+        console.log((0, chalk_1["default"])(templateObject_7 || (templateObject_7 = __makeTemplateObject(["{red ", "} ", ""], ["{red ", "} ", ""])), constants_1.ICON.cross, message));
+    }
+}
+exports.invalid = invalid;
+var templateObject_1, templateObject_2, templateObject_3, templateObject_4, templateObject_5, templateObject_6, templateObject_7;

package/dist/lib/newlines.d.ts

@@ -0,0 +1,6 @@
+type Ending = '\n' | '\r' | '\r\n' | string;
+export declare const newlines: {
+    detect(source: string): Ending;
+    fix(source: string, lineEnding: Ending): string;
+};
+export {};