syncpack 8.4.11 → 8.5.14

package/dist/lib/get-context/get-config/config.d.ts

@@ -0,0 +1,151 @@
+import type { ALL_DEPENDENCY_TYPES, RANGE } from '../../../constants';
+/** Aliases for locations within package.json files where versions can be found */
+export type DependencyType = (typeof ALL_DEPENDENCY_TYPES)[number];
+/** Aliases for semver range formats supported by syncpack */
+export type ValidRange = (typeof RANGE)[keyof typeof RANGE];
+export declare namespace Config {
+    export namespace SemverGroup {
+        /** All valid forms of Semver Group */
+        export type Any = Ignored | WithRange;
+        export interface Ignored extends Base {
+            /** Optionally force syncpack to ignore all dependencies in this group */
+            isIgnored: true;
+        }
+        export interface WithRange extends Base {
+            /** The semver range which dependencies in this group should use */
+            range: ValidRange;
+        }
+        interface Base {
+            /**
+             * The names of packages in your monorepo which belong to this group, taken
+             * from the "name" field in package.json, not the package directory name
+             */
+            packages: string[];
+            /** Dependency names (eg. "lodash") which belong to this group */
+            dependencies: string[];
+            /** Optionally limit this group to dependencies of the provided types */
+            dependencyTypes?: DependencyType[];
+        }
+        export {};
+    }
+    export namespace VersionGroup {
+        /** All valid forms of Version Group */
+        type Any = Standard | Banned | Ignored | Pinned;
+        interface Standard {
+            /**
+             * The names of packages in your monorepo which belong to this group, taken
+             * from the "name" field in package.json, not the package directory name
+             */
+            packages: string[];
+            /** Dependency names (eg. "lodash") which belong to this group */
+            dependencies: string[];
+            /** Optionally limit this group to dependencies of the provided types */
+            dependencyTypes?: DependencyType[];
+        }
+        interface Banned extends Standard {
+            /** Optionally force all dependencies in this group to be removed */
+            isBanned: true;
+        }
+        interface Ignored extends Standard {
+            /** Optionally force syncpack to ignore all dependencies in this group */
+            isIgnored?: true;
+        }
+        interface Pinned extends Standard {
+            /** Optionally force all dependencies in this group to have this version */
+            pinVersion?: string;
+        }
+    }
+    /** All valid config which can only be provided via .syncpackrc */
+    interface RcFileOnly {
+        /**
+         * When using the `format` command, determines which fields within
+         * package.json files should be sorted alphabetically. When the value is an
+         * Object, its keys are sorted alphabetically. When the value is an Array, its
+         * values are sorted alphabetically. There is no equivalent CLI Option for
+         * this configuration.
+         */
+        sortAz: string[];
+        /**
+         * When using the `format` command, determines which fields within package.json
+         * files should appear at the top, and in what order. There is no equivalent
+         * CLI Option for this configuration.
+         */
+        sortFirst: string[];
+        /** */
+        versionGroups: VersionGroup.Any[];
+        /** */
+        semverGroups: SemverGroup.Any[];
+    }
+    /** All valid config which can only be provided via the CLI */
+    interface CliOnly {
+        /** Absolute or relative path to a .syncpackrc */
+        configPath: string;
+    }
+    /** All valid config which can be provided via the CLI or .syncpackrc */
+    export interface CliAndRcFile {
+        /** Whether to search within `devDependencies` */
+        dev: boolean;
+        /** Whether to search within npm `overrides` */
+        overrides: boolean;
+        /** Whether to search within `peerDependencies` */
+        peer: boolean;
+        /** Whether to search within `pnpm.overrides` */
+        pnpmOverrides: boolean;
+        /** Whether to search within `dependencies` */
+        prod: boolean;
+        /** Whether to search within yarn `resolutions` */
+        resolutions: boolean;
+        /**
+         * Whether to include the versions of the `--source` packages developed in
+         * your workspace/monorepo as part of the search for versions to sync
+         */
+        workspace: boolean;
+        /**
+         * A string which will be passed to `new RegExp()` to match against package
+         * names that should be included.
+         *
+         * > ⚠️ `filter` was originally intended as a convenience to be used from the
+         * > command line to filter the output of `syncpack list`, it is not recommended
+         * > to add this to your config file to manage your project more generally.
+         * >
+         * > Instead use `versionGroups` and/or `semverGroups`.
+         *
+         */
+        filter: string;
+        /**
+         * The character(s) to be used to indent your package.json files when writing
+         * to disk
+         */
+        indent: string;
+        /**
+         * Defaulted to `""` to ensure that exact dependency versions are used instead
+         * of loose ranges, but this can be overridden in your config file or via the
+         * `--semver-range` command line option.
+         *
+         * | Supported Range |   Example |
+         * | --------------- | --------: |
+         * | `"<"`           |  `<1.4.2` |
+         * | `"<="`          | `<=1.4.2` |
+         * | `""`            |   `1.4.2` |
+         * | `"~"`           |  `~1.4.2` |
+         * | `"^"`           |  `^1.4.2` |
+         * | `">="`          | `>=1.4.2` |
+         * | `">"`           |  `>1.4.2` |
+         * | `"*"`           |       `*` |
+         */
+        semverRange: ValidRange;
+        /**
+         * Defaults to `["package.json", "packages/\*\/package.json"]` to match most
+         * Projects using Lerna or Yarn Workspaces, but this can be overridden in your
+         * config file or via multiple `--source` command line options.
+         *
+         * Supports any patterns supported by https://github.com/isaacs/node-glob
+         */
+        source: string[];
+    }
+    /** All valid config in .syncpackrc */
+    export type RcFile = RcFileOnly & CliAndRcFile;
+    /** All valid config recognised by Syncpack */
+    export type All = CliOnly & RcFile;
+    export {};
+}

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

@@ -0,0 +1,8 @@
+import type { Disk } from '../../disk';
+import type { Config } from './config';
+import type { InternalConfig } from './internal-config';
+/**
+ * Take all configuration from the command line and config file, combine it, and
+ * set defaults for anything which hasn't been defined.
+ */
+export declare const getConfig: (disk: Disk, program: Partial<Config.All>) => InternalConfig;

package/dist/lib/{get-input/get-config.js → get-context/get-config/index.js}

@@ -1,16 +1,38 @@
 "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;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 exports.__esModule = true;
 exports.getConfig = void 0;
 var expect_more_1 = require("expect-more");
-var constants_1 = require("../../constants");
-var is_semver_1 = require("../../lib/is-semver");
-var log_1 = require("../log");
+var constants_1 = require("../../../constants");
+var is_semver_1 = require("../../is-semver");
+var log_1 = require("../../log");
 /**
  * Take all configuration from the command line and config file, combine it, and
  * set defaults for anything which hasn't been defined.
- *
- * @param  rcFile   Optional configuration file contents
- * @param  program  Optional command line options
  */
 var getConfig = function (disk, program) {
     (0, log_1.verbose)('cli arguments:', program);
@@ -50,7 +72,7 @@ var getConfig = function (disk, program) {
         prod ||
         resolutions ||
         workspace
-        ? constants_1.DEPENDENCY_TYPES.filter(function (type) {
+        ? constants_1.ALL_DEPENDENCY_TYPES.filter(function (type) {
             return (type === 'devDependencies' && dev) ||
                 (type === 'overrides' && overrides) ||
                 (type === 'peerDependencies' && peer) ||
@@ -59,7 +81,7 @@ var getConfig = function (disk, program) {
                 (type === 'resolutions' && resolutions) ||
                 (type === 'workspace' && workspace);
         })
-        : constants_1.DEPENDENCY_TYPES;
+        : __spreadArray([], __read(constants_1.ALL_DEPENDENCY_TYPES), false);
     var filter = getOption('filter', expect_more_1.isNonEmptyString);
     var indent = getOption('indent', expect_more_1.isNonEmptyString);
     var semverRange = getOption('semverRange', is_semver_1.isValidSemverRange);
@@ -86,7 +108,6 @@ var getConfig = function (disk, program) {
     };
     var versionGroups = getOption('versionGroups', isArrayOfVersionGroups).concat(defaultVersionGroup);
     var finalConfig = {
-        dependencyTypes: dependencyTypes,
         dev: dev,
         filter: filter,
         indent: indent,
@@ -101,7 +122,11 @@ var getConfig = function (disk, program) {
         sortAz: sortAz,
         sortFirst: sortFirst,
         source: source,
-        versionGroups: versionGroups
+        versionGroups: versionGroups,
+        // The following are internal additions not exposed in public config
+        defaultSemverGroup: defaultSemverGroup,
+        defaultVersionGroup: defaultVersionGroup,
+        dependencyTypes: dependencyTypes
     };
     (0, log_1.verbose)('final config:', finalConfig);
     return finalConfig;

package/dist/lib/get-context/get-config/internal-config.d.ts

@@ -0,0 +1,24 @@
+import type { Config, DependencyType } from './config';
+export interface InternalConfig extends Config.RcFile {
+    /**
+     * The standard/catch-all semver group.
+     *
+     * + When no semver groups are defined, this will be the only group.
+     * + Otherwise this group will appear last, to be used when none of the user's
+     *   groups found a match.
+     */
+    defaultSemverGroup: Config.SemverGroup.WithRange;
+    /**
+     * The standard/catch-all version group.
+     *
+     * + When no version groups are defined, this will be the only group.
+     * + Otherwise this group will appear last, to be used when none of the user's
+     *   groups found a match.
+     */
+    defaultVersionGroup: Config.VersionGroup.Standard;
+    /**
+     * Aliases for locations of versions within package.json files, it is looped
+     * over by each command to operate on each are as defined by the user.
+     */
+    dependencyTypes: DependencyType[];
+}

package/dist/lib/get-context/get-groups/get-semver-groups.d.ts

@@ -0,0 +1,4 @@
+import type { InternalConfig } from '../get-config/internal-config';
+import type { Instance } from '../get-package-json-files/package-json-file/instance';
+import { SemverGroup } from './semver-group';
+export declare function getSemverGroups(input: InternalConfig, instances: Instance[]): SemverGroup[];

package/dist/lib/get-context/get-groups/get-semver-groups.js

@@ -0,0 +1,45 @@
+"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.getSemverGroups = void 0;
+var semver_group_1 = require("./semver-group");
+function getSemverGroups(input, instances) {
+    var semverGroups = input.semverGroups.map(function (semverGroup) { return new semver_group_1.SemverGroup(input, semverGroup); });
+    instances.forEach(function (instance) {
+        var e_1, _a;
+        var name = instance.name, pkgName = instance.pkgName;
+        try {
+            for (var semverGroups_1 = __values(semverGroups), semverGroups_1_1 = semverGroups_1.next(); !semverGroups_1_1.done; semverGroups_1_1 = semverGroups_1.next()) {
+                var semverGroup = semverGroups_1_1.value;
+                if (instance.matchesGroup(semverGroup)) {
+                    if (!semverGroup.instancesByName[name]) {
+                        semverGroup.instancesByName[name] = [];
+                    }
+                    semverGroup.instancesByName[name].push(instance);
+                    semverGroup.instances.push(instance);
+                    return;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (semverGroups_1_1 && !semverGroups_1_1.done && (_a = semverGroups_1["return"])) _a.call(semverGroups_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        throw new Error("".concat(name, " in ").concat(pkgName, " did not match any semverGroups"));
+    });
+    return semverGroups;
+}
+exports.getSemverGroups = getSemverGroups;

package/dist/lib/get-context/get-groups/get-version-groups.d.ts

@@ -0,0 +1,4 @@
+import type { InternalConfig } from '../get-config/internal-config';
+import type { Instance } from '../get-package-json-files/package-json-file/instance';
+import { VersionGroup } from './version-group';
+export declare function getVersionGroups(input: InternalConfig, instances: Instance[]): VersionGroup[];

package/dist/lib/get-context/get-groups/get-version-groups.js

@@ -0,0 +1,71 @@
+"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.");
+};
+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.getVersionGroups = void 0;
+var version_group_1 = require("./version-group");
+var instance_group_1 = require("./version-group/instance-group");
+function getVersionGroups(input, instances) {
+    var versionGroups = input.versionGroups.map(function (versionGroup) { return new version_group_1.VersionGroup(input, versionGroup); });
+    instances.forEach(function (instance) {
+        var e_1, _a;
+        var name = instance.name, pkgName = instance.pkgName;
+        try {
+            for (var versionGroups_1 = __values(versionGroups), versionGroups_1_1 = versionGroups_1.next(); !versionGroups_1_1.done; versionGroups_1_1 = versionGroups_1.next()) {
+                var versionGroup = versionGroups_1_1.value;
+                if (instance.matchesGroup(versionGroup)) {
+                    if (!versionGroup.instancesByName[name]) {
+                        versionGroup.instancesByName[name] = [];
+                    }
+                    versionGroup.instancesByName[name].push(instance);
+                    versionGroup.instances.push(instance);
+                    return;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (versionGroups_1_1 && !versionGroups_1_1.done && (_a = versionGroups_1["return"])) _a.call(versionGroups_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        throw new Error("".concat(name, " in ").concat(pkgName, " did not match any versionGroups"));
+    });
+    versionGroups.forEach(function (versionGroup) {
+        versionGroup.instanceGroups = getInstanceGroups(versionGroup);
+    });
+    return versionGroups;
+}
+exports.getVersionGroups = getVersionGroups;
+function getInstanceGroups(versionGroup) {
+    return Object.entries(versionGroup.instancesByName).map(function (_a) {
+        var _b = __read(_a, 2), name = _b[0], instances = _b[1];
+        return new instance_group_1.InstanceGroup(versionGroup, name, instances);
+    });
+}

package/dist/lib/get-context/get-groups/semver-group/index.d.ts

@@ -0,0 +1,30 @@
+import type { Config, DependencyType, ValidRange } from '../../get-config/config';
+import type { InternalConfig } from '../../get-config/internal-config';
+import type { Instance } from '../../get-package-json-files/package-json-file/instance';
+export declare class SemverGroup {
+    /** */
+    dependencies: string[];
+    /** Optionally limit this group to dependencies of the provided types */
+    dependencyTypes?: DependencyType[];
+    /** */
+    input: InternalConfig;
+    /** */
+    instances: Instance[];
+    /** */
+    instancesByName: Record<string, Instance[]>;
+    /** */
+    isDefault: boolean;
+    /** Optionally force syncpack to ignore all dependencies in this group */
+    isIgnored: boolean;
+    /** */
+    packages: string[];
+    /** The semver range which dependencies in this group should use */
+    range: ValidRange;
+    constructor(input: InternalConfig, semverGroup: Config.SemverGroup.Any);
+    /** Syncpack must report or fix this group's mismatches */
+    isInvalid(): boolean;
+    /** 1+ `Instance` has a version which does not follow the rules */
+    hasInvalidInstances(): boolean;
+    /** Get every `Instance` with a version which does not follow the rules */
+    getInvalidInstances(): Instance[];
+}

package/dist/lib/get-context/get-groups/semver-group/index.js

@@ -0,0 +1,33 @@
+"use strict";
+exports.__esModule = true;
+exports.SemverGroup = void 0;
+var SemverGroup = /** @class */ (function () {
+    function SemverGroup(input, semverGroup) {
+        this.dependencies = semverGroup.dependencies;
+        this.input = input;
+        this.instances = [];
+        this.instancesByName = {};
+        this.isDefault = semverGroup === input.defaultSemverGroup;
+        this.isIgnored = semverGroup.isIgnored === true;
+        this.packages = semverGroup.packages;
+        this.range = semverGroup.range;
+    }
+    /** Syncpack must report or fix this group's mismatches */
+    SemverGroup.prototype.isInvalid = function () {
+        return !this.isIgnored && this.hasInvalidInstances();
+    };
+    /** 1+ `Instance` has a version which does not follow the rules */
+    SemverGroup.prototype.hasInvalidInstances = function () {
+        return this.getInvalidInstances().length > 0;
+    };
+    /** Get every `Instance` with a version which does not follow the rules */
+    SemverGroup.prototype.getInvalidInstances = function () {
+        var _this = this;
+        return this.instances.filter(function (instance) {
+            return instance.dependencyType !== 'workspace' &&
+                !instance.hasRange(_this.range);
+        });
+    };
+    return SemverGroup;
+}());
+exports.SemverGroup = SemverGroup;

package/dist/lib/get-context/get-groups/version-group/index.d.ts

@@ -0,0 +1,30 @@
+import type { Config, DependencyType } from '../../get-config/config';
+import type { InternalConfig } from '../../get-config/internal-config';
+import type { Instance } from '../../get-package-json-files/package-json-file/instance';
+import type { InstanceGroup } from './instance-group';
+export declare class VersionGroup {
+    /** */
+    dependencies: string[];
+    /** Optionally limit this group to dependencies of the provided types */
+    dependencyTypes?: DependencyType[];
+    /** */
+    input: InternalConfig;
+    /** */
+    instanceGroups: InstanceGroup[];
+    /** */
+    instances: Instance[];
+    /** */
+    instancesByName: Record<string, Instance[]>;
+    /** */
+    isBanned: boolean;
+    /** */
+    isDefault: boolean;
+    /** */
+    isIgnored: boolean;
+    /** */
+    packages: string[];
+    /** Optionally force all dependencies in this group to have this version */
+    pinVersion?: string;
+    constructor(input: InternalConfig, versionGroup: Config.VersionGroup.Any);
+    getInvalidInstanceGroups(): InstanceGroup[];
+}

package/dist/lib/get-context/get-groups/version-group/index.js

@@ -0,0 +1,23 @@
+"use strict";
+exports.__esModule = true;
+exports.VersionGroup = void 0;
+var VersionGroup = /** @class */ (function () {
+    function VersionGroup(input, versionGroup) {
+        this.dependencies = versionGroup.dependencies;
+        this.dependencyTypes = versionGroup.dependencyTypes;
+        this.input = input;
+        this.instanceGroups = [];
+        this.instances = [];
+        this.instancesByName = {};
+        this.isBanned = versionGroup.isBanned === true;
+        this.isDefault = versionGroup === input.defaultVersionGroup;
+        this.isIgnored = versionGroup.isIgnored === true;
+        this.packages = versionGroup.packages;
+        this.pinVersion = versionGroup.pinVersion;
+    }
+    VersionGroup.prototype.getInvalidInstanceGroups = function () {
+        return this.instanceGroups.filter(function (group) { return group.isInvalid; });
+    };
+    return VersionGroup;
+}());
+exports.VersionGroup = VersionGroup;

package/dist/{bin-fix-mismatches/get-expected-version → lib/get-context/get-groups/version-group/instance-group}/get-highest-version.js

@@ -2,8 +2,8 @@
 exports.__esModule = true;
 exports.getHighestVersion = void 0;
 var semver_1 = require("semver");
-var constants_1 = require("../../constants");
-var is_semver_1 = require("../../lib/is-semver");
+var constants_1 = require("../../../../../constants");
+var is_semver_1 = require("../../../../is-semver");
 function getHighestVersion(versions) {
     return versions.reduce(function (rawHighest, raw) {
         var version = (0, semver_1.valid)((0, semver_1.coerce)(raw)) || '';
@@ -25,24 +25,24 @@ exports.getHighestVersion = getHighestVersion;
 function getRangeScore(version) {
     if (version === '')
         return 0;
-    if (version === constants_1.RANGE_ANY)
+    if (version === constants_1.RANGE.ANY)
         return 8;
     var range = getRange(version);
-    if (range === constants_1.RANGE_GT)
+    if (range === constants_1.RANGE.GT)
         return 7;
-    if (range === constants_1.RANGE_GTE)
+    if (range === constants_1.RANGE.GTE)
         return 6;
-    if (range === constants_1.RANGE_MINOR)
+    if (range === constants_1.RANGE.MINOR)
         return 5;
     if (version.indexOf('.x') !== -1)
         return 4;
-    if (range === constants_1.RANGE_PATCH)
+    if (range === constants_1.RANGE.PATCH)
         return 3;
-    if (range === constants_1.RANGE_EXACT)
+    if (range === constants_1.RANGE.EXACT)
         return 2;
-    if (range === constants_1.RANGE_LTE)
+    if (range === constants_1.RANGE.LTE)
         return 1;
-    if (range === constants_1.RANGE_LT)
+    if (range === constants_1.RANGE.LT)
         return 0;
     return 0;
 }

package/dist/lib/get-context/get-groups/version-group/instance-group/index.d.ts

@@ -0,0 +1,32 @@
+import type { VersionGroup } from '..';
+import type { Instance } from '../../../get-package-json-files/package-json-file/instance';
+/** Every `Instance` of eg `"lodash"` for a given `VersionGroup` */
+export declare class InstanceGroup {
+    /** 1+ `Instance` has a version which does not follow the rules */
+    hasMismatches: boolean;
+    /** Every package/dependencyType location where this dependency was found */
+    instances: Instance[];
+    /** Syncpack must report or fix this groups mismatches */
+    isInvalid: boolean;
+    /** 1+ `Instance` has a version not matching `VersionGroup.pinVersion` */
+    isUnpinned: boolean;
+    /** @example `"lodash"` */
+    name: string;
+    /** All `Instance` versions, with duplicates removed */
+    uniques: string[];
+    /** The `VersionGroup` which this `InstanceGroup` belongs to */
+    versionGroup: VersionGroup;
+    constructor(versionGroup: VersionGroup, name: string, instances: Instance[]);
+    getExpectedVersion(): string | undefined;
+    getPinnedVersion(): string;
+    /**
+     * If this dependency is a package developed locally, we should use its
+     * version as the source of truth.
+     */
+    getWorkspaceVersion(): string;
+    /**
+     * Find instance of this dependency which is a package developed locally in
+     * this monorepo.
+     */
+    getWorkspaceInstance(): Instance | undefined;
+}