syncpack 13.0.1 → 14.0.0-alpha.2

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

@@ -1,92 +0,0 @@
-import { EOL } from 'node:os';
-import chalk from 'chalk-template';
-import { Context, Effect, pipe } from 'effect';
-import { isNonEmptyArray } from 'tightrope/guard/is-non-empty-array.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 { exitIfInvalid } from '../io/exit-if-invalid.js';
-import { IoTag } from '../io/index.js';
-import { getSemverGroupHeader } from '../lib/get-group-header.js';
-import { padStart } from '../lib/pad-start.js';
-import { withLogger } from '../lib/with-logger.js';
-export function lintSemverRanges({ io, cli, errorHandlers = defaultErrorHandlers, }) {
-    return pipe(getContext({ io, cli, errorHandlers }), Effect.flatMap(ctx => pipeline(ctx, io, errorHandlers)), Effect.flatMap(exitIfInvalid), Effect.provide(pipe(Context.empty(), Context.add(CliConfigTag, cli), Context.add(IoTag, io))), withLogger);
-}
-/** Exported to be reused by `syncpack lint` */
-export function pipeline(ctx, io, errorHandlers) {
-    return Effect.gen(function* ($) {
-        // no semver groups have been configured, they are disabled by default
-        if (!isNonEmptyArray(ctx.config.rcFile.semverGroups)) {
-            yield* $(logSemverGroupsDisabledWarning());
-            return ctx;
-        }
-        const { semverGroups } = yield* $(getInstances(ctx, io, errorHandlers));
-        let index = 0;
-        for (const group of semverGroups) {
-            const groupSize = group.instances.length;
-            let validCount = 0;
-            if (group._tag === 'Ignored') {
-                yield* $(Effect.logInfo(getSemverGroupHeader({ group, index })));
-                yield* $(logIgnoredSize(groupSize));
-            }
-            else if (group._tag === 'WithRange') {
-                yield* $(Effect.logInfo(getSemverGroupHeader({ group, index })));
-                for (const instance of group.instances) {
-                    const report = yield* $(group.inspect(instance));
-                    if (report._tag === 'Valid') {
-                        validCount++;
-                        continue;
-                    }
-                    ctx.isInvalid = true;
-                    if (report._tag === 'SemverRangeMismatch') {
-                        yield* $(logSemverRangeMismatch(report));
-                    }
-                    else if (report._tag === 'UnsupportedMismatch') {
-                        yield* $(logUnsupportedMismatch(report));
-                    }
-                }
-            }
-            if (validCount > 0) {
-                yield* $(logValidSize(validCount));
-            }
-            index++;
-        }
-        return ctx;
-    });
-}
-export function logSemverGroupsDisabledWarning() {
-    return Effect.logInfo([
-        chalk `{red ${ICON.panic} it looks like semver ranges have not yet been configured for this project}`,
-        chalk `  {red see the guide at} {yellow https://jamiemason.github.io/syncpack/guide/semver-groups}`,
-    ].join(EOL));
-}
-export function logIgnoredSize(amount) {
-    const msg = chalk `${padStart(amount)} {dim ${ICON.skip}} ${amount} ignored`;
-    return Effect.logInfo(msg);
-}
-function logValidSize(amount) {
-    const msg = chalk `{green ${ICON.tick}} {dim ${amount} valid}`;
-    return Effect.logInfo(msg);
-}
-function logSemverRangeMismatch(report) {
-    const _tag = report._tag;
-    const instance = report.fixable.instance;
-    const name = instance.name;
-    const actual = instance.rawSpecifier.raw;
-    const expected = report.fixable.raw;
-    const propPath = instance.strategy.path;
-    const filePath = instance.packageJsonFile.jsonFile.shortPath;
-    return Effect.logInfo(chalk `{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${filePath} > ${propPath}} {blue [${_tag}]}`);
-}
-function logUnsupportedMismatch(report) {
-    const _tag = report._tag;
-    const instance = report.unfixable;
-    const name = instance.name;
-    const actual = instance.rawSpecifier.raw;
-    const propPath = instance.strategy.path;
-    const filePath = instance.packageJsonFile.jsonFile.shortPath;
-    return Effect.logInfo(chalk `{red ${ICON.cross} name {white ${name}} or version {white ${actual}} are not supported} {gray ${filePath} > ${propPath}} {blue [${_tag}]}`);
-}

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

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

package/dist/bin-list/index.js

@@ -1,27 +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 { list } from './list.js';
-program.description('  List all dependencies required by your packages.');
-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(list({
-    io,
-    cli: {
-        configPath: program.opts().config,
-        filter: program.opts().filter,
-        source: program.opts().source,
-        specs: program.opts().specs,
-        types: program.opts().types,
-    },
-}));

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

@@ -1,14 +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 { Ctx } from '../get-context/index.js';
-import type { Io } from '../io/index.js';
-interface Input {
-    io: Io;
-    cli: Partial<CliConfig>;
-    errorHandlers?: ErrorHandlers;
-}
-export declare function list({ io, cli, errorHandlers }: Input): Effect.Effect<unknown, never, never>;
-export declare function pipeline(ctx: Ctx, io: Io, errorHandlers: ErrorHandlers): Effect.Effect<Ctx>;
-export declare function logOtherCommands(): Effect.Effect<void, never, never>;
-export {};

package/dist/bin-list/list.js

@@ -1,151 +0,0 @@
-import { EOL } from 'node:os';
-import chalk from 'chalk-template';
-import { Context, Effect, pipe } from 'effect';
-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 { getVersionGroupHeader } from '../lib/get-group-header.js';
-import { padStart } from '../lib/pad-start.js';
-import { withLogger } from '../lib/with-logger.js';
-export function list({ io, cli, errorHandlers = defaultErrorHandlers }) {
-    return pipe(getContext({ io, cli, errorHandlers }), Effect.flatMap(ctx => pipeline(ctx, io, errorHandlers)), Effect.flatMap(exitIfInvalid), Effect.provide(pipe(Context.empty(), Context.add(CliConfigTag, cli), Context.add(IoTag, io))), withLogger);
-}
-export function pipeline(ctx, io, errorHandlers) {
-    return Effect.gen(function* ($) {
-        const { versionGroups } = yield* $(getInstances(ctx, io, errorHandlers));
-        let index = 0;
-        for (const group of versionGroups) {
-            yield* $(Effect.logInfo(getVersionGroupHeader({ group, index })));
-            yield* $(onGroupTag[group._tag](group));
-            if (group._tag === 'Banned' ||
-                group._tag === 'FilteredOut' ||
-                group._tag === 'Ignored') {
-                if (group._tag === 'Banned') {
-                    ctx.isInvalid = true;
-                }
-                index++;
-                continue;
-            }
-            for (const groupReport of yield* $(group.inspectAll())) {
-                const matches = new Set();
-                const mismatches = new Set();
-                for (const report of groupReport.reports) {
-                    if (report.isInvalid) {
-                        ctx.isInvalid = true;
-                    }
-                    switch (report._tagGroup) {
-                        case 'Valid': {
-                            const actual = report.specifier.raw;
-                            matches.add(chalk `{gray ${actual}}`);
-                            break;
-                        }
-                        case 'Fixable': {
-                            mismatches.add(getLogForFixable(report));
-                            break;
-                        }
-                        case 'Unfixable': {
-                            mismatches.add(getLogForUnfixable(report));
-                            break;
-                        }
-                    }
-                }
-                if (mismatches.size === 0) {
-                    yield* $(logMatchingReport(groupReport, matches));
-                }
-                else {
-                    yield* $(logMismatchingReport(groupReport, mismatches));
-                }
-            }
-            index++;
-        }
-        yield* $(logOtherCommands());
-        return ctx;
-    });
-}
-const onGroupTag = {
-    Banned(group) {
-        return Effect.gen(function* ($) {
-            for (const groupReport of yield* $(group.inspectAll())) {
-                const name = groupReport.name;
-                const usages = `${padStart(groupReport.reports.length)}x`;
-                const invalidLabel = chalk `{gray ${usages}} {red ${name}}`;
-                const msg = chalk `${invalidLabel} {gray [Banned]}`;
-                yield* $(Effect.logInfo(msg));
-            }
-        });
-    },
-    FilteredOut(group) {
-        return Effect.gen(function* ($) {
-            for (const groupReport of yield* $(group.inspectAll())) {
-                const name = groupReport.name;
-                const usages = `${padStart(groupReport.reports.length)}x`;
-                const invalidLabel = chalk `{gray ${usages}} {gray ${name}}`;
-                const msg = chalk `${invalidLabel} {gray [FilteredOut]}`;
-                yield* $(Effect.logInfo(msg));
-            }
-        });
-    },
-    Ignored(group) {
-        return Effect.gen(function* ($) {
-            for (const groupReport of yield* $(group.inspectAll())) {
-                const name = groupReport.name;
-                const usages = `${padStart(groupReport.reports.length)}x`;
-                const invalidLabel = chalk `{gray ${usages}} {gray ${name}}`;
-                const msg = chalk `${invalidLabel} {gray [Ignored]}`;
-                yield* $(Effect.logInfo(msg));
-            }
-        });
-    },
-    Pinned(_group) {
-        return Effect.void;
-    },
-    SameRange(_group) {
-        return Effect.void;
-    },
-    SnappedTo(_group) {
-        return Effect.void;
-    },
-    Standard(_group) {
-        return Effect.void;
-    },
-};
-function logMatchingReport(groupReport, messages) {
-    const name = groupReport.name;
-    const usages = `${padStart(groupReport.reports.length)}x`;
-    const label = chalk `{gray ${usages}} ${name}{gray :}`;
-    return Effect.logInfo(chalk `${label} ${[...messages].join(chalk `{gray , }`)}`);
-}
-function logMismatchingReport(groupReport, messages) {
-    const name = groupReport.name;
-    const usages = `${padStart(groupReport.reports.length)}x`;
-    const label = chalk `{gray ${usages}} {red ${name}}{gray :}`;
-    const indent = usages.replace(/./g, ' ');
-    return Effect.logInfo(chalk `${label}${['', ...messages].join(chalk `${EOL}${indent} {red ${ICON.cross}} `)}`);
-}
-function getLogForFixable(report) {
-    const _tag = report._tag;
-    const actual = report.fixable.instance.rawSpecifier.raw;
-    const expected = report.fixable.raw;
-    return chalk `{red ${actual}} {gray ${ICON.rightArrow}} {green ${expected}} {gray [${_tag}]}`;
-}
-function getLogForUnfixable(report) {
-    const _tag = report._tag;
-    const actual = report.unfixable.rawSpecifier.raw;
-    return chalk `{red ${actual}} {gray ${ICON.rightArrow}} {gray [${_tag}]}`;
-}
-export function logOtherCommands() {
-    return Effect.logInfo([
-        '',
-        '  What next?',
-        chalk `{dim -} {yellow syncpack list-mismatches} to see more detail about mismatching versions`,
-        chalk `{dim -} {yellow syncpack fix-mismatches} to fix version mismatches automatically`,
-        chalk `{dim -} {yellow syncpack format} to sort and prettify your package.json files`,
-        chalk `{dim -} {yellow syncpack update} to choose updates from the npm registry`,
-        chalk `{dim -} {yellow syncpack --help} for everything else`,
-        '',
-    ].join(EOL));
-}

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

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

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

@@ -1,29 +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 { listMismatches } from './list-mismatches.js';
-program.description(`
-  List dependencies which are required by multiple packages, where the version
-  is not the same across every package.`.replace(/^\n/, ''));
-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(listMismatches({
-    io,
-    cli: {
-        configPath: program.opts().config,
-        filter: program.opts().filter,
-        source: program.opts().source,
-        specs: program.opts().specs,
-        types: program.opts().types,
-    },
-}));

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

@@ -1,18 +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 { Ctx } from '../get-context/index.js';
-import type { Io } from '../io/index.js';
-interface Input {
-    io: Io;
-    cli: Partial<CliConfig>;
-    errorHandlers?: ErrorHandlers;
-}
-export declare function listMismatches({ io, cli, errorHandlers, }: Input): Effect.Effect<unknown, never, never>;
-/** Exported to be reused by `syncpack lint` */
-export declare function pipeline(ctx: Ctx, io: Io, errorHandlers: ErrorHandlers): Effect.Effect<Ctx>;
-export declare const logMissingLocalVersion: (report: any) => Effect.Effect<void>;
-export declare const logMissingSnappedToMismatch: (report: any) => Effect.Effect<void>;
-export declare const logUnsupportedMismatch: (report: any) => Effect.Effect<void>;
-export declare const logSameRangeMismatch: (report: any) => Effect.Effect<void>;
-export {};

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

@@ -1,224 +0,0 @@
-import { EOL } from 'node:os';
-import chalk from 'chalk-template';
-import { Context, Effect, pipe } from 'effect';
-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 { getVersionGroupHeader } from '../lib/get-group-header.js';
-import { padStart } from '../lib/pad-start.js';
-import { withLogger } from '../lib/with-logger.js';
-export function listMismatches({ io, cli, errorHandlers = defaultErrorHandlers, }) {
-    return pipe(getContext({ io, cli, errorHandlers }), Effect.flatMap(ctx => pipeline(ctx, io, errorHandlers)), Effect.flatMap(exitIfInvalid), Effect.provide(pipe(Context.empty(), Context.add(CliConfigTag, cli), Context.add(IoTag, io))), withLogger);
-}
-/** Exported to be reused by `syncpack lint` */
-export function pipeline(ctx, io, errorHandlers) {
-    return Effect.gen(function* ($) {
-        const { versionGroups } = yield* $(getInstances(ctx, io, errorHandlers));
-        let index = 0;
-        for (const group of versionGroups) {
-            const countByReportGroup = {
-                Excluded: 0,
-                Fixable: 0,
-                Unfixable: 0,
-                Valid: 0,
-            };
-            yield* $(Effect.logInfo(getVersionGroupHeader({ group, index })));
-            for (const groupReport of yield* $(group.inspectAll())) {
-                for (const report of groupReport.reports) {
-                    countByReportGroup[report._tagGroup]++;
-                    if (report.isInvalid) {
-                        ctx.isInvalid = true;
-                    }
-                    const logReport = onReportTag[report._tag];
-                    if (logReport) {
-                        yield* $(logReport(report));
-                    }
-                }
-            }
-            yield* $(onReportGroup.Valid(countByReportGroup.Valid));
-            yield* $(onReportGroup.Fixable(countByReportGroup.Fixable));
-            yield* $(onReportGroup.Unfixable(countByReportGroup.Unfixable));
-            yield* $(onReportGroup.Excluded(countByReportGroup.Excluded));
-            index++;
-        }
-        return ctx;
-    });
-}
-const onReportGroup = {
-    Excluded(amount) {
-        if (amount === 0) {
-            return Effect.void;
-        }
-        const msg = chalk `{gray ${padStart(amount)} ${ICON.rightArrow} ignored}`;
-        return Effect.logInfo(msg);
-    },
-    Fixable(amount) {
-        if (amount === 0) {
-            return Effect.void;
-        }
-        const msg = chalk `${padStart(amount)} {green ${ICON.tick}} can be auto-fixed`;
-        return Effect.logInfo(msg);
-    },
-    Unfixable(amount) {
-        if (amount === 0) {
-            return Effect.void;
-        }
-        const msg = chalk `{red ${padStart(amount)} ${ICON.panic} can be fixed manually using} {blue syncpack prompt}`;
-        return Effect.logInfo(msg);
-    },
-    Valid(amount) {
-        if (amount === 0) {
-            return Effect.void;
-        }
-        const msg = chalk `${padStart(amount)} {green ${ICON.tick}} already valid`;
-        return Effect.logInfo(msg);
-    },
-};
-const onReportTag = {
-    Banned(report) {
-        const _tag = report._tag;
-        const instance = report.fixable.instance;
-        const name = instance.name;
-        const jsonFile = instance.packageJsonFile.jsonFile;
-        const path = instance.strategy.path;
-        const shortPath = jsonFile.shortPath;
-        return Effect.logInfo(chalk `{red ${ICON.cross}} ${name} {red banned} {gray ${shortPath} > ${path}} {blue [${_tag}]}`);
-    },
-    Disabled(_report) {
-        return Effect.void;
-    },
-    FilteredOut(_report) {
-        return Effect.void;
-    },
-    HighestSemverMismatch(report) {
-        const _tag = report._tag;
-        const fixable = report.fixable;
-        const instance = fixable.instance;
-        const jsonFile = instance.packageJsonFile.jsonFile;
-        const actual = instance.rawSpecifier.raw;
-        const expected = fixable.raw;
-        const name = instance.name;
-        const path = instance.strategy.path;
-        const shortPath = jsonFile.shortPath;
-        return Effect.logInfo(chalk `{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`);
-    },
-    Ignored(_report) {
-        return Effect.void;
-    },
-    LocalPackageMismatch(report) {
-        const _tag = report._tag;
-        const fixable = report.fixable;
-        const instance = fixable.instance;
-        const actual = instance.rawSpecifier.raw;
-        const expected = fixable.raw;
-        const name = instance.name;
-        const path = instance.strategy.path;
-        const shortPath = instance.packageJsonFile.jsonFile.shortPath;
-        return Effect.logInfo(chalk `{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`);
-    },
-    LowestSemverMismatch(report) {
-        const _tag = report._tag;
-        const fixable = report.fixable;
-        const instance = fixable.instance;
-        const actual = instance.rawSpecifier.raw;
-        const expected = fixable.raw;
-        const name = instance.name;
-        const path = instance.strategy.path;
-        const shortPath = instance.packageJsonFile.jsonFile.shortPath;
-        return Effect.logInfo(chalk `{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`);
-    },
-    MissingLocalVersion(report) {
-        const instance = report.unfixable;
-        const localPath = report.localInstance.packageJsonFile.jsonFile.shortPath;
-        const jsonFile = instance.packageJsonFile.jsonFile;
-        const actual = instance.rawSpecifier.raw;
-        const name = instance.name;
-        const path = instance.strategy.path;
-        const shortPath = jsonFile.shortPath;
-        return Effect.logInfo([
-            chalk `{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {red ???} {gray ${shortPath} > ${path}} {blue [MissingLocalVersion]}`,
-            chalk `  {red ${localPath} does not have a .version property which is exact semver}`,
-        ].join(EOL));
-    },
-    MissingSnappedToMismatch(report) {
-        const instance = report.unfixable;
-        const jsonFile = instance.packageJsonFile.jsonFile;
-        const actual = instance.rawSpecifier.raw;
-        const name = instance.name;
-        const path = instance.strategy.path;
-        const shortPath = jsonFile.shortPath;
-        return Effect.logInfo([
-            chalk `{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {red ???} {gray ${shortPath} > ${path}} {blue [MissingSnappedToMismatch]}`,
-            chalk `  {red no package in this groups .snapTo array depend on ${name}}`,
-        ].join(EOL));
-    },
-    PinnedMismatch(report) {
-        const _tag = report._tag;
-        const fixable = report.fixable;
-        const instance = fixable.instance;
-        const actual = instance.rawSpecifier.raw;
-        const expected = fixable.raw;
-        const name = instance.name;
-        const path = instance.strategy.path;
-        const shortPath = instance.packageJsonFile.jsonFile.shortPath;
-        return Effect.logInfo(chalk `{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`);
-    },
-    SameRangeMismatch(report) {
-        const instance = report.unfixable;
-        const jsonFile = instance.packageJsonFile.jsonFile;
-        const actual = instance.rawSpecifier.raw;
-        const name = instance.name;
-        const path = instance.strategy.path;
-        const shortPath = jsonFile.shortPath;
-        const mismatches = report.mismatches;
-        return Effect.logInfo([
-            chalk `{red ${ICON.cross}} ${name} {red range ${actual} does not include ${mismatches.join(', ')}} {gray ${shortPath} > ${path}} {blue [SameRangeMismatch]}`,
-            chalk `  {gray use {blue syncpack prompt} to fix this manually}`,
-        ].join(EOL));
-    },
-    SemverRangeMismatch(report) {
-        const _tag = report._tag;
-        const fixable = report.fixable;
-        const instance = fixable.instance;
-        const actual = instance.rawSpecifier.raw;
-        const expected = fixable.raw;
-        const name = instance.name;
-        const path = instance.strategy.path;
-        const shortPath = instance.packageJsonFile.jsonFile.shortPath;
-        return Effect.logInfo(chalk `{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`);
-    },
-    SnappedToMismatch(report) {
-        const _tag = report._tag;
-        const fixable = report.fixable;
-        const instance = fixable.instance;
-        const actual = instance.rawSpecifier.raw;
-        const expected = fixable.raw;
-        const name = instance.name;
-        const path = instance.strategy.path;
-        const shortPath = instance.packageJsonFile.jsonFile.shortPath;
-        return Effect.logInfo(chalk `{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {green ${expected}} {gray ${shortPath} > ${path}} {blue [${_tag}]}`);
-    },
-    UnsupportedMismatch(report) {
-        const instance = report.unfixable;
-        const jsonFile = instance.packageJsonFile.jsonFile;
-        const actual = instance.rawSpecifier.raw;
-        const name = instance.name;
-        const path = instance.strategy.path;
-        const shortPath = jsonFile.shortPath;
-        return Effect.logInfo([
-            chalk `{red ${ICON.cross}} ${name} {red ${actual}} {dim ${ICON.rightArrow}} {red ???} {gray ${shortPath} > ${path}} {blue [UnsupportedMismatch]}`,
-            chalk `  {red use {blue syncpack prompt} to fix this manually}`,
-        ].join(EOL));
-    },
-    Valid(_report) {
-        return Effect.void;
-    },
-};
-export const logMissingLocalVersion = onReportTag.MissingLocalVersion;
-export const logMissingSnappedToMismatch = onReportTag.MissingSnappedToMismatch;
-export const logUnsupportedMismatch = onReportTag.UnsupportedMismatch;
-export const logSameRangeMismatch = onReportTag.SameRangeMismatch;

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

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

package/dist/bin-prompt/index.js

@@ -1,29 +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 { prompt } from './prompt.js';
-program.description('  displays a series of prompts to fix mismatches which syncpack cannot fix automatically');
-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(prompt({
-    io,
-    cli: {
-        configPath: program.opts().config,
-        filter: program.opts().filter,
-        source: program.opts().source,
-        specs: program.opts().specs,
-        types: program.opts().types,
-        indent: program.opts().indent,
-    },
-}));

package/dist/bin-prompt/prompt.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 prompt({ io, cli, errorHandlers, }: Input): Effect.Effect<unknown, never, never>;
-export {};