syncpack 13.0.1 → 14.0.0-alpha.2

package/dist/bin.js

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { program } from 'commander';
-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',
-})
-    .command('format', 'sort and shorten properties according to a convention', {
-    executableFile: './bin-format/index.js',
-})
-    .command('lint', 'lint all versions and ranges', {
-    executableFile: './bin-lint/index.js',
-})
-    .command('lint-semver-ranges', 'check dependency versions comply with the given semver range format', {
-    executableFile: './bin-lint-semver-ranges/index.js',
-})
-    .command('list-mismatches', 'list every dependency used with different versions in your packages', {
-    executableFile: './bin-list-mismatches/index.js',
-})
-    .command('list', 'list every dependency used in your packages', {
-    executableFile: './bin-list/index.js',
-})
-    .command('prompt', 'fix mismatches which syncpack cannot fix automatically', {
-    executableFile: './bin-prompt/index.js',
-})
-    .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,19 +0,0 @@
-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<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<Strategy.Any[], InvalidCustomTypeError>;
-export {};

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

@@ -1,57 +0,0 @@
-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') {
-}
-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 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, errNamePath);
-                }
-                return Effect.succeed(new NameAndVersionPropsStrategy(name, path, namePath));
-            }
-            case 'name@version': {
-                return Effect.succeed(new NamedVersionStringStrategy(name, path));
-            }
-            case 'version': {
-                return Effect.succeed(new UnnamedVersionStringStrategy(name, path));
-            }
-            case 'versionsByName': {
-                return Effect.succeed(new VersionsByNameStrategy(name, path));
-            }
-            default: {
-                return createError(config, errStrategy);
-            }
-        }
-    }));
-}
-function createError(config, reason) {
-    return Effect.fail(new InvalidCustomTypeError({ config, reason }));
-}

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

@@ -1,17 +0,0 @@
-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<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<Strategy.Any[], DeprecatedTypesError | InvalidCustomTypeError | RenamedWorkspaceTypeError>;
-export {};

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

@@ -1,109 +0,0 @@
-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') {
-}
-export class RenamedWorkspaceTypeError extends Data.TaggedClass('RenamedWorkspaceTypeError') {
-}
-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.succeed(INTERNAL_TYPES.filter(key => isBoolean(rcFile[key]))), 
-    // Short-circuit and quit if deprecated config is used
-    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.bind('allStrategiesByName', () => pipe(
-    // Get custom types if any are defined, short-circuit and quit if
-    // any are invalid
-    getCustomTypes({ cli, rcFile }), 
-    // Combine them with the default/internal dependency types
-    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.bind('allStrategyNames', ({ allStrategiesByName }) => Effect.succeed(Object.keys(allStrategiesByName))), 
-    // Create groupings to assign each provided dependencyType to
-    Effect.bind('strategyNamesByStatus', () => Effect.succeed({
-        provided: (isNonEmptyString(cli.types)
-            ? cli.types.split(',')
-            : isArrayOfStrings(rcFile.dependencyTypes)
-                ? rcFile.dependencyTypes
-                : []).filter(isNonEmptyString),
-        enabled: [],
-        positive: [],
-        negative: [],
-    })))), 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.flatMap(({ allStrategiesByName, allStrategyNames, strategyNamesByStatus }) => {
-        if (isEmptyArray(strategyNamesByStatus.provided) ||
-            strategyNamesByStatus.provided.join('') === '**') {
-            return Effect.succeed(allStrategyNames.map(getStrategyByName));
-        }
-        strategyNamesByStatus.provided.forEach(name => {
-            if (name.startsWith('!')) {
-                strategyNamesByStatus.negative.push(name.replace('!', ''));
-            }
-            else {
-                strategyNamesByStatus.positive.push(name);
-            }
-        });
-        if (isNonEmptyArray(strategyNamesByStatus.negative)) {
-            allStrategyNames.forEach(name => {
-                if (!strategyNamesByStatus.negative.includes(name)) {
-                    strategyNamesByStatus.enabled.push(name);
-                }
-            });
-        }
-        if (isNonEmptyArray(strategyNamesByStatus.positive)) {
-            strategyNamesByStatus.positive.forEach(name => {
-                if (!strategyNamesByStatus.enabled.includes(name)) {
-                    strategyNamesByStatus.enabled.push(name);
-                }
-            });
-        }
-        if (strategyNamesByStatus.enabled.includes('workspace')) {
-            return Effect.fail(new RenamedWorkspaceTypeError({}));
-        }
-        return Effect.succeed(strategyNamesByStatus.enabled.map(getStrategyByName));
-        function getStrategyByName(type) {
-            return allStrategiesByName[type];
-        }
-    }), Effect.tap(enabledTypes => Effect.logDebug(`enabled dependency types determined to be: ${JSON.stringify(enabledTypes)}`)));
-}

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

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

package/dist/config/get-filter.js

@@ -1,10 +0,0 @@
-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 isNonEmptyString(cli.filter)
-        ? cli.filter
-        : isNonEmptyString(rcFile.filter)
-            ? rcFile.filter
-            : DEFAULT_CONFIG.filter;
-}

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

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

package/dist/config/get-indent.js

@@ -1,9 +0,0 @@
-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')
-        : isNonEmptyString(rcFile.indent)
-            ? rcFile.indent
-            : DEFAULT_CONFIG.indent;
-}

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

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

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

@@ -1,8 +0,0 @@
-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
-        : DEFAULT_CONFIG.sortAz;
-}

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

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

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

@@ -1,9 +0,0 @@
-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 +0,0 @@
-import type { Ctx } from '../get-context/index.js';
-export declare function getSortFirst({ rcFile }: Ctx['config']): string[];

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

@@ -1,8 +0,0 @@
-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
-        : DEFAULT_CONFIG.sortFirst;
-}

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

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

package/dist/config/get-source.js

@@ -1,8 +0,0 @@
-import { isArrayOfStrings } from 'tightrope/guard/is-array-of-strings.js';
-export function getSource({ cli, rcFile }) {
-    return isArrayOfStrings(cli.source)
-        ? cli.source
-        : isArrayOfStrings(rcFile.source)
-            ? rcFile.source
-            : [];
-}

package/dist/config/tag.d.ts

@@ -1,3 +0,0 @@
-import { Context } from 'effect';
-import type { CliConfig } from './types.js';
-export declare const CliConfigTag: Context.Tag<Partial<CliConfig>, Partial<CliConfig>>;

package/dist/config/tag.js

@@ -1,2 +0,0 @@
-import { Context } from 'effect';
-export const CliConfigTag = Context.GenericTag('@services/CliConfigTag');

package/dist/config/types.d.ts

@@ -1,134 +0,0 @@
-import type { CUSTOM_TYPES } from '../constants.js';
-import type { Specifier } from '../specifier/index.js';
-/**
- * Aliases for semver range formats supported by syncpack
- *
- * Defaults to `""` to ensure that exact dependency versions are used instead of
- * loose ranges, but this can be overridden in your config file.
- *
- * | Supported Range |   Example |
- * | --------------- | --------: |
- * | `"<"`           |  `<1.4.2` |
- * | `"<="`          | `<=1.4.2` |
- * | `""`            |   `1.4.2` |
- * | `"~"`           |  `~1.4.2` |
- * | `"^"`           |  `^1.4.2` |
- * | `">="`          | `>=1.4.2` |
- * | `">"`           |  `>1.4.2` |
- * | `"*"`           |       `*` |
- *
- * @default ""
- */
-export type SemverRange = '' | '*' | '>' | '>=' | '.x' | '<' | '<=' | '^' | '~' | 'workspace:';
-type DefaultDependencyType = keyof typeof CUSTOM_TYPES;
-export type DependencyType = DefaultDependencyType | `!${DefaultDependencyType}` | (string & {});
-export type SpecifierType = Specifier.Any['name'] | `!${Specifier.Any['name']}` | (string & {});
-export interface GroupConfig {
-    dependencies?: string[];
-    dependencyTypes?: DependencyType[];
-    label?: string;
-    packages?: string[];
-    specifierTypes?: SpecifierType[];
-}
-export declare namespace SemverGroupConfig {
-    interface Disabled extends GroupConfig {
-        isDisabled: true;
-    }
-    interface Ignored extends GroupConfig {
-        isIgnored: true;
-    }
-    interface WithRange extends GroupConfig {
-        range: SemverRange;
-    }
-    type Any = Disabled | Ignored | WithRange;
-}
-export declare namespace VersionGroupConfig {
-    interface Banned extends GroupConfig {
-        isBanned: true;
-    }
-    interface Ignored extends GroupConfig {
-        isIgnored: true;
-    }
-    interface Pinned extends GroupConfig {
-        pinVersion: string;
-    }
-    interface SnappedTo extends GroupConfig {
-        snapTo: string[];
-    }
-    interface SameRange extends GroupConfig {
-        policy: 'sameRange';
-    }
-    interface Standard extends GroupConfig {
-        preferVersion?: 'highestSemver' | 'lowestSemver';
-    }
-    type Any = Banned | Ignored | Pinned | SameRange | SnappedTo | Standard;
-}
-declare namespace CustomTypeConfig {
-    interface NameAndVersionProps {
-        namePath: string;
-        path: string;
-        strategy: 'name~version';
-    }
-    interface NamedVersionString {
-        path: string;
-        strategy: 'name@version';
-    }
-    interface UnnamedVersionString {
-        path: string;
-        strategy: 'version';
-    }
-    interface VersionsByName {
-        path: string;
-        strategy: 'versionsByName';
-    }
-    type Any = NameAndVersionProps | NamedVersionString | UnnamedVersionString | VersionsByName;
-}
-export interface CliConfig {
-    readonly configPath?: string;
-    readonly filter: string;
-    readonly indent: string;
-    readonly source: string[];
-    readonly specs: string;
-    readonly types: string;
-}
-export interface RcConfig {
-    /** @see https://jamiemason.github.io/syncpack/integrations/json-schema */
-    $schema?: string;
-    /** @see https://jamiemason.github.io/syncpack/config/custom-types */
-    customTypes: {
-        [name: string]: CustomTypeConfig.Any;
-    };
-    /** @see https://jamiemason.github.io/syncpack/config/dependency-types */
-    dependencyTypes: DependencyType[];
-    /** @see https://jamiemason.github.io/syncpack/config/filter */
-    filter: string;
-    /** @see https://jamiemason.github.io/syncpack/config/format-bugs */
-    formatBugs: boolean;
-    /** @see https://jamiemason.github.io/syncpack/config/format-repository */
-    formatRepository: boolean;
-    /** @see https://jamiemason.github.io/syncpack/config/indent */
-    indent: string;
-    /** @see https://jamiemason.github.io/syncpack/config/lint-formatting */
-    lintFormatting: boolean;
-    /** @see https://jamiemason.github.io/syncpack/config/lint-semver-ranges */
-    lintSemverRanges: boolean;
-    /** @see https://jamiemason.github.io/syncpack/config/lint-versions */
-    lintVersions: boolean;
-    /** @see https://jamiemason.github.io/syncpack/config/semver-groups */
-    semverGroups: SemverGroupConfig.Any[];
-    /** @see https://jamiemason.github.io/syncpack/config/sort-az */
-    sortAz: string[];
-    /** @see https://jamiemason.github.io/syncpack/config/sort-exports */
-    sortExports: string[];
-    /** @see https://jamiemason.github.io/syncpack/config/sort-first */
-    sortFirst: string[];
-    /** @see https://jamiemason.github.io/syncpack/config/sort-packages */
-    sortPackages: boolean;
-    /** @see https://jamiemason.github.io/syncpack/config/source */
-    source: string[];
-    /** @see https://jamiemason.github.io/syncpack/config/specifier-types */
-    specifierTypes: SpecifierType[];
-    /** @see https://jamiemason.github.io/syncpack/config/version-groups */
-    versionGroups: VersionGroupConfig.Any[];
-}
-export {};

package/dist/config/types.js

@@ -1 +0,0 @@
-export {};

package/dist/constants.d.ts

@@ -1,106 +0,0 @@
-/** Single source of truth, intended to aid testing or to override */
-export declare const CWD: string;
-/** Single source of truth for icons used in output */
-export declare const ICON: {
-    readonly banned: "⦸";
-    readonly cross: "✘";
-    readonly debug: "?";
-    readonly info: "i";
-    readonly panic: "!";
-    readonly rightArrow: "→";
-    readonly skip: "-";
-    readonly tick: "✓";
-};
-export declare const RANGE: {
-    readonly ANY: "*";
-    readonly EXACT: "";
-    readonly GT: ">";
-    readonly GTE: ">=";
-    readonly LOOSE: ".x";
-    readonly LT: "<";
-    readonly LTE: "<=";
-    readonly MINOR: "^";
-    readonly PATCH: "~";
-    readonly WORKSPACE: "workspace:";
-};
-export declare const INTERNAL_TYPES: readonly ["dev", "local", "overrides", "peer", "pnpmOverrides", "prod", "resolutions"];
-export declare const CUSTOM_TYPES: {
-    readonly dev: {
-        readonly strategy: "versionsByName";
-        readonly path: "devDependencies";
-    };
-    readonly local: {
-        readonly strategy: "name~version";
-        readonly namePath: "name";
-        readonly path: "version";
-    };
-    readonly overrides: {
-        readonly strategy: "versionsByName";
-        readonly path: "overrides";
-    };
-    readonly peer: {
-        readonly strategy: "versionsByName";
-        readonly path: "peerDependencies";
-    };
-    readonly pnpmOverrides: {
-        readonly strategy: "versionsByName";
-        readonly path: "pnpm.overrides";
-    };
-    readonly prod: {
-        readonly strategy: "versionsByName";
-        readonly path: "dependencies";
-    };
-    readonly resolutions: {
-        readonly strategy: "versionsByName";
-        readonly path: "resolutions";
-    };
-};
-export declare const DEFAULT_CONFIG: {
-    customTypes: {
-        readonly dev: {
-            readonly strategy: "versionsByName";
-            readonly path: "devDependencies";
-        };
-        readonly local: {
-            readonly strategy: "name~version";
-            readonly namePath: "name";
-            readonly path: "version";
-        };
-        readonly overrides: {
-            readonly strategy: "versionsByName";
-            readonly path: "overrides";
-        };
-        readonly peer: {
-            readonly strategy: "versionsByName";
-            readonly path: "peerDependencies";
-        };
-        readonly pnpmOverrides: {
-            readonly strategy: "versionsByName";
-            readonly path: "pnpm.overrides";
-        };
-        readonly prod: {
-            readonly strategy: "versionsByName";
-            readonly path: "dependencies";
-        };
-        readonly resolutions: {
-            readonly strategy: "versionsByName";
-            readonly path: "resolutions";
-        };
-    };
-    dependencyTypes: "**"[];
-    filter: string;
-    formatBugs: true;
-    formatRepository: true;
-    indent: string;
-    lintFormatting: true;
-    lintSemverRanges: true;
-    lintVersions: true;
-    semverGroups: never[];
-    sortAz: string[];
-    sortExports: string[];
-    sortFirst: string[];
-    sortPackages: true;
-    source: string[];
-    specifierTypes: "**"[];
-    versionGroups: never[];
-};