syncpack 9.8.6 → 10.1.0

package/dist/bin-list/list.js

@@ -28,69 +28,73 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.list = void 0;
 const chalk_1 = __importDefault(require("chalk"));
-const pipe_1 = require("tightrope/fn/pipe");
-const unwrap_1 = require("tightrope/option/unwrap");
-const tap_1 = require("tightrope/result/tap");
+const uniq_1 = require("tightrope/array/uniq");
+const is_non_empty_array_1 = require("tightrope/guard/is-non-empty-array");
 const constants_1 = require("../constants");
-const _R_1 = require("../get-context/$R");
+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 list(ctx) {
-    const hasUserGroups = ctx.versionGroups.length > 1;
-    ctx.versionGroups.forEach((versionGroup, i) => {
-        const instanceGroups = versionGroup.getAllInstanceGroups();
-        // Nothing to do if empty
-        if (instanceGroups.length === 0)
-            return;
+    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) => {
         // Annotate each group
         hasUserGroups && log.versionGroupHeader(versionGroup, i);
-        instanceGroups.forEach((instanceGroup) => {
-            // Record that this project has mismatches, so that eg. the CLI can exit
-            // with the correct status code.
-            if (instanceGroup.isInvalid())
+        versionGroup
+            .inspect()
+            .sort(sort_by_name_1.sortByName)
+            .forEach((report) => {
+            // Allow eg. CLI to exit with the correct status code.
+            if (!report.isValid)
                 ctx.isInvalid = true;
-            if (versionGroup.isBanned())
-                return logBanned(instanceGroup);
-            if (versionGroup.isIgnored())
-                return logIgnored(instanceGroup);
-            if (versionGroup.isUnpinned())
-                return logUnpinned(instanceGroup);
-            if (instanceGroup.hasMismatchingVersions()) {
-                return instanceGroup.hasUnsupportedVersion()
-                    ? logUnsupportedMismatches(instanceGroup)
-                    : logVersionMismatch(instanceGroup);
+            switch (report.status) {
+                case 'HIGHEST_SEMVER_MISMATCH':
+                case 'LOWEST_SEMVER_MISMATCH':
+                case 'PINNED_MISMATCH':
+                case 'SNAPPED_TO_MISMATCH':
+                case 'WORKSPACE_MISMATCH': {
+                    console.log((0, chalk_1.default) `{red %s %s} %s`, constants_1.ICON.cross, report.name, listColouredVersions(report.expectedVersion, report.instances));
+                    break;
+                }
+                case 'BANNED': {
+                    console.log((0, chalk_1.default) `{red %s %s} {dim.red is banned in this version group}`, constants_1.ICON.cross, report.name);
+                    break;
+                }
+                // ignored completely
+                case 'FILTERED_OUT':
+                    break;
+                case 'IGNORED': {
+                    console.log((0, chalk_1.default) `{dim -} {dim %s} {white is ignored in this version group}`, report.name);
+                    break;
+                }
+                case 'VALID': {
+                    console.log((0, chalk_1.default) `{dim -} {white %s} {dim %s}`, report.name, report.instances?.[0]?.version);
+                    break;
+                }
+                case 'UNSUPPORTED_MISMATCH': {
+                    console.log((0, chalk_1.default) `{red %s %s} %s`, constants_1.ICON.cross, report.name, report.instances
+                        .map((instance) => chalk_1.default.red(instance.version))
+                        .join(chalk_1.default.dim(', ')));
+                    break;
+                }
+                // @TODO case 'SEMVER_UNSATISFIED': break;
+                // @TODO case 'WORKSPACE_UNSATISFIED': break;
+            }
+            function listColouredVersions(pinVersion, instances) {
+                return getAllVersions(pinVersion, instances)
+                    .map((version) => withColour(pinVersion, version))
+                    .join(chalk_1.default.dim(', '));
+            }
+            function withColour(pinVersion, version) {
+                return version === pinVersion
+                    ? chalk_1.default.green(version)
+                    : chalk_1.default.red(version);
+            }
+            function getAllVersions(pinVersion, instances) {
+                return (0, uniq_1.uniq)([pinVersion].concat(instances.map((i) => i.version)));
             }
-            logVersionMatch(instanceGroup);
         });
     });
     return ctx;
-    function logVersionMatch(instanceGroup) {
-        console.log((0, chalk_1.default) `{dim -} {white ${instanceGroup.name}} {dim ${instanceGroup.getUniqueVersions()}}`);
-    }
-    function logVersionMismatch(instanceGroup) {
-        (0, pipe_1.pipe)(instanceGroup.getExpectedVersion(), (0, tap_1.tap)((expectedVersion) => {
-            const uniqueVersions = instanceGroup.getUniqueVersions();
-            console.log((0, chalk_1.default) `{red ${constants_1.ICON.cross} ${instanceGroup.name}} ${uniqueVersions
-                .map((version) => version === expectedVersion
-                ? chalk_1.default.green(version)
-                : chalk_1.default.red(version))
-                .join(chalk_1.default.dim(', '))}`);
-        }), _R_1.$R.tapErrVerbose);
-    }
-    function logIgnored(instanceGroup) {
-        console.log((0, chalk_1.default) `{dim ${constants_1.ICON.skip} ${instanceGroup.name}} is ignored in this version group`);
-    }
-    function logBanned(instanceGroup) {
-        console.log((0, chalk_1.default) `{red ${constants_1.ICON.cross} ${instanceGroup.name}} {dim.red is banned in this version group}`);
-    }
-    function logUnpinned(instanceGroup) {
-        const pinVersion = (0, unwrap_1.unwrap)(instanceGroup.versionGroup.getPinnedVersion());
-        console.log((0, chalk_1.default) `{red ${constants_1.ICON.cross} ${instanceGroup.name}} {dim.red is pinned to ${pinVersion} in this version group}`);
-    }
-    function logUnsupportedMismatches(instanceGroup) {
-        console.log((0, chalk_1.default) `{red ${constants_1.ICON.cross} ${instanceGroup.name}} {dim.red has mismatched versions which syncpack cannot fix: ${instanceGroup
-            .getUniqueVersions()
-            .map((version) => chalk_1.default.yellow(version))
-            .join(chalk_1.default.dim(', '))}}`);
-    }
 }
 exports.list = list;

package/dist/bin-list-mismatches/list-mismatches-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 listMismatchesCli(input: Partial<Syncpack.Config.Cli>, disk: Disk): void;
+export declare function listMismatchesCli(input: Partial<CliConfig>, disk: Disk): void;

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

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listMismatchesCli = void 0;
+const pipe_1 = require("tightrope/fn/pipe");
 const get_context_1 = require("../get-context");
 const exit_if_invalid_1 = require("../lib/exit-if-invalid");
 const list_mismatches_1 = require("./list-mismatches");
 function listMismatchesCli(input, disk) {
-    (0, exit_if_invalid_1.exitIfInvalid)((0, list_mismatches_1.listMismatches)((0, get_context_1.getContext)(input, disk)));
+    (0, pipe_1.pipe)((0, get_context_1.getContext)(input, disk), list_mismatches_1.listMismatches, exit_if_invalid_1.exitIfInvalid);
 }
 exports.listMismatchesCli = listMismatchesCli;

package/dist/bin-list-mismatches/list-mismatches.d.ts

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

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

@@ -28,117 +28,83 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listMismatches = void 0;
 const chalk_1 = __importDefault(require("chalk"));
-const unwrap_1 = require("tightrope/option/unwrap");
-const unwrap_2 = require("tightrope/result/unwrap");
+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 = (0, unwrap_1.unwrap)(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 = (0, unwrap_2.unwrap)(instanceGroup.getSnappedVersion());
-        const snappedToPackages = (0, unwrap_1.unwrap)(versionGroup.getSnappedToPackages()).join(' || ');
-        const version = (0, unwrap_2.unwrap)(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 = (0, unwrap_2.unwrap)(instanceGroup.getWorkspaceInstance());
-        const shortPath = workspaceInstance?.packageJsonFile.shortPath;
-        const expected = (0, unwrap_2.unwrap)(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 = (0, unwrap_2.unwrap)(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/bin.js

@@ -9,6 +9,9 @@ commander_1.program
 })
     .command('format', 'sort and shorten properties according to a convention', {
     executableFile: './bin-format/index.js',
+})
+    .command('lint', 'lint all versions and ranges', {
+    executableFile: './bin-lint/index.js',
 })
     .command('lint-semver-ranges', 'check dependency versions comply with the given semver range format', {
     executableFile: './bin-lint-semver-ranges/index.js',

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[];