syncpack 12.4.0 → 14.0.0-alpha.1

package/dist/bin-update/effects.js

@@ -1,267 +0,0 @@
-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';
-import { isArray } from 'tightrope/guard/is-array.js';
-import { isEmptyObject } from 'tightrope/guard/is-empty-object.js';
-import { ICON } from '../constants.js';
-import { formatRepositoryUrl } from '../lib/format-repository-url.js';
-import { RingBuffer } from '../lib/ring-buffer.js';
-import { setSemverRange } from '../lib/set-semver-range.js';
-import { Specifier } from '../specifier/index.js';
-/** full release history from the npm registry for a given package */
-class Releases extends Data.TaggedClass('Releases') {
-}
-// https://github.com/terkelg/prompts?tab=readme-ov-file#prompts
-class PromptCancelled extends Data.TaggedClass('PromptCancelled') {
-}
-class HttpError extends Data.TaggedClass('HttpError') {
-}
-class NpmRegistryError extends Data.TaggedClass('NpmRegistryError') {
-}
-/** the API client for the terminal spinner */
-let spinner = null;
-/** how many HTTP requests have been sent */
-let fetchedCount = 0;
-/** how many instances have updates available */
-let outdatedCount = 0;
-/** names of instances currently being fetched from npm */
-const inFlight = new Set();
-/** names of instances most recently finished being fetched from npm */
-const mostRecent = new RingBuffer(5);
-/** page size when prompting */
-const optionsPerPage = 50;
-/** instance names in `inFlight` are formatted for display */
-function format(instance) {
-    return chalk `{gray ${instance.name}}`;
-}
-/** we need to remove colours when sorting loading status output */
-function stripAnsi(str) {
-    // eslint-disable-next-line no-control-regex
-    const ansiChars = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
-    return str.replace(ansiChars, '');
-}
-export const updateEffects = {
-    onFetchAllStart() {
-        if (!spinner)
-            spinner = ora().start();
-        fetchedCount = 0;
-        return Effect.void;
-    },
-    onFetchStart(instance, totalCount) {
-        inFlight.add(format(instance));
-        fetchedCount++;
-        if (spinner) {
-            const indent = `${EOL}  `;
-            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}`;
-        }
-        return Effect.void;
-    },
-    onFetchEnd(instance, versions) {
-        inFlight.delete(format(instance));
-        const latest = versions?.latest;
-        if (latest) {
-            if (gtr(latest, String(instance.rawSpecifier.raw), true)) {
-                outdatedCount++;
-                mostRecent.push(chalk `${instance.name} {gray {red ${String(instance.rawSpecifier.raw)}} ${ICON.rightArrow}} {green ${latest}}`);
-            }
-            else {
-                mostRecent.push(chalk `{green ${instance.name}}`);
-            }
-        }
-        return Effect.void;
-    },
-    /** After checking the registry, store this instance known to be up to date */
-    onUpToDate(instance) {
-        mostRecent.push(chalk `{green ${instance.name}}`);
-        return Effect.void;
-    },
-    /** After checking the registry, store this instance known to have newer versions available */
-    onOutdated(instance, latest) {
-        outdatedCount++;
-        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)
-            spinner.stop();
-        spinner = null;
-        fetchedCount = 0;
-        return Effect.void;
-    },
-    /** Fetch available versions for a given package from the npm registry */
-    fetchLatestVersions(instance) {
-        return pipe(fetchJson(`https://registry.npmjs.org/${instance.name}`), 
-        // parse and validate the specific data we expect
-        Effect.flatMap(Schema.decodeUnknownEither(Schema.Struct({
-            'dist-tags': Schema.Struct({ latest: 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;
-            return new Releases({
-                instance,
-                versions: {
-                    all: Object.keys(struct.time).filter((key) => key !== 'modified' && key !== 'created'),
-                    latest: struct['dist-tags'].latest,
-                },
-                repoUrl: formatRepositoryUrl(rawRepoUrl),
-            });
-        }), 
-        // hide ParseErrors and just treat them as another kind of NpmRegistryError
-        Effect.catchTags({
-            ParseError: () => Effect.fail(new NpmRegistryError({ error: `Invalid response for ${instance.name}` })),
-        }));
-    },
-    /** Given responses from npm, ask the user which they want */
-    promptForUpdates(outdated) {
-        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) => ({
-            title: chalk `${releasesByType[type].length} ${type}`,
-            selected: true,
-            value: type,
-        })))), 
-        // Ask which release types (major, minor, patch etc) they want
-        Effect.bind('releaseTypeAnswers', ({ releaseTypeQuestions }) => releaseTypeQuestions.length > 0
-            ? pipe(Effect.tryPromise({
-                try: () => prompts({
-                    name: 'releaseTypeAnswers',
-                    type: 'multiselect',
-                    instructions: true,
-                    message: `${outdated.length} updates are available`,
-                    choices: releaseTypeQuestions,
-                }).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)), 
-        /** Apply every update to the package.json files */
-        Effect.flatMap((doState) => pipe([
-            ...doState.prepatchAnswers,
-            ...doState.patchAnswers,
-            ...doState.preminorAnswers,
-            ...doState.minorAnswers,
-            ...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))));
-    },
-};
-function promptForReleaseType(releaseType, doState) {
-    const { releasesByType, releaseTypeAnswers } = doState;
-    const prop = `${releaseType}Answers`;
-    const releases = releasesByType[releaseType];
-    return releaseTypeAnswers.includes(releaseType)
-        ? pipe(Effect.tryPromise({
-            try: () => prompts({
-                name: prop,
-                type: 'multiselect',
-                instructions: false,
-                // @ts-expect-error optionsPerPage *does* exist https://github.com/terkelg/prompts#options-7
-                optionsPerPage,
-                message: `${releases.length} ${releaseType} updates`,
-                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 repoUrl = updateable.repoUrl
-                        ? chalk `${spacing} {white - ${updateable.repoUrl}}`
-                        : '';
-                    return {
-                        title: chalk `${updateable.instance.name} {gray ${String(updateable.instance.rawSpecifier.raw)} ${ICON.rightArrow}} {green ${updateable.versions.latest}} ${repoUrl}`,
-                        selected: true,
-                        value: updateable,
-                    };
-                }),
-            }),
-            catch: identity,
-        }), 
-        // Paper over errors in terkelg/prompts for now
-        Effect.catchAll(() => pipe(Effect.logError(`terkelg/prompts errored while prompting for ${prop}`), Effect.map(() => ({ [prop]: [] })))), 
-        // 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.fail(new PromptCancelled({ name: releaseType }))
-            : Effect.succeed(isArray(res?.[prop]) ? res?.[prop] : [])))
-        : Effect.succeed([]);
-}
-function groupByReleaseType(releases) {
-    return Effect.succeed(releases.reduce((releasesByType, release) => {
-        const previous = setSemverRange('', String(release.instance.rawSpecifier.raw));
-        const latest = release.versions.latest;
-        try {
-            const type = diff(previous, latest);
-            if (type && releasesByType[type]) {
-                releasesByType[type].push(release);
-            }
-        }
-        catch {
-            //
-        }
-        return releasesByType;
-    }, {
-        prepatch: [],
-        patch: [],
-        preminor: [],
-        minor: [],
-        premajor: [],
-        major: [],
-        prerelease: [],
-    }));
-}
-// @TODO: add a cache with a short TTL on disk in $TMPDIR
-function fetchJson(url) {
-    return pipe(Effect.async((resume) => {
-        // setTimeout(
-        //   () => {
-        //     resume(
-        //       Effect.succeed(
-        //         JSON.stringify({
-        //           'dist-tags': { latest: '3.1.1' },
-        //           'time': {
-        //             '0.3.1': new Date().toJSON(),
-        //           },
-        //         }),
-        //       ),
-        //     );
-        //   },
-        //   Math.floor(Math.random() * 500) + 1,
-        // );
-        https
-            .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: `Node https threw on ${url}: ${String(err)}` })));
-        });
-    }), Effect.flatMap((body) => Effect.try({
-        try: () => JSON.parse(body),
-        catch: () => new NpmRegistryError({ error: `JSON.parse threw on response from ${url}` }),
-    })));
-}

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

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

package/dist/bin-update/index.js

@@ -1,54 +0,0 @@
-#!/usr/bin/env node
-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
-  {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}
-`);
-});
-showHelpOnError(program);
-program
-    .option(...option.source)
-    .option(...option.filter)
-    .option(...option.config)
-    .option(...option.specs)
-    .option(...option.types)
-    .parse(process.argv);
-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 +0,0 @@
-import { Effect } from 'effect';
-import { type CliConfig } from '../config/types.js';
-import type { ErrorHandlers } from '../error-handlers/default-error-handlers.js';
-import type { Io } from '../io/index.js';
-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,59 +0,0 @@
-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('update', ({ instances }) => pipe(Effect.succeed(instances.all), Effect.map((instances) => {
-        const isVisitedByName = {};
-        const updateable = [];
-        instances.forEach((instance) => {
-            if (!isVisitedByName[instance.name] &&
-                (instance.versionGroup._tag === 'SameRange' ||
-                    instance.versionGroup._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.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))
-        ? 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
-    Effect.tapErrorTag('HttpError', ({ error }) => Effect.logError(chalk `{red ${ICON.cross} ${error}}`)), 
-    // log error but don't catch it
-    Effect.tapErrorTag('NpmRegistryError', ({ error }) => Effect.logError(chalk `{red ${ICON.cross} ${error}}`))), { concurrency: 10 }), 
-    // discard errors and up to date dependencies
-    Effect.flatMap(([_, outOfDate]) => Effect.succeed(outOfDate)))), 
-    // always remove the spinner when we're done
-    Effect.tapBoth({
-        onFailure: updateEffects.onFetchAllEnd,
-        onSuccess: updateEffects.onFetchAllEnd,
-    }), 
-    // ask the user which updates they want
-    Effect.flatMap(updateEffects.promptForUpdates), 
-    // if we think the user cancelled, say so
-    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.flatMap(exitIfInvalid), Effect.withConcurrency(10), Effect.provide(pipe(Context.empty(), Context.add(CliConfigTag, cli), Context.add(IoTag, io))), withLogger);
-}

package/dist/bin.d.ts

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

package/dist/bin.js

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-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',
-})
-    .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,50 +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 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);
-        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);
-                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, ERR_STRATEGY);
-            }
-        }
-    }));
-}
-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,94 +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[];