syncpack 12.2.0 → 12.3.1

package/dist/bin-update/index.js

@@ -1,19 +1,14 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const chalk_1 = __importDefault(require("chalk"));
-const commander_1 = require("commander");
-const effect_1 = require("effect");
-const io_1 = require("../io");
-const show_help_on_error_1 = require("../lib/show-help-on-error");
-const option_1 = require("../option");
-const update_1 = require("./update");
-commander_1.program.description('  Update to the latest versions on the npm registry.');
-commander_1.program.on('--help', () => {
-    console.log((0, chalk_1.default) `
+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 { 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
@@ -42,18 +37,18 @@ Reference:
   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.specs)
-    .option(...option_1.option.types)
+showHelpOnError(program);
+program
+    .option(...option.source)
+    .option(...option.filter)
+    .option(...option.config)
+    .option(...option.specs)
+    .option(...option.types)
     .parse(process.argv);
-effect_1.Effect.runPromise((0, update_1.update)(io_1.io, {
-    configPath: commander_1.program.opts().config,
-    filter: commander_1.program.opts().filter,
-    source: commander_1.program.opts().source,
-    specs: commander_1.program.opts().specs,
-    types: commander_1.program.opts().types,
+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 +1,6 @@
 import { Effect } from 'effect';
-import { type CliConfig } from '../config/types';
-import type { ErrorHandlers } from '../error-handlers/default-error-handlers';
-import type { Io } from '../io';
-import { updateEffects } from './effects';
-export declare function update(io: Io, cli: Partial<CliConfig>, effects?: typeof updateEffects, errorHandlers?: ErrorHandlers): Effect.Effect<never, never, unknown>;
+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,66 +1,58 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.update = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const effect_1 = require("effect");
-const semver_1 = require("semver");
-const tag_1 = require("../config/tag");
-const constants_1 = require("../constants");
-const default_error_handlers_1 = require("../error-handlers/default-error-handlers");
-const get_context_1 = require("../get-context");
-const get_instances_1 = require("../get-instances");
-const io_1 = require("../io");
-const exit_if_invalid_1 = require("../io/exit-if-invalid");
-const write_if_changed_1 = require("../io/write-if-changed");
-const with_logger_1 = require("../lib/with-logger");
-const specifier_1 = require("../specifier");
-const effects_1 = require("./effects");
-function update(io, cli, effects = effects_1.updateEffects, errorHandlers = default_error_handlers_1.defaultErrorHandlers) {
-    return (0, effect_1.pipe)(effect_1.Effect.Do, effect_1.Effect.bind('ctx', () => (0, get_context_1.getContext)({ io, cli, errorHandlers })), effect_1.Effect.bind('instances', ({ ctx }) => (0, get_instances_1.getInstances)(ctx, io, errorHandlers)), effect_1.Effect.bind('update', ({ instances }) => (0, effect_1.pipe)(effect_1.Effect.succeed(instances.all), effect_1.Effect.map((instances) => {
+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('updateable', ({ instances }) => {
         const isVisitedByName = {};
         const updateable = [];
-        instances.forEach((instance) => {
-            if (!isVisitedByName[instance.name] &&
-                (instance.versionGroup._tag === 'SameRange' ||
-                    instance.versionGroup._tag === 'Standard')) {
-                const specifier = specifier_1.Specifier.create(instance, instance.rawSpecifier.raw);
+        instances.all.forEach((instance) => {
+            const _tag = instance.versionGroup._tag;
+            if (!isVisitedByName[instance.name] && (_tag === 'SameRange' || _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_1.Effect.tap(effects_1.updateEffects.onFetchAllStart), effect_1.Effect.flatMap((instances) => (0, effect_1.pipe)(instances, effect_1.Effect.partition((instance) => (0, effect_1.pipe)(effect_1.Effect.succeed(instance), effect_1.Effect.tap(() => effects_1.updateEffects.onFetchStart(instance, instances.length)), effect_1.Effect.flatMap(effects.fetchLatestVersions), effect_1.Effect.tapBoth({
-        onFailure: () => effects_1.updateEffects.onFetchEnd(instance),
-        onSuccess: ({ versions }) => effects_1.updateEffects.onFetchEnd(instance, versions),
+        return Effect.succeed(updateable);
+    }), Effect.bind('update', ({ updateable }) => pipe(Effect.succeed(updateable), Effect.tap(effects.onFetchAllStart), Effect.flatMap((instances) => pipe(instances, Effect.partition((instance) => pipe(Effect.succeed(instance), Effect.tap(() => effects.onFetchStart(instance, instances.length)), Effect.flatMap(effects.fetchLatestVersions), Effect.tapBoth({
+        onFailure: () => effects.onFetchEnd(instance),
+        onSuccess: ({ versions }) => effects.onFetchEnd(instance, versions),
     }), 
     // move up to date dependencies to error channel
-    effect_1.Effect.flatMap((updateable) => (0, semver_1.gtr)(updateable.versions.latest, String(instance.rawSpecifier.raw))
-        ? (0, effect_1.pipe)(effects_1.updateEffects.onOutdated(instance, updateable.versions.latest), effect_1.Effect.map(() => updateable))
-        : (0, effect_1.pipe)(effects_1.updateEffects.onUpToDate(instance), effect_1.Effect.flatMap(() => effect_1.Effect.fail(updateable)))), 
+    Effect.flatMap((updateable) => gtr(updateable.versions.latest, String(instance.rawSpecifier.raw))
+        ? pipe(effects.onOutdated(instance, updateable.versions.latest), Effect.map(() => updateable))
+        : pipe(effects.onUpToDate(instance), Effect.flatMap(() => Effect.fail(updateable)))), 
     // log error but don't catch it
-    effect_1.Effect.tapErrorTag('HttpError', ({ error }) => effect_1.Effect.logError((0, chalk_1.default) `{red ${constants_1.ICON.cross} ${error}}`)), 
+    Effect.tapErrorTag('HttpError', ({ error }) => Effect.logError(chalk `{red ${ICON.cross} ${error}}`)), 
     // log error but don't catch it
-    effect_1.Effect.tapErrorTag('NpmRegistryError', ({ error }) => effect_1.Effect.logError((0, chalk_1.default) `{red ${constants_1.ICON.cross} ${error}}`))), { concurrency: 10 }), 
+    Effect.tapErrorTag('NpmRegistryError', ({ error }) => Effect.logError(chalk `{red ${ICON.cross} ${error}}`))), { concurrency: 10 }), 
     // discard errors and up to date dependencies
-    effect_1.Effect.flatMap(([_, outOfDate]) => effect_1.Effect.succeed(outOfDate)))), 
+    Effect.flatMap(([_, outOfDate]) => Effect.succeed(outOfDate)))), 
     // always remove the spinner when we're done
-    effect_1.Effect.tapBoth({
-        onFailure: effects_1.updateEffects.onFetchAllEnd,
-        onSuccess: effects_1.updateEffects.onFetchAllEnd,
+    Effect.tapBoth({
+        onFailure: effects.onFetchAllEnd,
+        onSuccess: effects.onFetchAllEnd,
     }), 
     // ask the user which updates they want
-    effect_1.Effect.flatMap(effects_1.updateEffects.promptForUpdates), 
+    Effect.flatMap(effects.promptForUpdates), 
     // if we think the user cancelled, say so
-    effect_1.Effect.catchTag('PromptCancelled', () => effect_1.Effect.logInfo((0, chalk_1.default) `{red ${constants_1.ICON.panic}} aborting after {blue syncpack update} was cancelled`)))), effect_1.Effect.flatMap(({ ctx }) => (0, effect_1.pipe)((0, write_if_changed_1.writeIfChanged)(ctx), effect_1.Effect.catchTags({
-        WriteFileError: (0, effect_1.flow)(errorHandlers.WriteFileError, effect_1.Effect.map(() => {
+    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_1.Effect.flatMap(exit_if_invalid_1.exitIfInvalid), effect_1.Effect.withConcurrency(10), effect_1.Effect.provide((0, effect_1.pipe)(effect_1.Context.empty(), effect_1.Context.add(tag_1.CliConfigTag, cli), effect_1.Context.add(io_1.IoTag, io))), with_logger_1.withLogger);
+    }))), Effect.flatMap(exitIfInvalid), Effect.withConcurrency(10), Effect.provide(pipe(Context.empty(), Context.add(CliConfigTag, cli), Context.add(IoTag, io))), withLogger);
 }
-exports.update = update;

package/dist/bin.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-commander_1.program
-    .version(require('../package.json').version)
+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
+    .version(JSON.parse(fs.readFileSync(`${__dirname}/../package.json`, 'utf8')).version)
     .command('fix-mismatches', 'set dependencies used with different versions to the same version', {
     executableFile: './bin-fix-mismatches/index.js',
 })

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

@@ -1,19 +1,19 @@
-import { Data, Effect } from 'effect';
-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';
-import { VersionsByNameStrategy } from '../strategy/versions-by-name';
+import { Effect } from 'effect';
+import type { Ctx } from '../get-context/index.js';
+import { NameAndVersionPropsStrategy } from '../strategy/name-and-version-props.js';
+import { NamedVersionStringStrategy } from '../strategy/named-version-string.js';
+import { UnnamedVersionStringStrategy } from '../strategy/unnamed-version-string.js';
+import { VersionsByNameStrategy } from '../strategy/versions-by-name.js';
 export declare namespace Strategy {
     type Any = NameAndVersionPropsStrategy | NamedVersionStringStrategy | UnnamedVersionStringStrategy | VersionsByNameStrategy;
 }
-declare const InvalidCustomTypeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
+declare const InvalidCustomTypeError_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: "InvalidCustomTypeError";
-}>;
+};
 export declare class InvalidCustomTypeError extends InvalidCustomTypeError_base<{
     readonly config: unknown;
     readonly reason: string;
 }> {
 }
-export declare function getCustomTypes({ rcFile, }: Ctx['config']): Effect.Effect<never, InvalidCustomTypeError, Strategy.Any[]>;
+export declare function getCustomTypes({ rcFile, }: Ctx['config']): Effect.Effect<Strategy.Any[], InvalidCustomTypeError>;
 export {};

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

@@ -1,47 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCustomTypes = exports.InvalidCustomTypeError = void 0;
-const effect_1 = require("effect");
-const is_non_empty_object_1 = require("tightrope/guard/is-non-empty-object");
-const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
-const is_object_1 = require("tightrope/guard/is-object");
-const constants_1 = require("../constants");
-const name_and_version_props_1 = require("../strategy/name-and-version-props");
-const named_version_string_1 = require("../strategy/named-version-string");
-const unnamed_version_string_1 = require("../strategy/unnamed-version-string");
-const versions_by_name_1 = require("../strategy/versions-by-name");
-class InvalidCustomTypeError extends effect_1.Data.TaggedClass('InvalidCustomTypeError') {
+import { Data, Effect } from 'effect';
+import { isNonEmptyObject } from 'tightrope/guard/is-non-empty-object.js';
+import { isNonEmptyString } from 'tightrope/guard/is-non-empty-string.js';
+import { isObject } from 'tightrope/guard/is-object.js';
+import { DEFAULT_CONFIG } from '../constants.js';
+import { NameAndVersionPropsStrategy } from '../strategy/name-and-version-props.js';
+import { NamedVersionStringStrategy } from '../strategy/named-version-string.js';
+import { UnnamedVersionStringStrategy } from '../strategy/unnamed-version-string.js';
+import { VersionsByNameStrategy } from '../strategy/versions-by-name.js';
+export class InvalidCustomTypeError extends Data.TaggedClass('InvalidCustomTypeError') {
 }
-exports.InvalidCustomTypeError = InvalidCustomTypeError;
-function getCustomTypes({ rcFile, }) {
-    if (!(0, is_non_empty_object_1.isNonEmptyObject)(rcFile.customTypes))
-        return effect_1.Effect.succeed([]);
-    return effect_1.Effect.all([...Object.entries(rcFile.customTypes), ...Object.entries(constants_1.DEFAULT_CONFIG.customTypes)].map(([name, config]) => {
+export function getCustomTypes({ rcFile, }) {
+    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 (!(0, is_object_1.isObject)(config))
+        if (!isObject(config))
             return createError(config, ERR_OBJ);
-        if (!(0, is_non_empty_string_1.isNonEmptyString)(config.path))
+        if (!isNonEmptyString(config.path))
             return createError(config, ERR_PATH);
         const path = config.path;
         const strategy = config.strategy;
         switch (strategy) {
             case 'name~version': {
                 const namePath = config.namePath;
-                if (!(0, is_non_empty_string_1.isNonEmptyString)(namePath))
+                if (!isNonEmptyString(namePath))
                     return createError(config, ERR_NAME_PATH);
-                return effect_1.Effect.succeed(new name_and_version_props_1.NameAndVersionPropsStrategy(name, path, namePath));
+                return Effect.succeed(new NameAndVersionPropsStrategy(name, path, namePath));
             }
             case 'name@version': {
-                return effect_1.Effect.succeed(new named_version_string_1.NamedVersionStringStrategy(name, path));
+                return Effect.succeed(new NamedVersionStringStrategy(name, path));
             }
             case 'version': {
-                return effect_1.Effect.succeed(new unnamed_version_string_1.UnnamedVersionStringStrategy(name, path));
+                return Effect.succeed(new UnnamedVersionStringStrategy(name, path));
             }
             case 'versionsByName': {
-                return effect_1.Effect.succeed(new versions_by_name_1.VersionsByNameStrategy(name, path));
+                return Effect.succeed(new VersionsByNameStrategy(name, path));
             }
             default: {
                 return createError(config, ERR_STRATEGY);
@@ -49,7 +45,6 @@ function getCustomTypes({ rcFile, }) {
         }
     }));
 }
-exports.getCustomTypes = getCustomTypes;
 function createError(config, reason) {
-    return effect_1.Effect.fail(new InvalidCustomTypeError({ config, reason }));
+    return Effect.fail(new InvalidCustomTypeError({ config, reason }));
 }

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

@@ -1,17 +1,17 @@
-import { Data, Effect } from 'effect';
-import type { Ctx } from '../get-context';
-import type { InvalidCustomTypeError, Strategy } from './get-custom-types';
-declare const DeprecatedTypesError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
+import { Effect } from 'effect';
+import type { Ctx } from '../get-context/index.js';
+import type { InvalidCustomTypeError, Strategy } from './get-custom-types.js';
+declare const DeprecatedTypesError_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: "DeprecatedTypesError";
-}>;
+};
 export declare class DeprecatedTypesError extends DeprecatedTypesError_base<{
     readonly types: string[];
 }> {
 }
-declare const RenamedWorkspaceTypeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
+declare const RenamedWorkspaceTypeError_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: "RenamedWorkspaceTypeError";
-}>;
+};
 export declare class RenamedWorkspaceTypeError extends RenamedWorkspaceTypeError_base<Record<string, never>> {
 }
-export declare function getEnabledTypes({ cli, rcFile, }: Ctx['config']): Effect.Effect<never, DeprecatedTypesError | InvalidCustomTypeError | RenamedWorkspaceTypeError, Strategy.Any[]>;
+export declare function getEnabledTypes({ cli, rcFile, }: Ctx['config']): Effect.Effect<Strategy.Any[], DeprecatedTypesError | InvalidCustomTypeError | RenamedWorkspaceTypeError>;
 export {};

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

@@ -1,70 +1,65 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnabledTypes = exports.RenamedWorkspaceTypeError = exports.DeprecatedTypesError = void 0;
-const effect_1 = require("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_array_1 = require("tightrope/guard/is-non-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 effect_1.Data.TaggedClass('DeprecatedTypesError') {
+import { Data, Effect, pipe } from 'effect';
+import { isArrayOfStrings } from 'tightrope/guard/is-array-of-strings.js';
+import { isBoolean } from 'tightrope/guard/is-boolean.js';
+import { isEmptyArray } from 'tightrope/guard/is-empty-array.js';
+import { isNonEmptyArray } from 'tightrope/guard/is-non-empty-array.js';
+import { isNonEmptyString } from 'tightrope/guard/is-non-empty-string.js';
+import { INTERNAL_TYPES } from '../constants.js';
+import { NameAndVersionPropsStrategy } from '../strategy/name-and-version-props.js';
+import { VersionsByNameStrategy } from '../strategy/versions-by-name.js';
+import { getCustomTypes } from './get-custom-types.js';
+export class DeprecatedTypesError extends Data.TaggedClass('DeprecatedTypesError') {
 }
-exports.DeprecatedTypesError = DeprecatedTypesError;
-class RenamedWorkspaceTypeError extends effect_1.Data.TaggedClass('RenamedWorkspaceTypeError') {
+export class RenamedWorkspaceTypeError extends Data.TaggedClass('RenamedWorkspaceTypeError') {
 }
-exports.RenamedWorkspaceTypeError = RenamedWorkspaceTypeError;
-function getEnabledTypes({ cli, rcFile, }) {
-    return (0, effect_1.pipe)(
+export function getEnabledTypes({ cli, rcFile, }) {
+    return pipe(
     // Look for dependency types defined using the old `{ prod: true }` syntax
     // deprecated in syncpack@9.0.0
-    effect_1.Effect.succeed(constants_1.INTERNAL_TYPES.filter((key) => (0, is_boolean_1.isBoolean)(rcFile[key]))), 
+    Effect.succeed(INTERNAL_TYPES.filter((key) => isBoolean(rcFile[key]))), 
     // Short-circuit and quit if deprecated config is used
-    effect_1.Effect.flatMap((deprecatedTypeProps) => deprecatedTypeProps.length > 0
-        ? effect_1.Effect.fail(new DeprecatedTypesError({ types: deprecatedTypeProps }))
-        : effect_1.Effect.unit), effect_1.Effect.flatMap(() => (0, effect_1.pipe)(effect_1.Effect.Do, 
+    Effect.flatMap((deprecatedTypeProps) => deprecatedTypeProps.length > 0
+        ? Effect.fail(new DeprecatedTypesError({ types: deprecatedTypeProps }))
+        : Effect.void), Effect.flatMap(() => pipe(Effect.Do, 
     // Get index of every available strategy, keyed by their names as
     // they're referred to in config
-    effect_1.Effect.bind('allStrategiesByName', () => (0, effect_1.pipe)(
+    Effect.bind('allStrategiesByName', () => pipe(
     // Get custom types if any are defined, short-circuit and quit if
     // any are invalid
-    (0, get_custom_types_1.getCustomTypes)({ cli, rcFile }), 
+    getCustomTypes({ cli, rcFile }), 
     // Combine them with the default/internal dependency types
-    effect_1.Effect.map((customTypes) => Object.fromEntries([
-        ['dev', new versions_by_name_1.VersionsByNameStrategy('dev', 'devDependencies')],
-        ['local', new name_and_version_props_1.NameAndVersionPropsStrategy('local', 'version', 'name')],
-        ['overrides', new versions_by_name_1.VersionsByNameStrategy('overrides', 'overrides')],
-        ['peer', new versions_by_name_1.VersionsByNameStrategy('peer', 'peerDependencies')],
-        ['pnpmOverrides', new versions_by_name_1.VersionsByNameStrategy('pnpmOverrides', 'pnpm.overrides')],
-        ['prod', new versions_by_name_1.VersionsByNameStrategy('prod', 'dependencies')],
-        ['resolutions', new versions_by_name_1.VersionsByNameStrategy('resolutions', 'resolutions')],
+    Effect.map((customTypes) => Object.fromEntries([
+        ['dev', new VersionsByNameStrategy('dev', 'devDependencies')],
+        ['local', new NameAndVersionPropsStrategy('local', 'version', 'name')],
+        ['overrides', new VersionsByNameStrategy('overrides', 'overrides')],
+        ['peer', new VersionsByNameStrategy('peer', 'peerDependencies')],
+        ['pnpmOverrides', new VersionsByNameStrategy('pnpmOverrides', 'pnpm.overrides')],
+        ['prod', new VersionsByNameStrategy('prod', 'dependencies')],
+        ['resolutions', new VersionsByNameStrategy('resolutions', 'resolutions')],
         ...customTypes.map((type) => [type.name, type]),
     ])))), 
     // The names of every available strategy
-    effect_1.Effect.bind('allStrategyNames', ({ allStrategiesByName }) => effect_1.Effect.succeed(Object.keys(allStrategiesByName))), 
+    Effect.bind('allStrategyNames', ({ allStrategiesByName }) => Effect.succeed(Object.keys(allStrategiesByName))), 
     // Create groupings to assign each provided dependencyType to
-    effect_1.Effect.bind('strategyNamesByStatus', () => effect_1.Effect.succeed({
-        provided: ((0, is_non_empty_string_1.isNonEmptyString)(cli.types)
+    Effect.bind('strategyNamesByStatus', () => Effect.succeed({
+        provided: (isNonEmptyString(cli.types)
             ? cli.types.split(',')
-            : (0, is_array_of_strings_1.isArrayOfStrings)(rcFile.dependencyTypes)
+            : isArrayOfStrings(rcFile.dependencyTypes)
                 ? rcFile.dependencyTypes
-                : []).filter(is_non_empty_string_1.isNonEmptyString),
+                : []).filter(isNonEmptyString),
         enabled: [],
         positive: [],
         negative: [],
-    })))), effect_1.Effect.tap(({ strategyNamesByStatus }) => effect_1.Effect.logDebug(`dependency types provided by user: ${JSON.stringify(strategyNamesByStatus.provided)}`)), 
+    })))), Effect.tap(({ strategyNamesByStatus }) => Effect.logDebug(`dependency types provided by user: ${JSON.stringify(strategyNamesByStatus.provided)}`)), 
     // Determine which dependencyTypes should be enabled based on:
     // * which are defined
     // * which were listed to be enabled
     // * which were listed but !negated
     // * etc.
-    effect_1.Effect.flatMap(({ allStrategiesByName, allStrategyNames, strategyNamesByStatus }) => {
-        if ((0, is_empty_array_1.isEmptyArray)(strategyNamesByStatus.provided) ||
+    Effect.flatMap(({ allStrategiesByName, allStrategyNames, strategyNamesByStatus }) => {
+        if (isEmptyArray(strategyNamesByStatus.provided) ||
             strategyNamesByStatus.provided.join('') === '**') {
-            return effect_1.Effect.succeed(allStrategyNames.map(getStrategyByName));
+            return Effect.succeed(allStrategyNames.map(getStrategyByName));
         }
         strategyNamesByStatus.provided.forEach((name) => {
             if (name.startsWith('!')) {
@@ -74,14 +69,14 @@ function getEnabledTypes({ cli, rcFile, }) {
                 strategyNamesByStatus.positive.push(name);
             }
         });
-        if ((0, is_non_empty_array_1.isNonEmptyArray)(strategyNamesByStatus.negative)) {
+        if (isNonEmptyArray(strategyNamesByStatus.negative)) {
             allStrategyNames.forEach((name) => {
                 if (!strategyNamesByStatus.negative.includes(name)) {
                     strategyNamesByStatus.enabled.push(name);
                 }
             });
         }
-        if ((0, is_non_empty_array_1.isNonEmptyArray)(strategyNamesByStatus.positive)) {
+        if (isNonEmptyArray(strategyNamesByStatus.positive)) {
             strategyNamesByStatus.positive.forEach((name) => {
                 if (!strategyNamesByStatus.enabled.includes(name)) {
                     strategyNamesByStatus.enabled.push(name);
@@ -89,12 +84,11 @@ function getEnabledTypes({ cli, rcFile, }) {
             });
         }
         if (strategyNamesByStatus.enabled.includes('workspace')) {
-            return effect_1.Effect.fail(new RenamedWorkspaceTypeError({}));
+            return Effect.fail(new RenamedWorkspaceTypeError({}));
         }
-        return effect_1.Effect.succeed(strategyNamesByStatus.enabled.map(getStrategyByName));
+        return Effect.succeed(strategyNamesByStatus.enabled.map(getStrategyByName));
         function getStrategyByName(type) {
             return allStrategiesByName[type];
         }
-    }), effect_1.Effect.tap((enabledTypes) => effect_1.Effect.logDebug(`enabled dependency types determined to be: ${JSON.stringify(enabledTypes)}`)));
+    }), Effect.tap((enabledTypes) => Effect.logDebug(`enabled dependency types determined to be: ${JSON.stringify(enabledTypes)}`)));
 }
-exports.getEnabledTypes = getEnabledTypes;

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

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

package/dist/config/get-filter.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFilter = void 0;
-const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
-function getFilter({ cli, rcFile }) {
+import { isNonEmptyString } from 'tightrope/guard/is-non-empty-string.js';
+import { DEFAULT_CONFIG } from '../constants.js';
+export function getFilter({ cli, rcFile }) {
     // @TODO Deprecate `filter` in .syncpackrc
-    return (0, is_non_empty_string_1.isNonEmptyString)(cli.filter)
+    return isNonEmptyString(cli.filter)
         ? cli.filter
-        : (0, is_non_empty_string_1.isNonEmptyString)(rcFile.filter)
+        : isNonEmptyString(rcFile.filter)
             ? rcFile.filter
-            : '.';
+            : DEFAULT_CONFIG.filter;
 }
-exports.getFilter = getFilter;

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

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

package/dist/config/get-indent.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIndent = void 0;
-const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
-function getIndent({ cli, rcFile }) {
-    return (0, is_non_empty_string_1.isNonEmptyString)(cli.indent)
+import { isNonEmptyString } from 'tightrope/guard/is-non-empty-string.js';
+import { DEFAULT_CONFIG } from '../constants.js';
+export function getIndent({ cli, rcFile }) {
+    return isNonEmptyString(cli.indent)
         ? cli.indent.replaceAll('\\t', '\t')
-        : (0, is_non_empty_string_1.isNonEmptyString)(rcFile.indent)
+        : isNonEmptyString(rcFile.indent)
             ? rcFile.indent
-            : '  ';
+            : DEFAULT_CONFIG.indent;
 }
-exports.getIndent = getIndent;

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

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

package/dist/config/get-sort-az.js

@@ -1,19 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSortAz = void 0;
-const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
-function getSortAz({ rcFile }) {
-    return (0, is_array_of_strings_1.isArrayOfStrings)(rcFile.sortAz)
+import { isArrayOfStrings } from 'tightrope/guard/is-array-of-strings.js';
+import { isEmptyArray } from 'tightrope/guard/is-empty-array.js';
+import { DEFAULT_CONFIG } from '../constants.js';
+export function getSortAz({ rcFile }) {
+    return isArrayOfStrings(rcFile.sortAz) || isEmptyArray(rcFile.sortAz)
         ? rcFile.sortAz
-        : [
-            'bin',
-            'contributors',
-            'dependencies',
-            'devDependencies',
-            'keywords',
-            'peerDependencies',
-            'resolutions',
-            'scripts',
-        ];
+        : DEFAULT_CONFIG.sortAz;
 }
-exports.getSortAz = getSortAz;

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

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

package/dist/config/get-sort-exports.js

@@ -0,0 +1,8 @@
+import { isArrayOfStrings } from 'tightrope/guard/is-array-of-strings.js';
+import { isEmptyArray } from 'tightrope/guard/is-empty-array.js';
+import { DEFAULT_CONFIG } from '../constants.js';
+export function getSortExports({ rcFile }) {
+    return isArrayOfStrings(rcFile.sortExports) || isEmptyArray(rcFile.sortExports)
+        ? rcFile.sortExports
+        : DEFAULT_CONFIG.sortExports;
+}

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

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

package/dist/config/get-sort-first.js

@@ -1,10 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSortFirst = void 0;
-const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
-function getSortFirst({ rcFile }) {
-    return (0, is_array_of_strings_1.isArrayOfStrings)(rcFile.sortFirst)
+import { isArrayOfStrings } from 'tightrope/guard/is-array-of-strings.js';
+import { isEmptyArray } from 'tightrope/guard/is-empty-array.js';
+import { DEFAULT_CONFIG } from '../constants.js';
+export function getSortFirst({ rcFile }) {
+    return isArrayOfStrings(rcFile.sortFirst) || isEmptyArray(rcFile.sortFirst)
         ? rcFile.sortFirst
-        : ['name', 'description', 'version', 'author'];
+        : DEFAULT_CONFIG.sortFirst;
 }
-exports.getSortFirst = getSortFirst;