syncpack 10.5.1 → 10.7.2

package/dist/bin-update/effects.js

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

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

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

package/dist/bin-update/index.js

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

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

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

package/dist/bin-update/update.js

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

package/dist/bin.js

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

package/dist/config/get-custom-types.d.ts

@@ -1,4 +1,4 @@
-import type { Context } from '../get-context';
+import type { Ctx } from '../get-context';
 import { NameAndVersionPropsStrategy } from '../strategy/name-and-version-props';
 import { NamedVersionStringStrategy } from '../strategy/named-version-string';
 import { UnnamedVersionStringStrategy } from '../strategy/unnamed-version-string';
@@ -6,4 +6,4 @@ import { VersionsByNameStrategy } from '../strategy/versions-by-name';
 export declare namespace Strategy {
     type Any = NameAndVersionPropsStrategy | NamedVersionStringStrategy | UnnamedVersionStringStrategy | VersionsByNameStrategy;
 }
-export declare function getCustomTypes({ rcFile }: Context['config']): Strategy.Any[];
+export declare function getCustomTypes({ rcFile }: Ctx['config']): Strategy.Any[];

package/dist/config/get-enabled-types.d.ts

@@ -1,3 +1,13 @@
-import type { Context } from '../get-context';
+import * as Data from '@effect/data/Data';
+import * as Effect from '@effect/io/Effect';
+import type { Ctx } from '../get-context';
 import type { Strategy } from './get-custom-types';
-export declare function getEnabledTypes({ cli, rcFile, }: Context['config']): Strategy.Any[];
+declare const DeprecatedTypesError_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+    _tag: "DeprecatedTypesError";
+}>;
+export declare class DeprecatedTypesError extends DeprecatedTypesError_base<{
+    readonly types: string[];
+}> {
+}
+export declare function getEnabledTypes({ cli, rcFile, }: Ctx['config']): Effect.Effect<never, DeprecatedTypesError, Strategy.Any[]>;
+export {};

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

@@ -1,12 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnabledTypes = void 0;
+exports.getEnabledTypes = exports.DeprecatedTypesError = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Effect = __importStar(require("@effect/io/Effect"));
 const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
+const is_boolean_1 = require("tightrope/guard/is-boolean");
 const is_empty_array_1 = require("tightrope/guard/is-empty-array");
 const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
+const constants_1 = require("../constants");
 const name_and_version_props_1 = require("../strategy/name-and-version-props");
 const versions_by_name_1 = require("../strategy/versions-by-name");
 const get_custom_types_1 = require("./get-custom-types");
+class DeprecatedTypesError extends Data.TaggedClass('DeprecatedTypesError') {
+}
+exports.DeprecatedTypesError = DeprecatedTypesError;
+// @TODO accept `dependencyTypes: ['**']`
+// @TODO support `dependencyTypes: ['!dev']`
 function getEnabledTypes({ cli, rcFile, }) {
     const enabledTypes = [];
     const enabledTypeNames = ((0, is_non_empty_string_1.isNonEmptyString)(cli.types)
@@ -14,9 +46,11 @@ function getEnabledTypes({ cli, rcFile, }) {
         : (0, is_array_of_strings_1.isArrayOfStrings)(rcFile.dependencyTypes)
             ? rcFile.dependencyTypes
             : []).filter(is_non_empty_string_1.isNonEmptyString);
-    // @TODO accept `dependencyTypes: ['**']`
-    // @TODO support `dependencyTypes: ['!dev']`
     const useDefaults = (0, is_empty_array_1.isEmptyArray)(enabledTypeNames);
+    const deprecatedTypes = constants_1.DEFAULT_CONFIG.dependencyTypes.filter((key) => (0, is_boolean_1.isBoolean)(rcFile[key]));
+    if (deprecatedTypes.length > 0) {
+        return Effect.fail(new DeprecatedTypesError({ types: deprecatedTypes }));
+    }
     if (useDefaults || enabledTypeNames.includes('dev')) {
         enabledTypes.push(new versions_by_name_1.VersionsByNameStrategy('dev', 'devDependencies'));
     }
@@ -43,6 +77,6 @@ function getEnabledTypes({ cli, rcFile, }) {
             enabledTypes.push(customType);
         }
     });
-    return enabledTypes;
+    return Effect.succeed(enabledTypes);
 }
 exports.getEnabledTypes = getEnabledTypes;

package/dist/config/get-filter.d.ts

@@ -1,2 +1,2 @@
-import type { Context } from '../get-context';
-export declare function getFilter({ cli, rcFile }: Context['config']): string;
+import type { Ctx } from '../get-context';
+export declare function getFilter({ cli, rcFile }: Ctx['config']): string;

package/dist/config/get-indent.d.ts

@@ -1,2 +1,2 @@
-import type { Context } from '../get-context';
-export declare function getIndent({ cli, rcFile }: Context['config']): string;
+import type { Ctx } from '../get-context';
+export declare function getIndent({ cli, rcFile }: Ctx['config']): string;

package/dist/config/get-semver-range.d.ts

@@ -1,3 +1,3 @@
-import type { Context } from '../get-context';
+import type { Ctx } from '../get-context';
 import type { SemverRange } from './types';
-export declare function getSemverRange({ cli, rcFile, }: Context['config']): SemverRange;
+export declare function getSemverRange({ cli, rcFile }: Ctx['config']): SemverRange;

package/dist/config/get-semver-range.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSemverRange = void 0;
-const is_semver_1 = require("../lib/is-semver");
-function getSemverRange({ cli, rcFile, }) {
-    return (0, is_semver_1.isValidSemverRange)(cli.semverRange)
+const is_valid_semver_range_1 = require("../guards/is-valid-semver-range");
+function getSemverRange({ cli, rcFile }) {
+    return (0, is_valid_semver_range_1.isValidSemverRange)(cli.semverRange)
         ? cli.semverRange
-        : (0, is_semver_1.isValidSemverRange)(rcFile.semverRange)
+        : (0, is_valid_semver_range_1.isValidSemverRange)(rcFile.semverRange)
             ? rcFile.semverRange
             : '';
 }

package/dist/config/get-sort-az.d.ts

@@ -1,2 +1,2 @@
-import type { Context } from '../get-context';
-export declare function getSortAz({ rcFile }: Context['config']): string[];
+import type { Ctx } from '../get-context';
+export declare function getSortAz({ rcFile }: Ctx['config']): string[];

package/dist/config/get-sort-first.d.ts

@@ -1,2 +1,2 @@
-import type { Context } from '../get-context';
-export declare function getSortFirst({ rcFile }: Context['config']): string[];
+import type { Ctx } from '../get-context';
+export declare function getSortFirst({ rcFile }: Ctx['config']): string[];

package/dist/config/get-source.d.ts

@@ -1,2 +1,2 @@
-import type { Context } from '../get-context';
-export declare function getSource({ cli, rcFile }: Context['config']): string[];
+import type { Ctx } from '../get-context';
+export declare function getSource({ cli, rcFile }: Ctx['config']): string[];

package/dist/config/get-source.js

@@ -2,12 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSource = void 0;
 const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
-const constants_1 = require("../constants");
 function getSource({ cli, rcFile }) {
     return (0, is_array_of_strings_1.isArrayOfStrings)(cli.source)
         ? cli.source
         : (0, is_array_of_strings_1.isArrayOfStrings)(rcFile.source)
             ? rcFile.source
-            : [...constants_1.DEFAULT_CONFIG.source];
+            : [];
 }
 exports.getSource = getSource;

package/dist/config/types.d.ts

@@ -1,3 +1,4 @@
+import * as Context from '@effect/data/Context';
 import type { Union } from 'ts-toolbelt';
 /**
  * Aliases for semver range formats supported by syncpack
@@ -80,13 +81,14 @@ declare namespace CustomTypeConfig {
     type Any = Union.Strict<NameAndVersionProps | NamedVersionString | UnnamedVersionString | VersionsByName>;
 }
 export interface CliConfig {
-    configPath?: string;
-    filter: string;
-    indent: string;
-    semverRange: SemverRange;
-    source: string[];
-    types: string;
+    readonly configPath?: string;
+    readonly filter: string;
+    readonly indent: string;
+    readonly semverRange: SemverRange;
+    readonly source: string[];
+    readonly types: string;
 }
+export declare const CliConfigTag: Context.Tag<Partial<CliConfig>, Partial<CliConfig>>;
 export interface RcConfig {
     /** @see https://jamiemason.github.io/syncpack/config/custom-types */
     customTypes: Record<string, CustomTypeConfig.Any>;

package/dist/config/types.js

@@ -1,2 +1,28 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliConfigTag = void 0;
+const Context = __importStar(require("@effect/data/Context"));
+exports.CliConfigTag = Context.Tag();

package/dist/constants.d.ts

@@ -31,6 +31,6 @@ export declare const DEFAULT_CONFIG: {
     readonly semverRange: "";
     readonly sortAz: readonly ["contributors", "dependencies", "devDependencies", "keywords", "peerDependencies", "resolutions", "scripts"];
     readonly sortFirst: readonly ["name", "description", "version", "author"];
-    readonly source: readonly [];
+    readonly source: string[];
     readonly versionGroups: readonly [];
 };

package/dist/constants.js

@@ -50,6 +50,6 @@ exports.DEFAULT_CONFIG = {
         'scripts',
     ],
     sortFirst: ['name', 'description', 'version', 'author'],
-    source: [],
+    source: exports.DEFAULT_SOURCES,
     versionGroups: [],
 };

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

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

package/dist/create-program/effects.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+import * as Effect from '@effect/io/Effect';
+import type { DeprecatedTypesError } from '../config/get-enabled-types';
+import type { Env } from '../env/create-env';
+import type { Ctx } from '../get-context';
+import type { SemverGroupConfigError } from '../get-semver-groups';
+import type { SemverRangeEffects } from './effects';
+export declare function createSemverRangesProgram<T extends SemverRangeEffects<any>>(ctx: Ctx, effects: T): Effect.Effect<Env, SemverGroupConfigError | DeprecatedTypesError, Ctx>;