syncpack 12.3.3 → 13.0.0

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

@@ -1,6 +1,6 @@
+import { EOL } from 'node:os';
 import chalk from 'chalk-template';
 import { Context, Effect, pipe } from 'effect';
-import { EOL } from 'os';
 import { CliConfigTag } from '../config/tag.js';
 import { ICON } from '../constants.js';
 import { defaultErrorHandlers } from '../error-handlers/default-error-handlers.js';
@@ -11,8 +11,8 @@ 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);
+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) {
@@ -30,11 +30,13 @@ export function pipeline(ctx, io, errorHandlers) {
             for (const groupReport of yield* $(group.inspectAll())) {
                 for (const report of groupReport.reports) {
                     countByReportGroup[report._tagGroup]++;
-                    if (report.isInvalid)
+                    if (report.isInvalid) {
                         ctx.isInvalid = true;
+                    }
                     const logReport = onReportTag[report._tag];
-                    if (logReport)
+                    if (logReport) {
                         yield* $(logReport(report));
+                    }
                 }
             }
             yield* $(onReportGroup.Valid(countByReportGroup.Valid));
@@ -48,26 +50,30 @@ export function pipeline(ctx, io, errorHandlers) {
 }
 const onReportGroup = {
     Excluded(amount) {
-        if (amount === 0)
+        if (amount === 0) {
             return Effect.void;
+        }
         const msg = chalk `{gray ${padStart(amount)} ${ICON.rightArrow} ignored}`;
         return Effect.logInfo(msg);
     },
     Fixable(amount) {
-        if (amount === 0)
+        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)
+        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)
+        if (amount === 0) {
             return Effect.void;
+        }
         const msg = chalk `${padStart(amount)} {green ${ICON.tick}} already valid`;
         return Effect.logInfo(msg);
     },

package/dist/bin-prompt/index.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import chalk from 'chalk-template';
 import { program } from 'commander';
 import { Effect } from 'effect';
 import { io } from '../io/index.js';
@@ -7,38 +6,7 @@ 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', () => {
-    console.log(chalk `
-  Examples:
-  {dim # uses defaults for resolving packages}
-  syncpack prompt
-  {dim # uses packages defined by --source when provided}
-  syncpack prompt --source {yellow "apps/*/package.json"}
-  {dim # multiple globs can be provided like this}
-  syncpack prompt --source {yellow "apps/*/package.json"} --source {yellow "core/*/package.json"}
-  {dim # uses dependencies regular expression defined by --filter when provided}
-  syncpack prompt --filter {yellow "typescript|tslint"}
-  {dim # only inspect "devDependencies"}
-  syncpack prompt --types dev
-  {dim # only inspect "devDependencies" and "peerDependencies"}
-  syncpack prompt --types dev,peer
-  {dim # indent package.json with 4 spaces instead of 2}
-  syncpack prompt --indent {yellow "    "}
-
-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}
-`);
-});
+program.on('--help', () => { });
 showHelpOnError(program);
 program
     .option(...option.source)

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

@@ -1,5 +1,5 @@
 import { Effect } from 'effect';
-import { type CliConfig } from '../config/types.js';
+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 {
@@ -7,5 +7,5 @@ interface Input {
     cli: Partial<CliConfig>;
     errorHandlers?: ErrorHandlers;
 }
-export declare function prompt({ io, cli, errorHandlers }: Input): Effect.Effect<unknown, never, never>;
+export declare function prompt({ io, cli, errorHandlers, }: Input): Effect.Effect<unknown, never, never>;
 export {};

package/dist/bin-prompt/prompt.js

@@ -15,8 +15,8 @@ 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* ($) {
+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;
@@ -60,32 +60,34 @@ function isUnfixable(report) {
 }
 function askForNextVersion(groupReport, unfixable) {
     return pipe(Effect.gen(function* ($) {
-        const choices = uniq(groupReport.reports.map((report) => report._tagGroup === 'Fixable'
+        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}`;
+        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],
+            choices: [...choices, other, skip, quit],
         }));
-        if (choice === SKIP)
+        if (choice === skip) {
             return;
+        }
         // @TODO: Learn https://www.effect.website/docs/data-types/exit
-        if (choice === QUIT)
+        if (choice === quit) {
             return process.exit(0);
-        const nextVersion = choice === OTHER
+        }
+        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))));
+        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.js

@@ -9,44 +9,7 @@ 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', () => {
-    console.log(chalk `
-Examples:
-  {dim # uses defaults for resolving packages}
-  syncpack set-semver-ranges
-  {dim # uses packages defined by --source when provided}
-  syncpack set-semver-ranges --source {yellow "apps/*/package.json"}
-  {dim # multiple globs can be provided like this}
-  syncpack set-semver-ranges --source {yellow "apps/*/package.json"} --source {yellow "core/*/package.json"}
-  {dim # uses dependencies regular expression defined by --filter when provided}
-  syncpack set-semver-ranges --filter {yellow "typescript|tslint"}
-  {dim # indent package.json with 4 spaces instead of 2}
-  syncpack set-semver-ranges --indent {yellow "    "}
-
-Supported Ranges:
-  <  {dim <1.4.2}
-  <= {dim <=1.4.2}
-  "" {dim 1.4.2}
-  ~  {dim ~1.4.2}
-  ^  {dim ^1.4.2}
-  >= {dim >=1.4.2}
-  >  {dim >1.4.2}
-  *  {dim *}
-
-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}
-`);
-});
+program.on('--help', () => { });
 showHelpOnError(program);
 program
     .option(...option.source)

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

@@ -1,5 +1,5 @@
 import { Effect } from 'effect';
-import { type CliConfig } from '../config/types.js';
+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 {
@@ -7,5 +7,5 @@ interface Input {
     cli: Partial<CliConfig>;
     errorHandlers?: ErrorHandlers;
 }
-export declare function setSemverRanges({ io, cli, errorHandlers }: Input): Effect.Effect<unknown, never, never>;
+export declare function setSemverRanges({ io, cli, errorHandlers, }: Input): Effect.Effect<unknown, never, never>;
 export {};

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

@@ -11,8 +11,8 @@ 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* ($) {
+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;
@@ -42,12 +42,15 @@ export function setSemverRanges({ io, cli, errorHandlers = defaultErrorHandlers
                 }
             }
         }
-        if (validCount)
+        if (validCount) {
             yield* $(logAlreadyValidSize(validCount));
-        if (fixedCount)
+        }
+        if (fixedCount) {
             yield* $(logFixedSize(fixedCount));
-        if (unfixableCount)
+        }
+        if (unfixableCount) {
             yield* $(logUnfixableSize(unfixableCount));
+        }
         return ctx;
     }), Effect.flatMap(writeIfChanged), Effect.catchTags({
         WriteFileError: flow(errorHandlers.WriteFileError, Effect.map(() => {

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

@@ -37,7 +37,7 @@ declare class NpmRegistryError extends NpmRegistryError_base<{
 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>;
+    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 */

package/dist/bin-update/effects.js

@@ -1,9 +1,9 @@
+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 https from 'https';
 import ora from 'ora';
-import { EOL } from 'os';
 import prompts from 'prompts';
 import { diff } from 'semver';
 import gtr from 'semver/ranges/gtr.js';
@@ -48,8 +48,9 @@ function stripAnsi(str) {
 }
 export const updateEffects = {
     onFetchAllStart() {
-        if (!spinner)
+        if (!spinner) {
             spinner = ora().start();
+        }
         fetchedCount = 0;
         return Effect.void;
     },
@@ -58,7 +59,10 @@ export const updateEffects = {
         fetchedCount++;
         if (spinner) {
             const indent = `${EOL}  `;
-            const progress = new Set([...mostRecent.filter(Boolean), ...inFlight.values()]);
+            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}`;
@@ -71,7 +75,7 @@ export const updateEffects = {
         if (latest) {
             if (gtr(latest, String(instance.rawSpecifier.raw), true)) {
                 outdatedCount++;
-                mostRecent.push(chalk `${instance.name} {gray {red ${instance.rawSpecifier.raw}} ${ICON.rightArrow}} {green ${latest}}`);
+                mostRecent.push(chalk `${instance.name} {gray {red ${String(instance.rawSpecifier.raw)}} ${ICON.rightArrow}} {green ${latest}}`);
             }
             else {
                 mostRecent.push(chalk `{green ${instance.name}}`);
@@ -87,13 +91,14 @@ export const updateEffects = {
     /** After checking the registry, store this instance known to have newer versions available */
     onOutdated(instance, latest) {
         outdatedCount++;
-        mostRecent.push(chalk `${instance.name} {gray {red ${instance.rawSpecifier.raw}} ${ICON.rightArrow}} {green ${latest}}`);
+        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)
+        if (spinner) {
             spinner.stop();
+        }
         spinner = null;
         fetchedCount = 0;
         return Effect.void;
@@ -104,17 +109,19 @@ export const updateEffects = {
         // parse and validate the specific data we expect
         Effect.flatMap(Schema.decodeUnknownEither(Schema.Struct({
             'dist-tags': Schema.Struct({ latest: Schema.String }),
-            'time': Schema.Record(Schema.String, Schema.String),
-            'homepage': Schema.optional(Schema.String),
-            'repository': Schema.optional(Schema.Union(Schema.String, Schema.Struct({ url: Schema.optional(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;
+        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'),
+                    all: Object.keys(struct.time).filter(key => key !== 'modified' && key !== 'created'),
                     latest: struct['dist-tags'].latest,
                 },
                 repoUrl: formatRepositoryUrl(rawRepoUrl),
@@ -122,7 +129,9 @@ export const updateEffects = {
         }), 
         // hide ParseErrors and just treat them as another kind of NpmRegistryError
         Effect.catchTags({
-            ParseError: () => Effect.fail(new NpmRegistryError({ error: `Invalid response for ${instance.name}` })),
+            ParseError: () => Effect.fail(new NpmRegistryError({
+                error: `Invalid response for ${instance.name}`,
+            })),
         }));
     },
     /** Given responses from npm, ask the user which they want */
@@ -130,8 +139,8 @@ export const updateEffects = {
         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) => ({
+            .filter(type => releasesByType[type].length > 0)
+            .map(type => ({
             title: chalk `${releasesByType[type].length} ${type}`,
             selected: true,
             value: type,
@@ -145,14 +154,14 @@ export const updateEffects = {
                     instructions: true,
                     message: `${outdated.length} updates are available`,
                     choices: releaseTypeQuestions,
-                }).then((res) => res?.releaseTypeAnswers || []),
+                }).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)), 
+        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([
+        Effect.flatMap(doState => pipe([
             ...doState.prepatchAnswers,
             ...doState.patchAnswers,
             ...doState.preminorAnswers,
@@ -160,7 +169,7 @@ export const updateEffects = {
             ...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))));
+        ], 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) {
@@ -176,17 +185,19 @@ function promptForReleaseType(releaseType, doState) {
                 // @ts-expect-error optionsPerPage *does* exist https://github.com/terkelg/prompts#options-7
                 optionsPerPage,
                 message: `${releases.length} ${releaseType} updates`,
-                choices: releases.map((updateable) => {
+                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 spacing = Array.from({ length: spacingValue })
+                        .fill(' ')
+                        .join('');
                     const repoUrl = updateable.repoUrl
                         ? chalk `${spacing} {white - ${updateable.repoUrl}}`
                         : '';
                     return {
-                        title: chalk `${updateable.instance.name} {gray ${updateable.instance.rawSpecifier.raw} ${ICON.rightArrow}} {green ${updateable.versions.latest}} ${repoUrl}`,
+                        title: chalk `${updateable.instance.name} {gray ${String(updateable.instance.rawSpecifier.raw)} ${ICON.rightArrow}} {green ${updateable.versions.latest}} ${repoUrl}`,
                         selected: true,
                         value: updateable,
                     };
@@ -199,7 +210,7 @@ function promptForReleaseType(releaseType, doState) {
         // 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.flatMap(res => isEmptyObject(res)
             ? Effect.fail(new PromptCancelled({ name: releaseType }))
             : Effect.succeed(isArray(res?.[prop]) ? res?.[prop] : [])))
         : Effect.succeed([]);
@@ -230,7 +241,7 @@ function groupByReleaseType(releases) {
 }
 // @TODO: add a cache with a short TTL on disk in $TMPDIR
 function fetchJson(url) {
-    return pipe(Effect.async((resume) => {
+    return pipe(Effect.async(resume => {
         // setTimeout(
         //   () => {
         //     resume(
@@ -247,21 +258,25 @@ function fetchJson(url) {
         //   Math.floor(Math.random() * 500) + 1,
         // );
         https
-            .get(url, (res) => {
+            .get(url, res => {
             let body = '';
             res.setEncoding('utf8');
-            res.on('data', (chunk) => {
+            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)}` })));
+            .on('error', err => {
+            resume(Effect.fail(new HttpError({
+                error: `Node https threw on ${url}: ${String(err)}`,
+            })));
         });
-    }), Effect.flatMap((body) => Effect.try({
+    }), Effect.flatMap(body => Effect.try({
         try: () => JSON.parse(body),
-        catch: () => new NpmRegistryError({ error: `JSON.parse threw on response from ${url}` }),
+        catch: () => new NpmRegistryError({
+            error: `JSON.parse threw on response from ${url}`,
+        }),
     })));
 }

package/dist/bin-update/index.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import chalk from 'chalk-template';
 import { program } from 'commander';
 import { Effect } from 'effect';
 import { io } from '../io/index.js';
@@ -7,36 +6,7 @@ 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', () => {
-    console.log(chalk `
-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}
-`);
-});
+program.on('--help', () => { });
 showHelpOnError(program);
 program
     .option(...option.source)

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

@@ -1,5 +1,5 @@
 import { Effect } from 'effect';
-import { type CliConfig } from '../config/types.js';
+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';

package/dist/bin-update/update.js

@@ -13,10 +13,10 @@ 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) => {
+    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) => {
+        instances.forEach(instance => {
             if (!isVisitedByName[instance.name] &&
                 (instance.versionGroup._tag === 'SameRange' ||
                     instance.versionGroup._tag === 'Standard')) {
@@ -28,12 +28,12 @@ export function update(io, cli, effects = updateEffects, errorHandlers = default
             }
         });
         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({
+    }), 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))
+    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

package/dist/bin.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { program } from 'commander';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 program

package/dist/config/get-custom-types.js

@@ -10,24 +10,31 @@ import { VersionsByNameStrategy } from '../strategy/versions-by-name.js';
 export class InvalidCustomTypeError extends Data.TaggedClass('InvalidCustomTypeError') {
 }
 export function getCustomTypes({ rcFile, }) {
-    if (!isNonEmptyObject(rcFile.customTypes))
+    if (!isNonEmptyObject(rcFile.customTypes)) {
         return Effect.succeed([]);
-    return Effect.all([...Object.entries(rcFile.customTypes), ...Object.entries(DEFAULT_CONFIG.customTypes)].map(([name, config]) => {
-        const ERR_OBJ = 'Invalid customType';
-        const ERR_PATH = 'Invalid customType.path';
-        const ERR_NAME_PATH = 'Invalid customType.namePath';
-        const ERR_STRATEGY = 'Invalid customType.strategy';
-        if (!isObject(config))
-            return createError(config, ERR_OBJ);
-        if (!isNonEmptyString(config.path))
-            return createError(config, ERR_PATH);
+    }
+    return Effect.all([
+        ...Object.entries(rcFile.customTypes),
+        ...Object.entries(DEFAULT_CONFIG.customTypes),
+    ].map(([name, config]) => {
+        const errObj = 'Invalid customType';
+        const errPath = 'Invalid customType.path';
+        const errNamePath = 'Invalid customType.namePath';
+        const errStrategy = 'Invalid customType.strategy';
+        if (!isObject(config)) {
+            return createError(config, errObj);
+        }
+        if (!isNonEmptyString(config.path)) {
+            return createError(config, errPath);
+        }
         const path = config.path;
         const strategy = config.strategy;
         switch (strategy) {
             case 'name~version': {
                 const namePath = config.namePath;
-                if (!isNonEmptyString(namePath))
-                    return createError(config, ERR_NAME_PATH);
+                if (!isNonEmptyString(namePath)) {
+                    return createError(config, errNamePath);
+                }
                 return Effect.succeed(new NameAndVersionPropsStrategy(name, path, namePath));
             }
             case 'name@version': {
@@ -40,7 +47,7 @@ export function getCustomTypes({ rcFile, }) {
                 return Effect.succeed(new VersionsByNameStrategy(name, path));
             }
             default: {
-                return createError(config, ERR_STRATEGY);
+                return createError(config, errStrategy);
             }
         }
     }));