syncpack 11.2.1 → 12.0.0-alpha.0

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

@@ -1,43 +1,57 @@
 "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.setSemverRanges = void 0;
-const Context = __importStar(require("@effect/data/Context"));
-const Function_1 = require("@effect/data/Function");
-const Effect = __importStar(require("@effect/io/Effect"));
+const effect_1 = require("effect");
+const is_non_empty_array_1 = require("tightrope/guard/is-non-empty-array");
+const fix_mismatches_1 = require("../bin-fix-mismatches/fix-mismatches");
+const lint_semver_ranges_1 = require("../bin-lint-semver-ranges/lint-semver-ranges");
+const list_mismatches_1 = require("../bin-list-mismatches/list-mismatches");
 const tag_1 = require("../config/tag");
-const semver_ranges_1 = require("../create-program/semver-ranges");
-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 setSemverRanges(cli, env) {
-    return (0, Function_1.pipe)((0, get_context_1.getContext)(), Effect.flatMap((ctx) => (0, semver_ranges_1.createSemverRangesProgram)(ctx, effects_1.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.provideContext((0, Function_1.pipe)(Context.empty(), Context.add(tag_1.CliConfigTag, cli), Context.add(tags_1.EnvTag, (0, create_env_1.createEnv)(env)))));
+const get_instances_1 = require("../get-instances");
+const io_1 = require("../io");
+const exit_if_invalid_1 = require("../io/exit-if-invalid");
+const write_if_changed_1 = require("../io/write-if-changed");
+const with_logger_1 = require("../lib/with-logger");
+function setSemverRanges({ io, cli, errorHandlers = default_error_handlers_1.defaultErrorHandlers }) {
+    return (0, effect_1.pipe)((0, get_context_1.getContext)({ io, cli, errorHandlers }), effect_1.Effect.flatMap((ctx) => (0, effect_1.pipe)(effect_1.Effect.gen(function* ($) {
+        // no semver groups have been configured, they are disabled by default
+        if (!(0, is_non_empty_array_1.isNonEmptyArray)(ctx.config.rcFile.semverGroups)) {
+            ctx.isInvalid = true;
+            yield* $((0, lint_semver_ranges_1.logSemverGroupsDisabledWarning)());
+            return ctx;
+        }
+        const { semverGroups } = yield* $((0, get_instances_1.getInstances)(ctx, io, errorHandlers));
+        let fixedCount = 0;
+        let unfixableCount = 0;
+        let validCount = 0;
+        for (const group of semverGroups) {
+            if (group._tag === 'WithRange') {
+                for (const instance of group.instances) {
+                    const report = yield* $(group.inspect(instance));
+                    const _tag = report._tag;
+                    if (_tag === 'SemverRangeMismatch') {
+                        yield* $((0, fix_mismatches_1.fixMismatch)(report));
+                        fixedCount++;
+                    }
+                    else if (_tag === 'UnsupportedMismatch') {
+                        yield* $((0, list_mismatches_1.logUnsupportedMismatch)(report));
+                        unfixableCount++;
+                    }
+                    else {
+                        validCount++;
+                    }
+                }
+            }
+        }
+        if (validCount)
+            yield* $((0, fix_mismatches_1.logAlreadyValidSize)(validCount));
+        if (fixedCount)
+            yield* $((0, fix_mismatches_1.logFixedSize)(fixedCount));
+        if (unfixableCount)
+            yield* $((0, fix_mismatches_1.logUnfixableSize)(unfixableCount));
+        return ctx;
+    }), effect_1.Effect.flatMap(write_if_changed_1.writeIfChanged), effect_1.Effect.catchTags((0, default_error_handlers_1.chainErrorHandlers)(ctx, errorHandlers)), effect_1.Effect.flatMap(exit_if_invalid_1.exitIfInvalid))), effect_1.Effect.provide((0, effect_1.pipe)(effect_1.Context.empty(), effect_1.Context.add(tag_1.CliConfigTag, cli), effect_1.Context.add(io_1.IoTag, io))), with_logger_1.withLogger);
 }
 exports.setSemverRanges = setSemverRanges;

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

@@ -1,11 +1,51 @@
-import type { VersionEffectInput as Input, VersionEffects } from '../create-program/effects';
-import type { VersionGroupReport } from '../get-version-groups';
-interface InputWithVersions {
-    input: Input<VersionGroupReport.Any>;
+import { Data, Effect } from 'effect';
+import type { Instance } from '../get-instances/instance';
+declare const Releases_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "Releases";
+}>;
+/** full release history from the npm registry for a given package */
+declare class Releases extends Releases_base<{
+    instance: Instance;
     versions: {
         all: string[];
         latest: string;
     };
+}> {
 }
-export declare const updateEffects: VersionEffects<InputWithVersions | void>;
+declare const PromptCancelled_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "PromptCancelled";
+}>;
+declare class PromptCancelled extends PromptCancelled_base<{
+    name: string;
+}> {
+}
+declare const HttpError_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "HttpError";
+}>;
+declare class HttpError extends HttpError_base<{
+    error: string;
+}> {
+}
+declare const NpmRegistryError_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "NpmRegistryError";
+}>;
+declare class NpmRegistryError extends NpmRegistryError_base<{
+    error: string;
+}> {
+}
+export declare const updateEffects: {
+    onFetchAllStart(): Effect.Effect<never, never, void>;
+    onFetchStart(instance: Instance, totalCount: number): Effect.Effect<never, never, void>;
+    onFetchEnd(instance: Instance, versions?: Releases['versions']): Effect.Effect<never, never, void>;
+    /** After checking the registry, store this instance known to be up to date */
+    onUpToDate(instance: Instance): Effect.Effect<never, never, void>;
+    /** After checking the registry, store this instance known to have newer versions available */
+    onOutdated(instance: Instance, latest: string): Effect.Effect<never, never, void>;
+    /** As the last request completes, remove the progress information */
+    onFetchAllEnd(): Effect.Effect<never, never, void>;
+    /** Fetch available versions for a given package from the npm registry */
+    fetchLatestVersions(instance: Instance): Effect.Effect<never, HttpError | NpmRegistryError, Releases>;
+    /** Given responses from npm, ask the user which they want */
+    promptForUpdates(outdated: Releases[]): Effect.Effect<never, PromptCancelled, void>;
+};
 export {};

package/dist/bin-update/effects.js

@@ -27,151 +27,237 @@ var __importDefault = (this && this.__importDefault) || function (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 effect_1 = require("effect");
 const https_1 = __importDefault(require("https"));
 const ora_1 = __importDefault(require("ora"));
+const os_1 = require("os");
 const prompts_1 = __importDefault(require("prompts"));
-const unwrap_1 = require("tightrope/result/unwrap");
+const semver_1 = require("semver");
+const gtr_1 = __importDefault(require("semver/ranges/gtr"));
+const is_array_1 = require("tightrope/guard/is-array");
+const is_empty_object_1 = require("tightrope/guard/is-empty-object");
 const constants_1 = require("../constants");
-const get_highest_version_1 = require("../get-version-groups/lib/get-highest-version");
-const get_unique_specifiers_1 = require("../get-version-groups/lib/get-unique-specifiers");
-const log_verbose_1 = require("../lib/log-verbose");
+const ring_buffer_1 = require("../lib/ring-buffer");
 const set_semver_range_1 = require("../lib/set-semver-range");
-let spinner;
-let fetchCount = 0;
+const specifier_1 = require("../specifier");
+/** full release history from the npm registry for a given package */
+class Releases extends effect_1.Data.TaggedClass('Releases') {
+}
+// https://github.com/terkelg/prompts?tab=readme-ov-file#prompts
+class PromptCancelled extends effect_1.Data.TaggedClass('PromptCancelled') {
+}
+class HttpError extends effect_1.Data.TaggedClass('HttpError') {
+}
+class NpmRegistryError extends effect_1.Data.TaggedClass('NpmRegistryError') {
+}
+/** the API client for the terminal spinner */
+let spinner = null;
+/** how many HTTP requests have been sent */
+let fetchedCount = 0;
+/** how many instances have updates available */
+let outdatedCount = 0;
+/** names of instances currently being fetched from npm */
+const inFlight = new Set();
+/** names of instances most recently finished being fetched from npm */
+const mostRecent = new ring_buffer_1.RingBuffer(5);
+/** page size when prompting */
+const optionsPerPage = 50;
+/** instance names in `inFlight` are formatted for display */
+function format(instance) {
+    return (0, chalk_1.default) `{gray ${instance.name}}`;
+}
+/** we need to remove colours when sorting loading status output */
+function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    const ansiChars = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+    return str.replace(ansiChars, '');
+}
 exports.updateEffects = {
-    onFilteredOut() {
-        return Effect.unit;
-    },
-    onIgnored() {
-        return Effect.unit;
+    onFetchAllStart() {
+        if (!spinner)
+            spinner = (0, ora_1.default)().start();
+        fetchedCount = 0;
+        return effect_1.Effect.unit;
     },
-    onValid(input) {
-        return fetchPackageVersions(input);
+    onFetchStart(instance, totalCount) {
+        inFlight.add(format(instance));
+        fetchedCount++;
+        if (spinner) {
+            const indent = `${os_1.EOL}  `;
+            const progress = new Set([...mostRecent.filter(Boolean), ...inFlight.values()]);
+            const sortedProgress = Array.from(progress).sort((a, b) => stripAnsi(a).localeCompare(stripAnsi(b)));
+            const suffixText = sortedProgress.join(indent);
+            spinner.text = (0, chalk_1.default) `${outdatedCount} updates found in ${fetchedCount}/${totalCount} dependencies${indent}${suffixText}`;
+        }
+        return effect_1.Effect.unit;
     },
-    onBanned() {
-        return Effect.unit;
+    onFetchEnd(instance, versions) {
+        inFlight.delete(format(instance));
+        const latest = versions?.latest;
+        if (latest) {
+            if ((0, gtr_1.default)(latest, instance.rawSpecifier, true)) {
+                outdatedCount++;
+                mostRecent.push((0, chalk_1.default) `${instance.name} {gray {red ${instance.rawSpecifier}} ${constants_1.ICON.rightArrow}} {green ${latest}}`);
+            }
+            else {
+                mostRecent.push((0, chalk_1.default) `{green ${instance.name}}`);
+            }
+        }
+        return effect_1.Effect.unit;
     },
-    onHighestSemverMismatch(input) {
-        return fetchPackageVersions(input);
+    /** After checking the registry, store this instance known to be up to date */
+    onUpToDate(instance) {
+        mostRecent.push((0, chalk_1.default) `{green ${instance.name}}`);
+        return effect_1.Effect.unit;
     },
-    onLowestSemverMismatch() {
-        return Effect.unit;
+    /** After checking the registry, store this instance known to have newer versions available */
+    onOutdated(instance, latest) {
+        outdatedCount++;
+        mostRecent.push((0, chalk_1.default) `${instance.name} {gray {red ${instance.rawSpecifier}} ${constants_1.ICON.rightArrow}} {green ${latest}}`);
+        return effect_1.Effect.unit;
     },
-    onPinnedMismatch() {
-        return Effect.unit;
+    /** As the last request completes, remove the progress information */
+    onFetchAllEnd() {
+        if (spinner)
+            spinner.stop();
+        spinner = null;
+        fetchedCount = 0;
+        return effect_1.Effect.unit;
     },
-    onSameRangeMismatch(input) {
-        return fetchPackageVersions(input);
-    },
-    onSnappedToMismatch() {
-        return Effect.unit;
-    },
-    onNonSemverMismatch() {
-        return Effect.unit;
-    },
-    onLocalPackageMismatch() {
-        return Effect.unit;
+    /** Fetch available versions for a given package from the npm registry */
+    fetchLatestVersions(instance) {
+        return (0, effect_1.pipe)(fetchJson(`https://registry.npmjs.org/${instance.name}`), 
+        // parse and validate the specific data we expect
+        effect_1.Effect.flatMap(Schema.parse(Schema.struct({
+            'dist-tags': Schema.struct({ latest: Schema.string }),
+            'time': Schema.record(Schema.string, Schema.string),
+        }))), 
+        // transform it into something more appropriate
+        effect_1.Effect.map((struct) => new Releases({
+            instance,
+            versions: {
+                all: Object.keys(struct.time).filter((key) => key !== 'modified' && key !== 'created'),
+                latest: struct['dist-tags'].latest,
+            },
+        })), 
+        // hide ParseErrors and just treat them as another kind of NpmRegistryError
+        effect_1.Effect.catchTags({
+            ParseError: () => effect_1.Effect.fail(new NpmRegistryError({ error: `Invalid response for ${instance.name}` })),
+        }));
     },
-    onComplete(ctx, results) {
-        return promptForUpdates(results);
+    /** Given responses from npm, ask the user which they want */
+    promptForUpdates(outdated) {
+        return (0, effect_1.pipe)(effect_1.Effect.Do, effect_1.Effect.bind('releasesByType', () => groupByReleaseType(outdated)), 
+        // Create choices to ask if they want major, minor, patch etc
+        effect_1.Effect.bind('releaseTypeQuestions', ({ releasesByType }) => effect_1.Effect.succeed(Object.keys(releasesByType)
+            .filter((type) => releasesByType[type].length > 0)
+            .map((type) => ({
+            title: (0, chalk_1.default) `${releasesByType[type].length} ${type}`,
+            selected: true,
+            value: type,
+        })))), 
+        // Ask which release types (major, minor, patch etc) they want
+        effect_1.Effect.bind('releaseTypeAnswers', ({ releaseTypeQuestions }) => releaseTypeQuestions.length > 0
+            ? (0, effect_1.pipe)(effect_1.Effect.tryPromise({
+                try: () => (0, prompts_1.default)({
+                    name: 'releaseTypeAnswers',
+                    type: 'multiselect',
+                    instructions: true,
+                    message: `${outdated.length} updates are available`,
+                    choices: releaseTypeQuestions,
+                }).then((res) => res?.releaseTypeAnswers || []),
+                catch: effect_1.identity,
+            }), effect_1.Effect.catchAll(() => (0, effect_1.pipe)(effect_1.Effect.logError('Error when prompting for releaseTypeAnswers'), effect_1.Effect.map(() => []))))
+            : effect_1.Effect.succeed([])), 
+        // For each chosen release type, list the available updates to choose from
+        effect_1.Effect.bind('prepatchAnswers', (doState) => promptForReleaseType('prepatch', doState)), effect_1.Effect.bind('patchAnswers', (doState) => promptForReleaseType('patch', doState)), effect_1.Effect.bind('preminorAnswers', (doState) => promptForReleaseType('preminor', doState)), effect_1.Effect.bind('minorAnswers', (doState) => promptForReleaseType('minor', doState)), effect_1.Effect.bind('premajorAnswers', (doState) => promptForReleaseType('premajor', doState)), effect_1.Effect.bind('majorAnswers', (doState) => promptForReleaseType('major', doState)), effect_1.Effect.bind('prereleaseAnswers', (doState) => promptForReleaseType('prerelease', doState)), 
+        /** Apply every update to the package.json files */
+        effect_1.Effect.flatMap((doState) => (0, effect_1.pipe)([
+            ...doState.prepatchAnswers,
+            ...doState.patchAnswers,
+            ...doState.preminorAnswers,
+            ...doState.minorAnswers,
+            ...doState.premajorAnswers,
+            ...doState.majorAnswers,
+            ...doState.prereleaseAnswers,
+        ], effect_1.Effect.forEach(({ instance, versions }) => (0, effect_1.pipe)(instance.semverGroup.getFixed(specifier_1.Specifier.create(instance, versions.latest)), effect_1.Effect.flatMap((latestWithRange) => instance.write(latestWithRange.raw)), effect_1.Effect.catchTag('NonSemverError', effect_1.Effect.logError))), effect_1.Effect.flatMap(() => effect_1.Effect.unit))));
     },
 };
-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_specifiers_1.getUniqueSpecifiers)(input.report.instances).map((i) => i.specifier);
-        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.tryPromise({
-        try: () => (0, prompts_1.default)([
-            {
-                name: 'indexes',
+function promptForReleaseType(releaseType, doState) {
+    const { releasesByType, releaseTypeAnswers } = doState;
+    const prop = `${releaseType}Answers`;
+    const releases = releasesByType[releaseType];
+    return releaseTypeAnswers.includes(releaseType)
+        ? (0, effect_1.pipe)(effect_1.Effect.tryPromise({
+            try: () => (0, prompts_1.default)({
+                name: prop,
                 type: 'multiselect',
-                message: 'Choose which packages to upgrade',
-                instructions: true,
+                instructions: false,
                 // @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)),
-        catch: () => 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.specifier);
-                const latestWithRange = (0, set_semver_range_1.setSemverRange)(semverRange, versions.latest);
-                instance.setSpecifier(latestWithRange);
-            });
-        });
-    })), Effect.catchAll(() => Effect.unit));
+                optionsPerPage,
+                message: `${releases.length} ${releaseType} updates`,
+                choices: releases.map((updateable) => ({
+                    title: (0, chalk_1.default) `${updateable.instance.name} {gray ${updateable.instance.rawSpecifier} ${constants_1.ICON.rightArrow}} {green ${updateable.versions.latest}}`,
+                    selected: true,
+                    value: updateable,
+                })),
+            }),
+            catch: effect_1.identity,
+        }), 
+        // Paper over errors in terkelg/prompts for now
+        effect_1.Effect.catchAll(() => (0, effect_1.pipe)(effect_1.Effect.logError(`terkelg/prompts errored while prompting for ${prop}`), effect_1.Effect.map(() => ({ [prop]: [] })))), 
+        // In terkelg/prompts, an empty object means that the user cancelled via
+        // ctrl+c or the escape key etc. Handle this case so we can skip any
+        // remaining steps.
+        effect_1.Effect.flatMap((res) => (0, is_empty_object_1.isEmptyObject)(res)
+            ? effect_1.Effect.fail(new PromptCancelled({ name: releaseType }))
+            : effect_1.Effect.succeed((0, is_array_1.isArray)(res?.[prop]) ? res?.[prop] : [])))
+        : effect_1.Effect.succeed([]);
+}
+function groupByReleaseType(releases) {
+    return effect_1.Effect.succeed(releases.reduce((releasesByType, release) => {
+        const previous = (0, set_semver_range_1.setSemverRange)('', release.instance.rawSpecifier);
+        const latest = release.versions.latest;
+        try {
+            const type = (0, semver_1.diff)(previous, latest);
+            if (type && releasesByType[type]) {
+                releasesByType[type].push(release);
+            }
+        }
+        catch {
+            //
+        }
+        return releasesByType;
+    }, {
+        prepatch: [],
+        patch: [],
+        preminor: [],
+        minor: [],
+        premajor: [],
+        major: [],
+        prerelease: [],
+    }));
 }
 // @TODO: add a cache with a short TTL on disk in $TMPDIR
-function fetchUrl(url) {
-    return (0, Function_1.pipe)(Effect.async((resume) => {
+function fetchJson(url) {
+    return (0, effect_1.pipe)(effect_1.Effect.async((resume) => {
+        // setTimeout(
+        //   () => {
+        //     resume(
+        //       Effect.succeed(
+        //         JSON.stringify({
+        //           'dist-tags': { latest: '3.1.1' },
+        //           'time': {
+        //             '0.3.1': new Date().toJSON(),
+        //           },
+        //         }),
+        //       ),
+        //     );
+        //   },
+        //   Math.floor(Math.random() * 500) + 1,
+        // );
         https_1.default
             .get(url, (res) => {
             let body = '';
@@ -180,14 +266,14 @@ function fetchUrl(url) {
                 body = `${body}${chunk}`;
             });
             res.on('end', () => {
-                resume(Effect.succeed(body));
+                resume(effect_1.Effect.succeed(body));
             });
         })
             .on('error', (err) => {
-            resume(Effect.fail(new HttpError({ error: String(err) })));
+            resume(effect_1.Effect.fail(new HttpError({ error: `Node https threw on ${url}: ${String(err)}` })));
         });
-    }), Effect.flatMap((body) => Effect.try({
+    }), effect_1.Effect.flatMap((body) => effect_1.Effect.try({
         try: () => JSON.parse(body),
-        catch: (err) => new JsonParseError({ error: String(err) }),
+        catch: () => new NpmRegistryError({ error: `JSON.parse threw on response from ${url}` }),
     })));
 }

package/dist/bin-update/index.js

@@ -1,36 +1,13 @@
 #!/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 effect_1 = require("effect");
+const io_1 = require("../io");
 const show_help_on_error_1 = require("../lib/show-help-on-error");
 const option_1 = require("../option");
 const update_1 = require("./update");
@@ -72,9 +49,9 @@ commander_1.program
     .option(...option_1.option.config)
     .option(...option_1.option.types)
     .parse(process.argv);
-Effect.runPromise((0, update_1.update)({
+effect_1.Effect.runPromise((0, update_1.update)(io_1.io, {
     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

@@ -1,4 +1,6 @@
-import * as Effect from '@effect/io/Effect';
+import { Effect } from '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>;
+import type { ErrorHandlers } from '../error-handlers/default-error-handlers';
+import type { Io } from '../io';
+import { updateEffects } from './effects';
+export declare function update(io: Io, cli: Partial<CliConfig>, effects?: typeof updateEffects, errorHandlers?: ErrorHandlers): Effect.Effect<never, never, unknown>;