syncpack 13.0.1 → 14.0.0-alpha.2

package/dist/bin-prompt/prompt.js

@@ -1,95 +0,0 @@
-import chalk from 'chalk-template';
-import { Context, Effect, flow, pipe } from 'effect';
-import { uniq } from 'tightrope/array/uniq.js';
-import { isString } from 'tightrope/guard/is-string.js';
-import { logOtherCommands } from '../bin-list/list.js';
-import { CliConfigTag } from '../config/tag.js';
-import { ICON } from '../constants.js';
-import { defaultErrorHandlers } from '../error-handlers/default-error-handlers.js';
-import { getContext } from '../get-context/index.js';
-import { getInstances } from '../get-instances/index.js';
-import { askForChoice } from '../io/ask-for-choice.js';
-import { askForInput } from '../io/ask-for-input.js';
-import { exitIfInvalid } from '../io/exit-if-invalid.js';
-import { IoTag } from '../io/index.js';
-import { writeIfChanged } from '../io/write-if-changed.js';
-import { getVersionGroupHeader } from '../lib/get-group-header.js';
-import { withLogger } from '../lib/with-logger.js';
-export function prompt({ io, cli, errorHandlers = defaultErrorHandlers, }) {
-    return pipe(getContext({ io, cli, errorHandlers }), Effect.flatMap(ctx => pipe(Effect.gen(function* ($) {
-        const { versionGroups } = yield* $(getInstances(ctx, io, errorHandlers));
-        let unfixableCount = 0;
-        let index = 0;
-        for (const group of versionGroups) {
-            const unfixable = [];
-            for (const groupReport of yield* $(group.inspectAll())) {
-                for (const report of groupReport.reports) {
-                    if (isUnfixable(report)) {
-                        unfixable.push(report);
-                    }
-                }
-                if (unfixable.length > 0) {
-                    unfixableCount += unfixable.length;
-                    Effect.logInfo(getVersionGroupHeader({ group, index }));
-                    yield* $(askForNextVersion(groupReport, unfixable));
-                }
-            }
-            index++;
-        }
-        if (unfixableCount) {
-            yield* $(writeIfChanged(ctx));
-        }
-        else {
-            const msg = chalk `{green ${ICON.tick}} no issues which syncpack cannot fix automatically`;
-            yield* $(Effect.logInfo(msg));
-            yield* $(logOtherCommands());
-        }
-        return ctx;
-    }), Effect.catchTags({
-        WriteFileError: flow(errorHandlers.WriteFileError, Effect.map(() => {
-            ctx.isInvalid = true;
-            return ctx;
-        })),
-    }), Effect.flatMap(exitIfInvalid))), Effect.provide(pipe(Context.empty(), Context.add(CliConfigTag, cli), Context.add(IoTag, io))), withLogger);
-}
-function isUnfixable(report) {
-    return (report._tag === 'MissingLocalVersion' ||
-        report._tag === 'MissingSnappedToMismatch' ||
-        report._tag === 'SameRangeMismatch' ||
-        report._tag === 'UnsupportedMismatch');
-}
-function askForNextVersion(groupReport, unfixable) {
-    return pipe(Effect.gen(function* ($) {
-        const choices = uniq(groupReport.reports.map(report => report._tagGroup === 'Fixable'
-            ? report.fixable.raw
-            : report._tagGroup === 'Unfixable'
-                ? report.unfixable.rawSpecifier
-                : report._tagGroup === 'Valid'
-                    ? report.specifier.raw
-                    : null)).filter(isString);
-        const other = chalk `{dim Other}`;
-        const skip = chalk `{dim Skip}`;
-        const quit = chalk `{dim Quit}`;
-        // Ask user to choose a version to align on
-        const choice = yield* $(askForChoice({
-            message: groupReport.name,
-            choices: [...choices, other, skip, quit],
-        }));
-        if (choice === skip) {
-            return;
-        }
-        // @TODO: Learn https://www.effect.website/docs/data-types/exit
-        if (choice === quit) {
-            return process.exit(0);
-        }
-        const nextVersion = choice === other
-            ? yield* $(askForInput({
-                message: chalk `${groupReport.name} {dim Enter a replacement version}`,
-            }))
-            : choice;
-        yield* $(pipe(unfixable, Effect.forEach(report => report.unfixable.write(nextVersion))));
-    }), Effect.catchTags({
-        AskForChoiceError: Effect.logDebug,
-        AskForInputError: Effect.logDebug,
-    }));
-}

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

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

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

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-import chalk from 'chalk-template';
-import { program } from 'commander';
-import { Effect } from 'effect';
-import { io } from '../io/index.js';
-import { showHelpOnError } from '../lib/show-help-on-error.js';
-import { option } from '../option.js';
-import { setSemverRanges } from './set-semver-ranges.js';
-program.description(chalk `
-  Ensure dependency versions within {yellow dependencies}, {yellow devDependencies},
-  {yellow peerDependencies}, {yellow overrides}, and {yellow resolutions} follow a consistent format.`.replace(/^\n/, ''));
-program.on('--help', () => { });
-showHelpOnError(program);
-program
-    .option(...option.source)
-    .option(...option.filter)
-    .option(...option.config)
-    .option(...option.specs)
-    .option(...option.types)
-    .option(...option.indent)
-    .parse(process.argv);
-Effect.runPromise(setSemverRanges({
-    io,
-    cli: {
-        configPath: program.opts().config,
-        filter: program.opts().filter,
-        indent: program.opts().indent,
-        source: program.opts().source,
-        specs: program.opts().specs,
-        types: program.opts().types,
-    },
-}));

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

@@ -1,11 +0,0 @@
-import { Effect } from 'effect';
-import type { CliConfig } from '../config/types.js';
-import type { ErrorHandlers } from '../error-handlers/default-error-handlers.js';
-import type { Io } from '../io/index.js';
-interface Input {
-    io: Io;
-    cli: Partial<CliConfig>;
-    errorHandlers?: ErrorHandlers;
-}
-export declare function setSemverRanges({ io, cli, errorHandlers, }: Input): Effect.Effect<unknown, never, never>;
-export {};

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

@@ -1,61 +0,0 @@
-import { Context, Effect, flow, pipe } from 'effect';
-import { isNonEmptyArray } from 'tightrope/guard/is-non-empty-array.js';
-import { fixMismatch, logAlreadyValidSize, logFixedSize, logUnfixableSize, } from '../bin-fix-mismatches/fix-mismatches.js';
-import { logSemverGroupsDisabledWarning } from '../bin-lint-semver-ranges/lint-semver-ranges.js';
-import { logUnsupportedMismatch } from '../bin-list-mismatches/list-mismatches.js';
-import { CliConfigTag } from '../config/tag.js';
-import { defaultErrorHandlers } from '../error-handlers/default-error-handlers.js';
-import { getContext } from '../get-context/index.js';
-import { getInstances } from '../get-instances/index.js';
-import { exitIfInvalid } from '../io/exit-if-invalid.js';
-import { IoTag } from '../io/index.js';
-import { writeIfChanged } from '../io/write-if-changed.js';
-import { withLogger } from '../lib/with-logger.js';
-export function setSemverRanges({ io, cli, errorHandlers = defaultErrorHandlers, }) {
-    return pipe(getContext({ io, cli, errorHandlers }), Effect.flatMap(ctx => pipe(Effect.gen(function* ($) {
-        // no semver groups have been configured, they are disabled by default
-        if (!isNonEmptyArray(ctx.config.rcFile.semverGroups)) {
-            ctx.isInvalid = true;
-            yield* $(logSemverGroupsDisabledWarning());
-            return ctx;
-        }
-        const { semverGroups } = yield* $(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* $(fixMismatch(report));
-                        fixedCount++;
-                    }
-                    else if (_tag === 'UnsupportedMismatch') {
-                        yield* $(logUnsupportedMismatch(report));
-                        unfixableCount++;
-                    }
-                    else {
-                        validCount++;
-                    }
-                }
-            }
-        }
-        if (validCount) {
-            yield* $(logAlreadyValidSize(validCount));
-        }
-        if (fixedCount) {
-            yield* $(logFixedSize(fixedCount));
-        }
-        if (unfixableCount) {
-            yield* $(logUnfixableSize(unfixableCount));
-        }
-        return ctx;
-    }), Effect.flatMap(writeIfChanged), Effect.catchTags({
-        WriteFileError: flow(errorHandlers.WriteFileError, Effect.map(() => {
-            ctx.isInvalid = true;
-            return ctx;
-        })),
-    }), Effect.flatMap(exitIfInvalid))), Effect.provide(pipe(Context.empty(), Context.add(CliConfigTag, cli), Context.add(IoTag, io))), withLogger);
-}

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

@@ -1,52 +0,0 @@
-import { Effect } from 'effect';
-import type { Instance } from '../get-instances/instance.js';
-declare const Releases_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<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;
-    };
-    repoUrl: string | undefined;
-}> {
-}
-declare const PromptCancelled_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<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<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<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<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
-    readonly _tag: "NpmRegistryError";
-};
-declare class NpmRegistryError extends NpmRegistryError_base<{
-    error: string;
-}> {
-}
-export declare const updateEffects: {
-    onFetchAllStart(): Effect.Effect<void, never, never>;
-    onFetchStart(instance: Instance, totalCount: number): Effect.Effect<void, never, never>;
-    onFetchEnd(instance: Instance, versions?: Releases["versions"]): Effect.Effect<void, never, never>;
-    /** After checking the registry, store this instance known to be up to date */
-    onUpToDate(instance: Instance): Effect.Effect<void, never, never>;
-    /** After checking the registry, store this instance known to have newer versions available */
-    onOutdated(instance: Instance, latest: string): Effect.Effect<void, never, never>;
-    /** As the last request completes, remove the progress information */
-    onFetchAllEnd(): Effect.Effect<void, never, never>;
-    /** Fetch available versions for a given package from the npm registry */
-    fetchLatestVersions(instance: Instance): Effect.Effect<Releases, HttpError | NpmRegistryError>;
-    /** Given responses from npm, ask the user which they want */
-    promptForUpdates(outdated: Releases[]): Effect.Effect<void, PromptCancelled>;
-};
-export {};

package/dist/bin-update/effects.js

@@ -1,282 +0,0 @@
-import https from 'node:https';
-import { EOL } from 'node:os';
-import * as Schema from '@effect/schema/Schema';
-import chalk from 'chalk-template';
-import { Data, Effect, identity, pipe } from 'effect';
-import ora from 'ora';
-import prompts from 'prompts';
-import { diff } from 'semver';
-import gtr from 'semver/ranges/gtr.js';
-import { isArray } from 'tightrope/guard/is-array.js';
-import { isEmptyObject } from 'tightrope/guard/is-empty-object.js';
-import { ICON } from '../constants.js';
-import { formatRepositoryUrl } from '../lib/format-repository-url.js';
-import { RingBuffer } from '../lib/ring-buffer.js';
-import { setSemverRange } from '../lib/set-semver-range.js';
-import { Specifier } from '../specifier/index.js';
-/** full release history from the npm registry for a given package */
-class Releases extends Data.TaggedClass('Releases') {
-}
-// https://github.com/terkelg/prompts?tab=readme-ov-file#prompts
-class PromptCancelled extends Data.TaggedClass('PromptCancelled') {
-}
-class HttpError extends Data.TaggedClass('HttpError') {
-}
-class NpmRegistryError extends 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 RingBuffer(5);
-/** page size when prompting */
-const optionsPerPage = 50;
-/** instance names in `inFlight` are formatted for display */
-function format(instance) {
-    return chalk `{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, '');
-}
-export const updateEffects = {
-    onFetchAllStart() {
-        if (!spinner) {
-            spinner = ora().start();
-        }
-        fetchedCount = 0;
-        return Effect.void;
-    },
-    onFetchStart(instance, totalCount) {
-        inFlight.add(format(instance));
-        fetchedCount++;
-        if (spinner) {
-            const indent = `${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 = chalk `${outdatedCount} updates found in ${fetchedCount}/${totalCount} dependencies${indent}${suffixText}`;
-        }
-        return Effect.void;
-    },
-    onFetchEnd(instance, versions) {
-        inFlight.delete(format(instance));
-        const latest = versions?.latest;
-        if (latest) {
-            if (gtr(latest, String(instance.rawSpecifier.raw), true)) {
-                outdatedCount++;
-                mostRecent.push(chalk `${instance.name} {gray {red ${String(instance.rawSpecifier.raw)}} ${ICON.rightArrow}} {green ${latest}}`);
-            }
-            else {
-                mostRecent.push(chalk `{green ${instance.name}}`);
-            }
-        }
-        return Effect.void;
-    },
-    /** After checking the registry, store this instance known to be up to date */
-    onUpToDate(instance) {
-        mostRecent.push(chalk `{green ${instance.name}}`);
-        return Effect.void;
-    },
-    /** After checking the registry, store this instance known to have newer versions available */
-    onOutdated(instance, latest) {
-        outdatedCount++;
-        mostRecent.push(chalk `${instance.name} {gray {red ${String(instance.rawSpecifier.raw)}} ${ICON.rightArrow}} {green ${latest}}`);
-        return Effect.void;
-    },
-    /** As the last request completes, remove the progress information */
-    onFetchAllEnd() {
-        if (spinner) {
-            spinner.stop();
-        }
-        spinner = null;
-        fetchedCount = 0;
-        return Effect.void;
-    },
-    /** Fetch available versions for a given package from the npm registry */
-    fetchLatestVersions(instance) {
-        return pipe(fetchJson(`https://registry.npmjs.org/${instance.name}`), 
-        // parse and validate the specific data we expect
-        Effect.flatMap(Schema.decodeUnknownEither(Schema.Struct({
-            'dist-tags': Schema.Struct({ latest: Schema.String }),
-            time: Schema.Record({ key: Schema.String, value: Schema.String }),
-            homepage: Schema.optional(Schema.String),
-            repository: Schema.optional(Schema.Union(Schema.String, Schema.Struct({ url: Schema.optional(Schema.String) }))),
-        }))), 
-        // transform it into something more appropriate
-        Effect.map(struct => {
-            const rawRepoUrl = typeof struct.repository === 'object'
-                ? struct.repository.url
-                : struct.repository;
-            return new Releases({
-                instance,
-                versions: {
-                    all: Object.keys(struct.time).filter(key => key !== 'modified' && key !== 'created'),
-                    latest: struct['dist-tags'].latest,
-                },
-                repoUrl: formatRepositoryUrl(rawRepoUrl),
-            });
-        }), 
-        // hide ParseErrors and just treat them as another kind of NpmRegistryError
-        Effect.catchTags({
-            ParseError: () => Effect.fail(new NpmRegistryError({
-                error: `Invalid response for ${instance.name}`,
-            })),
-        }));
-    },
-    /** Given responses from npm, ask the user which they want */
-    promptForUpdates(outdated) {
-        return pipe(Effect.Do, Effect.bind('releasesByType', () => groupByReleaseType(outdated)), 
-        // Create choices to ask if they want major, minor, patch etc
-        Effect.bind('releaseTypeQuestions', ({ releasesByType }) => Effect.succeed(Object.keys(releasesByType)
-            .filter(type => releasesByType[type].length > 0)
-            .map(type => ({
-            title: chalk `${releasesByType[type].length} ${type}`,
-            selected: true,
-            value: type,
-        })))), 
-        // Ask which release types (major, minor, patch etc) they want
-        Effect.bind('releaseTypeAnswers', ({ releaseTypeQuestions }) => releaseTypeQuestions.length > 0
-            ? pipe(Effect.tryPromise({
-                try: () => prompts({
-                    name: 'releaseTypeAnswers',
-                    type: 'multiselect',
-                    instructions: true,
-                    message: `${outdated.length} updates are available`,
-                    choices: releaseTypeQuestions,
-                }).then(res => res?.releaseTypeAnswers || []),
-                catch: identity,
-            }), Effect.catchAll(() => pipe(Effect.logError('Error when prompting for releaseTypeAnswers'), Effect.map(() => []))))
-            : Effect.succeed([])), 
-        // For each chosen release type, list the available updates to choose from
-        Effect.bind('prepatchAnswers', doState => promptForReleaseType('prepatch', doState)), Effect.bind('patchAnswers', doState => promptForReleaseType('patch', doState)), Effect.bind('preminorAnswers', doState => promptForReleaseType('preminor', doState)), Effect.bind('minorAnswers', doState => promptForReleaseType('minor', doState)), Effect.bind('premajorAnswers', doState => promptForReleaseType('premajor', doState)), Effect.bind('majorAnswers', doState => promptForReleaseType('major', doState)), Effect.bind('prereleaseAnswers', doState => promptForReleaseType('prerelease', doState)), 
-        /** Apply every update to the package.json files */
-        Effect.flatMap(doState => pipe([
-            ...doState.prepatchAnswers,
-            ...doState.patchAnswers,
-            ...doState.preminorAnswers,
-            ...doState.minorAnswers,
-            ...doState.premajorAnswers,
-            ...doState.majorAnswers,
-            ...doState.prereleaseAnswers,
-        ], Effect.forEach(({ instance, versions }) => pipe(instance.semverGroup.getFixed(Specifier.create(instance, versions.latest)), Effect.flatMap(latestWithRange => instance.write(latestWithRange.raw)), Effect.catchTag('NonSemverError', Effect.logError))), Effect.flatMap(() => Effect.void))));
-    },
-};
-function promptForReleaseType(releaseType, doState) {
-    const { releasesByType, releaseTypeAnswers } = doState;
-    const prop = `${releaseType}Answers`;
-    const releases = releasesByType[releaseType];
-    return releaseTypeAnswers.includes(releaseType)
-        ? pipe(Effect.tryPromise({
-            try: () => prompts({
-                name: prop,
-                type: 'multiselect',
-                instructions: false,
-                // @ts-expect-error optionsPerPage *does* exist https://github.com/terkelg/prompts#options-7
-                optionsPerPage,
-                message: `${releases.length} ${releaseType} updates`,
-                choices: releases.map(updateable => {
-                    const spacingValue = 50 -
-                        updateable.instance.name.length -
-                        String(updateable.instance.rawSpecifier).length -
-                        updateable.versions.latest.length;
-                    const spacing = Array.from({ length: spacingValue })
-                        .fill(' ')
-                        .join('');
-                    const repoUrl = updateable.repoUrl
-                        ? chalk `${spacing} {white - ${updateable.repoUrl}}`
-                        : '';
-                    return {
-                        title: chalk `${updateable.instance.name} {gray ${String(updateable.instance.rawSpecifier.raw)} ${ICON.rightArrow}} {green ${updateable.versions.latest}} ${repoUrl}`,
-                        selected: true,
-                        value: updateable,
-                    };
-                }),
-            }),
-            catch: identity,
-        }), 
-        // Paper over errors in terkelg/prompts for now
-        Effect.catchAll(() => pipe(Effect.logError(`terkelg/prompts errored while prompting for ${prop}`), 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.flatMap(res => isEmptyObject(res)
-            ? Effect.fail(new PromptCancelled({ name: releaseType }))
-            : Effect.succeed(isArray(res?.[prop]) ? res?.[prop] : [])))
-        : Effect.succeed([]);
-}
-function groupByReleaseType(releases) {
-    return Effect.succeed(releases.reduce((releasesByType, release) => {
-        const previous = setSemverRange('', String(release.instance.rawSpecifier.raw));
-        const latest = release.versions.latest;
-        try {
-            const type = 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 fetchJson(url) {
-    return pipe(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
-            .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: `Node https threw on ${url}: ${String(err)}`,
-            })));
-        });
-    }), Effect.flatMap(body => Effect.try({
-        try: () => JSON.parse(body),
-        catch: () => new NpmRegistryError({
-            error: `JSON.parse threw on response from ${url}`,
-        }),
-    })));
-}

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

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

package/dist/bin-update/index.js

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-import { program } from 'commander';
-import { Effect } from 'effect';
-import { io } from '../io/index.js';
-import { showHelpOnError } from '../lib/show-help-on-error.js';
-import { option } from '../option.js';
-import { update } from './update.js';
-program.description('  Update to the latest versions on the npm registry.');
-program.on('--help', () => { });
-showHelpOnError(program);
-program
-    .option(...option.source)
-    .option(...option.filter)
-    .option(...option.config)
-    .option(...option.specs)
-    .option(...option.types)
-    .parse(process.argv);
-Effect.runPromise(update(io, {
-    configPath: program.opts().config,
-    filter: program.opts().filter,
-    source: program.opts().source,
-    specs: program.opts().specs,
-    types: program.opts().types,
-}));

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

@@ -1,6 +0,0 @@
-import { Effect } from 'effect';
-import type { CliConfig } from '../config/types.js';
-import type { ErrorHandlers } from '../error-handlers/default-error-handlers.js';
-import type { Io } from '../io/index.js';
-import { updateEffects } from './effects.js';
-export declare function update(io: Io, cli: Partial<CliConfig>, effects?: typeof updateEffects, errorHandlers?: ErrorHandlers): Effect.Effect<unknown, never, never>;

package/dist/bin-update/update.js

@@ -1,59 +0,0 @@
-import chalk from 'chalk-template';
-import { Context, Effect, flow, pipe } from 'effect';
-import { gtr } from 'semver';
-import { CliConfigTag } from '../config/tag.js';
-import { ICON } from '../constants.js';
-import { defaultErrorHandlers } from '../error-handlers/default-error-handlers.js';
-import { getContext } from '../get-context/index.js';
-import { getInstances } from '../get-instances/index.js';
-import { exitIfInvalid } from '../io/exit-if-invalid.js';
-import { IoTag } from '../io/index.js';
-import { writeIfChanged } from '../io/write-if-changed.js';
-import { withLogger } from '../lib/with-logger.js';
-import { Specifier } from '../specifier/index.js';
-import { updateEffects } from './effects.js';
-export function update(io, cli, effects = updateEffects, errorHandlers = defaultErrorHandlers) {
-    return pipe(Effect.Do, Effect.bind('ctx', () => getContext({ io, cli, errorHandlers })), Effect.bind('instances', ({ ctx }) => getInstances(ctx, io, errorHandlers)), Effect.bind('update', ({ instances }) => pipe(Effect.succeed(instances.all), Effect.map(instances => {
-        const isVisitedByName = {};
-        const updateable = [];
-        instances.forEach(instance => {
-            if (!isVisitedByName[instance.name] &&
-                (instance.versionGroup._tag === 'SameRange' ||
-                    instance.versionGroup._tag === 'Standard')) {
-                const specifier = Specifier.create(instance, instance.rawSpecifier.raw);
-                if (specifier._tag === 'Range' || specifier._tag === 'Exact') {
-                    isVisitedByName[instance.name] = true;
-                    updateable.push(instance);
-                }
-            }
-        });
-        return updateable;
-    }), Effect.tap(updateEffects.onFetchAllStart), Effect.flatMap(instances => pipe(instances, Effect.partition(instance => pipe(Effect.succeed(instance), Effect.tap(() => updateEffects.onFetchStart(instance, instances.length)), Effect.flatMap(effects.fetchLatestVersions), Effect.tapBoth({
-        onFailure: () => updateEffects.onFetchEnd(instance),
-        onSuccess: ({ versions }) => updateEffects.onFetchEnd(instance, versions),
-    }), 
-    // move up to date dependencies to error channel
-    Effect.flatMap(updateable => gtr(updateable.versions.latest, String(instance.rawSpecifier.raw))
-        ? pipe(updateEffects.onOutdated(instance, updateable.versions.latest), Effect.map(() => updateable))
-        : pipe(updateEffects.onUpToDate(instance), Effect.flatMap(() => Effect.fail(updateable)))), 
-    // log error but don't catch it
-    Effect.tapErrorTag('HttpError', ({ error }) => Effect.logError(chalk `{red ${ICON.cross} ${error}}`)), 
-    // log error but don't catch it
-    Effect.tapErrorTag('NpmRegistryError', ({ error }) => Effect.logError(chalk `{red ${ICON.cross} ${error}}`))), { concurrency: 10 }), 
-    // discard errors and up to date dependencies
-    Effect.flatMap(([_, outOfDate]) => Effect.succeed(outOfDate)))), 
-    // always remove the spinner when we're done
-    Effect.tapBoth({
-        onFailure: updateEffects.onFetchAllEnd,
-        onSuccess: updateEffects.onFetchAllEnd,
-    }), 
-    // ask the user which updates they want
-    Effect.flatMap(updateEffects.promptForUpdates), 
-    // if we think the user cancelled, say so
-    Effect.catchTag('PromptCancelled', () => Effect.logInfo(chalk `{red ${ICON.panic}} aborting after {blue syncpack update} was cancelled`)))), Effect.flatMap(({ ctx }) => pipe(writeIfChanged(ctx), Effect.catchTags({
-        WriteFileError: flow(errorHandlers.WriteFileError, Effect.map(() => {
-            ctx.isInvalid = true;
-            return ctx;
-        })),
-    }))), Effect.flatMap(exitIfInvalid), Effect.withConcurrency(10), Effect.provide(pipe(Context.empty(), Context.add(CliConfigTag, cli), Context.add(IoTag, io))), withLogger);
-}

package/dist/bin.d.ts

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