syncpack 12.4.0 → 13.0.0

package/dist/lib/get.js

@@ -3,34 +3,42 @@ import { isFunction } from 'tightrope/guard/is-function.js';
 import { isPrimitive } from 'tightrope/guard/is-primitive.js';
 import { isReadable } from 'tightrope/guard/is-readable.js';
 export function get(origin, ...props) {
-    return isReadable(origin) ? props.reduce(getChild, origin) : ERR_UNREADABLE_ORIGIN(props, origin);
+    return isReadable(origin)
+        ? props.reduce(getChild, origin)
+        : errUnreadableOrigin(props, origin);
 }
 /** Used internally by get to retrieve a single child property from a parent object. */
 function getChild(parent, prop) {
     // quit if any ancestor was already not found
-    if (Either.isEither(parent) && Either.isLeft(parent))
+    if (Either.isEither(parent) && Either.isLeft(parent)) {
         return parent;
+    }
     // ensure we have a plain value and not an Ok
-    const value = Either.isEither(parent) && Either.isRight(parent) ? Either.getOrThrow(parent) : parent;
+    const value = Either.isEither(parent) && Either.isRight(parent)
+        ? Either.getOrThrow(parent)
+        : parent;
     // quit if we can't read properties of value (eg value.likeThis)
-    if (!isReadable(value))
-        return ERR_UNREADABLE_CHILD(prop, value);
+    if (!isReadable(value)) {
+        return errUnreadableChild(prop, value);
+    }
     // quit if value is object/array/function etc but the child is not found
-    if (!isPrimitive(value) && prop in value === false)
-        return ERR_NOT_FOUND(prop, value);
+    if (!isPrimitive(value) && prop in value === false) {
+        return errNotFound(prop, value);
+    }
     // quit if eg true.toFixed, 12.toUpperCase
-    if (isPrimitive(value) && value[prop] === undefined)
-        return ERR_NOT_FOUND(prop, value);
+    if (isPrimitive(value) && value[prop] === undefined) {
+        return errNotFound(prop, value);
+    }
     // the value is present, return it
     const child = value[prop];
     return Either.right(isFunction(child) ? child.bind(value) : child);
 }
-function ERR_UNREADABLE_CHILD(child, value) {
+function errUnreadableChild(child, value) {
     return Either.left(new Error(`Cannot read "${child}" from unreadable value: ${value}`));
 }
-function ERR_NOT_FOUND(child, value) {
+function errNotFound(child, value) {
     return Either.left(new Error(`Property "${child}" not found on value: ${value}`));
 }
-function ERR_UNREADABLE_ORIGIN(props, origin) {
+function errUnreadableOrigin(props, origin) {
     return Either.left(new Error(`Cannot read "${props.join('.')}" from unreadable value: ${origin}`));
 }

package/dist/lib/ring-buffer.js

@@ -11,7 +11,7 @@ export class RingBuffer extends Array {
         this.fixedLength = fixedLength;
     }
     push(...values) {
-        values.forEach((value) => {
+        values.forEach(value => {
             this[this.cursor++] = value;
             this.cursor %= this.length;
         });

package/dist/lib/set-semver-range.js

@@ -4,11 +4,15 @@ import { isSemver } from '../guards/is-semver.js';
 import { isValidSemverRange } from '../guards/is-valid-semver-range.js';
 /** @deprecated migrate to make better use of npm-package-arg */
 export function setSemverRange(semverRange, version) {
-    if (!isSemver(version) || !isValidSemverRange(semverRange))
+    if (!(isSemver(version) && isValidSemverRange(semverRange))) {
         return version;
-    if (semverRange === '*')
+    }
+    if (semverRange === '*') {
         return semverRange;
-    const nextVersion = isLooseSemver(version) ? version.replace(/\.x/g, '.0') : version;
+    }
+    const nextVersion = isLooseSemver(version)
+        ? version.replace(/\.x/g, '.0')
+        : version;
     const from1stNumber = nextVersion.search(/[0-9]/);
     const from1stDot = nextVersion.indexOf('.');
     return semverRange === RANGE.LOOSE
@@ -16,5 +20,5 @@ export function setSemverRange(semverRange, version) {
         : `${semverRange}${nextVersion.slice(from1stNumber)}`;
 }
 function isLooseSemver(version) {
-    return isString(version) && isSemver(version) && version.search(/\.x(\.|$)/) !== -1;
+    return (isString(version) && isSemver(version) && version.search(/\.x(\.|$)/) !== -1);
 }

package/dist/lib/with-logger.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk-template';
-import { Effect, Logger, LogLevel } from 'effect';
+import { Effect, LogLevel, Logger } from 'effect';
 export function withLogger(program) {
     const logger = Logger.make(({ logLevel, message }) => {
         const args = Array.isArray(message) ? message : [message];
@@ -16,7 +16,6 @@ export function withLogger(program) {
             globalThis.console.warn(chalk `{yellow ! %s}`, ...args);
         }
         else {
-            globalThis.console.log(chalk `{cyan [%s] %s}`, logLevel, ...args);
         }
     });
     const layer = Logger.replace(Logger.defaultLogger, logger);

package/dist/option.js

@@ -6,7 +6,10 @@ export const option = {
         '-f, --filter [pattern]',
         chalk `only include dependencies whose {yellow name} matches this regex`,
     ],
-    indent: ['-i, --indent [value]', `override indentation. defaults to "${DEFAULT_CONFIG.indent}"`],
+    indent: [
+        '-i, --indent [value]',
+        `override indentation. defaults to "${DEFAULT_CONFIG.indent}"`,
+    ],
     source: [
         '-s, --source [pattern]',
         'glob pattern for package.json files to read from',

package/dist/semver-group/create-semver-groups.js

@@ -29,7 +29,7 @@ export function createSemverGroups(ctx) {
                     error: 'config is not an object',
                 })));
             }
-            const mutuallyExclusiveProps = ['isIgnored', 'range'].filter((prop) => Boolean(config[prop]));
+            const mutuallyExclusiveProps = ['isIgnored', 'range'].filter(prop => Boolean(config[prop]));
             if (mutuallyExclusiveProps.length > 1) {
                 return semverGroups.push(Effect.fail(new SemverGroup.ConfigError({
                     config,
@@ -40,8 +40,12 @@ export function createSemverGroups(ctx) {
             const dependencyTypes = isArrayOfStrings(config.dependencyTypes)
                 ? config.dependencyTypes
                 : ['**'];
-            const dependencies = isArrayOfStrings(config.dependencies) ? config.dependencies : ['**'];
-            const packages = isArrayOfStrings(config.packages) ? config.packages : ['**'];
+            const dependencies = isArrayOfStrings(config.dependencies)
+                ? config.dependencies
+                : ['**'];
+            const packages = isArrayOfStrings(config.packages)
+                ? config.packages
+                : ['**'];
             const specifierTypes = isArrayOfStrings(config.specifierTypes)
                 ? config.specifierTypes
                 : ['**'];

package/dist/semver-group/disabled.js

@@ -20,7 +20,7 @@ export class DisabledSemverGroup extends Data.TaggedClass('Disabled') {
         return Effect.succeed(specifier);
     }
     inspectAll() {
-        return Effect.all(this.instances.map((instance) => this.inspect(instance)));
+        return Effect.all(this.instances.map(instance => this.inspect(instance)));
     }
     inspect(instance) {
         return Effect.succeed(new Report.Disabled(instance));

package/dist/semver-group/filtered-out.js

@@ -26,7 +26,7 @@ export class FilteredOutSemverGroup extends Data.TaggedClass('FilteredOut') {
         return Effect.succeed(specifier);
     }
     inspectAll() {
-        return Effect.all(this.instances.map((instance) => this.inspect(instance)));
+        return Effect.all(this.instances.map(instance => this.inspect(instance)));
     }
     inspect(instance) {
         return Effect.succeed(new Report.FilteredOut(instance));

package/dist/semver-group/ignored.js

@@ -16,7 +16,7 @@ export class IgnoredSemverGroup extends Data.TaggedClass('Ignored') {
         return Effect.succeed(specifier);
     }
     inspectAll() {
-        return Effect.all(this.instances.map((instance) => this.inspect(instance)));
+        return Effect.all(this.instances.map(instance => this.inspect(instance)));
     }
     inspect(instance) {
         return Effect.succeed(new Report.Ignored(instance));

package/dist/semver-group/with-range.js

@@ -16,16 +16,16 @@ export class WithRangeSemverGroup extends Data.TaggedClass('WithRange') {
         return true;
     }
     getFixed(specifier) {
-        return pipe(specifier.getSemver(), Effect.map((semver) => setSemverRange(this.config.range, semver)), Effect.flatMap((nextSemver) => specifier.setSemver(nextSemver)));
+        return pipe(specifier.getSemver(), Effect.map(semver => setSemverRange(this.config.range, semver)), Effect.flatMap(nextSemver => specifier.setSemver(nextSemver)));
     }
     inspectAll() {
-        return Effect.all(this.instances.map((instance) => this.inspect(instance)));
+        return Effect.all(this.instances.map(instance => this.inspect(instance)));
     }
     inspect(instance) {
         const current = Specifier.create(instance, instance.rawSpecifier.raw);
         return pipe(this.getFixed(current), Effect.match({
             // if range is fixable
-            onSuccess: (valid) => 
+            onSuccess: valid => 
             // if it is pinned and matches its pin
             instance.versionGroup._tag === 'Pinned' &&
                 instance.rawSpecifier.raw === instance.versionGroup.config.pinVersion

package/dist/specifier/alias.js

@@ -9,12 +9,13 @@ export class AliasSpecifier extends BaseSpecifier {
     name = 'alias';
     /** Return the version portion if it is valid semver */
     getSemver() {
-        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.subSpec), Effect.flatMap((subSpec) => ['range', 'version'].includes(subSpec.type) && subSpec.fetchSpec !== null
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map(parsed => parsed.subSpec), Effect.flatMap(subSpec => ['range', 'version'].includes(subSpec.type) &&
+            subSpec.fetchSpec !== null
             ? Effect.succeed(subSpec.fetchSpec)
             : NonSemverError.asEffect(this)));
     }
     /** Get a new `Specifier` from the given semver version applied to this one */
     setSemver(version) {
-        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.subSpec), Effect.map((subSpec) => subSpec.name || ''), Effect.map((name) => `npm:${name}@${version}`), Effect.map((raw) => Specifier.create(this.instance, raw)));
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map(parsed => parsed.subSpec), Effect.map(subSpec => subSpec.name || ''), Effect.map(name => `npm:${name}@${version}`), Effect.map(raw => Specifier.create(this.instance, raw)));
     }
 }

package/dist/specifier/exact.js

@@ -12,7 +12,7 @@ export class ExactSpecifier extends BaseSpecifier {
     name = 'exact';
     /** Return the semver version */
     getSemver() {
-        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.fetchSpec));
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map(parsed => parsed.fetchSpec));
     }
     /** Get a new `Specifier` from the given semver version applied to this one */
     setSemver(version) {

package/dist/specifier/hosted-git.js

@@ -10,13 +10,15 @@ export class HostedGitSpecifier extends BaseSpecifier {
     name = 'hosted-git';
     /** Return the git tag if it is valid semver */
     getSemver() {
-        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.gitCommittish || ''), Effect.flatMap((gitCommittish) => isSemver(gitCommittish) ? Effect.succeed(gitCommittish) : NonSemverError.asEffect(this)));
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map(parsed => parsed.gitCommittish || ''), Effect.flatMap(gitCommittish => isSemver(gitCommittish)
+            ? Effect.succeed(gitCommittish)
+            : NonSemverError.asEffect(this)));
     }
     /** Get a new `Specifier` from the given semver version applied to this one */
     setSemver(version) {
-        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => ({
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map(parsed => ({
             gitCommittish: parsed.gitCommittish || '',
             rawSpec: parsed.rawSpec || '',
-        })), Effect.map(({ gitCommittish, rawSpec }) => rawSpec.replace(gitCommittish, version)), Effect.map((raw) => Specifier.create(this.instance, raw)));
+        })), Effect.map(({ gitCommittish, rawSpec }) => rawSpec.replace(gitCommittish, version)), Effect.map(raw => Specifier.create(this.instance, raw)));
     }
 }

package/dist/specifier/index.js

@@ -25,34 +25,46 @@ export var Specifier;
     Specifier.Url = UrlSpecifier;
     Specifier.WorkspaceProtocol = WorkspaceProtocolSpecifier;
     function create(instance, raw) {
-        if (raw === DELETE)
+        if (raw === DELETE) {
             return new Specifier.Delete({ instance, raw });
-        if (!raw)
+        }
+        if (!raw) {
             return new Specifier.Unsupported({ instance, raw });
+        }
         try {
-            if (raw === 'latest')
-                raw = '*';
-            const parsed = parseSpecifier(instance.name, raw, instance.packageJsonFile);
+            const data = {
+                instance,
+                raw: raw === 'latest' ? '*' : raw,
+            };
+            const parsed = parseSpecifier(instance.name, data.raw, instance.packageJsonFile);
             const type = parsed.type;
-            const data = { instance, raw };
-            if (raw === '*')
+            if (data.raw === '*') {
                 return new Specifier.Latest(data);
-            if (type === 'version')
+            }
+            if (type === 'version') {
                 return new Specifier.Exact(data);
-            if (type === 'range')
+            }
+            if (type === 'range') {
                 return new Specifier.Range(data);
-            if (type === 'workspaceProtocol')
+            }
+            if (type === 'workspaceProtocol') {
                 return new Specifier.WorkspaceProtocol(data);
-            if (type === 'alias')
+            }
+            if (type === 'alias') {
                 return new Specifier.Alias(data);
-            if (type === 'file' || type === 'directory')
+            }
+            if (type === 'file' || type === 'directory') {
                 return new Specifier.File(data);
-            if (type === 'remote')
+            }
+            if (type === 'remote') {
                 return new Specifier.Url(data);
-            if (type === 'git')
+            }
+            if (type === 'git') {
                 return new Specifier.HostedGit(data);
-            if (type === 'tag')
+            }
+            if (type === 'tag') {
                 return new Specifier.Tag(data);
+            }
             return new Specifier.Unsupported(data);
         }
         catch {

package/dist/specifier/latest.js

@@ -11,7 +11,7 @@ export class LatestSpecifier extends BaseSpecifier {
     name = 'latest';
     /** Return the semver version including the range */
     getSemver() {
-        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.fetchSpec));
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map(parsed => parsed.fetchSpec));
     }
     /** Get a new `Specifier` from the given semver version applied to this one */
     setSemver(version) {

package/dist/specifier/lib/parse-specifier.js

@@ -1,6 +1,8 @@
 import npa from 'npm-package-arg';
 export function parseSpecifier(name, specifier, packageJsonFile) {
-    if (specifier === 'workspace:*' || specifier === 'workspace:~' || specifier === 'workspace:^') {
+    if (specifier === 'workspace:*' ||
+        specifier === 'workspace:~' ||
+        specifier === 'workspace:^') {
         const parsed = npa.resolve(name, packageJsonFile.jsonFile.dirPath, specifier.replace('workspace:', 'file:'));
         return {
             escapedName: parsed.escapedName,

package/dist/specifier/range.js

@@ -11,7 +11,7 @@ export class RangeSpecifier extends BaseSpecifier {
     name = 'range';
     /** Return the semver version including the range */
     getSemver() {
-        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.fetchSpec));
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map(parsed => parsed.fetchSpec));
     }
     /** Get a new `Specifier` from the given semver version applied to this one */
     setSemver(version) {

package/dist/specifier/workspace-protocol.js

@@ -19,8 +19,9 @@ export class WorkspaceProtocolSpecifier extends BaseSpecifier {
             const range = this.raw.replace('workspace:', '');
             const local = ctx.packageJsonFilesByName[this.instance.name];
             const version = local?.jsonFile?.contents?.version;
-            if (version)
+            if (version) {
                 return Effect.succeed(`${range}${version}`);
+            }
         }
         return Effect.succeed('0.0.0');
     }

package/dist/strategy/lib/get-non-empty-string-prop.js

@@ -3,5 +3,5 @@ import { isNonEmptyString } from 'tightrope/guard/is-non-empty-string.js';
 import { get } from '../../lib/get.js';
 const getOptionOfNonEmptyString = Option.liftPredicate(isNonEmptyString);
 export function getNonEmptyStringProp(propPath, file) {
-    return pipe(get(file.jsonFile.contents, ...propPath.split('.')), Effect.flatMap((value) => getOptionOfNonEmptyString(value)), Effect.tapError(() => Effect.logDebug(`<${file.jsonFile.shortPath}>.${propPath} is not a non-empty string`)));
+    return pipe(get(file.jsonFile.contents, ...propPath.split('.')), Effect.flatMap(value => getOptionOfNonEmptyString(value)), Effect.tapError(() => Effect.logDebug(`<${file.jsonFile.shortPath}>.${propPath} is not a non-empty string`)));
 }

package/dist/strategy/name-and-version-props.js

@@ -1,4 +1,4 @@
-import { Effect, identity, Option, pipe } from 'effect';
+import { Effect, Option, identity, pipe } from 'effect';
 import { isObject } from 'tightrope/guard/is-object.js';
 import { get } from '../lib/get.js';
 import { DELETE } from '../version-group/lib/delete.js';
@@ -47,14 +47,14 @@ export class NameAndVersionPropsStrategy {
             const fullPath = path.split('.');
             const pathToParent = fullPath.slice(0, fullPath.length - 1).join('.');
             const key = fullPath.slice(-1).join('');
-            return pipe(get(contents, ...pathToParent.split('.')), Effect.flatMap(getOptionOfObject), Effect.flatMap((parent) => Effect.try(() => {
+            return pipe(get(contents, ...pathToParent.split('.')), Effect.flatMap(getOptionOfObject), Effect.flatMap(parent => Effect.try(() => {
                 parent[key] = nextValue;
+                file.applyEdit(fullPath, nextValue);
             })), Effect.tapError(() => Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), Effect.catchAll(() => Effect.succeed(file)), Effect.map(() => file));
         }
-        else {
-            return pipe(getOptionOfObject(contents), Effect.flatMap((parent) => Effect.try(() => {
-                parent[this.path] = nextValue;
-            })), Effect.tapError(() => Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), Effect.catchAll(() => Effect.succeed(file)), Effect.map(() => file));
-        }
+        return pipe(getOptionOfObject(contents), Effect.flatMap(parent => Effect.try(() => {
+            parent[this.path] = nextValue;
+            file.applyEdit([this.path], nextValue);
+        })), Effect.tapError(() => Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), Effect.catchAll(() => Effect.succeed(file)), Effect.map(() => file));
     }
 }

package/dist/strategy/named-version-string.js

@@ -20,9 +20,12 @@ export class NamedVersionStringStrategy {
         // get version prop
         getNonEmptyStringProp(path, file), 
         // if it is a non empty string, we can read it
-        Effect.map((value) => value.split(/@(.*)/)), 
+        Effect.map(value => value.split(/@(.*)/)), 
         // check the string was properly formed
-        Effect.flatMap(([name, version]) => Effect.all([getOptionOfNonEmptyString(name), getOptionOfNonEmptyString(version)])), 
+        Effect.flatMap(([name, version]) => Effect.all([
+            getOptionOfNonEmptyString(name),
+            getOptionOfNonEmptyString(version),
+        ])), 
         // return an array of one entry if valid
         Effect.map(([name, version]) => [[name, version]]), Effect.tapError(() => Effect.logDebug(`NamedVersionStringStrategy#${this.name} found nothing at <${file.jsonFile.shortPath}>.${this.path}`)), 
         // if value is invalid, default to empty
@@ -36,14 +39,14 @@ export class NamedVersionStringStrategy {
             const fullPath = this.path.split('.');
             const pathToParent = fullPath.slice(0, fullPath.length - 1).join('.');
             const key = fullPath.slice(-1).join('');
-            return pipe(get(contents, ...pathToParent.split('.')), Effect.flatMap(getOptionOfNonEmptyObject), Effect.flatMap((parent) => Effect.try(() => {
+            return pipe(get(contents, ...pathToParent.split('.')), Effect.flatMap(getOptionOfNonEmptyObject), Effect.flatMap(parent => Effect.try(() => {
                 parent[key] = nextValue;
+                file.applyEdit(fullPath, nextValue);
             })), Effect.tapError(() => Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), Effect.catchAll(() => Effect.succeed(file)), Effect.map(() => file));
         }
-        else {
-            return pipe(getOptionOfNonEmptyObject(contents), Effect.flatMap((parent) => Effect.try(() => {
-                parent[this.path] = nextValue;
-            })), Effect.tapError(() => Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), Effect.catchAll(() => Effect.succeed(file)), Effect.map(() => file));
-        }
+        return pipe(getOptionOfNonEmptyObject(contents), Effect.flatMap(parent => Effect.try(() => {
+            parent[this.path] = nextValue;
+            file.applyEdit([this.path], nextValue);
+        })), Effect.tapError(() => Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), Effect.catchAll(() => Effect.succeed(file)), Effect.map(() => file));
     }
 }

package/dist/strategy/unnamed-version-string.js

@@ -32,14 +32,14 @@ export class UnnamedVersionStringStrategy {
             const fullPath = this.path.split('.');
             const pathToParent = fullPath.slice(0, fullPath.length - 1).join('.');
             const key = fullPath.slice(-1).join('');
-            return pipe(get(contents, ...pathToParent.split('.')), Effect.flatMap(getOptionOfNonEmptyObject), Effect.flatMap((parent) => Effect.try(() => {
+            return pipe(get(contents, ...pathToParent.split('.')), Effect.flatMap(getOptionOfNonEmptyObject), Effect.flatMap(parent => Effect.try(() => {
                 parent[key] = nextValue;
+                file.applyEdit(fullPath, nextValue);
             })), Effect.tapError(() => Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), Effect.catchAll(() => Effect.succeed(file)), Effect.map(() => file));
         }
-        else {
-            return pipe(getOptionOfNonEmptyObject(contents), Effect.flatMap((parent) => Effect.try(() => {
-                parent[this.path] = nextValue;
-            })), Effect.tapError(() => Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), Effect.catchAll(() => Effect.succeed(file)), Effect.map(() => file));
-        }
+        return pipe(getOptionOfNonEmptyObject(contents), Effect.flatMap(parent => Effect.try(() => {
+            parent[this.path] = nextValue;
+            file.applyEdit([this.path], nextValue);
+        })), Effect.tapError(() => Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), Effect.catchAll(() => Effect.succeed(file)), Effect.map(() => file));
     }
 }

package/dist/strategy/versions-by-name.js

@@ -12,14 +12,16 @@ export class VersionsByNameStrategy {
         this.path = path;
     }
     read(file) {
-        return pipe(get(file.jsonFile.contents, ...this.path.split('.')), Effect.flatMap((value) => getOptionOfNonEmptyObject(value)), Effect.map((obj) => Object.entries(obj)), Effect.tapError(() => Effect.logDebug(`VersionsByNameStrategy#${this.name} found nothing at <${file.jsonFile.shortPath}>.${this.path}`)), 
+        return pipe(get(file.jsonFile.contents, ...this.path.split('.')), Effect.flatMap(value => getOptionOfNonEmptyObject(value)), Effect.map(obj => Object.entries(obj)), Effect.tapError(() => Effect.logDebug(`VersionsByNameStrategy#${this.name} found nothing at <${file.jsonFile.shortPath}>.${this.path}`)), 
         // if value is invalid, default to empty
         Effect.catchAll(() => Effect.succeed([])));
     }
     write(file, [name, version]) {
         const nextValue = version === DELETE ? undefined : version;
-        return pipe(get(file.jsonFile.contents, ...this.path.split('.')), Effect.flatMap(getOptionOfNonEmptyObject), Effect.flatMap((parent) => Effect.try(() => {
+        const fullPath = this.path.split('.');
+        return pipe(get(file.jsonFile.contents, ...fullPath), Effect.flatMap(getOptionOfNonEmptyObject), Effect.flatMap(parent => Effect.try(() => {
             parent[name] = nextValue;
+            file.applyEdit(fullPath.concat(name), nextValue);
         })), Effect.tapError(() => Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}.${name}`)), Effect.catchAll(() => Effect.succeed(file)), Effect.map(() => file));
     }
 }

package/dist/version-group/banned.js

@@ -17,7 +17,7 @@ export class BannedVersionGroup extends Data.TaggedClass('Banned') {
     inspectAll() {
         return Effect.succeed(Object.entries(groupBy('name', this.instances)).map(([name, instances]) => ({
             name,
-            reports: instances.map((instance) => 
+            reports: instances.map(instance => 
             // ✘ package should not be used
             // ✓ is a mismatch we can auto-fix
             new Report.Banned(Specifier.create(instance, DELETE))),

package/dist/version-group/create-version-groups.js

@@ -13,9 +13,7 @@ import { SnappedToVersionGroup } from './snapped-to.js';
 import { StandardVersionGroup } from './standard.js';
 export function createVersionGroups(ctx) {
     const { rcFile } = ctx.config;
-    const versionGroups = [
-        Effect.succeed(new FilteredOutVersionGroup(ctx)),
-    ];
+    const versionGroups = [Effect.succeed(new FilteredOutVersionGroup(ctx))];
     if (isNonEmptyArray(rcFile.versionGroups)) {
         rcFile.versionGroups.forEach((config) => {
             if (!isObject(config)) {
@@ -24,7 +22,7 @@ export function createVersionGroups(ctx) {
                     error: 'config is not an object',
                 })));
             }
-            const mutuallyExclusiveProps = ['isBanned', 'isIgnored', 'pinVersion', 'snapTo', 'policy'].filter((prop) => Boolean(config[prop]));
+            const mutuallyExclusiveProps = ['isBanned', 'isIgnored', 'pinVersion', 'snapTo', 'policy'].filter(prop => Boolean(config[prop]));
             if (mutuallyExclusiveProps.length > 1) {
                 return versionGroups.push(Effect.fail(new VersionGroup.ConfigError({
                     config,
@@ -35,8 +33,12 @@ export function createVersionGroups(ctx) {
             const dependencyTypes = isArrayOfStrings(config.dependencyTypes)
                 ? config.dependencyTypes
                 : ['**'];
-            const dependencies = isArrayOfStrings(config.dependencies) ? config.dependencies : ['**'];
-            const packages = isArrayOfStrings(config.packages) ? config.packages : ['**'];
+            const dependencies = isArrayOfStrings(config.dependencies)
+                ? config.dependencies
+                : ['**'];
+            const packages = isArrayOfStrings(config.packages)
+                ? config.packages
+                : ['**'];
             const specifierTypes = isArrayOfStrings(config.specifierTypes)
                 ? config.specifierTypes
                 : ['**'];
@@ -97,7 +99,9 @@ export function createVersionGroups(ctx) {
                     specifierTypes,
                     label,
                     packages,
-                    preferVersion: config.preferVersion === 'lowestSemver' ? 'lowestSemver' : 'highestSemver',
+                    preferVersion: config.preferVersion === 'lowestSemver'
+                        ? 'lowestSemver'
+                        : 'highestSemver',
                 })));
             }
         });

package/dist/version-group/filtered-out.js

@@ -22,7 +22,7 @@ export class FilteredOutVersionGroup extends Data.TaggedClass('FilteredOut') {
     inspectAll() {
         return Effect.succeed(Object.entries(groupBy('name', this.instances)).map(([name, instances]) => ({
             name,
-            reports: instances.map((instance) => 
+            reports: instances.map(instance => 
             // ✓ is ignored and dismissed as valid
             new Report.FilteredOut(instance)),
         })));

package/dist/version-group/ignored.js

@@ -15,7 +15,7 @@ export class IgnoredVersionGroup extends Data.TaggedClass('Ignored') {
     inspectAll() {
         return Effect.succeed(Object.entries(groupBy('name', this.instances)).map(([name, instances]) => ({
             name,
-            reports: instances.map((instance) => 
+            reports: instances.map(instance => 
             // ✓ is ignored and dismissed as valid
             new Report.Ignored(instance)),
         })));

package/dist/version-group/lib/get-preferred-version.js

@@ -6,39 +6,48 @@ import { getRangeScore } from './get-range-score.js';
 export function getPreferredVersion(preferVersion, specifiers) {
     return pipe(
     // every instance must have a semver version
-    Effect.all(specifiers.map((specifier) => pipe(specifier.getSemver(), Effect.map((semver) => ({ semver, specifier }))))), 
+    Effect.all(specifiers.map(specifier => pipe(specifier.getSemver(), Effect.map(semver => ({ semver, specifier }))))), 
     // comparing semver can error on some loose ranges, all must succeed
-    Effect.map((semvers) => semvers.sort((a, b) => compareSemver(a.semver, b.semver))), 
+    Effect.map(semvers => semvers.sort((a, b) => compareSemver(a.semver, b.semver))), 
     // get the preferred value from the list
-    Effect.map((sorted) => sorted[preferVersion === 'lowestSemver' ? 0 : sorted.length - 1]), 
+    Effect.map(sorted => sorted[preferVersion === 'lowestSemver' ? 0 : sorted.length - 1]), 
     // return just the specifier
-    Effect.map((preferred) => preferred?.specifier));
+    Effect.map(preferred => preferred?.specifier));
 }
 const EQ = 0;
 const LT = -1;
 const GT = 1;
 function compareSemver(a, b) {
-    if (a.startsWith('workspace:'))
+    if (a.startsWith('workspace:')) {
         return LT;
-    if (b.startsWith('workspace:'))
+    }
+    if (b.startsWith('workspace:')) {
         return GT;
-    if (a === b)
+    }
+    if (a === b) {
         return EQ;
-    if (a === '*')
+    }
+    if (a === '*') {
         return GT;
-    if (b === '*')
+    }
+    if (b === '*') {
         return LT;
+    }
     const cleanA = clean(a);
     const cleanB = clean(b);
-    if (gt(cleanA, cleanB))
+    if (gt(cleanA, cleanB)) {
         return GT;
-    if (lt(cleanA, cleanB))
+    }
+    if (lt(cleanA, cleanB)) {
         return LT;
+    }
     const scoreA = getRangeScore(a);
     const scoreB = getRangeScore(b);
-    if (scoreA < scoreB)
+    if (scoreA < scoreB) {
         return LT;
-    if (scoreA > scoreB)
+    }
+    if (scoreA > scoreB) {
         return GT;
+    }
     return EQ;
 }

package/dist/version-group/lib/get-range-score.js

@@ -13,6 +13,8 @@ const scoresByRange = {
 };
 /** Rank a Semver Range according to its greediness */
 export function getRangeScore(version) {
-    const range = version.indexOf('.x') !== -1 ? RANGE.LOOSE : version.slice(0, version.search(/[0-9]/));
+    const range = version.indexOf('.x') !== -1
+        ? RANGE.LOOSE
+        : version.slice(0, version.search(/[0-9]/));
     return scoresByRange[range] || 0;
 }