syncpack 8.5.14 → 9.0.0

package/dist/constants.d.ts

@@ -1,4 +1,3 @@
-import type { Config } from './lib/get-context/get-config/config';
 /** Single source of truth, intended to aid testing or to override */
 export declare const CWD: string;
 /** Where to search for packages if none are provided by the user */
@@ -11,11 +10,6 @@ export declare const ICON: {
     readonly skip: "-";
     readonly tick: "✓";
 };
-/**
- * Aliases for locations of versions within package.json files, it is looped
- * over by each command to operate on each are as defined by the user.
- */
-export declare const ALL_DEPENDENCY_TYPES: readonly ["dependencies", "devDependencies", "overrides", "peerDependencies", "pnpmOverrides", "resolutions", "workspace"];
 export declare const RANGE: {
     readonly ANY: "*";
     readonly EXACT: "";
@@ -27,4 +21,14 @@ export declare const RANGE: {
     readonly MINOR: "^";
     readonly PATCH: "~";
 };
-export declare const DEFAULT_CONFIG: Config.RcFile;
+export declare const DEFAULT_CONFIG: {
+    readonly dependencyTypes: readonly ["dev", "overrides", "peer", "pnpmOverrides", "prod", "resolutions", "workspace"];
+    readonly filter: ".";
+    readonly indent: "  ";
+    readonly semverGroups: readonly [];
+    readonly semverRange: "";
+    readonly sortAz: readonly ["contributors", "dependencies", "devDependencies", "keywords", "peerDependencies", "resolutions", "scripts"];
+    readonly sortFirst: readonly ["name", "description", "version", "author"];
+    readonly source: readonly [];
+    readonly versionGroups: readonly [];
+};

package/dist/constants.js

@@ -1,8 +1,8 @@
 "use strict";
 exports.__esModule = true;
-exports.DEFAULT_CONFIG = exports.RANGE = exports.ALL_DEPENDENCY_TYPES = exports.ICON = exports.DEFAULT_SOURCES = exports.CWD = void 0;
+exports.DEFAULT_CONFIG = exports.RANGE = exports.ICON = exports.DEFAULT_SOURCES = exports.CWD = void 0;
 /** Single source of truth, intended to aid testing or to override */
-exports.CWD = process.cwd();
+exports.CWD = process.env.MOCK_CWD || process.cwd();
 /** Where to search for packages if none are provided by the user */
 exports.DEFAULT_SOURCES = ['package.json', 'packages/*/package.json'];
 /** Single source of truth for icons used in output */
@@ -13,19 +13,6 @@ exports.ICON = {
     skip: '-',
     tick: '✓'
 };
-/**
- * Aliases for locations of versions within package.json files, it is looped
- * over by each command to operate on each are as defined by the user.
- */
-exports.ALL_DEPENDENCY_TYPES = [
-    'dependencies',
-    'devDependencies',
-    'overrides',
-    'peerDependencies',
-    'pnpmOverrides',
-    'resolutions',
-    'workspace',
-];
 exports.RANGE = {
     ANY: '*',
     EXACT: '',
@@ -38,15 +25,17 @@ exports.RANGE = {
     PATCH: '~'
 };
 exports.DEFAULT_CONFIG = {
-    dev: true,
+    dependencyTypes: [
+        'dev',
+        'overrides',
+        'peer',
+        'pnpmOverrides',
+        'prod',
+        'resolutions',
+        'workspace',
+    ],
     filter: '.',
     indent: '  ',
-    overrides: true,
-    peer: true,
-    pnpmOverrides: true,
-    prod: true,
-    resolutions: true,
-    workspace: true,
     semverGroups: [],
     semverRange: '',
     sortAz: [

package/dist/get-context/$R.d.ts

@@ -0,0 +1,13 @@
+import { R } from '@mobily/ts-belt';
+import { BaseError } from '../lib/error';
+/** Additional helpers for https://mobily.github.io/ts-belt/api/result */
+export declare const $R: {
+    /**
+     * Return a single `R.Ok<output[]>` containing an array of the output of every
+     * `R.Result` returned by `getResult(input)` which succeeded, or a single
+     * `R.Error<BaseError>` if none succeeded.
+     */
+    onlyOk<Input, Output = Input>(getResult: (value: Input) => R.Result<Output, BaseError>): (inputs: Input[]) => R.Result<Output[], BaseError>;
+    /** Log verbose only when R.Result is an R.Err */
+    tapErrVerbose<T extends R.Result<unknown, BaseError>>(result: T): T;
+};

package/dist/get-context/$R.js

@@ -0,0 +1,56 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+exports.__esModule = true;
+exports.$R = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var error_1 = require("../lib/error");
+var log_1 = require("../lib/log");
+/** Additional helpers for https://mobily.github.io/ts-belt/api/result */
+exports.$R = {
+    /**
+     * Return a single `R.Ok<output[]>` containing an array of the output of every
+     * `R.Result` returned by `getResult(input)` which succeeded, or a single
+     * `R.Error<BaseError>` if none succeeded.
+     */
+    onlyOk: function (getResult) {
+        return function (inputs) {
+            var e_1, _a;
+            var outputs = [];
+            try {
+                for (var inputs_1 = __values(inputs), inputs_1_1 = inputs_1.next(); !inputs_1_1.done; inputs_1_1 = inputs_1.next()) {
+                    var value = inputs_1_1.value;
+                    var result = getResult(value);
+                    if (ts_belt_1.R.isError(result))
+                        continue;
+                    outputs.push(ts_belt_1.R.getExn(result));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (inputs_1_1 && !inputs_1_1.done && (_a = inputs_1["return"])) _a.call(inputs_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return outputs.length > 0
+                ? ts_belt_1.R.Ok(outputs)
+                : ts_belt_1.R.Error(new error_1.BaseError('No R.Ok() returned by $R.onlyOk'));
+        };
+    },
+    /** Log verbose only when R.Result is an R.Err */
+    tapErrVerbose: function (result) {
+        if (ts_belt_1.R.isError(result))
+            (0, log_1.verbose)(result._0.message);
+        return result;
+    }
+};

package/dist/{lib/get-context → get-context}/get-all-instances.js

@@ -1,7 +1,7 @@
 "use strict";
 exports.__esModule = true;
 exports.getAllInstances = void 0;
-var sort_by_name_1 = require("../sort-by-name");
+var sort_by_name_1 = require("../lib/sort-by-name");
 function getAllInstances(packageJsonFiles) {
     return packageJsonFiles.flatMap(function (pkg) { return pkg.getInstances(); }).sort(sort_by_name_1.sortByName);
 }

package/dist/get-context/get-config/get-core-types.d.ts

@@ -0,0 +1,36 @@
+import type { Syncpack } from '../../types';
+type CoreTypes = typeof coreTypes;
+export type CoreTypeName = keyof CoreTypes;
+declare const coreTypes: {
+    readonly dev: {
+        readonly path: "devDependencies";
+        readonly strategy: "versionsByName";
+    };
+    readonly overrides: {
+        readonly path: "overrides";
+        readonly strategy: "versionsByName";
+    };
+    readonly peer: {
+        readonly path: "peerDependencies";
+        readonly strategy: "versionsByName";
+    };
+    readonly pnpmOverrides: {
+        readonly path: "pnpm.overrides";
+        readonly strategy: "versionsByName";
+    };
+    readonly prod: {
+        readonly path: "dependencies";
+        readonly strategy: "versionsByName";
+    };
+    readonly resolutions: {
+        readonly path: "resolutions";
+        readonly strategy: "versionsByName";
+    };
+    readonly workspace: {
+        readonly namePath: "name";
+        readonly path: "version";
+        readonly strategy: "name~version";
+    };
+};
+export declare function getCoreTypes(): Syncpack.PathDefinition[];
+export {};

package/dist/get-context/get-config/get-core-types.js

@@ -0,0 +1,68 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+exports.__esModule = true;
+exports.getCoreTypes = void 0;
+var coreTypes = {
+    dev: {
+        path: 'devDependencies',
+        strategy: 'versionsByName'
+    },
+    overrides: {
+        path: 'overrides',
+        strategy: 'versionsByName'
+    },
+    peer: {
+        path: 'peerDependencies',
+        strategy: 'versionsByName'
+    },
+    pnpmOverrides: {
+        path: 'pnpm.overrides',
+        strategy: 'versionsByName'
+    },
+    prod: {
+        path: 'dependencies',
+        strategy: 'versionsByName'
+    },
+    resolutions: {
+        path: 'resolutions',
+        strategy: 'versionsByName'
+    },
+    workspace: {
+        namePath: 'name',
+        path: 'version',
+        strategy: 'name~version'
+    }
+};
+function getCoreTypes() {
+    return Object.entries(coreTypes).map(function (_a) {
+        var _b = __read(_a, 2), name = _b[0], pathDef = _b[1];
+        return (__assign(__assign({}, pathDef), { name: name }));
+    });
+}
+exports.getCoreTypes = getCoreTypes;

package/dist/get-context/get-config/get-custom-types.d.ts

@@ -0,0 +1,4 @@
+import type { Syncpack } from '../../types';
+type Options = Pick<Partial<Syncpack.Config.Public>, 'customTypes'>;
+export declare function getCustomTypes({ customTypes, }: Options): Syncpack.PathDefinition[];
+export {};

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

@@ -0,0 +1,28 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+exports.getCustomTypes = void 0;
+var expect_more_1 = require("expect-more");
+function getCustomTypes(_a) {
+    var customTypes = _a.customTypes;
+    return customTypes
+        ? Object.keys(customTypes)
+            .map(function (name) {
+            var pathDef = customTypes[name];
+            if (pathDef)
+                return __assign(__assign({}, pathDef), { name: name });
+        })
+            .filter((expect_more_1.isObject))
+        : [];
+}
+exports.getCustomTypes = getCustomTypes;

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

@@ -0,0 +1,4 @@
+import type { Syncpack } from '../../types';
+type Options = Pick<Partial<Syncpack.Config.Public>, 'dependencyTypes' | 'types'>;
+export declare function getEnabledTypes(allTypes: Syncpack.PathDefinition[], { dependencyTypes, types }: Options): Syncpack.PathDefinition[];
+export {};

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

@@ -0,0 +1,19 @@
+"use strict";
+exports.__esModule = true;
+exports.getEnabledTypes = void 0;
+var expect_more_1 = require("expect-more");
+function getEnabledTypes(allTypes, _a) {
+    var dependencyTypes = _a.dependencyTypes, types = _a.types;
+    var enabledNames = (0, expect_more_1.isNonEmptyString)(types)
+        ? types.split(',')
+        : (0, expect_more_1.isArrayOfStrings)(dependencyTypes)
+            ? dependencyTypes
+            : [];
+    return (0, expect_more_1.isNonEmptyArray)(enabledNames)
+        ? allTypes.filter(function (_a) {
+            var name = _a.name;
+            return enabledNames.includes(name);
+        })
+        : allTypes;
+}
+exports.getEnabledTypes = getEnabledTypes;

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

@@ -0,0 +1,7 @@
+import type { Disk } from '../../lib/disk';
+import type { Syncpack } from '../../types';
+/**
+ * Take all configuration from the command line and config file, combine it, and
+ * set defaults for anything which hasn't been defined.
+ */
+export declare const getConfig: (disk: Disk, fromCli: Partial<Syncpack.Config.Cli>) => Syncpack.Config.Private;

package/dist/get-context/get-config/index.js

@@ -0,0 +1,115 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.getConfig = void 0;
+var log_1 = require("../../lib/log");
+var get_core_types_1 = require("./get-core-types");
+var get_custom_types_1 = require("./get-custom-types");
+var get_enabled_types_1 = require("./get-enabled-types");
+var ConfigSchema = __importStar(require("./schema"));
+/**
+ * Take all configuration from the command line and config file, combine it, and
+ * set defaults for anything which hasn't been defined.
+ */
+var getConfig = function (disk, fromCli) {
+    (0, log_1.verbose)('cli arguments:', fromCli);
+    var fromRcFile = disk.readConfigFileSync(fromCli.configPath);
+    (0, log_1.verbose)('rcfile contents:', fromRcFile);
+    var fromPublic = ConfigSchema.Public.parse({
+        customTypes: getConfigByName('customTypes'),
+        dependencyTypes: fromRcFile === null || fromRcFile === void 0 ? void 0 : fromRcFile.dependencyTypes,
+        filter: getConfigByName('filter'),
+        indent: getConfigByName('indent'),
+        semverGroups: getConfigByName('semverGroups'),
+        semverRange: getConfigByName('semverRange'),
+        sortAz: getConfigByName('sortAz'),
+        sortFirst: getConfigByName('sortFirst'),
+        source: getConfigByName('source'),
+        types: fromCli === null || fromCli === void 0 ? void 0 : fromCli.types,
+        versionGroups: getConfigByName('versionGroups')
+    });
+    (0, log_1.verbose)('user config:', fromPublic);
+    var coreTypes = (0, get_core_types_1.getCoreTypes)();
+    var customTypes = (0, get_custom_types_1.getCustomTypes)(fromPublic);
+    var allTypes = __spreadArray(__spreadArray([], __read(coreTypes), false), __read(customTypes), false);
+    var enabledTypes = (0, get_enabled_types_1.getEnabledTypes)(allTypes, fromPublic);
+    var allConfig = ConfigSchema.Private.parse(__assign(__assign({}, fromPublic), { allTypes: allTypes, enabledTypes: enabledTypes, defaultSemverGroup: {
+            dependencies: ['**'],
+            isDefault: true,
+            packages: ['**'],
+            range: fromPublic.semverRange
+        }, defaultVersionGroup: {
+            dependencies: ['**'],
+            isDefault: true,
+            packages: ['**']
+        } }));
+    allConfig.semverGroups.push(allConfig.defaultSemverGroup);
+    allConfig.versionGroups.push(allConfig.defaultVersionGroup);
+    (0, log_1.verbose)('final config:', allConfig);
+    return allConfig;
+    function getConfigByName(name) {
+        if (name in fromCli)
+            return fromCli[name];
+        if (name in fromRcFile)
+            return fromRcFile[name];
+    }
+};
+exports.getConfig = getConfig;

package/dist/get-context/get-config/path-strategy/index.d.ts

@@ -0,0 +1,8 @@
+export type StrategyByName = typeof strategyByName;
+export declare const strategyByName: {
+    readonly 'name@version': import("./types").Strategy<"name@version">;
+    readonly 'name~version': import("./types").Strategy<"name~version">;
+    readonly version: import("./types").Strategy<"version">;
+    readonly versionsByName: import("./types").Strategy<"versionsByName">;
+};
+export declare function exhaustiveCheck(strategyName: never): never;

package/dist/get-context/get-config/path-strategy/index.js

@@ -0,0 +1,18 @@
+"use strict";
+exports.__esModule = true;
+exports.exhaustiveCheck = exports.strategyByName = void 0;
+var error_1 = require("../../../lib/error");
+var name_and_version_props_1 = require("./name-and-version-props");
+var name_and_version_string_1 = require("./name-and-version-string");
+var version_string_1 = require("./version-string");
+var versions_by_name_1 = require("./versions-by-name");
+exports.strategyByName = {
+    'name@version': name_and_version_string_1.nameAndVersionString,
+    'name~version': name_and_version_props_1.nameAndVersionProps,
+    'version': version_string_1.versionString,
+    'versionsByName': versions_by_name_1.versionsByName
+};
+function exhaustiveCheck(strategyName) {
+    throw new error_1.BaseError("Unrecognised strategy \"".concat(strategyName, "\""));
+}
+exports.exhaustiveCheck = exhaustiveCheck;

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

@@ -0,0 +1,4 @@
+import type { R } from '@mobily/ts-belt';
+import { BaseError } from '../../../../lib/error';
+import type { PackageJsonFile } from '../../../get-package-json-files/package-json-file';
+export declare function getNonEmptyStringProp(propPath: string, file: PackageJsonFile): R.Result<string, BaseError>;

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

@@ -0,0 +1,11 @@
+"use strict";
+exports.__esModule = true;
+exports.getNonEmptyStringProp = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var expect_more_1 = require("expect-more");
+var error_1 = require("../../../../lib/error");
+var props_1 = require("../../../get-package-json-files/get-patterns/props");
+function getNonEmptyStringProp(propPath, file) {
+    return (0, ts_belt_1.pipe)(file.contents, (0, props_1.props)(propPath, expect_more_1.isNonEmptyString), ts_belt_1.O.toResult(new error_1.BaseError("Failed to get ".concat(propPath, " in ").concat(file.shortPath))));
+}
+exports.getNonEmptyStringProp = getNonEmptyStringProp;

package/dist/get-context/get-config/path-strategy/name-and-version-props.d.ts

@@ -0,0 +1,2 @@
+import type { Strategy } from './types';
+export declare const nameAndVersionProps: Strategy<'name~version'>;

package/dist/get-context/get-config/path-strategy/name-and-version-props.js

@@ -0,0 +1,66 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+exports.__esModule = true;
+exports.nameAndVersionProps = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var expect_more_1 = require("expect-more");
+var error_1 = require("../../../lib/error");
+var props_1 = require("../../get-package-json-files/get-patterns/props");
+var get_non_empty_string_prop_1 = require("./lib/get-non-empty-string-prop");
+exports.nameAndVersionProps = {
+    read: function (file, pathDef) {
+        return (0, ts_belt_1.pipe)(
+        // get name prop
+        (0, get_non_empty_string_prop_1.getNonEmptyStringProp)(pathDef.namePath, file), ts_belt_1.R.mapError(function () {
+            return new error_1.BaseError("Strategy<name~version> failed to get ".concat(pathDef.namePath, " in ").concat(file.shortPath));
+        }), 
+        // add the version prop
+        ts_belt_1.R.flatMap(function (name) {
+            return (0, ts_belt_1.pipe)((0, get_non_empty_string_prop_1.getNonEmptyStringProp)(pathDef.path, file), ts_belt_1.R.map(function (version) { return ({ name: name, version: version }); }), ts_belt_1.R.mapError(function () {
+                return new error_1.BaseError("Strategy<name~version> failed to get ".concat(pathDef.path, " in ").concat(file.shortPath));
+            }));
+        }), 
+        // if both are non empty strings, we can return them
+        ts_belt_1.R.map(function (_a) {
+            var name = _a.name, version = _a.version;
+            return [[name, version]];
+        }));
+    },
+    write: function (file, pathDef, _a) {
+        var _b = __read(_a, 2), version = _b[1];
+        var contents = file.contents, shortPath = file.shortPath;
+        var isNestedPath = pathDef.path.includes('.');
+        if (isNestedPath) {
+            var fullPath = pathDef.path.split('.');
+            var pathToParent = fullPath.slice(0, fullPath.length - 1).join('.');
+            var key_1 = fullPath.slice(-1).join('');
+            return (0, ts_belt_1.pipe)(contents, (0, props_1.props)(pathToParent, expect_more_1.isObject), ts_belt_1.O.toResult(onError()), ts_belt_1.R.tap(function (parent) {
+                parent[key_1] = version;
+            }), ts_belt_1.R.mapError(onError), ts_belt_1.R.map(function () { return file; }));
+        }
+        else {
+            return (0, ts_belt_1.pipe)(ts_belt_1.R.fromExecution(function () {
+                contents[pathDef.path] = version;
+            }), ts_belt_1.R.mapError(onError), ts_belt_1.R.map(function () { return file; }));
+        }
+        function onError() {
+            var msg = "Strategy<name~version> failed to set ".concat(pathDef.path, " in ").concat(shortPath);
+            return new error_1.BaseError(msg);
+        }
+    }
+};

package/dist/get-context/get-config/path-strategy/name-and-version-string.d.ts

@@ -0,0 +1,2 @@
+import type { Strategy } from './types';
+export declare const nameAndVersionString: Strategy<'name@version'>;

package/dist/get-context/get-config/path-strategy/name-and-version-string.js

@@ -0,0 +1,60 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+exports.__esModule = true;
+exports.nameAndVersionString = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var expect_more_1 = require("expect-more");
+var error_1 = require("../../../lib/error");
+var props_1 = require("../../get-package-json-files/get-patterns/props");
+var get_non_empty_string_prop_1 = require("./lib/get-non-empty-string-prop");
+exports.nameAndVersionString = {
+    read: function (file, pathDef) {
+        return (0, ts_belt_1.pipe)(
+        // get version prop
+        (0, get_non_empty_string_prop_1.getNonEmptyStringProp)(pathDef.path, file), 
+        // if it is a non empty string, we can read it
+        ts_belt_1.R.flatMap(function (value) {
+            var _a = __read(value.split('@'), 2), name = _a[0], version = _a[1];
+            return (0, expect_more_1.isNonEmptyString)(name) && (0, expect_more_1.isNonEmptyString)(version)
+                ? ts_belt_1.R.Ok([[name, version]])
+                : ts_belt_1.R.Error(new error_1.BaseError("Strategy<name@version> failed to get ".concat(pathDef.path, " in ").concat(file.shortPath)));
+        }));
+    },
+    write: function (file, pathDef, _a) {
+        var _b = __read(_a, 2), name = _b[0], version = _b[1];
+        var contents = file.contents, shortPath = file.shortPath;
+        var isNestedPath = pathDef.path.includes('.');
+        if (isNestedPath) {
+            var fullPath = pathDef.path.split('.');
+            var pathToParent = fullPath.slice(0, fullPath.length - 1).join('.');
+            var key_1 = fullPath.slice(-1).join('');
+            return (0, ts_belt_1.pipe)(contents, (0, props_1.props)(pathToParent, expect_more_1.isObject), ts_belt_1.O.toResult(onError()), ts_belt_1.R.tap(function (parent) {
+                parent[key_1] = "".concat(name, "@").concat(version);
+            }), ts_belt_1.R.mapError(onError), ts_belt_1.R.map(function () { return file; }));
+        }
+        else {
+            return (0, ts_belt_1.pipe)(ts_belt_1.R.fromExecution(function () {
+                contents[pathDef.path] = "".concat(name, "@").concat(version);
+            }), ts_belt_1.R.mapError(onError), ts_belt_1.R.map(function () { return file; }));
+        }
+        function onError() {
+            var msg = "Strategy<name@version> failed to set ".concat(pathDef.path, " in ").concat(shortPath);
+            return new error_1.BaseError(msg);
+        }
+    }
+};

package/dist/get-context/get-config/path-strategy/types.d.ts

@@ -0,0 +1,15 @@
+import type { R } from '@mobily/ts-belt';
+import type { BaseError } from '../../../lib/error';
+import type { Syncpack } from '../../../types';
+import type { PackageJsonFile } from '../../get-package-json-files/package-json-file';
+export type PathDef<T extends Syncpack.PathDefinition['strategy']> = Syncpack.PathDefinition & {
+    strategy: T;
+};
+/** A name/version pair */
+export type Entry = [string, string];
+export interface Strategy<T extends Syncpack.PathDefinition['strategy']> {
+    /** Read from in-memory package.json file */
+    read(file: PackageJsonFile, pathDef: PathDef<T>): R.Result<Entry[], BaseError>;
+    /** Mutate in-memory package.json file */
+    write(file: PackageJsonFile, pathDef: PathDef<T>, entry: [string, string | undefined]): R.Result<PackageJsonFile, BaseError>;
+}