syncpack 9.8.4 → 10.0.0

package/dist/bin-list-mismatches/list-mismatches.js

@@ -27,117 +27,84 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listMismatches = void 0;
-const ts_belt_1 = require("@mobily/ts-belt");
 const chalk_1 = __importDefault(require("chalk"));
+const is_non_empty_array_1 = require("tightrope/guard/is-non-empty-array");
+const constants_1 = require("../constants");
+const get_version_groups_1 = require("../get-version-groups");
 const log = __importStar(require("../lib/log"));
+const sort_by_name_1 = require("../lib/sort-by-name");
 function listMismatches(ctx) {
-    const hasUserGroups = ctx.versionGroups.length > 1;
-    ctx.versionGroups.forEach((versionGroup, i) => {
-        const invalidGroups = versionGroup.getInvalidInstanceGroups();
-        // Nothing to do if there are no mismatches
-        if (invalidGroups.length === 0)
-            return;
-        // Record that this project has mismatches, so that eg. the CLI can exit
-        // with the correct status code.
-        ctx.isInvalid = true;
-        // Annotate each group
-        hasUserGroups && log.versionGroupHeader(versionGroup, i);
-        // Log the mismatches
-        invalidGroups.forEach((instanceGroup) => {
-            if (versionGroup.isBanned())
-                return logBanned(instanceGroup);
-            if (versionGroup.isUnpinned())
-                return logUnpinned(instanceGroup);
-            if (versionGroup.hasSnappedToPackages())
-                return logSnappedTo(instanceGroup);
-            if (instanceGroup.hasUnsupportedVersion())
-                return logUnsupportedMismatches(instanceGroup);
-            if (instanceGroup.hasWorkspaceInstance()) {
-                return logWorkspaceMismatch(instanceGroup);
+    const versionGroups = (0, get_version_groups_1.getVersionGroups)(ctx);
+    const hasUserGroups = (0, is_non_empty_array_1.isNonEmptyArray)(ctx.config.rcFile.versionGroups);
+    versionGroups.forEach((versionGroup, i) => {
+        versionGroup
+            .inspect()
+            .sort(sort_by_name_1.sortByName)
+            .forEach((report, ii) => {
+            // no action needed
+            if (report.isValid)
+                return;
+            // Allow eg. CLI to exit with the correct status code.
+            ctx.isInvalid = true;
+            // Annotate each group
+            if (ii === 0 && hasUserGroups)
+                log.versionGroupHeader(versionGroup, i);
+            switch (report.status) {
+                case 'BANNED':
+                    console.log((0, chalk_1.default) `  {red %s} %s {dim is banned in this version group}`, constants_1.ICON.cross, report.name);
+                    report.instances.forEach((instance) => {
+                        console.log((0, chalk_1.default) `  {red %s} {dim in %s of %s}`, instance.version, instance.strategy.path, instance.packageJsonFile.shortPath);
+                    });
+                    break;
+                case 'HIGHEST_SEMVER_MISMATCH':
+                case 'LOWEST_SEMVER_MISMATCH': {
+                    console.log((0, chalk_1.default) `{red %s} %s {green %s} {dim is the %s valid semver version in use}`, constants_1.ICON.cross, report.name, report.expectedVersion, report.status === 'LOWEST_SEMVER_MISMATCH' ? 'lowest' : 'highest');
+                    report.instances.forEach((instance) => {
+                        if (instance.version !== report.expectedVersion) {
+                            console.log((0, chalk_1.default) `  {red %s} {dim in %s of %s}`, instance.version, instance.strategy.path, instance.packageJsonFile.shortPath);
+                        }
+                    });
+                    break;
+                }
+                case 'PINNED_MISMATCH': {
+                    console.log((0, chalk_1.default) `{red %s} %s {dim is pinned in this version group at} {green %s}`, constants_1.ICON.cross, report.name, report.expectedVersion);
+                    report.instances.forEach((instance) => {
+                        if (instance.version !== report.expectedVersion) {
+                            console.log((0, chalk_1.default) `  {red %s} {dim in %s of %s}`, instance.version, instance.strategy.path, instance.packageJsonFile.shortPath);
+                        }
+                    });
+                    break;
+                }
+                case 'SNAPPED_TO_MISMATCH': {
+                    console.log((0, chalk_1.default) `{red %s} %s {dim should snap to {reset.green %s}, used by %s}`, constants_1.ICON.cross, report.name, report.expectedVersion, versionGroup.config.snapTo.join(' || '));
+                    report.instances.forEach((instance) => {
+                        if (instance.version !== report.expectedVersion) {
+                            console.log((0, chalk_1.default) `  {red %s} {dim in %s of %s}`, instance.version, instance.strategy.path, instance.packageJsonFile.shortPath);
+                        }
+                    });
+                    break;
+                }
+                case 'UNSUPPORTED_MISMATCH': {
+                    console.log((0, chalk_1.default) `{red %s} %s {dim has mismatched versions which syncpack cannot fix}`, constants_1.ICON.cross, report.name);
+                    report.instances.forEach((instance) => {
+                        console.log((0, chalk_1.default) `  {yellow %s} {dim in %s of %s}`, instance.version, instance.strategy.path, instance.packageJsonFile.shortPath);
+                    });
+                    break;
+                }
+                case 'WORKSPACE_MISMATCH': {
+                    console.log((0, chalk_1.default) `{red %s} %s {green %s} {dim is developed in this repo at %s}`, constants_1.ICON.cross, report.name, report.expectedVersion, report.workspaceInstance.packageJsonFile.shortPath);
+                    report.instances.forEach((instance) => {
+                        if (instance.version !== report.expectedVersion) {
+                            console.log((0, chalk_1.default) `  {red %s} {dim in %s of %s}`, instance.version, instance.strategy.path, instance.packageJsonFile.shortPath);
+                        }
+                    });
+                    break;
+                }
+                // @TODO case 'SEMVER_UNSATISFIED': break;
+                // @TODO case 'WORKSPACE_UNSATISFIED': break;
             }
-            logHighLowVersionMismatch(instanceGroup);
         });
     });
     return ctx;
-    function logBanned(instanceGroup) {
-        const name = instanceGroup.name;
-        log.invalid(name, 'is banned in this version group');
-        // Log each of the dependencies mismatches
-        instanceGroup.instances.forEach((instance) => {
-            logVersionMismatch(instance);
-        });
-    }
-    function logUnsupportedMismatches(instanceGroup) {
-        const name = instanceGroup.name;
-        log.invalid(name, 'has mismatched versions which syncpack cannot fix');
-        // Log each of the dependencies mismatches
-        instanceGroup.instances.forEach((instance) => {
-            logUnsupportedVersionMismatch(instance);
-        });
-    }
-    function logUnpinned(instanceGroup) {
-        const name = instanceGroup.name;
-        const pinVersion = ts_belt_1.O.getExn(instanceGroup.versionGroup.getPinnedVersion());
-        log.invalid(name, (0, chalk_1.default) `is pinned in this version group at {reset.green ${pinVersion}}`);
-        // Log each of the dependencies mismatches
-        instanceGroup.instances.forEach((instance) => {
-            if (instance.version !== pinVersion) {
-                logVersionMismatch(instance);
-            }
-        });
-    }
-    function logSnappedTo(instanceGroup) {
-        const name = instanceGroup.name;
-        const versionGroup = instanceGroup.versionGroup;
-        const snappedVersion = ts_belt_1.R.getExn(instanceGroup.getSnappedVersion());
-        const snappedToPackages = ts_belt_1.O.getExn(versionGroup.getSnappedToPackages()).join(' || ');
-        const version = ts_belt_1.R.getExn(instanceGroup.getExpectedVersion());
-        log.invalid(name, (0, chalk_1.default) `should snap to {reset.green ${version}}, used by ${snappedToPackages}`);
-        // Log each of the dependencies mismatches
-        instanceGroup.instances.forEach((instance) => {
-            if (instance.version !== snappedVersion) {
-                logVersionMismatch(instance);
-            }
-        });
-    }
-    function logWorkspaceMismatch(instanceGroup) {
-        const name = instanceGroup.name;
-        const workspaceInstance = ts_belt_1.O.getExn(instanceGroup.getWorkspaceInstance());
-        const shortPath = workspaceInstance?.packageJsonFile.shortPath;
-        const expected = ts_belt_1.R.getExn(instanceGroup.getExpectedVersion());
-        log.invalid(name, (0, chalk_1.default) `{reset.green ${expected}} {dim is developed in this repo at ${shortPath}}`);
-        // Log each of the dependencies mismatches
-        instanceGroup.instances.forEach((instance) => {
-            if (instance.version !== expected) {
-                logVersionMismatch(instance);
-            }
-        });
-    }
-    function logHighLowVersionMismatch(instanceGroup) {
-        const name = instanceGroup.name;
-        const preference = instanceGroup.versionGroup
-            .groupConfig.preferVersion;
-        const direction = preference === 'highestSemver' ? 'highest' : 'lowest';
-        const expected = ts_belt_1.R.getExn(instanceGroup.getExpectedVersion());
-        log.invalid(name, (0, chalk_1.default) `{reset.green ${expected}} {dim is the ${direction} valid semver version in use}`);
-        // Log each of the dependencies mismatches
-        instanceGroup.instances.forEach((instance) => {
-            if (instance.version !== expected) {
-                logVersionMismatch(instance);
-            }
-        });
-    }
-    function logVersionMismatch(instance) {
-        const type = instance.pathDef.path;
-        const shortPath = instance.packageJsonFile.shortPath;
-        const actual = instance.version;
-        console.log((0, chalk_1.default) `  {red ${actual}} {dim in ${type} of ${shortPath}}`);
-    }
-    function logUnsupportedVersionMismatch(instance) {
-        const type = instance.pathDef.path;
-        const shortPath = instance.packageJsonFile.shortPath;
-        const actual = instance.version;
-        console.log((0, chalk_1.default) `  {yellow ${actual}} {dim in ${type} of ${shortPath}}`);
-    }
 }
 exports.listMismatches = listMismatches;

package/dist/bin-set-semver-ranges/set-semver-ranges-cli.d.ts

@@ -1,3 +1,3 @@
+import type { CliConfig } from '../config/types';
 import type { Disk } from '../lib/disk';
-import type { Syncpack } from '../types';
-export declare function setSemverRangesCli(input: Partial<Syncpack.Config.Cli>, disk: Disk): void;
+export declare function setSemverRangesCli(input: Partial<CliConfig>, disk: Disk): void;

package/dist/bin-set-semver-ranges/set-semver-ranges-cli.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setSemverRangesCli = void 0;
+const pipe_1 = require("tightrope/fn/pipe");
 const get_context_1 = require("../get-context");
 const write_if_changed_1 = require("../lib/write-if-changed");
 const set_semver_ranges_1 = require("./set-semver-ranges");
 function setSemverRangesCli(input, disk) {
-    (0, write_if_changed_1.writeIfChanged)((0, set_semver_ranges_1.setSemverRanges)((0, get_context_1.getContext)(input, disk)));
+    (0, pipe_1.pipe)((0, get_context_1.getContext)(input, disk), set_semver_ranges_1.setSemverRanges, write_if_changed_1.writeIfChanged);
 }
 exports.setSemverRangesCli = setSemverRangesCli;

package/dist/bin-set-semver-ranges/set-semver-ranges.d.ts

@@ -1,2 +1,2 @@
-import type { Syncpack } from '../types';
-export declare const setSemverRanges: (ctx: Syncpack.Ctx) => Syncpack.Ctx;
+import type { Context } from '../get-context';
+export declare const setSemverRanges: (ctx: Context) => Context;

package/dist/bin-set-semver-ranges/set-semver-ranges.js

@@ -1,10 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setSemverRanges = void 0;
+const get_semver_groups_1 = require("../get-semver-groups");
 const setSemverRanges = (ctx) => {
-    ctx.semverGroups.forEach((semverGroup) => {
-        semverGroup.instances.forEach((instance) => {
-            instance.setVersion(semverGroup.getExpectedVersion(instance));
+    (0, get_semver_groups_1.getSemverGroups)(ctx).forEach((semverGroup) => {
+        semverGroup.inspect().forEach((report) => {
+            switch (report.status) {
+                case 'WORKSPACE_SEMVER_RANGE_MISMATCH':
+                case 'SEMVER_RANGE_MISMATCH': {
+                    report.instance.setVersion(report.expectedVersion);
+                    break;
+                }
+                case 'FILTERED_OUT':
+                case 'IGNORED':
+                case 'UNSUPPORTED_VERSION':
+                case 'VALID': {
+                    // no action needed
+                    break;
+                }
+            }
         });
     });
     return ctx;

package/dist/config/get-custom-types.d.ts

@@ -0,0 +1,9 @@
+import type { Context } from '../get-context';
+import { NameAndVersionPropsStrategy } from '../strategy/name-and-version-props';
+import { NamedVersionStringStrategy } from '../strategy/named-version-string';
+import { UnnamedVersionStringStrategy } from '../strategy/unnamed-version-string';
+import { VersionsByNameStrategy } from '../strategy/versions-by-name';
+export declare namespace Strategy {
+    type Any = NameAndVersionPropsStrategy | NamedVersionStringStrategy | UnnamedVersionStringStrategy | VersionsByNameStrategy;
+}
+export declare function getCustomTypes({ rcFile }: Context['config']): Strategy.Any[];

package/dist/config/get-custom-types.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCustomTypes = void 0;
+const is_non_empty_object_1 = require("tightrope/guard/is-non-empty-object");
+const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
+const is_object_1 = require("tightrope/guard/is-object");
+const name_and_version_props_1 = require("../strategy/name-and-version-props");
+const named_version_string_1 = require("../strategy/named-version-string");
+const unnamed_version_string_1 = require("../strategy/unnamed-version-string");
+const versions_by_name_1 = require("../strategy/versions-by-name");
+function getCustomTypes({ rcFile }) {
+    if (!(0, is_non_empty_object_1.isNonEmptyObject)(rcFile.customTypes))
+        return [];
+    const ERR_OBJ = new Error('Invalid customType');
+    const ERR_NAME = new Error('Invalid customType name');
+    const ERR_PATH = new Error('Invalid customType.path');
+    const ERR_NAME_PATH = new Error('Invalid customType namePath');
+    const ERR_STRATEGY = new Error('Invalid customType.strategy');
+    return Object.entries(rcFile.customTypes).map(([name, config]) => {
+        if (!(0, is_object_1.isObject)(config))
+            throw ERR_OBJ;
+        if (!(0, is_non_empty_string_1.isNonEmptyString)(name))
+            throw ERR_NAME;
+        if (!(0, is_non_empty_string_1.isNonEmptyString)(config.path))
+            throw ERR_PATH;
+        const path = config.path;
+        const strategy = config.strategy;
+        switch (strategy) {
+            case 'name~version': {
+                const namePath = config.namePath;
+                if (!(0, is_non_empty_string_1.isNonEmptyString)(namePath))
+                    throw ERR_NAME_PATH;
+                return new name_and_version_props_1.NameAndVersionPropsStrategy(name, path, namePath);
+            }
+            case 'name@version': {
+                return new named_version_string_1.NamedVersionStringStrategy(name, path);
+            }
+            case 'version': {
+                return new unnamed_version_string_1.UnnamedVersionStringStrategy(name, path);
+            }
+            case 'versionsByName': {
+                return new versions_by_name_1.VersionsByNameStrategy(name, path);
+            }
+            default:
+                throw ERR_STRATEGY;
+        }
+    });
+}
+exports.getCustomTypes = getCustomTypes;

package/dist/config/get-enabled-types.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '../get-context';
+import type { Strategy } from './get-custom-types';
+export declare function getEnabledTypes({ cli, rcFile, }: Context['config']): Strategy.Any[];

package/dist/config/get-enabled-types.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnabledTypes = void 0;
+const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
+const is_empty_array_1 = require("tightrope/guard/is-empty-array");
+const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
+const name_and_version_props_1 = require("../strategy/name-and-version-props");
+const versions_by_name_1 = require("../strategy/versions-by-name");
+const get_custom_types_1 = require("./get-custom-types");
+function getEnabledTypes({ cli, rcFile, }) {
+    const enabledTypes = [];
+    const enabledTypeNames = ((0, is_non_empty_string_1.isNonEmptyString)(cli.types)
+        ? cli.types.split(',')
+        : (0, is_array_of_strings_1.isArrayOfStrings)(rcFile.dependencyTypes)
+            ? rcFile.dependencyTypes
+            : []).filter(is_non_empty_string_1.isNonEmptyString);
+    // @TODO accept `dependencyTypes: ['**']`
+    // @TODO support `dependencyTypes: ['!dev']`
+    const useDefaults = (0, is_empty_array_1.isEmptyArray)(enabledTypeNames);
+    if (useDefaults || enabledTypeNames.includes('dev')) {
+        enabledTypes.push(new versions_by_name_1.VersionsByNameStrategy('dev', 'devDependencies'));
+    }
+    if (useDefaults || enabledTypeNames.includes('overrides')) {
+        enabledTypes.push(new versions_by_name_1.VersionsByNameStrategy('overrides', 'overrides'));
+    }
+    if (useDefaults || enabledTypeNames.includes('peer')) {
+        enabledTypes.push(new versions_by_name_1.VersionsByNameStrategy('peer', 'peerDependencies'));
+    }
+    if (useDefaults || enabledTypeNames.includes('pnpmOverrides')) {
+        enabledTypes.push(new versions_by_name_1.VersionsByNameStrategy('pnpmOverrides', 'pnpm.overrides'));
+    }
+    if (useDefaults || enabledTypeNames.includes('prod')) {
+        enabledTypes.push(new versions_by_name_1.VersionsByNameStrategy('prod', 'dependencies'));
+    }
+    if (useDefaults || enabledTypeNames.includes('resolutions')) {
+        enabledTypes.push(new versions_by_name_1.VersionsByNameStrategy('resolutions', 'resolutions'));
+    }
+    if (useDefaults || enabledTypeNames.includes('workspace')) {
+        enabledTypes.push(new name_and_version_props_1.NameAndVersionPropsStrategy('workspace', 'version', 'name'));
+    }
+    (0, get_custom_types_1.getCustomTypes)({ cli, rcFile }).forEach((customType) => {
+        if (useDefaults || enabledTypeNames.includes(customType.name)) {
+            enabledTypes.push(customType);
+        }
+    });
+    return enabledTypes;
+}
+exports.getEnabledTypes = getEnabledTypes;

package/dist/config/get-filter.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../get-context';
+export declare function getFilter({ cli, rcFile }: Context['config']): string;

package/dist/config/get-filter.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilter = void 0;
+const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
+function getFilter({ cli, rcFile }) {
+    // @TODO Deprecate `filter` in .syncpackrc
+    return (0, is_non_empty_string_1.isNonEmptyString)(cli.filter)
+        ? cli.filter
+        : (0, is_non_empty_string_1.isNonEmptyString)(rcFile.filter)
+            ? rcFile.filter
+            : '.';
+}
+exports.getFilter = getFilter;

package/dist/config/get-indent.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../get-context';
+export declare function getIndent({ cli, rcFile }: Context['config']): string;

package/dist/config/get-indent.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIndent = void 0;
+const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
+function getIndent({ cli, rcFile }) {
+    return (0, is_non_empty_string_1.isNonEmptyString)(cli.indent)
+        ? cli.indent
+        : (0, is_non_empty_string_1.isNonEmptyString)(rcFile.indent)
+            ? rcFile.indent
+            : '  ';
+}
+exports.getIndent = getIndent;

package/dist/config/get-semver-range.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '../get-context';
+import type { SemverRange } from './types';
+export declare function getSemverRange({ cli, rcFile, }: Context['config']): SemverRange;

package/dist/config/get-semver-range.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSemverRange = void 0;
+const is_semver_1 = require("../lib/is-semver");
+function getSemverRange({ cli, rcFile, }) {
+    return (0, is_semver_1.isValidSemverRange)(cli.semverRange)
+        ? cli.semverRange
+        : (0, is_semver_1.isValidSemverRange)(rcFile.semverRange)
+            ? rcFile.semverRange
+            : '';
+}
+exports.getSemverRange = getSemverRange;

package/dist/config/get-sort-az.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../get-context';
+export declare function getSortAz({ rcFile }: Context['config']): string[];

package/dist/config/get-sort-az.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSortAz = void 0;
+const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
+function getSortAz({ rcFile }) {
+    return (0, is_array_of_strings_1.isArrayOfStrings)(rcFile.sortAz)
+        ? rcFile.sortAz
+        : [
+            'contributors',
+            'dependencies',
+            'devDependencies',
+            'keywords',
+            'peerDependencies',
+            'resolutions',
+            'scripts',
+        ];
+}
+exports.getSortAz = getSortAz;

package/dist/config/get-sort-first.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../get-context';
+export declare function getSortFirst({ rcFile }: Context['config']): string[];

package/dist/config/get-sort-first.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSortFirst = void 0;
+const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
+function getSortFirst({ rcFile }) {
+    return (0, is_array_of_strings_1.isArrayOfStrings)(rcFile.sortFirst)
+        ? rcFile.sortFirst
+        : ['name', 'description', 'version', 'author'];
+}
+exports.getSortFirst = getSortFirst;

package/dist/config/get-source.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../get-context';
+export declare function getSource({ cli, rcFile }: Context['config']): string[];

package/dist/config/get-source.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSource = void 0;
+const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
+const constants_1 = require("../constants");
+function getSource({ cli, rcFile }) {
+    return (0, is_array_of_strings_1.isArrayOfStrings)(cli.source)
+        ? cli.source
+        : (0, is_array_of_strings_1.isArrayOfStrings)(rcFile.source)
+            ? rcFile.source
+            : [...constants_1.DEFAULT_CONFIG.source];
+}
+exports.getSource = getSource;

package/dist/config/types.d.ts

@@ -0,0 +1,106 @@
+import type { Union } from 'ts-toolbelt';
+/**
+ * Aliases for semver range formats supported by syncpack
+ *
+ * Defaults 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` |
+ * | `"*"`           |       `*` |
+ *
+ * @default ""
+ */
+export type SemverRange = '' | '*' | '>' | '>=' | '.x' | '<' | '<=' | '^' | '~';
+export interface GroupConfig {
+    dependencies: string[];
+    dependencyTypes?: string[];
+    label?: string;
+    packages: string[];
+}
+export declare namespace SemverGroupConfig {
+    interface Ignored extends GroupConfig {
+        isIgnored: true;
+    }
+    interface WithRange extends GroupConfig {
+        range: SemverRange;
+    }
+    type Any = Union.Strict<Ignored | WithRange>;
+}
+export declare namespace VersionGroupConfig {
+    interface Banned extends GroupConfig {
+        isBanned: true;
+    }
+    interface Ignored extends GroupConfig {
+        isIgnored: true;
+    }
+    interface Pinned extends GroupConfig {
+        pinVersion: string;
+    }
+    interface SnappedTo extends GroupConfig {
+        snapTo: string[];
+    }
+    interface Standard extends GroupConfig {
+        preferVersion?: 'highestSemver' | 'lowestSemver';
+    }
+    type Any = Union.Strict<Standard | Banned | Ignored | Pinned | SnappedTo>;
+}
+declare namespace CustomTypeConfig {
+    interface NameAndVersionProps {
+        namePath: string;
+        path: string;
+        strategy: 'name~version';
+    }
+    interface NamedVersionString {
+        path: string;
+        strategy: 'name@version';
+    }
+    interface UnnamedVersionString {
+        path: string;
+        strategy: 'version';
+    }
+    interface VersionsByName {
+        path: string;
+        strategy: 'versionsByName';
+    }
+    type Any = Union.Strict<NameAndVersionProps | NamedVersionString | UnnamedVersionString | VersionsByName>;
+}
+export interface CliConfig {
+    configPath?: string;
+    filter: string;
+    indent: string;
+    semverRange: SemverRange;
+    source: string[];
+    types: string;
+}
+export interface RcConfig {
+    /** @see https://jamiemason.github.io/syncpack/config/custom-types */
+    customTypes: Record<string, CustomTypeConfig.Any>;
+    /** @see https://jamiemason.github.io/syncpack/config/dependency-types */
+    dependencyTypes: string[];
+    /** @see https://jamiemason.github.io/syncpack/config/filter */
+    filter: string;
+    /** @see https://jamiemason.github.io/syncpack/config/indent */
+    indent: string;
+    /** @see https://jamiemason.github.io/syncpack/config/semver-groups */
+    semverGroups: SemverGroupConfig.Any[];
+    /** @see https://jamiemason.github.io/syncpack/config/semver-range */
+    semverRange: SemverRange;
+    /** @see https://jamiemason.github.io/syncpack/config/sort-az */
+    sortAz: string[];
+    /** @see https://jamiemason.github.io/syncpack/config/sort-first */
+    sortFirst: string[];
+    /** @see https://jamiemason.github.io/syncpack/config/source */
+    source: string[];
+    /** @see https://jamiemason.github.io/syncpack/config/version-groups */
+    versionGroups: VersionGroupConfig.Any[];
+}
+export {};

package/dist/constants.d.ts

@@ -21,6 +21,7 @@ export declare const RANGE: {
     readonly LTE: "<=";
     readonly MINOR: "^";
     readonly PATCH: "~";
+    readonly WORKSPACE: "workspace:";
 };
 export declare const DEFAULT_CONFIG: {
     readonly dependencyTypes: readonly ["dev", "overrides", "peer", "pnpmOverrides", "prod", "resolutions", "workspace"];

package/dist/constants.js

@@ -24,6 +24,7 @@ exports.RANGE = {
     LTE: '<=',
     MINOR: '^',
     PATCH: '~',
+    WORKSPACE: 'workspace:',
 };
 exports.DEFAULT_CONFIG = {
     dependencyTypes: [

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

@@ -1,22 +1,14 @@
+import type { O } from 'ts-toolbelt';
+import type { CliConfig, RcConfig } from '../config/types';
+import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
 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 interface Context {
-    config: Syncpack.Config.Private;
+    config: {
+        cli: Partial<CliConfig>;
+        rcFile: O.Partial<RcConfig, 'deep'>;
+    };
     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;
+export declare function getContext(cli: Partial<CliConfig>, disk: Disk): Context;