syncpack 9.8.6 → 10.1.0

package/dist/get-version-groups/pinned.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinnedVersionGroup = void 0;
+const group_by_1 = require("./lib/group-by");
+class PinnedVersionGroup {
+    constructor(config) {
+        this._tag = 'Pinned';
+        this.config = config;
+        this.instances = [];
+    }
+    canAdd(_) {
+        return true;
+    }
+    inspect() {
+        const report = [];
+        const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
+        const expectedVersion = this.config.pinVersion;
+        Object.entries(instancesByName).forEach(([name, instances]) => {
+            if (hasMismatch(expectedVersion, instances)) {
+                report.push({
+                    expectedVersion,
+                    instances,
+                    isValid: false,
+                    name,
+                    status: 'PINNED_MISMATCH',
+                });
+            }
+            else {
+                report.push({
+                    instances,
+                    isValid: true,
+                    name,
+                    status: 'VALID',
+                });
+            }
+        });
+        return report;
+    }
+}
+exports.PinnedVersionGroup = PinnedVersionGroup;
+function hasMismatch(pinVersion, instances) {
+    return instances.some((instance) => instance.version !== pinVersion);
+}

package/dist/get-version-groups/snapped-to.d.ts

@@ -0,0 +1,11 @@
+import type { VersionGroupReport } from '.';
+import type { VersionGroupConfig } from '../config/types';
+import type { Instance } from '../get-package-json-files/instance';
+export declare class SnappedToVersionGroup {
+    _tag: string;
+    config: VersionGroupConfig.SnappedTo;
+    instances: Instance[];
+    constructor(config: VersionGroupConfig.SnappedTo);
+    canAdd(_: Instance): boolean;
+    inspect(): VersionGroupReport[];
+}

package/dist/get-version-groups/snapped-to.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnappedToVersionGroup = void 0;
+const group_by_1 = require("./lib/group-by");
+class SnappedToVersionGroup {
+    constructor(config) {
+        this._tag = 'SnappedTo';
+        this.config = config;
+        this.instances = [];
+    }
+    canAdd(_) {
+        return true;
+    }
+    inspect() {
+        const report = [];
+        const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
+        Object.entries(instancesByName).forEach(([name, instances]) => {
+            const snapTo = this.config.snapTo;
+            const expectedVersion = getExpectedVersion(snapTo, instances);
+            if (hasMismatch(expectedVersion, instances)) {
+                report.push({
+                    expectedVersion,
+                    instances,
+                    isValid: false,
+                    name,
+                    status: 'SNAPPED_TO_MISMATCH',
+                });
+            }
+            else {
+                report.push({
+                    instances,
+                    isValid: true,
+                    name,
+                    status: 'VALID',
+                });
+            }
+        });
+        return report;
+    }
+}
+exports.SnappedToVersionGroup = SnappedToVersionGroup;
+function getExpectedVersion(snapTo, instances) {
+    const expectedVersion = instances
+        .filter((i) => snapTo.includes(i.pkgName))
+        .find((i) => i.version)?.version;
+    if (expectedVersion)
+        return expectedVersion;
+    throw new Error('versionGroup.snapTo does not match any package versions');
+}
+function hasMismatch(expectedVersion, instances) {
+    return instances.some((instance) => instance.version !== expectedVersion);
+}

package/dist/get-version-groups/standard.d.ts

@@ -0,0 +1,11 @@
+import type { VersionGroupReport } from '.';
+import type { VersionGroupConfig } from '../config/types';
+import type { Instance } from '../get-package-json-files/instance';
+export declare class StandardVersionGroup {
+    _tag: string;
+    config: VersionGroupConfig.Standard;
+    instances: Instance[];
+    constructor(config: VersionGroupConfig.Standard);
+    canAdd(_: Instance): boolean;
+    inspect(): VersionGroupReport[];
+}

package/dist/get-version-groups/standard.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardVersionGroup = void 0;
+const unwrap_1 = require("tightrope/result/unwrap");
+const is_semver_1 = require("../lib/is-semver");
+const get_highest_version_1 = require("./lib/get-highest-version");
+const get_lowest_version_1 = require("./lib/get-lowest-version");
+const get_unique_versions_1 = require("./lib/get-unique-versions");
+const group_by_1 = require("./lib/group-by");
+class StandardVersionGroup {
+    constructor(config) {
+        this._tag = 'Standard';
+        this.config = config;
+        this.instances = [];
+    }
+    canAdd(_) {
+        return true;
+    }
+    inspect() {
+        const report = [];
+        const instancesByName = (0, group_by_1.groupBy)('name', this.instances);
+        Object.entries(instancesByName).forEach(([name, instances]) => {
+            if (!hasMismatch(instances)) {
+                return report.push({
+                    status: 'VALID',
+                    instances,
+                    isValid: true,
+                    name,
+                });
+            }
+            const wsInstance = getWorkspaceInstance(instances);
+            const wsFile = wsInstance?.packageJsonFile;
+            const wsVersion = wsFile?.contents?.version;
+            const isWorkspacePackage = wsInstance && wsVersion;
+            if (isWorkspacePackage) {
+                const nonWsInstances = getNonWorkspaceInstances(instances);
+                if (!hasMismatch(nonWsInstances)) {
+                    return report.push({
+                        status: 'VALID',
+                        instances,
+                        isValid: true,
+                        name,
+                    });
+                }
+                return report.push({
+                    status: 'WORKSPACE_MISMATCH',
+                    expectedVersion: wsVersion,
+                    instances,
+                    isValid: false,
+                    name,
+                    workspaceInstance: wsInstance,
+                });
+            }
+            if (hasUnsupported(instances)) {
+                return report.push({
+                    status: 'UNSUPPORTED_MISMATCH',
+                    instances,
+                    isValid: false,
+                    name,
+                });
+            }
+            const preferVersion = this.config.preferVersion;
+            const expectedVersion = getExpectedVersion(preferVersion, instances);
+            return report.push({
+                status: preferVersion === 'highestSemver'
+                    ? 'HIGHEST_SEMVER_MISMATCH'
+                    : 'LOWEST_SEMVER_MISMATCH',
+                expectedVersion,
+                instances,
+                isValid: false,
+                name,
+            });
+        });
+        return report;
+    }
+}
+exports.StandardVersionGroup = StandardVersionGroup;
+function getExpectedVersion(preferVersion, instances) {
+    const versions = (0, get_unique_versions_1.getUniqueVersions)(instances);
+    return (0, unwrap_1.unwrap)(preferVersion === 'highestSemver'
+        ? (0, get_highest_version_1.getHighestVersion)(versions)
+        : (0, get_lowest_version_1.getLowestVersion)(versions));
+}
+function hasMismatch(instances) {
+    return (0, get_unique_versions_1.getUniqueVersions)(instances).length > 1;
+}
+function hasUnsupported(instances) {
+    return instances.some((instance) => !(0, is_semver_1.isSupported)(instance.version));
+}
+function getWorkspaceInstance(instances) {
+    return instances.find((instance) => instance.strategy.name === 'workspace');
+}
+function getNonWorkspaceInstances(instances) {
+    return instances.filter((instance) => instance.strategy.name !== 'workspace');
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { RcConfig } from './config/types';
+export type RcFile = Partial<RcConfig>;

package/dist/{get-context → lib}/$R.d.ts

@@ -4,9 +4,9 @@ export declare const $R: {
     /**
      * Return a single `Ok<output[]>` containing an array of the output of every
      * `Result` returned by `getResult(input)` which succeeded, or a single
-     * `Err<BaseError>` if none succeeded.
+     * `Err<Error>` if none succeeded.
      */
-    onlyOk<Input, Output = Input>(getResult: (value: Input) => Result<Output, unknown>): (inputs: Input[]) => Result<Output[], unknown>;
+    onlyOk<Input, Output = Input>(getResult: (value: Input) => Result<Output>): (inputs: Input[]) => Result<Output[]>;
     /** Log verbose only when Result is an Err */
     tapErrVerbose<T extends AnyResult>(result: T): T;
 };

package/dist/{get-context → lib}/$R.js

@@ -4,13 +4,12 @@ exports.$R = void 0;
 const result_1 = require("tightrope/result");
 const is_err_1 = require("tightrope/result/is-err");
 const unwrap_1 = require("tightrope/result/unwrap");
-const error_1 = require("../lib/error");
-const log_1 = require("../lib/log");
+const log_1 = require("./log");
 exports.$R = {
     /**
      * Return a single `Ok<output[]>` containing an array of the output of every
      * `Result` returned by `getResult(input)` which succeeded, or a single
-     * `Err<BaseError>` if none succeeded.
+     * `Err<Error>` if none succeeded.
      */
     onlyOk(getResult) {
         return (inputs) => {
@@ -23,7 +22,7 @@ exports.$R = {
             }
             return outputs.length > 0
                 ? new result_1.Ok(outputs)
-                : new result_1.Err(new error_1.BaseError('No Ok() returned by $R.onlyOk'));
+                : new result_1.Err(new Error('No Ok() returned by $R.onlyOk'));
         };
     },
     /** Log verbose only when Result is an Err */

package/dist/lib/disk.d.ts

@@ -1,10 +1,11 @@
-import type { Syncpack } from '../types';
+import type { O } from 'ts-toolbelt';
+import type { RcConfig } from '../config/types';
 export type Disk = {
     process: {
         exit: (code: number) => void;
     };
     globSync: (pattern: string) => string[];
-    readConfigFileSync: (configPath?: string) => Partial<Syncpack.Config.SyncpackRc>;
+    readConfigFileSync: (configPath?: string) => O.Partial<RcConfig, 'deep'>;
     readFileSync: (filePath: string) => string;
     readYamlFileSync: <T = unknown>(filePath: string) => T;
     removeSync: (filePath: string) => void;

package/dist/lib/exit-if-invalid.d.ts

@@ -1,2 +1,2 @@
-import type { Syncpack } from '../types';
-export declare function exitIfInvalid(ctx: Syncpack.Ctx): Syncpack.Ctx;
+import type { Context } from '../get-context';
+export declare function exitIfInvalid(ctx: Context): Context;

package/dist/lib/is-semver.d.ts

@@ -1,4 +1,6 @@
-import type { Syncpack } from '../types';
-export declare function isValidSemverRange(value: unknown): value is Syncpack.Config.SemverRange.Value;
-export declare function isSemver(version: unknown): version is string;
+import type { SemverRange } from '../config/types';
+export declare function isValidSemverRange(value: unknown): value is SemverRange;
+export declare function isSupported(version: unknown): version is string;
+export declare function isWorkspaceProtocol(version: unknown): boolean;
+export declare function isSemver(version: unknown): boolean;
 export declare function isLooseSemver(version: unknown): boolean;

package/dist/lib/is-semver.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLooseSemver = exports.isSemver = exports.isValidSemverRange = void 0;
+exports.isLooseSemver = exports.isSemver = exports.isWorkspaceProtocol = exports.isSupported = exports.isValidSemverRange = void 0;
 const is_string_1 = require("tightrope/guard/is-string");
 const constants_1 = require("../constants");
 function isValidSemverRange(value) {
@@ -12,9 +12,23 @@ function isValidSemverRange(value) {
         value === constants_1.RANGE.LT ||
         value === constants_1.RANGE.LTE ||
         value === constants_1.RANGE.MINOR ||
-        value === constants_1.RANGE.PATCH);
+        value === constants_1.RANGE.PATCH ||
+        value === constants_1.RANGE.WORKSPACE);
 }
 exports.isValidSemverRange = isValidSemverRange;
+function isSupported(version) {
+    return version === '*' || isSemver(version) || isWorkspaceProtocol(version);
+}
+exports.isSupported = isSupported;
+function isWorkspaceProtocol(version) {
+    if (!(0, is_string_1.isString)(version))
+        return false;
+    if (!version.startsWith('workspace:'))
+        return false;
+    const value = version.replace(/^workspace:/, '');
+    return value === '*' || isSemver(value);
+}
+exports.isWorkspaceProtocol = isWorkspaceProtocol;
 function isSemver(version) {
     const range = '(~|\\^|>=|>|<=|<)?';
     const ints = '[0-9]+';
@@ -30,6 +44,6 @@ function isSemver(version) {
 }
 exports.isSemver = isSemver;
 function isLooseSemver(version) {
-    return isSemver(version) && version.search(/\.x(\.|$)/) !== -1;
+    return ((0, is_string_1.isString)(version) && isSemver(version) && version.search(/\.x(\.|$)/) !== -1);
 }
 exports.isLooseSemver = isLooseSemver;

package/dist/lib/log.d.ts

@@ -1,9 +1,5 @@
-import type { SemverGroup } from '../get-context/get-groups/semver-group';
-import type { VersionGroup } from '../get-context/get-groups/version-group';
+import type { AnySemverGroup } from '../get-semver-groups';
+import type { AnyVersionGroup } from '../get-version-groups';
 export declare function verbose(...values: unknown[]): void;
-export declare function fixed(message: string): void;
-export declare function skip(message: string): void;
-export declare function valid(message: string, comment?: string): void;
-export declare function invalid(message: string, comment?: string): void;
-export declare function semverGroupHeader(group: SemverGroup, i: number): void;
-export declare function versionGroupHeader(group: VersionGroup, i: number): void;
+export declare function semverGroupHeader(group: AnySemverGroup, i: number): void;
+export declare function versionGroupHeader(group: AnyVersionGroup, i: number): void;

package/dist/lib/log.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.versionGroupHeader = exports.semverGroupHeader = exports.invalid = exports.valid = exports.skip = exports.fixed = exports.verbose = void 0;
+exports.versionGroupHeader = exports.semverGroupHeader = exports.verbose = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const is_string_1 = require("tightrope/guard/is-string");
 const util_1 = require("util");
@@ -22,32 +22,6 @@ function verbose(...values) {
     }
 }
 exports.verbose = verbose;
-function fixed(message) {
-    console.log((0, chalk_1.default) `{green ${constants_1.ICON.tick}}`, message);
-}
-exports.fixed = fixed;
-function skip(message) {
-    console.log(chalk_1.default.dim(constants_1.ICON.skip), chalk_1.default.dim(message));
-}
-exports.skip = skip;
-function valid(message, comment) {
-    if (comment) {
-        console.log((0, chalk_1.default) `{dim ${constants_1.ICON.skip}} ${message} {dim ${comment}}`);
-    }
-    else {
-        console.log((0, chalk_1.default) `{dim ${constants_1.ICON.skip}} ${message}`);
-    }
-}
-exports.valid = valid;
-function invalid(message, comment) {
-    if (comment) {
-        console.log((0, chalk_1.default) `{red ${constants_1.ICON.cross}} ${message} {dim ${comment}}`);
-    }
-    else {
-        console.log((0, chalk_1.default) `{red ${constants_1.ICON.cross}} ${message}`);
-    }
-}
-exports.invalid = invalid;
 function semverGroupHeader(group, i) {
     logHeader(group, 'Semver', i);
 }
@@ -57,8 +31,8 @@ function versionGroupHeader(group, i) {
 }
 exports.versionGroupHeader = versionGroupHeader;
 function logHeader(group, type, i) {
-    const customLabel = group.groupConfig.label;
-    const labelWhenDefault = group.isDefault ? `Default ${type} Group` : '';
+    const customLabel = group.config.label;
+    const labelWhenDefault = group._tag === 'CatchAll' ? `Default ${type} Group` : '';
     const anonymousLabel = `${type} Group ${i + 1}`;
     const label = (customLabel || labelWhenDefault || anonymousLabel).trim();
     const hasNewLines = label.search(/[\r\n]/) !== -1;

package/dist/lib/set-semver-range.d.ts

@@ -1,2 +1,2 @@
-import type { Syncpack } from '../types';
-export declare function setSemverRange(semverRange: Syncpack.Config.SemverRange.Value, version: string): string;
+import type { SemverRange } from '../config/types';
+export declare function setSemverRange(semverRange: SemverRange, version: string): string;

package/dist/lib/write-if-changed.d.ts

@@ -1,2 +1,2 @@
-import type { Syncpack } from '../types';
-export declare function writeIfChanged(ctx: Syncpack.Ctx): Syncpack.Ctx;
+import type { Context } from '../get-context';
+export declare function writeIfChanged(ctx: Context): Context;

package/dist/lib/write-if-changed.js

@@ -1,38 +1,19 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeIfChanged = void 0;
-const log = __importStar(require("./log"));
+const chalk_1 = __importDefault(require("chalk"));
+const constants_1 = require("../constants");
 function writeIfChanged(ctx) {
     ctx.packageJsonFiles.forEach((packageJsonFile) => {
         if (packageJsonFile.hasChanged()) {
             packageJsonFile.write();
-            log.fixed(packageJsonFile.shortPath);
+            console.log((0, chalk_1.default) `{green ${constants_1.ICON.tick}}`, packageJsonFile.shortPath);
         }
         else {
-            log.skip(packageJsonFile.shortPath);
+            console.log(chalk_1.default.dim(constants_1.ICON.skip), chalk_1.default.dim(packageJsonFile.shortPath));
         }
     });
     return ctx;

package/dist/{get-context/get-config/path-strategy → strategy}/lib/get-non-empty-string-prop.d.ts

@@ -1,3 +1,3 @@
 import type { Result } from 'tightrope/result';
-import type { PackageJsonFile } from '../../../get-package-json-files/package-json-file';
+import type { PackageJsonFile } from '../../get-package-json-files/package-json-file';
 export declare function getNonEmptyStringProp(propPath: string, file: PackageJsonFile): Result<string>;

package/dist/{get-context/get-config/path-strategy → strategy}/lib/get-non-empty-string-prop.js

@@ -6,8 +6,7 @@ const pipe_1 = require("tightrope/fn/pipe");
 const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
 const filter_1 = require("tightrope/result/filter");
 const map_err_1 = require("tightrope/result/map-err");
-const error_1 = require("../../../../lib/error");
 function getNonEmptyStringProp(propPath, file) {
-    return (0, pipe_1.pipe)((0, get_1.get)(file.contents, ...propPath.split('.')), (0, filter_1.filter)(is_non_empty_string_1.isNonEmptyString, ''), (0, map_err_1.mapErr)(() => new error_1.BaseError(`Failed to get ${propPath} in ${file.shortPath}`)));
+    return (0, pipe_1.pipe)((0, get_1.get)(file.contents, ...propPath.split('.')), (0, filter_1.filter)(is_non_empty_string_1.isNonEmptyString, ''), (0, map_err_1.mapErr)(() => new Error(`Failed to get ${propPath} in ${file.shortPath}`)));
 }
 exports.getNonEmptyStringProp = getNonEmptyStringProp;

package/dist/strategy/name-and-version-props.d.ts

@@ -0,0 +1,12 @@
+import type { Result } from 'tightrope/result';
+import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
+import type { Delete } from '../get-version-groups/lib/delete';
+export declare class NameAndVersionPropsStrategy {
+    _tag: string;
+    name: string;
+    path: string;
+    namePath: string;
+    constructor(name: string, path: string, namePath: string);
+    read(file: PackageJsonFile): Result<[string, string][]>;
+    write(file: PackageJsonFile, [, version]: [string, string | Delete]): Result<PackageJsonFile>;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NameAndVersionPropsStrategy = void 0;
+const get_1 = require("tightrope/fn/get");
+const pipe_1 = require("tightrope/fn/pipe");
+const and_then_1 = require("tightrope/result/and-then");
+const from_try_1 = require("tightrope/result/from-try");
+const map_1 = require("tightrope/result/map");
+const tap_1 = require("tightrope/result/tap");
+const delete_1 = require("../get-version-groups/lib/delete");
+const get_non_empty_string_prop_1 = require("./lib/get-non-empty-string-prop");
+class NameAndVersionPropsStrategy {
+    constructor(name, path, namePath) {
+        this._tag = 'name~version';
+        this.name = name;
+        this.path = path;
+        this.namePath = namePath;
+    }
+    read(file) {
+        const path = this.path;
+        const namePath = this.namePath;
+        return (0, pipe_1.pipe)(
+        // get name prop
+        (0, get_non_empty_string_prop_1.getNonEmptyStringProp)(namePath, file), 
+        // add the version prop
+        (0, and_then_1.andThen)((name) => (0, pipe_1.pipe)((0, get_non_empty_string_prop_1.getNonEmptyStringProp)(path, file), (0, map_1.map)((version) => ({ name, version })))), 
+        // if both are non empty strings, we can return them
+        (0, map_1.map)(({ name, version }) => [[name, version]]));
+    }
+    write(file, [, version]) {
+        const path = this.path;
+        const { contents } = file;
+        const isNestedPath = path.includes('.');
+        const nextValue = version === delete_1.DELETE ? undefined : version;
+        if (isNestedPath) {
+            const fullPath = path.split('.');
+            const pathToParent = fullPath.slice(0, fullPath.length - 1).join('.');
+            const key = fullPath.slice(-1).join('');
+            return (0, pipe_1.pipe)((0, get_1.get)(contents, ...pathToParent.split('.')), (0, tap_1.tap)((parent) => {
+                parent[key] = version;
+            }), (0, map_1.map)(() => file));
+        }
+        else {
+            return (0, pipe_1.pipe)((0, from_try_1.fromTry)(() => {
+                contents[path] = nextValue;
+            }), (0, map_1.map)(() => file));
+        }
+    }
+}
+exports.NameAndVersionPropsStrategy = NameAndVersionPropsStrategy;

package/dist/strategy/named-version-string.d.ts

@@ -0,0 +1,11 @@
+import type { Result } from 'tightrope/result';
+import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
+import type { Delete } from '../get-version-groups/lib/delete';
+export declare class NamedVersionStringStrategy {
+    _tag: string;
+    name: string;
+    path: string;
+    constructor(name: string, path: string);
+    read(file: PackageJsonFile): Result<[string, string][]>;
+    write(file: PackageJsonFile, [name, version]: [string, string | Delete]): Result<PackageJsonFile>;
+}

package/dist/{get-context/get-config/path-strategy/name-and-version-string.js → strategy/named-version-string.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nameAndVersionString = void 0;
+exports.NamedVersionStringStrategy = void 0;
 const get_1 = require("tightrope/fn/get");
 const pipe_1 = require("tightrope/fn/pipe");
 const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
@@ -8,42 +8,46 @@ const result_1 = require("tightrope/result");
 const and_then_1 = require("tightrope/result/and-then");
 const from_try_1 = require("tightrope/result/from-try");
 const map_1 = require("tightrope/result/map");
-const map_err_1 = require("tightrope/result/map-err");
 const tap_1 = require("tightrope/result/tap");
-const error_1 = require("../../../lib/error");
+const delete_1 = require("../get-version-groups/lib/delete");
 const get_non_empty_string_prop_1 = require("./lib/get-non-empty-string-prop");
-exports.nameAndVersionString = {
-    read(file, pathDef) {
+class NamedVersionStringStrategy {
+    constructor(name, path) {
+        this._tag = 'name@version';
+        this.name = name;
+        this.path = path;
+    }
+    read(file) {
+        const path = this.path;
         return (0, pipe_1.pipe)(
         // get version prop
-        (0, get_non_empty_string_prop_1.getNonEmptyStringProp)(pathDef.path, file), 
+        (0, get_non_empty_string_prop_1.getNonEmptyStringProp)(path, file), 
         // if it is a non empty string, we can read it
         (0, and_then_1.andThen)((value) => {
             const [name, version] = value.split('@');
             return (0, is_non_empty_string_1.isNonEmptyString)(name) && (0, is_non_empty_string_1.isNonEmptyString)(version)
                 ? new result_1.Ok([[name, version]])
-                : new result_1.Err(new error_1.BaseError(`Strategy<name@version> failed to get ${pathDef.path} in ${file.shortPath}`));
+                : new result_1.Err(new Error(`Strategy<name@version> failed to get ${path} in ${file.shortPath}`));
         }));
-    },
-    write(file, pathDef, [name, version]) {
-        const { contents, shortPath } = file;
-        const isNestedPath = pathDef.path.includes('.');
+    }
+    write(file, [name, version]) {
+        const { contents } = file;
+        const path = this.path;
+        const isNestedPath = path.includes('.');
+        const nextValue = version === delete_1.DELETE ? undefined : `${name}@${version}`;
         if (isNestedPath) {
-            const fullPath = pathDef.path.split('.');
+            const fullPath = path.split('.');
             const pathToParent = fullPath.slice(0, fullPath.length - 1).join('.');
             const key = fullPath.slice(-1).join('');
             return (0, pipe_1.pipe)((0, get_1.get)(contents, ...pathToParent.split('.')), (0, tap_1.tap)((parent) => {
-                parent[key] = `${name}@${version}`;
-            }), (0, map_err_1.mapErr)(onError), (0, map_1.map)(() => file));
+                parent[key] = nextValue;
+            }), (0, map_1.map)(() => file));
         }
         else {
             return (0, pipe_1.pipe)((0, from_try_1.fromTry)(() => {
-                contents[pathDef.path] = `${name}@${version}`;
-            }), (0, map_err_1.mapErr)(onError), (0, map_1.map)(() => file));
+                contents[path] = nextValue;
+            }), (0, map_1.map)(() => file));
         }
-        function onError() {
-            const msg = `Strategy<name@version> failed to set ${pathDef.path} in ${shortPath}`;
-            return new error_1.BaseError(msg);
-        }
-    },
-};
+    }
+}
+exports.NamedVersionStringStrategy = NamedVersionStringStrategy;

package/dist/strategy/unnamed-version-string.d.ts

@@ -0,0 +1,11 @@
+import type { Result } from 'tightrope/result';
+import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
+import type { Delete } from '../get-version-groups/lib/delete';
+export declare class UnnamedVersionStringStrategy {
+    _tag: string;
+    name: string;
+    path: string;
+    constructor(name: string, path: string);
+    read(file: PackageJsonFile): Result<[string, string][]>;
+    write(file: PackageJsonFile, [, version]: [string, string | Delete]): Result<PackageJsonFile>;
+}