syncpack 10.6.1 → 10.7.2

package/README.md

@@ -45,17 +45,20 @@ List all dependencies required by your packages.
 List dependencies which are required by multiple packages, where the version is not the same across
 every package.
 
+### [prompt](https://jamiemason.github.io/syncpack/prompt)
+
+Displays a series of prompts to fix mismatches which syncpack cannot fix automatically.
+
 ### [set-semver-ranges](https://jamiemason.github.io/syncpack/set-semver-ranges)
 
 Ensure dependency versions used within `"dependencies"`, `"devDependencies"` etc follow a consistent
 format.
 
-## Breaking Changes
+### [update](https://jamiemason.github.io/syncpack/update)
 
-Version [9.0.0](https://github.com/JamieMason/syncpack/releases/tag/9.0.0) required some breaking
-API changes to add support for a new
-[`customTypes`](https://jamiemason.github.io/syncpack/config/custom-types) feature, but they are
-very simple to make.
+Interactively update packages to the latest versions from the npm registry, wherever they are in
+your monorepo. You can update every dependency, just dev/peer/prod dependencies, just packages which
+match a name filter, and more.
 
 ## Badges
 

package/dist/bin-fix-mismatches/effects.d.ts

@@ -1,2 +1,2 @@
 import type { VersionEffects } from '../create-program/effects';
-export declare const fixMismatchesEffects: VersionEffects;
+export declare const fixMismatchesEffects: VersionEffects<void>;

package/dist/bin-fix-mismatches/effects.js

@@ -37,40 +37,40 @@ const constants_1 = require("../constants");
 const delete_1 = require("../get-version-groups/lib/delete");
 const log_group_header_1 = require("../lib/log-group-header");
 exports.fixMismatchesEffects = {
-    FilteredOut() {
+    onFilteredOut() {
         return Effect.unit();
     },
-    Ignored() {
+    onIgnored() {
         return Effect.unit();
     },
-    Valid() {
+    onValid() {
         return Effect.unit();
     },
-    Banned: (input) => {
+    onBanned(input) {
         return Effect.sync(() => removeVersions(input));
     },
-    HighestSemverMismatch: (input) => {
+    onHighestSemverMismatch(input) {
         return Effect.sync(() => setVersions(input));
     },
-    LowestSemverMismatch: (input) => {
+    onLowestSemverMismatch(input) {
         return Effect.sync(() => setVersions(input));
     },
-    PinnedMismatch: (input) => {
+    onPinnedMismatch(input) {
         return Effect.sync(() => setVersions(input));
     },
-    SameRangeMismatch: (input) => {
+    onSameRangeMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logSameRangeMismatch));
     },
-    SnappedToMismatch: (input) => {
+    onSnappedToMismatch(input) {
         return Effect.sync(() => setVersions(input));
     },
-    UnsupportedMismatch: (input) => {
+    onUnsupportedMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logUnsupportedMismatch));
     },
-    WorkspaceMismatch: (input) => {
+    onWorkspaceMismatch(input) {
         return Effect.sync(() => setVersions(input));
     },
-    TearDown(ctx) {
+    onComplete(ctx) {
         return Effect.sync(() => deleteEmptyObjects(ctx));
     },
 };

package/dist/bin-lint-semver-ranges/effects.d.ts

@@ -1,2 +1,2 @@
 import type { SemverRangeEffects } from '../create-program/effects';
-export declare const lintSemverRangesEffects: SemverRangeEffects;
+export declare const lintSemverRangesEffects: SemverRangeEffects<void>;

package/dist/bin-lint-semver-ranges/effects.js

@@ -33,25 +33,25 @@ const chalk_1 = __importDefault(require("chalk"));
 const constants_1 = require("../constants");
 const log_group_header_1 = require("../lib/log-group-header");
 exports.lintSemverRangesEffects = {
-    FilteredOut() {
+    onFilteredOut() {
         return Effect.unit();
     },
-    Ignored() {
+    onIgnored() {
         return Effect.unit();
     },
-    Valid() {
+    onValid() {
         return Effect.unit();
     },
-    SemverRangeMismatch(input) {
+    onSemverRangeMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logRangeMismatch));
     },
-    UnsupportedVersion(input) {
+    onUnsupportedVersion(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logUnsupportedVersion));
     },
-    WorkspaceSemverRangeMismatch(input) {
+    onWorkspaceSemverRangeMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logRangeMismatch));
     },
-    TearDown() {
+    onComplete() {
         return Effect.unit();
     },
 };

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

@@ -1,2 +1,2 @@
 import type { VersionEffects } from '../create-program/effects';
-export declare const listEffects: VersionEffects;
+export declare const listEffects: VersionEffects<void>;

package/dist/bin-list/effects.js

@@ -36,40 +36,40 @@ const get_unique_versions_1 = require("../get-version-groups/lib/get-unique-vers
 const is_supported_1 = require("../guards/is-supported");
 const log_group_header_1 = require("../lib/log-group-header");
 exports.listEffects = {
-    FilteredOut() {
+    onFilteredOut() {
         return Effect.unit();
     },
-    Ignored(input) {
+    onIgnored(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logIgnored));
     },
-    Valid(input) {
+    onValid(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logValid));
     },
-    Banned(input) {
+    onBanned(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logBanned));
     },
-    HighestSemverMismatch(input) {
+    onHighestSemverMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logFixableMismatch));
     },
-    LowestSemverMismatch(input) {
+    onLowestSemverMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logFixableMismatch));
     },
-    PinnedMismatch(input) {
+    onPinnedMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logFixableMismatch));
     },
-    SameRangeMismatch(input) {
+    onSameRangeMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logUnfixableMismatch));
     },
-    SnappedToMismatch(input) {
+    onSnappedToMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logFixableMismatch));
     },
-    UnsupportedMismatch(input) {
+    onUnsupportedMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logUnfixableMismatch));
     },
-    WorkspaceMismatch(input) {
+    onWorkspaceMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logFixableMismatch));
     },
-    TearDown() {
+    onComplete() {
         return Effect.unit();
     },
 };

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

@@ -1,2 +1,2 @@
 import type { VersionEffects } from '../create-program/effects';
-export declare const listMismatchesEffects: VersionEffects;
+export declare const listMismatchesEffects: VersionEffects<void>;

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

@@ -34,40 +34,40 @@ const os_1 = require("os");
 const constants_1 = require("../constants");
 const log_group_header_1 = require("../lib/log-group-header");
 exports.listMismatchesEffects = {
-    FilteredOut() {
+    onFilteredOut() {
         return Effect.unit();
     },
-    Ignored() {
+    onIgnored() {
         return Effect.unit();
     },
-    Valid() {
+    onValid() {
         return Effect.unit();
     },
-    Banned(input) {
+    onBanned(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logBanned));
     },
-    HighestSemverMismatch(input) {
+    onHighestSemverMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logHighLowSemverMismatch));
     },
-    LowestSemverMismatch(input) {
+    onLowestSemverMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logHighLowSemverMismatch));
     },
-    PinnedMismatch(input) {
+    onPinnedMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logPinnedMismatch));
     },
-    SameRangeMismatch(input) {
+    onSameRangeMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logSameRangeMismatch));
     },
-    SnappedToMismatch(input) {
+    onSnappedToMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logSnappedToMismatch));
     },
-    UnsupportedMismatch(input) {
+    onUnsupportedMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logUnsupportedMismatch));
     },
-    WorkspaceMismatch(input) {
+    onWorkspaceMismatch(input) {
         return Effect.sync(() => (0, Function_1.pipe)(input, logHeader, logWorkspaceMismatch));
     },
-    TearDown() {
+    onComplete() {
         return Effect.unit();
     },
 };

package/dist/bin-prompt/effects.d.ts

@@ -1,2 +1,2 @@
 import type { VersionEffects } from '../create-program/effects';
-export declare const promptEffects: VersionEffects;
+export declare const promptEffects: VersionEffects<void>;

package/dist/bin-prompt/effects.js

@@ -35,40 +35,40 @@ const tags_1 = require("../env/tags");
 const get_unique_versions_1 = require("../get-version-groups/lib/get-unique-versions");
 const log_group_header_1 = require("../lib/log-group-header");
 exports.promptEffects = {
-    FilteredOut() {
+    onFilteredOut() {
         return Effect.unit();
     },
-    Ignored() {
+    onIgnored() {
         return Effect.unit();
     },
-    Valid() {
+    onValid() {
         return Effect.unit();
     },
-    Banned() {
+    onBanned() {
         return Effect.unit();
     },
-    HighestSemverMismatch() {
+    onHighestSemverMismatch() {
         return Effect.unit();
     },
-    LowestSemverMismatch() {
+    onLowestSemverMismatch() {
         return Effect.unit();
     },
-    PinnedMismatch() {
+    onPinnedMismatch() {
         return Effect.unit();
     },
-    SameRangeMismatch(input) {
+    onSameRangeMismatch(input) {
         return (0, Function_1.pipe)(Effect.sync(() => logHeader(input)), Effect.flatMap(askForNextVersion));
     },
-    SnappedToMismatch() {
+    onSnappedToMismatch() {
         return Effect.unit();
     },
-    UnsupportedMismatch(input) {
+    onUnsupportedMismatch(input) {
         return (0, Function_1.pipe)(Effect.sync(() => logHeader(input)), Effect.flatMap(askForNextVersion));
     },
-    WorkspaceMismatch() {
+    onWorkspaceMismatch() {
         return Effect.unit();
     },
-    TearDown() {
+    onComplete() {
         return Effect.unit();
     },
 };

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

@@ -1,2 +1,2 @@
 import type { SemverRangeEffects } from '../create-program/effects';
-export declare const setSemverRangesEffects: SemverRangeEffects;
+export declare const setSemverRangesEffects: SemverRangeEffects<void>;

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

@@ -31,25 +31,25 @@ const Effect = __importStar(require("@effect/io/Effect"));
 const chalk_1 = __importDefault(require("chalk"));
 const constants_1 = require("../constants");
 exports.setSemverRangesEffects = {
-    FilteredOut() {
+    onFilteredOut() {
         return Effect.unit();
     },
-    Ignored() {
+    onIgnored() {
         return Effect.unit();
     },
-    Valid() {
+    onValid() {
         return Effect.unit();
     },
-    SemverRangeMismatch(input) {
+    onSemverRangeMismatch(input) {
         return Effect.sync(() => setVersions(input));
     },
-    UnsupportedVersion(input) {
+    onUnsupportedVersion(input) {
         return Effect.sync(() => logUnsupportedVersion(input));
     },
-    WorkspaceSemverRangeMismatch(input) {
+    onWorkspaceSemverRangeMismatch(input) {
         return Effect.sync(() => setVersions(input));
     },
-    TearDown() {
+    onComplete() {
         return Effect.unit();
     },
 };

package/dist/bin-update/effects.d.ts

@@ -0,0 +1,11 @@
+import type { VersionEffectInput as Input, VersionEffects } from '../create-program/effects';
+import type { VersionGroupReport } from '../get-version-groups';
+interface InputWithVersions {
+    input: Input<VersionGroupReport.Any>;
+    versions: {
+        all: string[];
+        latest: string;
+    };
+}
+export declare const updateEffects: VersionEffects<InputWithVersions | void>;
+export {};

package/dist/bin-update/effects.js

@@ -0,0 +1,187 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateEffects = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Function_1 = require("@effect/data/Function");
+const Effect = __importStar(require("@effect/io/Effect"));
+const Schema = __importStar(require("@effect/schema/Schema"));
+const chalk_1 = __importDefault(require("chalk"));
+const https_1 = __importDefault(require("https"));
+const ora_1 = __importDefault(require("ora"));
+const prompts_1 = __importDefault(require("prompts"));
+const unwrap_1 = require("tightrope/result/unwrap");
+const constants_1 = require("../constants");
+const get_highest_version_1 = require("../get-version-groups/lib/get-highest-version");
+const get_unique_versions_1 = require("../get-version-groups/lib/get-unique-versions");
+const log_verbose_1 = require("../lib/log-verbose");
+const set_semver_range_1 = require("../lib/set-semver-range");
+let spinner;
+let fetchCount = 0;
+exports.updateEffects = {
+    onFilteredOut() {
+        return Effect.unit();
+    },
+    onIgnored() {
+        return Effect.unit();
+    },
+    onValid(input) {
+        return fetchPackageVersions(input);
+    },
+    onBanned() {
+        return Effect.unit();
+    },
+    onHighestSemverMismatch(input) {
+        return fetchPackageVersions(input);
+    },
+    onLowestSemverMismatch() {
+        return Effect.unit();
+    },
+    onPinnedMismatch() {
+        return Effect.unit();
+    },
+    onSameRangeMismatch(input) {
+        return fetchPackageVersions(input);
+    },
+    onSnappedToMismatch() {
+        return Effect.unit();
+    },
+    onUnsupportedMismatch() {
+        return Effect.unit();
+    },
+    onWorkspaceMismatch() {
+        return Effect.unit();
+    },
+    onComplete(ctx, results) {
+        return promptForUpdates(results);
+    },
+};
+const safeGetVersion = Schema.parseEither(Schema.struct({
+    'dist-tags': Schema.struct({ latest: Schema.string }),
+    'time': Schema.record(Schema.string, Schema.string),
+}));
+class HttpError extends Data.TaggedClass('HttpError') {
+}
+class JsonParseError extends Data.TaggedClass('JsonParseError') {
+}
+function fetchPackageVersions(input) {
+    if (!spinner)
+        spinner = (0, ora_1.default)().start();
+    fetchCount++;
+    spinner.text = chalk_1.default.blue(`Checked updates for ${fetchCount} dependencies`);
+    return (0, Function_1.pipe)(fetchUrl(`https://registry.npmjs.org/${input.report.name}`), Effect.flatMap(safeGetVersion), Effect.map((struct) => ({
+        input,
+        versions: {
+            all: Object.keys(struct.time).filter((key) => key !== 'modified' && key !== 'created'),
+            latest: struct['dist-tags'].latest,
+        },
+    })), Effect.catchTags({
+        HttpError(err) {
+            return Effect.sync(() => {
+                (0, log_verbose_1.logVerbose)(`HttpError for "${input.report.name}" ${err}`);
+            });
+        },
+        JsonParseError(err) {
+            return Effect.sync(() => {
+                (0, log_verbose_1.logVerbose)(`JsonParseError for "${input.report.name}" ${err}`);
+            });
+        },
+        ParseError(err) {
+            return Effect.sync(() => {
+                (0, log_verbose_1.logVerbose)(`ParseError for "${input.report.name}" ${err}`);
+            });
+        },
+    }));
+}
+function promptForUpdates(results) {
+    spinner.stop();
+    return (0, Function_1.pipe)(Effect.Do(), Effect.bind('choices', () => Effect.sync(() => results.reduce((arr, result) => {
+        if (!result)
+            return arr;
+        if (!['SameRange', 'Standard'].includes(result.input.group._tag))
+            return arr;
+        const input = result.input;
+        const latestVersion = result.versions.latest;
+        const uniqueVersions = (0, get_unique_versions_1.getUniqueVersions)(input.report.instances);
+        const highestVersion = (0, unwrap_1.unwrap)((0, get_highest_version_1.getHighestVersion)(uniqueVersions));
+        const exactHighestVersion = (0, set_semver_range_1.setSemverRange)('', highestVersion);
+        if (exactHighestVersion === latestVersion)
+            return arr;
+        const semverRange = (0, set_semver_range_1.getSemverRange)(highestVersion);
+        const latestWithRange = (0, set_semver_range_1.setSemverRange)(semverRange, latestVersion);
+        arr.push({
+            result,
+            selected: true,
+            title: (0, chalk_1.default) `NAME {red OLD} ARROW {green NEW}`
+                .replace('NAME', input.report.name)
+                .replace('OLD', uniqueVersions.join(chalk_1.default.dim(', ')))
+                .replace('ARROW', constants_1.ICON.rightArrow)
+                .replace('NEW', latestWithRange),
+        });
+        return arr;
+    }, []))), Effect.bind('chosenUpdates', ({ choices }) => Effect.tryCatchPromise(() => (0, prompts_1.default)([
+        {
+            name: 'indexes',
+            type: 'multiselect',
+            message: 'Choose which packages to upgrade',
+            instructions: true,
+            // @ts-expect-error optionsPerPage *does* exist https://github.com/terkelg/prompts#options-7
+            optionsPerPage: 50,
+            choices: choices,
+        },
+    ])
+        .then(({ indexes = [] }) => ({ choices, indexes }))
+        .then(({ choices, indexes }) => indexes.map((i) => choices[i].result)), () => new Error('Prompt failed'))), Effect.flatMap(({ chosenUpdates }) => Effect.sync(() => {
+        chosenUpdates.forEach(({ input, versions }) => {
+            input.report.instances.forEach((instance) => {
+                const semverRange = (0, set_semver_range_1.getSemverRange)(instance.version);
+                const latestWithRange = (0, set_semver_range_1.setSemverRange)(semverRange, versions.latest);
+                instance.setVersion(latestWithRange);
+            });
+        });
+    })), Effect.catchAll(() => Effect.unit()));
+}
+// @TODO: add a cache with a short TTL on disk in $TMPDIR
+function fetchUrl(url) {
+    return (0, Function_1.pipe)(Effect.async((resume) => {
+        https_1.default
+            .get(url, (res) => {
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => {
+                body = `${body}${chunk}`;
+            });
+            res.on('end', () => {
+                resume(Effect.succeed(body));
+            });
+        })
+            .on('error', (err) => {
+            resume(Effect.fail(new HttpError({ error: String(err) })));
+        });
+    }), Effect.flatMap((body) => Effect.tryCatch(() => JSON.parse(body), (err) => new JsonParseError({ error: String(err) }))));
+}

package/dist/bin-update/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin-update/index.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Effect = __importStar(require("@effect/io/Effect"));
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const default_env_1 = require("../env/default-env");
+const show_help_on_error_1 = require("../lib/show-help-on-error");
+const option_1 = require("../option");
+const update_1 = require("./update");
+commander_1.program.description('  Update to the latest versions on the npm registry.');
+commander_1.program.on('--help', () => {
+    console.log((0, chalk_1.default) `
+Examples:
+  {dim # uses defaults for resolving packages}
+  syncpack update
+  {dim # uses packages defined by --source when provided}
+  syncpack update --source {yellow "apps/*/package.json"}
+  {dim # multiple globs can be provided like this}
+  syncpack update --source {yellow "apps/*/package.json"} --source {yellow "core/*/package.json"}
+  {dim # uses dependencies regular expression defined by --filter when provided}
+  syncpack update --filter {yellow "typescript|tslint"}
+  {dim # only inspect "devDependencies"}
+  syncpack update --types dev
+  {dim # only inspect "devDependencies" and "peerDependencies"}
+  syncpack update --types dev,peer
+
+Resolving Packages:
+  1. If {yellow --source} globs are provided, use those.
+  2. If using Pnpm Workspaces, read {yellow packages} from {yellow pnpm-workspace.yaml} in the root of the project.
+  3. If using Yarn Workspaces, read {yellow workspaces} from {yellow package.json}.
+  4. If using Lerna, read {yellow packages} from {yellow lerna.json}.
+  5. Default to {yellow "package.json"} and {yellow "packages/*/package.json"}.
+
+Reference:
+  globs            {blue.underline https://github.com/isaacs/node-glob#glob-primer}
+  lerna.json       {blue.underline https://github.com/lerna/lerna#lernajson}
+  Yarn Workspaces  {blue.underline https://yarnpkg.com/lang/en/docs/workspaces}
+  Pnpm Workspaces  {blue.underline https://pnpm.js.org/en/workspaces}
+`);
+});
+(0, show_help_on_error_1.showHelpOnError)(commander_1.program);
+commander_1.program
+    .option(...option_1.option.source)
+    .option(...option_1.option.filter)
+    .option(...option_1.option.config)
+    .option(...option_1.option.types)
+    .parse(process.argv);
+Effect.runPromise((0, update_1.update)({
+    configPath: commander_1.program.opts().config,
+    filter: commander_1.program.opts().filter,
+    source: commander_1.program.opts().source,
+    types: commander_1.program.opts().types,
+}, default_env_1.defaultEnv));

package/dist/bin-update/update.d.ts

@@ -0,0 +1,4 @@
+import * as Effect from '@effect/io/Effect';
+import { type CliConfig } from '../config/types';
+import type { DefaultEnv } from '../env/default-env';
+export declare function update(cli: Partial<CliConfig>, env: DefaultEnv): Effect.Effect<never, never, void | import("../get-context").Ctx>;

package/dist/bin-update/update.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = void 0;
+const Context = __importStar(require("@effect/data/Context"));
+const Function_1 = require("@effect/data/Function");
+const Effect = __importStar(require("@effect/io/Effect"));
+// import { setSemverRangesEffects } from '../bin-set-semver-ranges/effects';
+const types_1 = require("../config/types");
+// import { createSemverRangesProgram } from '../create-program/semver-ranges';
+const versions_1 = require("../create-program/versions");
+const create_env_1 = require("../env/create-env");
+const exit_if_invalid_1 = require("../env/exit-if-invalid");
+const tags_1 = require("../env/tags");
+const write_if_changed_1 = require("../env/write-if-changed");
+const create_error_handlers_1 = require("../error-handlers/create-error-handlers");
+const default_error_handlers_1 = require("../error-handlers/default-error-handlers");
+const get_context_1 = require("../get-context");
+const effects_1 = require("./effects");
+function update(cli, env) {
+    return (0, Function_1.pipe)((0, get_context_1.getContext)(), Effect.flatMap((ctx) => (0, versions_1.createVersionsProgram)(ctx, effects_1.updateEffects)), 
+    // Effect.flatMap((ctx) => createSemverRangesProgram(ctx, setSemverRangesEffects)),
+    Effect.flatMap(write_if_changed_1.writeIfChanged), Effect.flatMap(exit_if_invalid_1.exitIfInvalid), Effect.catchTags((0, create_error_handlers_1.createErrorHandlers)(default_error_handlers_1.defaultErrorHandlers)), Effect.withParallelism(10), Effect.provideContext((0, Function_1.pipe)(Context.empty(), Context.add(types_1.CliConfigTag, cli), Context.add(tags_1.EnvTag, (0, create_env_1.createEnv)(env)))));
+}
+exports.update = update;

package/dist/bin.js

@@ -28,5 +28,8 @@ commander_1.program
 })
     .command('set-semver-ranges', 'set semver ranges to the given format', {
     executableFile: './bin-set-semver-ranges/index.js',
+})
+    .command('update', 'update to the latest versions on the npm registry', {
+    executableFile: './bin-update/index.js',
 })
     .parse(process.argv);

package/dist/create-program/effects.d.ts

@@ -3,7 +3,6 @@ import type { Env } from '../env/create-env';
 import type { Ctx } from '../get-context';
 import type { AnySemverGroup, SemverGroupReport as SR } from '../get-semver-groups';
 import type { AnyVersionGroup, VersionGroupReport as VR } from '../get-version-groups';
-type R = Effect.Effect<Env | never, never, void>;
 export interface SemverRangeEffectInput<T> {
     ctx: Ctx;
     group: AnySemverGroup;
@@ -16,27 +15,26 @@ export interface VersionEffectInput<T> {
     index: number;
     report: T;
 }
-export interface SemverRangeEffects {
-    FilteredOut: (input: SemverRangeEffectInput<SR.FilteredOut>) => R;
-    Ignored: (input: SemverRangeEffectInput<SR.Ignored>) => R;
-    SemverRangeMismatch: (input: SemverRangeEffectInput<SR.SemverRangeMismatch>) => R;
-    UnsupportedVersion: (input: SemverRangeEffectInput<SR.UnsupportedVersion>) => R;
-    Valid: (input: SemverRangeEffectInput<SR.Valid>) => R;
-    WorkspaceSemverRangeMismatch: (input: SemverRangeEffectInput<SR.WorkspaceSemverRangeMismatch>) => R;
-    TearDown: (ctx: Ctx) => R;
+export interface SemverRangeEffects<A> {
+    onFilteredOut: (input: SemverRangeEffectInput<SR.FilteredOut>) => Effect.Effect<Env | never, never, A>;
+    onIgnored: (input: SemverRangeEffectInput<SR.Ignored>) => Effect.Effect<Env | never, never, A>;
+    onSemverRangeMismatch: (input: SemverRangeEffectInput<SR.SemverRangeMismatch>) => Effect.Effect<Env | never, never, A>;
+    onUnsupportedVersion: (input: SemverRangeEffectInput<SR.UnsupportedVersion>) => Effect.Effect<Env | never, never, A>;
+    onValid: (input: SemverRangeEffectInput<SR.Valid>) => Effect.Effect<Env | never, never, A>;
+    onWorkspaceSemverRangeMismatch: (input: SemverRangeEffectInput<SR.WorkspaceSemverRangeMismatch>) => Effect.Effect<Env | never, never, A>;
+    onComplete: (ctx: Ctx, results: A[]) => Effect.Effect<Env | never, never, A>;
 }
-export interface VersionEffects {
-    Banned: (input: VersionEffectInput<VR.Banned>) => R;
-    FilteredOut: (input: VersionEffectInput<VR.FilteredOut>) => R;
-    HighestSemverMismatch: (input: VersionEffectInput<VR.HighestSemverMismatch>) => R;
-    Ignored: (input: VersionEffectInput<VR.Ignored>) => R;
-    LowestSemverMismatch: (input: VersionEffectInput<VR.LowestSemverMismatch>) => R;
-    PinnedMismatch: (input: VersionEffectInput<VR.PinnedMismatch>) => R;
-    SameRangeMismatch: (input: VersionEffectInput<VR.SameRangeMismatch>) => R;
-    SnappedToMismatch: (input: VersionEffectInput<VR.SnappedToMismatch>) => R;
-    UnsupportedMismatch: (input: VersionEffectInput<VR.UnsupportedMismatch>) => R;
-    Valid: (input: VersionEffectInput<VR.Valid>) => R;
-    WorkspaceMismatch: (input: VersionEffectInput<VR.WorkspaceMismatch>) => R;
-    TearDown: (ctx: Ctx) => R;
+export interface VersionEffects<A> {
+    onBanned: (input: VersionEffectInput<VR.Banned>) => Effect.Effect<Env | never, never, A>;
+    onFilteredOut: (input: VersionEffectInput<VR.FilteredOut>) => Effect.Effect<Env | never, never, A>;
+    onHighestSemverMismatch: (input: VersionEffectInput<VR.HighestSemverMismatch>) => Effect.Effect<Env | never, never, A>;
+    onIgnored: (input: VersionEffectInput<VR.Ignored>) => Effect.Effect<Env | never, never, A>;
+    onLowestSemverMismatch: (input: VersionEffectInput<VR.LowestSemverMismatch>) => Effect.Effect<Env | never, never, A>;
+    onPinnedMismatch: (input: VersionEffectInput<VR.PinnedMismatch>) => Effect.Effect<Env | never, never, A>;
+    onSameRangeMismatch: (input: VersionEffectInput<VR.SameRangeMismatch>) => Effect.Effect<Env | never, never, A>;
+    onSnappedToMismatch: (input: VersionEffectInput<VR.SnappedToMismatch>) => Effect.Effect<Env | never, never, A>;
+    onUnsupportedMismatch: (input: VersionEffectInput<VR.UnsupportedMismatch>) => Effect.Effect<Env | never, never, A>;
+    onValid: (input: VersionEffectInput<VR.Valid>) => Effect.Effect<Env | never, never, A>;
+    onWorkspaceMismatch: (input: VersionEffectInput<VR.WorkspaceMismatch>) => Effect.Effect<Env | never, never, A>;
+    onComplete: (ctx: Ctx, results: A[]) => Effect.Effect<Env | never, never, A>;
 }
-export {};

package/dist/create-program/semver-ranges.d.ts

@@ -4,4 +4,4 @@ import type { Env } from '../env/create-env';
 import type { Ctx } from '../get-context';
 import type { SemverGroupConfigError } from '../get-semver-groups';
 import type { SemverRangeEffects } from './effects';
-export declare function createSemverRangesProgram(ctx: Ctx, effects: SemverRangeEffects): Effect.Effect<Env, SemverGroupConfigError | DeprecatedTypesError, Ctx>;
+export declare function createSemverRangesProgram<T extends SemverRangeEffects<any>>(ctx: Ctx, effects: T): Effect.Effect<Env, SemverGroupConfigError | DeprecatedTypesError, Ctx>;

package/dist/create-program/semver-ranges.js

@@ -30,14 +30,26 @@ const Effect = __importStar(require("@effect/io/Effect"));
 const Match = __importStar(require("@effect/match"));
 const get_semver_groups_1 = require("../get-semver-groups");
 function createSemverRangesProgram(ctx, effects) {
-    return (0, Function_1.pipe)((0, get_semver_groups_1.getSemverGroups)(ctx), Effect.flatMap((semverGroups) => Effect.all(semverGroups.map((group) => Effect.all(group.inspect().map((reportEffect, index) => (0, Function_1.pipe)((0, Unify_1.unify)(reportEffect), Effect.flatMap((0, Function_1.pipe)(Match.type(), Match.tagsExhaustive({
-        FilteredOut: (report) => (0, Function_1.pipe)(effects.FilteredOut({ ctx, group, index, report }), Effect.map(() => report)),
-        Ignored: (report) => (0, Function_1.pipe)(effects.Ignored({ ctx, group, index, report }), Effect.map(() => report)),
-        Valid: (report) => (0, Function_1.pipe)(effects.Valid({ ctx, group, index, report }), Effect.map(() => report)),
+    return (0, Function_1.pipe)((0, get_semver_groups_1.getSemverGroups)(ctx), Effect.flatMap((semverGroups) => Effect.allPar(semverGroups.flatMap((group) => group.inspect().map((reportEffect, index) => (0, Function_1.pipe)((0, Unify_1.unify)(reportEffect), Effect.flatMap((0, Function_1.pipe)(Match.type(), Match.tagsExhaustive({
+        FilteredOut(report) {
+            return effects.onFilteredOut({ ctx, group, index, report });
+        },
+        Ignored(report) {
+            return effects.onIgnored({ ctx, group, index, report });
+        },
+        Valid(report) {
+            return effects.onValid({ ctx, group, index, report });
+        },
     }))), Effect.catchTags({
-        SemverRangeMismatch: (report) => (0, Function_1.pipe)(effects.SemverRangeMismatch({ ctx, group, index, report }), Effect.map(() => report)),
-        UnsupportedVersion: (report) => (0, Function_1.pipe)(effects.UnsupportedVersion({ ctx, group, index, report }), Effect.map(() => report)),
-        WorkspaceSemverRangeMismatch: (report) => (0, Function_1.pipe)(effects.WorkspaceSemverRangeMismatch({ ctx, group, index, report }), Effect.map(() => report)),
-    }))))))), Effect.flatMap(() => effects.TearDown(ctx)), Effect.map(() => ctx));
+        SemverRangeMismatch(report) {
+            return effects.onSemverRangeMismatch({ ctx, group, index, report });
+        },
+        UnsupportedVersion(report) {
+            return effects.onUnsupportedVersion({ ctx, group, index, report });
+        },
+        WorkspaceSemverRangeMismatch(report) {
+            return effects.onWorkspaceSemverRangeMismatch({ ctx, group, index, report });
+        },
+    })))))), Effect.flatMap((results) => effects.onComplete(ctx, results)), Effect.map(() => ctx));
 }
 exports.createSemverRangesProgram = createSemverRangesProgram;

package/dist/create-program/versions.d.ts

@@ -4,4 +4,4 @@ import type { Env } from '../env/create-env';
 import type { Ctx } from '../get-context';
 import type { VersionGroupConfigError } from '../get-version-groups';
 import type { VersionEffects } from './effects';
-export declare function createVersionsProgram(ctx: Ctx, effects: VersionEffects): Effect.Effect<Env, VersionGroupConfigError | DeprecatedTypesError, Ctx>;
+export declare function createVersionsProgram<T extends VersionEffects<any>>(ctx: Ctx, effects: T): Effect.Effect<Env, VersionGroupConfigError | DeprecatedTypesError, Ctx>;

package/dist/create-program/versions.js

@@ -30,19 +30,41 @@ const Effect = __importStar(require("@effect/io/Effect"));
 const Match = __importStar(require("@effect/match"));
 const get_version_groups_1 = require("../get-version-groups");
 function createVersionsProgram(ctx, effects) {
-    return (0, Function_1.pipe)((0, get_version_groups_1.getVersionGroups)(ctx), Effect.flatMap((versionGroups) => Effect.all(versionGroups.map((group) => Effect.all(group.inspect().map((reportEffect, index) => (0, Function_1.pipe)((0, Unify_1.unify)(reportEffect), Effect.flatMap((0, Function_1.pipe)(Match.type(), Match.tagsExhaustive({
-        FilteredOut: (report) => (0, Function_1.pipe)(effects.FilteredOut({ ctx, group, index, report }), Effect.map(() => report)),
-        Ignored: (report) => (0, Function_1.pipe)(effects.Ignored({ ctx, group, index, report }), Effect.map(() => report)),
-        Valid: (report) => (0, Function_1.pipe)(effects.Valid({ ctx, group, index, report }), Effect.map(() => report)),
+    return (0, Function_1.pipe)((0, get_version_groups_1.getVersionGroups)(ctx), Effect.flatMap((versionGroups) => Effect.allPar(versionGroups.flatMap((group) => group.inspect().map((reportEffect, index) => (0, Function_1.pipe)((0, Unify_1.unify)(reportEffect), Effect.flatMap((0, Function_1.pipe)(Match.type(), Match.tagsExhaustive({
+        FilteredOut(report) {
+            return effects.onFilteredOut({ ctx, group, index, report });
+        },
+        Ignored(report) {
+            return effects.onIgnored({ ctx, group, index, report });
+        },
+        Valid(report) {
+            return effects.onValid({ ctx, group, index, report });
+        },
     }))), Effect.catchTags({
-        Banned: (report) => (0, Function_1.pipe)(effects.Banned({ ctx, group, index, report }), Effect.map(() => report)),
-        HighestSemverMismatch: (report) => (0, Function_1.pipe)(effects.HighestSemverMismatch({ ctx, group, index, report }), Effect.map(() => report)),
-        LowestSemverMismatch: (report) => (0, Function_1.pipe)(effects.LowestSemverMismatch({ ctx, group, index, report }), Effect.map(() => report)),
-        PinnedMismatch: (report) => (0, Function_1.pipe)(effects.PinnedMismatch({ ctx, group, index, report }), Effect.map(() => report)),
-        SameRangeMismatch: (report) => (0, Function_1.pipe)(effects.SameRangeMismatch({ ctx, group, index, report }), Effect.map(() => report)),
-        SnappedToMismatch: (report) => (0, Function_1.pipe)(effects.SnappedToMismatch({ ctx, group, index, report }), Effect.map(() => report)),
-        UnsupportedMismatch: (report) => (0, Function_1.pipe)(effects.UnsupportedMismatch({ ctx, group, index, report }), Effect.map(() => report)),
-        WorkspaceMismatch: (report) => (0, Function_1.pipe)(effects.WorkspaceMismatch({ ctx, group, index, report }), Effect.map(() => report)),
-    }))))))), Effect.flatMap(() => effects.TearDown(ctx)), Effect.map(() => ctx));
+        Banned(report) {
+            return effects.onBanned({ ctx, group, index, report });
+        },
+        HighestSemverMismatch(report) {
+            return effects.onHighestSemverMismatch({ ctx, group, index, report });
+        },
+        LowestSemverMismatch(report) {
+            return effects.onLowestSemverMismatch({ ctx, group, index, report });
+        },
+        PinnedMismatch(report) {
+            return effects.onPinnedMismatch({ ctx, group, index, report });
+        },
+        SameRangeMismatch(report) {
+            return effects.onSameRangeMismatch({ ctx, group, index, report });
+        },
+        SnappedToMismatch(report) {
+            return effects.onSnappedToMismatch({ ctx, group, index, report });
+        },
+        UnsupportedMismatch(report) {
+            return effects.onUnsupportedMismatch({ ctx, group, index, report });
+        },
+        WorkspaceMismatch(report) {
+            return effects.onWorkspaceMismatch({ ctx, group, index, report });
+        },
+    })))))), Effect.flatMap((results) => effects.onComplete(ctx, results)), Effect.map(() => ctx));
 }
 exports.createVersionsProgram = createVersionsProgram;

package/dist/lib/set-semver-range.d.ts

@@ -1,2 +1,3 @@
 import type { SemverRange } from '../config/types';
+export declare function getSemverRange(version: string): SemverRange;
 export declare function setSemverRange(semverRange: SemverRange, version: string): string;

package/dist/lib/set-semver-range.js

@@ -1,10 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setSemverRange = void 0;
+exports.setSemverRange = exports.getSemverRange = void 0;
 const constants_1 = require("../constants");
 const is_loose_semver_1 = require("../guards/is-loose-semver");
 const is_semver_1 = require("../guards/is-semver");
 const is_valid_semver_range_1 = require("../guards/is-valid-semver-range");
+function getSemverRange(version) {
+    if (version === '*')
+        return version;
+    const from1stNumber = version.search(/[0-9]/);
+    const semverRange = version.slice(0, from1stNumber);
+    return (0, is_valid_semver_range_1.isValidSemverRange)(semverRange) ? semverRange : '';
+}
+exports.getSemverRange = getSemverRange;
 function setSemverRange(semverRange, version) {
     if (!(0, is_semver_1.isSemver)(version) || !(0, is_valid_semver_range_1.isValidSemverRange)(semverRange))
         return version;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "syncpack",
   "description": "Consistent dependency versions in large JavaScript Monorepos",
-  "version": "10.6.1",
+  "version": "10.7.2",
   "author": "Jamie Mason <jamie@foldleft.io> (https://github.com/JamieMason)",
   "bin": {
     "syncpack": "dist/bin.js",
@@ -12,7 +12,8 @@
     "syncpack-list": "dist/bin-list/index.js",
     "syncpack-list-mismatches": "dist/bin-list-mismatches/index.js",
     "syncpack-prompt": "dist/bin-prompt/index.js",
-    "syncpack-set-semver-ranges": "dist/bin-set-semver-ranges/index.js"
+    "syncpack-set-semver-ranges": "dist/bin-set-semver-ranges/index.js",
+    "syncpack-update": "dist/bin-update/index.js"
   },
   "bugs": "https://github.com/JamieMason/syncpack/issues",
   "contributors": [
@@ -30,42 +31,46 @@
     "Tom Fletcher (https://github.com/tom-fletcher)"
   ],
   "dependencies": {
-    "@effect/data": "0.12.5",
-    "@effect/io": "0.26.0",
-    "@effect/match": "0.24.4",
+    "@effect/data": "0.12.9",
+    "@effect/io": "0.27.0",
+    "@effect/match": "0.24.5",
+    "@effect/schema": "0.21.0",
     "chalk": "4.1.2",
     "commander": "11.0.0",
     "cosmiconfig": "8.2.0",
     "enquirer": "2.3.6",
     "fs-extra": "11.1.1",
     "globby": "11.1.0",
-    "minimatch": "9.0.1",
+    "minimatch": "9.0.2",
+    "ora": "5.4.1",
+    "prompts": "2.4.2",
     "read-yaml-file": "2.1.0",
-    "semver": "7.5.2",
+    "semver": "7.5.3",
     "tightrope": "0.1.0",
     "ts-toolbelt": "9.6.0"
   },
   "devDependencies": {
-    "@tsconfig/node14": "1.0.3",
+    "@tsconfig/node18": "18.2.0",
     "@types/fs-extra": "11.0.1",
     "@types/jest": "29.5.2",
     "@types/node": "14.18.36",
+    "@types/prompts": "2.4.4",
     "@types/semver": "7.5.0",
-    "@typescript-eslint/eslint-plugin": "5.59.11",
-    "@typescript-eslint/parser": "5.59.11",
-    "eslint": "8.43.0",
+    "@typescript-eslint/eslint-plugin": "5.60.1",
+    "@typescript-eslint/parser": "5.60.1",
+    "eslint": "8.44.0",
     "eslint-plugin-import": "2.27.5",
-    "eslint-plugin-jest": "27.2.1",
+    "eslint-plugin-jest": "27.2.2",
     "expect-more-jest": "5.5.0",
     "jest": "29.5.0",
     "prettier": "2.8.8",
     "rimraf": "5.0.1",
-    "ts-jest": "29.1.0",
+    "ts-jest": "29.1.1",
     "ts-node": "10.9.1",
-    "typescript": "5.1.3"
+    "typescript": "5.1.6"
   },
   "engines": {
-    "node": ">=14"
+    "node": ">=18"
   },
   "files": [
     "dist"