syncpack 12.3.3 → 13.0.0

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

@@ -16,9 +16,9 @@ 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]))), 
+    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.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
@@ -30,13 +30,28 @@ export function getEnabledTypes({ 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')],
+        [
+            '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]),
+        [
+            '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))), 
@@ -61,7 +76,7 @@ export function getEnabledTypes({ cli, rcFile, }) {
             strategyNamesByStatus.provided.join('') === '**') {
             return Effect.succeed(allStrategyNames.map(getStrategyByName));
         }
-        strategyNamesByStatus.provided.forEach((name) => {
+        strategyNamesByStatus.provided.forEach(name => {
             if (name.startsWith('!')) {
                 strategyNamesByStatus.negative.push(name.replace('!', ''));
             }
@@ -70,14 +85,14 @@ export function getEnabledTypes({ cli, rcFile, }) {
             }
         });
         if (isNonEmptyArray(strategyNamesByStatus.negative)) {
-            allStrategyNames.forEach((name) => {
+            allStrategyNames.forEach(name => {
                 if (!strategyNamesByStatus.negative.includes(name)) {
                     strategyNamesByStatus.enabled.push(name);
                 }
             });
         }
         if (isNonEmptyArray(strategyNamesByStatus.positive)) {
-            strategyNamesByStatus.positive.forEach((name) => {
+            strategyNamesByStatus.positive.forEach(name => {
                 if (!strategyNamesByStatus.enabled.includes(name)) {
                     strategyNamesByStatus.enabled.push(name);
                 }
@@ -90,5 +105,5 @@ export function getEnabledTypes({ cli, rcFile, }) {
         function getStrategyByName(type) {
             return allStrategiesByName[type];
         }
-    }), Effect.tap((enabledTypes) => 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)}`)));
 }

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

@@ -2,7 +2,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)
+    return isArrayOfStrings(rcFile.sortExports) ||
+        isEmptyArray(rcFile.sortExports)
         ? rcFile.sortExports
         : DEFAULT_CONFIG.sortExports;
 }

package/dist/config/types.d.ts

@@ -92,6 +92,8 @@ export interface CliConfig {
     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: Record<string, CustomTypeConfig.Any>;
     /** @see https://jamiemason.github.io/syncpack/config/dependency-types */

package/dist/error-handlers/default-error-handlers.js

@@ -1,6 +1,6 @@
+import { EOL } from 'node:os';
 import chalk from 'chalk';
 import { Effect } from 'effect';
-import { EOL } from 'os';
 export const defaultErrorHandlers = {
     // getContext
     GlobError(err) {
@@ -13,7 +13,7 @@ export const defaultErrorHandlers = {
         return Effect.logError([
             chalk.red('An error was found when parsing a JSON file'),
             chalk.red('  File:', err.filePath),
-            chalk.red('  Error:', err.error),
+            chalk.red('  Error:', err.errors),
         ].join(EOL));
     },
     NoSourcesFoundError(err) {

package/dist/get-context/index.d.ts

@@ -1,6 +1,6 @@
 import { Effect } from 'effect';
 import type { O } from 'ts-toolbelt';
-import { type CliConfig, type RcConfig } from '../config/types.js';
+import type { CliConfig, RcConfig } from '../config/types.js';
 import type { ErrorHandlers } from '../error-handlers/default-error-handlers.js';
 import type { PackageJsonFile } from '../get-package-json-files/package-json-file.js';
 import type { Io } from '../io/index.js';
@@ -19,5 +19,5 @@ interface Input {
     cli: Partial<CliConfig>;
     errorHandlers: ErrorHandlers;
 }
-export declare function getContext({ io, cli, errorHandlers }: Input): Effect.Effect<Ctx>;
+export declare function getContext({ io, cli, errorHandlers, }: Input): Effect.Effect<Ctx>;
 export {};

package/dist/get-context/index.js

@@ -2,7 +2,7 @@ import { Effect, flow, pipe } from 'effect';
 import { getPackageJsonFiles } from '../get-package-json-files/index.js';
 import { readConfigFile } from '../io/read-config-file.js';
 import { keyBy } from './lib/key-by.js';
-export function getContext({ io, cli, errorHandlers }) {
+export function getContext({ io, cli, errorHandlers, }) {
     const exitOnError = Effect.flatMap(() => Effect.failSync(() => io.process.exit(1)));
     return pipe(Effect.Do, Effect.bind('rcFile', () => readConfigFile(io, cli.configPath)), Effect.bind('packageJsonFiles', ({ rcFile }) => getPackageJsonFiles(io, { cli, rcFile })), Effect.map(({ rcFile, packageJsonFiles }) => ({
         config: { cli, rcFile },

package/dist/get-instances/index.js

@@ -6,22 +6,22 @@ import { createSemverGroups } from '../semver-group/create-semver-groups.js';
 import { createVersionGroups } from '../version-group/create-version-groups.js';
 export function getInstances(ctx, io, errorHandlers) {
     const exitOnError = Effect.flatMap(() => Effect.failSync(() => io.process.exit(1)));
-    return pipe(Effect.Do, Effect.bind('enabledTypes', () => getEnabledTypes(ctx.config)), Effect.bind('semverGroups', () => createSemverGroups(ctx)), Effect.bind('versionGroups', () => createVersionGroups(ctx)), Effect.bind('instances', (acc) => pipe(ctx.packageJsonFiles, Effect.forEach((file) => file.getInstances(acc.enabledTypes)), Effect.map((instancesByFile) => instancesByFile.flat()))), Effect.tap(({ instances, semverGroups, versionGroups }) => Effect.sync(() => {
+    return pipe(Effect.Do, Effect.bind('enabledTypes', () => getEnabledTypes(ctx.config)), Effect.bind('semverGroups', () => createSemverGroups(ctx)), Effect.bind('versionGroups', () => createVersionGroups(ctx)), Effect.bind('instances', acc => pipe(ctx.packageJsonFiles, Effect.forEach(file => file.getInstances(acc.enabledTypes)), Effect.map(instancesByFile => instancesByFile.flat()))), Effect.tap(({ instances, semverGroups, versionGroups }) => Effect.sync(() => {
         for (const instance of instances) {
             // assign each instance to its semver group, first match wins
-            assignToSemverGroup: for (const group of semverGroups) {
+            for (const group of semverGroups) {
                 if (canAddToGroup(ctx.packageJsonFilesByName, group, instance)) {
                     instance.semverGroup = group;
                     group.instances.push(instance);
-                    break assignToSemverGroup;
+                    break;
                 }
             }
             // assign each instance to its version group, first match wins
-            assignToVersionGroup: for (const group of versionGroups) {
+            for (const group of versionGroups) {
                 if (canAddToGroup(ctx.packageJsonFilesByName, group, instance)) {
                     instance.versionGroup = group;
                     group.instances.push(instance);
-                    break assignToVersionGroup;
+                    break;
                 }
             }
         }
@@ -37,6 +37,6 @@ export function getInstances(ctx, io, errorHandlers) {
         VersionGroupConfigError: flow(errorHandlers.VersionGroupConfigError, exitOnError),
     }));
     function getSortedAndFiltered(groups) {
-        return groups.filter((group) => group.instances.sort(sortByName).length > 0);
+        return groups.filter(group => group.instances.sort(sortByName).length > 0);
     }
 }

package/dist/get-instances/instance.js

@@ -16,7 +16,8 @@ export class Instance {
     versionGroup;
     constructor(name, rawSpecifier, packageJsonFile, strategy) {
         this.name = name;
-        this.pkgName = packageJsonFile.jsonFile.contents.name || 'PACKAGE_JSON_HAS_NO_NAME';
+        this.pkgName =
+            packageJsonFile.jsonFile.contents.name || 'PACKAGE_JSON_HAS_NO_NAME';
         this.packageJsonFile = packageJsonFile;
         this.strategy = strategy;
         this.semverGroup = null;
@@ -26,6 +27,9 @@ export class Instance {
     /** Mutate the package.json file in memory with the latest version specifier */
     write(rawSpecifier) {
         this.rawSpecifier = Specifier.create(this, rawSpecifier);
-        return this.strategy.write(this.packageJsonFile, [this.name, this.rawSpecifier.raw]);
+        return this.strategy.write(this.packageJsonFile, [
+            this.name,
+            this.rawSpecifier.raw,
+        ]);
     }
 }

package/dist/get-package-json-files/get-patterns/get-lerna-patterns.js

@@ -1,9 +1,11 @@
+import { join } from 'node:path';
 import { Effect, Option as O, pipe } from 'effect';
-import { join } from 'path';
 import { isArrayOfStrings } from 'tightrope/guard/is-array-of-strings.js';
 import { readJsonFileSync } from '../../io/read-json-file-sync.js';
 export function getLernaPatterns(io) {
-    return pipe(readJsonFileSync(io, join(io.process.cwd(), 'lerna.json')), Effect.map((file) => isArrayOfStrings(file.contents.packages) ? O.some(file.contents.packages) : O.none()), Effect.catchTags({
+    return pipe(readJsonFileSync(io, join(io.process.cwd(), 'lerna.json')), Effect.map(file => isArrayOfStrings(file.contents.packages)
+        ? O.some(file.contents.packages)
+        : O.none()), Effect.catchTags({
         ReadFileError: () => Effect.succeed(O.none()),
         JsonParseError: () => Effect.succeed(O.none()),
     }));

package/dist/get-package-json-files/get-patterns/get-pnpm-patterns.d.ts

@@ -1,3 +1,3 @@
 import { Effect, Option as O } from 'effect';
-import { type Io } from '../../io/index.js';
+import type { Io } from '../../io/index.js';
 export declare function getPnpmPatterns(io: Io): Effect.Effect<O.Option<string[]>>;

package/dist/get-package-json-files/get-patterns/get-pnpm-patterns.js

@@ -1,5 +1,5 @@
+import { join } from 'node:path';
 import { Effect, Option as O, pipe } from 'effect';
-import { join } from 'path';
 import { isArrayOfStrings } from 'tightrope/guard/is-array-of-strings.js';
 import { readYamlFileSync } from '../../io/read-yaml-file-sync.js';
 export function getPnpmPatterns(io) {
@@ -8,7 +8,7 @@ export function getPnpmPatterns(io) {
     //   - "packages/**"
     //   - "components/**"
     //   - "!**/test/**"
-    readYamlFileSync(io, join(io.process.cwd(), 'pnpm-workspace.yaml')), Effect.map((file) => (isArrayOfStrings(file?.packages) ? O.some(file.packages) : O.none())), Effect.catchTags({
+    readYamlFileSync(io, join(io.process.cwd(), 'pnpm-workspace.yaml')), Effect.map(file => isArrayOfStrings(file?.packages) ? O.some(file.packages) : O.none()), Effect.catchTags({
         ReadYamlFileError: () => Effect.succeed(O.none()),
     }));
 }

package/dist/get-package-json-files/get-patterns/get-yarn-patterns.js

@@ -1,10 +1,10 @@
+import { join } from 'node:path';
 import { Effect, Option as O, pipe } from 'effect';
-import { join } from 'path';
 import { isArrayOfStrings } from 'tightrope/guard/is-array-of-strings.js';
 import { isNonEmptyObject } from 'tightrope/guard/is-non-empty-object.js';
 import { readJsonFileSync } from '../../io/read-json-file-sync.js';
 export function getYarnPatterns(io) {
-    return pipe(readJsonFileSync(io, join(io.process.cwd(), 'package.json')), Effect.map((file) => isNonEmptyObject(file.contents.workspaces) &&
+    return pipe(readJsonFileSync(io, join(io.process.cwd(), 'package.json')), Effect.map(file => isNonEmptyObject(file.contents.workspaces) &&
         isArrayOfStrings(file.contents.workspaces.packages)
         ? O.some(file.contents.workspaces.packages)
         : isArrayOfStrings(file.contents.workspaces)

package/dist/get-package-json-files/get-patterns/index.js

@@ -10,14 +10,14 @@ import { getYarnPatterns } from './get-yarn-patterns.js';
  * this monorepo.
  */
 export function getPatterns(io, config) {
-    return pipe(getCliPatterns(), Effect.flatMap((opt) => (O.isSome(opt) ? Effect.succeed(opt) : getWorkspacePatterns())), Effect.map(O.map(limitToPackageJson)), Effect.map(O.getOrElse(() => [...DEFAULT_CONFIG.source])));
+    return pipe(getCliPatterns(), Effect.flatMap(opt => O.isSome(opt) ? Effect.succeed(opt) : getWorkspacePatterns()), Effect.map(O.map(limitToPackageJson)), Effect.map(O.getOrElse(() => [...DEFAULT_CONFIG.source])));
     function getCliPatterns() {
         return pipe(O.some(getSource(config)), O.filter(isArrayOfStrings), Effect.succeed);
     }
     function getWorkspacePatterns() {
-        return pipe(getYarnPatterns(io), Effect.flatMap((opt) => (O.isSome(opt) ? Effect.succeed(opt) : getPnpmPatterns(io))), Effect.flatMap((opt) => (O.isSome(opt) ? Effect.succeed(opt) : getLernaPatterns(io))), Effect.map(O.map((patterns) => ['package.json', ...patterns])));
+        return pipe(getYarnPatterns(io), Effect.flatMap(opt => O.isSome(opt) ? Effect.succeed(opt) : getPnpmPatterns(io)), Effect.flatMap(opt => O.isSome(opt) ? Effect.succeed(opt) : getLernaPatterns(io)), Effect.map(O.map(patterns => ['package.json', ...patterns])));
     }
     function limitToPackageJson(patterns) {
-        return patterns.map((pattern) => pattern.includes('package.json') ? pattern : `${pattern}/package.json`);
+        return patterns.map(pattern => pattern.includes('package.json') ? pattern : `${pattern}/package.json`);
     }
 }

package/dist/get-package-json-files/index.js

@@ -4,5 +4,5 @@ import { getFilePaths } from './get-file-paths.js';
 import { PackageJsonFile } from './package-json-file.js';
 /** Create an API for every package.json file needed. */
 export function getPackageJsonFiles(io, config) {
-    return pipe(getFilePaths(io, config), Effect.flatMap((filePaths) => Effect.all(filePaths.map((filePath) => readJsonFileSync(io, filePath)))), Effect.map((files) => files.map((file) => new PackageJsonFile(file, config))), Effect.tap((files) => Effect.logDebug(`${files.length} package.json files found`)));
+    return pipe(getFilePaths(io, config), Effect.flatMap(filePaths => Effect.all(filePaths.map(filePath => readJsonFileSync(io, filePath)))), Effect.map(files => files.map(file => new PackageJsonFile(file, config))), Effect.tap(files => Effect.logDebug(`${files.length} package.json files found`)));
 }

package/dist/get-package-json-files/package-json-file.d.ts

@@ -42,6 +42,13 @@ export declare class PackageJsonFile {
     jsonFile: JsonFile<PackageJson>;
     /** the .name property from the package.json file */
     name: string | undefined;
+    /** the next package.json file contents after modification, with formatting preserved */
+    nextJson: string;
     constructor(jsonFile: JsonFile<PackageJson>, config: Ctx['config']);
     getInstances(enabledTypes: Strategy.Any[]): Effect.Effect<Instance[]>;
+    /**
+     * Apply an edit to the raw JSON string which will be written to disk. This string preserves the
+     * original formatting of the file.
+     */
+    applyEdit(fullPath: string[], value: string | undefined): void;
 }

package/dist/get-package-json-files/package-json-file.js

@@ -1,4 +1,5 @@
 import { Effect, pipe } from 'effect';
+import { applyEdits, modify } from 'jsonc-parser';
 import { Instance } from '../get-instances/instance.js';
 export class PackageJsonFile {
     /** resolved configuration */
@@ -9,21 +10,35 @@ export class PackageJsonFile {
     jsonFile;
     /** the .name property from the package.json file */
     name;
+    /** the next package.json file contents after modification, with formatting preserved */
+    nextJson;
     constructor(jsonFile, config) {
         this._instances = null;
         this.config = config;
         this.jsonFile = jsonFile;
         this.name = jsonFile.contents.name;
+        this.nextJson = jsonFile.json;
     }
     getInstances(enabledTypes) {
         if (!this._instances) {
-            return pipe(Effect.all(enabledTypes.map((strategy) => pipe(strategy.read(this), Effect.map((entries) => entries.map(([name, rawSpecifier]) => new Instance(name, rawSpecifier, this, strategy)))))), Effect.map((array) => array.flat()), Effect.tapBoth({
-                onSuccess: (instances) => Effect.logDebug(`found ${instances.length} instances in <${this.jsonFile.shortPath}>`),
+            return pipe(Effect.all(enabledTypes.map(strategy => pipe(strategy.read(this), Effect.map(entries => entries.map(([name, rawSpecifier]) => new Instance(name, rawSpecifier, this, strategy)))))), Effect.map(array => array.flat()), Effect.tapBoth({
+                onSuccess: instances => Effect.logDebug(`found ${instances.length} instances in <${this.jsonFile.shortPath}>`),
                 onFailure: () => Effect.logError(`failed to get instances from <${this.jsonFile.shortPath}>`),
-            }), Effect.catchAll(() => Effect.succeed([])), Effect.tap((instances) => Effect.sync(() => {
+            }), Effect.catchAll(() => Effect.succeed([])), Effect.tap(instances => Effect.sync(() => {
                 this._instances = instances;
             })));
         }
         return Effect.succeed(this._instances);
     }
+    /**
+     * Apply an edit to the raw JSON string which will be written to disk. This string preserves the
+     * original formatting of the file.
+     */
+    applyEdit(fullPath, value) {
+        const edits = modify(this.nextJson, fullPath.map(parseNumericStrings), value, {});
+        this.nextJson = applyEdits(this.nextJson, edits);
+    }
+}
+function parseNumericStrings(key) {
+    return /[^0-9]/.test(key) ? key : Number(key);
 }

package/dist/guards/can-add-to-group.js

@@ -10,19 +10,19 @@ export function canAddToGroup(packageJsonFilesByName, group, instance) {
 }
 function matchesDependencies(packageJsonFilesByName, group, dependencies, instance) {
     // matches if not defined
-    if (!isNonEmptyArray(dependencies))
+    if (!isNonEmptyArray(dependencies)) {
         return true;
-    return dependencies.some((pattern) => (pattern === '$LOCAL' &&
+    }
+    return dependencies.some(pattern => (pattern === '$LOCAL' &&
         instance.name in packageJsonFilesByName &&
-        ((group.groupType === 'versionGroup' && instance.versionGroup === null) ||
-            (group.groupType === 'semverGroup' && instance.semverGroup === null))) ||
+        ((group.groupType === 'versionGroup' &&
+            instance.versionGroup === null) ||
+            (group.groupType === 'semverGroup' &&
+                instance.semverGroup === null))) ||
         minimatch(instance.name, pattern));
 }
 function matchesPackages(packages, instance) {
-    // matches if not defined
-    if (!isNonEmptyArray(packages))
-        return true;
-    return packages.some((pattern) => minimatch(instance.pkgName, pattern));
+    return matchesKnownList(packages, instance.pkgName);
 }
 function matchesDependencyTypes(dependencyTypes, instance) {
     return matchesKnownList(dependencyTypes, instance.strategy.name);
@@ -32,13 +32,15 @@ function matchesSpecifierTypes(specifierTypes, instance) {
 }
 function matchesKnownList(values, value) {
     // matches if not defined
-    if (!isNonEmptyArray(values))
+    if (!isNonEmptyArray(values)) {
         return true;
-    if (values.join('') === '**')
+    }
+    if (values.join('') === '**') {
         return true;
+    }
     const negative = [];
     const positive = [];
-    values.forEach((name) => {
+    values.forEach(name => {
         if (name.startsWith('!')) {
             negative.push(name.replace('!', ''));
         }
@@ -46,7 +48,11 @@ function matchesKnownList(values, value) {
             positive.push(name);
         }
     });
-    if (isNonEmptyArray(negative) && !negative.includes(value))
+    if (isNonEmptyArray(negative) && !someMinimatch(value, negative)) {
         return true;
-    return isNonEmptyArray(positive) && positive.includes(value);
+    }
+    return isNonEmptyArray(positive) && someMinimatch(value, positive);
+}
+function someMinimatch(value, patterns) {
+    return patterns.some(pattern => minimatch(value, pattern));
 }

package/dist/guards/is-semver.js

@@ -9,5 +9,7 @@ export function isSemver(version) {
     const minor = new RegExp(`^${range}${ints}${dot}${intsOrX}$`);
     const patch = new RegExp(`^${range}${ints}${dot}${intsOrX}${dot}${intsOrX}$`);
     return (isString(version) &&
-        (version.search(major) !== -1 || version.search(minor) !== -1 || version.search(patch) !== -1));
+        (version.search(major) !== -1 ||
+            version.search(minor) !== -1 ||
+            version.search(patch) !== -1));
 }

package/dist/io/ask-for-choice.js

@@ -3,7 +3,7 @@ import { IoTag } from './index.js';
 class AskForChoiceError extends Data.TaggedClass('AskForChoiceError') {
 }
 export function askForChoice(opts) {
-    return pipe(IoTag, Effect.flatMap((io) => Effect.tryPromise({
+    return pipe(IoTag, Effect.flatMap(io => Effect.tryPromise({
         try: () => io.enquirer
             .prompt({
             type: 'select',
@@ -11,7 +11,7 @@ export function askForChoice(opts) {
             message: opts.message,
             choices: opts.choices,
         })
-            .then((res) => res.choice),
-        catch: (err) => new AskForChoiceError({ error: String(err) }),
+            .then(res => res.choice),
+        catch: err => new AskForChoiceError({ error: String(err) }),
     })));
 }

package/dist/io/ask-for-input.js

@@ -3,12 +3,12 @@ import { IoTag } from './index.js';
 class AskForInputError extends Data.TaggedClass('AskForInputError') {
 }
 export function askForInput(opts) {
-    return pipe(IoTag, Effect.flatMap((io) => Effect.tryPromise({
+    return pipe(IoTag, Effect.flatMap(io => Effect.tryPromise({
         try: () => io.enquirer.prompt({
             name: 'version',
             type: 'input',
             message: opts.message,
         }),
-        catch: (err) => new AskForInputError({ error: String(err) }),
+        catch: err => new AskForInputError({ error: String(err) }),
     })));
 }

package/dist/io/exit-if-invalid.js

@@ -1,7 +1,7 @@
 import { Effect, pipe } from 'effect';
 import { IoTag } from './index.js';
 export function exitIfInvalid(ctx) {
-    return pipe(IoTag, Effect.tap((io) => Effect.sync(() => {
+    return pipe(IoTag, Effect.tap(io => Effect.sync(() => {
         if (ctx.isInvalid) {
             io.process.exit(1);
         }

package/dist/io/glob-sync.js

@@ -9,6 +9,6 @@ export function globSync(io, patterns) {
             fs: io.fs,
             ignore: ['**/node_modules/**'],
         }),
-        catch: (err) => new GlobError({ error: String(err) }),
+        catch: err => new GlobError({ error: String(err) }),
     });
 }

package/dist/io/index.d.ts

@@ -1,8 +1,7 @@
-/// <reference types="node" resolution-mode="require"/>
+import fs from 'node:fs';
 import { cosmiconfig } from 'cosmiconfig';
 import { Context } from 'effect';
 import enquirer from 'enquirer';
-import fs from 'fs';
 import { globbySync } from 'globby';
 import { sync as readYamlFileSync } from 'read-yaml-file';
 export interface Io {

package/dist/io/index.js

@@ -1,7 +1,7 @@
+import fs from 'node:fs';
 import { cosmiconfig } from 'cosmiconfig';
 import { Context } from 'effect';
 import enquirer from 'enquirer';
-import fs from 'fs';
 import { globbySync } from 'globby';
 import { sync as readYamlFileSync } from 'read-yaml-file';
 export const IoTag = Context.GenericTag('@services/IoTag');

package/dist/io/read-config-file.js

@@ -1,10 +1,12 @@
+import { join } from 'node:path';
 import { Effect, Option, pipe } from 'effect';
-import { join } from 'path';
 import { isNonEmptyObject } from 'tightrope/guard/is-non-empty-object.js';
 import { readJsonFileSync } from './read-json-file-sync.js';
 const getOptionOfNonEmptyObject = Option.liftPredicate((isNonEmptyObject));
 export function readConfigFile(io, configPath) {
-    return pipe(Effect.try(() => io.cosmiconfig.cosmiconfig('syncpack')), Effect.flatMap((client) => Effect.tryPromise(() => (configPath ? client.load(configPath) : client.search()))), Effect.flatMap((result) => result !== null ? getValueFromCosmiconfig(result) : findConfigInPackageJson(io)), Effect.tap((config) => Effect.logDebug(`config file found: ${JSON.stringify(config)}`)), Effect.tapError(() => Effect.logDebug('no config file found, will use defaults')), Effect.catchAll(() => Effect.succeed({})));
+    return pipe(Effect.try(() => io.cosmiconfig.cosmiconfig('syncpack')), Effect.flatMap(client => Effect.tryPromise(() => configPath ? client.load(configPath) : client.search())), Effect.flatMap(result => result !== null
+        ? getValueFromCosmiconfig(result)
+        : findConfigInPackageJson(io)), Effect.tap(config => Effect.logDebug(`config file found: ${JSON.stringify(config)}`)), Effect.tapError(() => Effect.logDebug('no config file found, will use defaults')), Effect.catchAll(() => Effect.succeed({})));
 }
 /**
  * Look for a .config.syncpack property in the root package.json.
@@ -18,5 +20,5 @@ function findConfigInPackageJson(io) {
 }
 /** Extract the value from a successful search by cosmiconfig */
 function getValueFromCosmiconfig(result) {
-    return pipe(Effect.succeed(result), Effect.tap((result) => Effect.logDebug(`cosmiconfig found ${result.filepath}`)), Effect.flatMap((result) => getOptionOfNonEmptyObject(result.config)));
+    return pipe(Effect.succeed(result), Effect.tap(result => Effect.logDebug(`cosmiconfig found ${result.filepath}`)), Effect.flatMap(result => getOptionOfNonEmptyObject(result.config)));
 }

package/dist/io/read-file-sync.js

@@ -4,6 +4,6 @@ export class ReadFileError extends Data.TaggedClass('ReadFileError') {
 export function readFileSync(io, filePath) {
     return Effect.try({
         try: () => io.fs.readFileSync(filePath, { encoding: 'utf8' }),
-        catch: (err) => new ReadFileError({ filePath, error: String(err) }),
+        catch: err => new ReadFileError({ filePath, error: String(err) }),
     });
 }

package/dist/io/read-json-file-sync.d.ts

@@ -1,11 +1,12 @@
 import { Effect } from 'effect';
+import { type ParseError } from 'jsonc-parser';
 import type { Io } from './index.js';
 import type { ReadFileError } from './read-file-sync.js';
 declare const JsonParseError_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: "JsonParseError";
 };
 export declare class JsonParseError extends JsonParseError_base<{
-    readonly error: unknown;
+    readonly errors: ParseError[];
     readonly filePath: string;
     readonly json: string;
 }> {

package/dist/io/read-json-file-sync.js

@@ -1,15 +1,19 @@
+import { dirname, relative } from 'node:path';
 import { Data, Effect, pipe } from 'effect';
-import { dirname, relative } from 'path';
+import { parse } from 'jsonc-parser';
 import { readFileSync } from './read-file-sync.js';
 export class JsonParseError extends Data.TaggedClass('JsonParseError') {
 }
 export class JsonFile extends Data.TaggedClass('JsonFile') {
 }
 export function readJsonFileSync(io, filePath) {
-    return pipe(Effect.Do, Effect.bind('json', () => readFileSync(io, filePath)), Effect.bind('contents', ({ json }) => Effect.try({
-        try: () => JSON.parse(json),
-        catch: (error) => new JsonParseError({ error, filePath, json }),
-    })), Effect.map(({ contents, json }) => new JsonFile({
+    return pipe(Effect.Do, Effect.bind('json', () => readFileSync(io, filePath)), Effect.bind('contents', ({ json }) => {
+        const errors = [];
+        const data = parse(json, errors);
+        return errors.length === 0
+            ? Effect.succeed(data)
+            : Effect.fail(new JsonParseError({ errors, filePath, json }));
+    }), Effect.map(({ contents, json }) => new JsonFile({
         contents,
         dirPath: dirname(filePath),
         filePath,

package/dist/io/read-yaml-file-sync.js

@@ -4,6 +4,6 @@ class ReadYamlFileError extends Data.TaggedClass('ReadYamlFileError') {
 export function readYamlFileSync(io, filePath) {
     return Effect.try({
         try: () => io.readYamlFile.sync(filePath),
-        catch: (err) => new ReadYamlFileError({ filePath, error: String(err) }),
+        catch: err => new ReadYamlFileError({ filePath, error: String(err) }),
     });
 }

package/dist/io/{to-json.d.ts → to-formatted-json.d.ts}

@@ -5,5 +5,5 @@ export declare const newlines: {
     detect(source: string): Ending;
     fix(source: string, lineEnding: Ending): string;
 };
-export declare function toJson(ctx: Ctx, file: PackageJsonFile): string;
+export declare function toFormattedJson(ctx: Ctx, file: PackageJsonFile): string;
 export {};

package/dist/io/{to-json.js → to-formatted-json.js}

@@ -1,4 +1,4 @@
-import { EOL } from 'os';
+import { EOL } from 'node:os';
 import { getIndent } from '../config/get-indent.js';
 const CR = '\r';
 const CRLF = '\r\n';
@@ -8,22 +8,25 @@ export const newlines = {
         const cr = source.split(CR).length;
         const lf = source.split(LF).length;
         const crlf = source.split(CRLF).length;
-        if (cr + lf === 0)
+        if (cr + lf === 0) {
             return EOL;
-        if (crlf === cr && crlf === lf)
+        }
+        if (crlf === cr && crlf === lf) {
             return CRLF;
-        if (cr > lf)
+        }
+        if (cr > lf) {
             return CR;
+        }
         return LF;
     },
     fix(source, lineEnding) {
         return source.replace(/\r\n|\n|\r/g, lineEnding);
     },
 };
-export function toJson(ctx, file) {
+export function toFormattedJson(ctx, file) {
     const contents = file.jsonFile.contents;
     const indent = getIndent(ctx.config);
-    const EOL = newlines.detect(file.jsonFile.json);
-    const source = `${JSON.stringify(contents, null, indent)}${EOL}`;
-    return newlines.fix(source, EOL);
+    const eol = newlines.detect(file.jsonFile.json);
+    const source = `${JSON.stringify(contents, null, indent)}${eol}`;
+    return newlines.fix(source, eol);
 }