syncpack 10.9.3 → 12.0.0-alpha.0

package/dist/specifier/index.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Specifier = void 0;
+const delete_1 = require("../version-group/lib/delete");
+const alias_1 = require("./alias");
+const delete_2 = require("./delete");
+const file_1 = require("./file");
+const hosted_git_1 = require("./hosted-git");
+const parse_specifier_1 = require("./lib/parse-specifier");
+const range_1 = require("./range");
+const tag_1 = require("./tag");
+const unsupported_1 = require("./unsupported");
+const url_1 = require("./url");
+const version_1 = require("./version");
+const workspace_protocol_1 = require("./workspace-protocol");
+var Specifier;
+(function (Specifier) {
+    Specifier.Alias = alias_1.AliasSpecifier;
+    Specifier.Delete = delete_2.DeleteSpecifier;
+    Specifier.File = file_1.FileSpecifier;
+    Specifier.HostedGit = hosted_git_1.HostedGitSpecifier;
+    Specifier.Range = range_1.RangeSpecifier;
+    Specifier.Tag = tag_1.TagSpecifier;
+    Specifier.Unsupported = unsupported_1.UnsupportedSpecifier;
+    Specifier.Url = url_1.UrlSpecifier;
+    Specifier.Version = version_1.VersionSpecifier;
+    Specifier.WorkspaceProtocol = workspace_protocol_1.WorkspaceProtocolSpecifier;
+    function create(instance, raw) {
+        if (raw === delete_1.DELETE)
+            return new Specifier.Delete({ instance, raw });
+        if (!raw)
+            return new Specifier.Unsupported({ instance, raw });
+        try {
+            if (raw === 'latest')
+                raw = '*';
+            const parsed = (0, parse_specifier_1.parseSpecifier)(instance.name, raw, instance.packageJsonFile);
+            const type = parsed.type;
+            const data = { instance, raw };
+            if (type === 'version')
+                return new Specifier.Version(data);
+            if (type === 'range')
+                return new Specifier.Range(data);
+            if (type === 'workspaceProtocol')
+                return new Specifier.WorkspaceProtocol(data);
+            if (type === 'alias')
+                return new Specifier.Alias(data);
+            if (type === 'file' || type === 'directory')
+                return new Specifier.File(data);
+            if (type === 'remote')
+                return new Specifier.Url(data);
+            if (type === 'git')
+                return new Specifier.HostedGit(data);
+            if (type === 'tag')
+                return new Specifier.Tag(data);
+            return new Specifier.Unsupported(data);
+        }
+        catch {
+            return new Specifier.Unsupported({ instance, raw });
+        }
+    }
+    Specifier.create = create;
+})(Specifier || (exports.Specifier = Specifier = {}));

package/dist/specifier/lib/non-semver-error.d.ts

@@ -0,0 +1,11 @@
+import { Data, Effect } from 'effect';
+import type { Specifier } from '..';
+declare const NonSemverError_base: new <A extends Record<string, any>>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("effect/dist/declarations/src/Equal").Equal>) => Data.Data<A & {
+    readonly _tag: "NonSemverError";
+}>;
+export declare class NonSemverError extends NonSemverError_base<{
+    specifier: Specifier.Any;
+}> {
+    static asEffect<T>(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, T>;
+}
+export {};

package/dist/specifier/lib/non-semver-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonSemverError = void 0;
+const effect_1 = require("effect");
+class NonSemverError extends effect_1.Data.TaggedClass('NonSemverError') {
+    static asEffect(specifier) {
+        return effect_1.Effect.fail(new NonSemverError({ specifier }));
+    }
+}
+exports.NonSemverError = NonSemverError;

package/dist/specifier/lib/parse-specifier.d.ts

@@ -0,0 +1,14 @@
+import npa from 'npm-package-arg';
+import type { PackageJsonFile } from '../../get-package-json-files/package-json-file';
+/** Extends npm/npm-package-arg to support "workspace:*" */
+export interface WorkspaceProtocolResult {
+    type: 'workspaceProtocol';
+    raw: string;
+    name: string | null;
+    escapedName: string | null;
+    scope: string | null;
+    rawSpec: string;
+    saveSpec: string;
+}
+export type NpmPackageArgResult = ReturnType<typeof npa.resolve> | WorkspaceProtocolResult;
+export declare function parseSpecifier(name: string, specifier: string, packageJsonFile: PackageJsonFile): NpmPackageArgResult;

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

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSpecifier = void 0;
+const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
+function parseSpecifier(name, specifier, packageJsonFile) {
+    if (specifier === 'workspace:*' || specifier === 'workspace:~') {
+        const parsed = npm_package_arg_1.default.resolve(name, packageJsonFile.jsonFile.dirPath, specifier.replace('workspace:', 'file:'));
+        return {
+            escapedName: parsed.escapedName,
+            name: parsed.name,
+            raw: parsed.raw.replace('file:', 'workspace:'),
+            rawSpec: parsed.rawSpec.replace('file:', 'workspace:'),
+            saveSpec: parsed.saveSpec.replace('file:', 'workspace:'),
+            scope: parsed.scope,
+            type: 'workspaceProtocol',
+        };
+    }
+    return npm_package_arg_1.default.resolve(name, specifier, packageJsonFile.jsonFile.dirPath);
+}
+exports.parseSpecifier = parseSpecifier;

package/dist/specifier/lib/specific-registry-result.d.ts

@@ -0,0 +1,9 @@
+import type { RegistryResult } from 'npm-package-arg';
+/**
+ * A helper to create specific classes for each of the possible
+ * `RegistryResult` types from npm/npm-package-arg. Instead of grouping them
+ * together we are being more specific
+ */
+export type SpecificRegistryResult<T extends RegistryResult['type'] | 'local'> = Omit<RegistryResult, 'type'> & {
+    type: T;
+};

package/dist/specifier/lib/specific-registry-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/specifier/range.d.ts

@@ -0,0 +1,18 @@
+import { Effect } from 'effect';
+import { Specifier } from '.';
+import { BaseSpecifier } from './base';
+import { NonSemverError } from './lib/non-semver-error';
+import type { SpecificRegistryResult } from './lib/specific-registry-result';
+type T = SpecificRegistryResult<'range'>;
+/**
+ * @example "*"
+ * @example "^1.2.3"
+ */
+export declare class RangeSpecifier extends BaseSpecifier<T> {
+    _tag: string;
+    /** Return the semver version including the range */
+    getSemver(): Effect.Effect<never, NonSemverError, string>;
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(version: string): Effect.Effect<never, never, Specifier.Any>;
+}
+export {};

package/dist/specifier/range.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangeSpecifier = void 0;
+const effect_1 = require("effect");
+const _1 = require(".");
+const base_1 = require("./base");
+const non_semver_error_1 = require("./lib/non-semver-error");
+/**
+ * @example "*"
+ * @example "^1.2.3"
+ */
+class RangeSpecifier extends base_1.BaseSpecifier {
+    constructor() {
+        super(...arguments);
+        this._tag = 'RangeSpecifier';
+    }
+    /** Return the semver version including the range */
+    getSemver() {
+        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.fetchSpec));
+    }
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(version) {
+        return effect_1.Effect.succeed(_1.Specifier.create(this.instance, version));
+    }
+}
+exports.RangeSpecifier = RangeSpecifier;

package/dist/specifier/tag.d.ts

@@ -0,0 +1,9 @@
+import { BaseSpecifier } from './base';
+import type { SpecificRegistryResult } from './lib/specific-registry-result';
+/**
+ * @example "latest"
+ * @example "made-up-by-some-dev"
+ */
+export declare class TagSpecifier extends BaseSpecifier<SpecificRegistryResult<'tag'>> {
+    _tag: string;
+}

package/dist/specifier/tag.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagSpecifier = void 0;
+const base_1 = require("./base");
+/**
+ * @example "latest"
+ * @example "made-up-by-some-dev"
+ */
+class TagSpecifier extends base_1.BaseSpecifier {
+    constructor() {
+        super(...arguments);
+        this._tag = 'TagSpecifier';
+    }
+}
+exports.TagSpecifier = TagSpecifier;

package/dist/specifier/unsupported.d.ts

@@ -0,0 +1,5 @@
+import { BaseSpecifier } from './base';
+/** A specifier not supported by the `npm` package manager */
+export declare class UnsupportedSpecifier extends BaseSpecifier<unknown> {
+    _tag: string;
+}

package/dist/specifier/unsupported.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedSpecifier = void 0;
+const base_1 = require("./base");
+/** A specifier not supported by the `npm` package manager */
+class UnsupportedSpecifier extends base_1.BaseSpecifier {
+    constructor() {
+        super(...arguments);
+        this._tag = 'UnsupportedSpecifier';
+    }
+}
+exports.UnsupportedSpecifier = UnsupportedSpecifier;

package/dist/specifier/url.d.ts

@@ -0,0 +1,6 @@
+import type { URLResult } from 'npm-package-arg';
+import { BaseSpecifier } from './base';
+/** @example "http://x.com/foo.tgz" */
+export declare class UrlSpecifier extends BaseSpecifier<URLResult> {
+    _tag: string;
+}

package/dist/specifier/url.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlSpecifier = void 0;
+const base_1 = require("./base");
+/** @example "http://x.com/foo.tgz" */
+class UrlSpecifier extends base_1.BaseSpecifier {
+    constructor() {
+        super(...arguments);
+        this._tag = 'UrlSpecifier';
+        // @TODO: If file name is semver, return that in getSemver()
+    }
+}
+exports.UrlSpecifier = UrlSpecifier;

package/dist/specifier/version.d.ts

@@ -0,0 +1,18 @@
+import { Effect } from 'effect';
+import { Specifier } from '.';
+import { BaseSpecifier } from './base';
+import { NonSemverError } from './lib/non-semver-error';
+import type { SpecificRegistryResult } from './lib/specific-registry-result';
+type T = SpecificRegistryResult<'version'>;
+/**
+ * An exact semver version
+ * @example "1.4.4"
+ */
+export declare class VersionSpecifier extends BaseSpecifier<T> {
+    _tag: string;
+    /** Return the semver version */
+    getSemver(): Effect.Effect<never, NonSemverError, string>;
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(version: string): Effect.Effect<never, never, Specifier.Any>;
+}
+export {};

package/dist/specifier/version.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionSpecifier = void 0;
+const effect_1 = require("effect");
+const _1 = require(".");
+const base_1 = require("./base");
+const non_semver_error_1 = require("./lib/non-semver-error");
+/**
+ * An exact semver version
+ * @example "1.4.4"
+ */
+class VersionSpecifier extends base_1.BaseSpecifier {
+    constructor() {
+        super(...arguments);
+        this._tag = 'VersionSpecifier';
+    }
+    /** Return the semver version */
+    getSemver() {
+        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.fetchSpec));
+    }
+    /** Get a new `Specifier` from the given semver version applied to this one */
+    setSemver(version) {
+        return effect_1.Effect.succeed(_1.Specifier.create(this.instance, version));
+    }
+}
+exports.VersionSpecifier = VersionSpecifier;

package/dist/specifier/workspace-protocol.d.ts

@@ -0,0 +1,17 @@
+import { Effect } from 'effect';
+import { Specifier } from '.';
+import type { Ctx } from '../get-context';
+import { BaseSpecifier } from './base';
+import type { WorkspaceProtocolResult } from './lib/parse-specifier';
+/** Represents "workspace:*" and "workspace:~" */
+export declare class WorkspaceProtocolSpecifier extends BaseSpecifier<WorkspaceProtocolResult> {
+    _tag: string;
+    /**
+     * Return an equivalent value which actually is semver, so that it can be used
+     * with tools which expect values which conform to the spec. This value is
+     * used only when sorting versions.
+     */
+    getSemverEquivalent(ctx: Ctx): Effect.Effect<never, never, string>;
+    getSemver(): Effect.Effect<never, never, string>;
+    setSemver(version: string): Effect.Effect<never, never, Specifier.Any>;
+}

package/dist/specifier/workspace-protocol.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceProtocolSpecifier = void 0;
+const effect_1 = require("effect");
+const _1 = require(".");
+const base_1 = require("./base");
+/** Represents "workspace:*" and "workspace:~" */
+class WorkspaceProtocolSpecifier extends base_1.BaseSpecifier {
+    constructor() {
+        super(...arguments);
+        this._tag = 'WorkspaceProtocolSpecifier';
+    }
+    /**
+     * Return an equivalent value which actually is semver, so that it can be used
+     * with tools which expect values which conform to the spec. This value is
+     * used only when sorting versions.
+     */
+    getSemverEquivalent(ctx) {
+        if (this.raw === 'workspace:*') {
+            return effect_1.Effect.succeed('*');
+        }
+        if (this.raw === 'workspace:~') {
+            const local = ctx.packageJsonFilesByName[this.instance.name];
+            const version = local?.jsonFile?.contents?.version;
+            if (version)
+                return effect_1.Effect.succeed(`~${version}`);
+        }
+        return effect_1.Effect.succeed('0.0.0');
+    }
+    // @TODO: this name is inaccurate, check how it is used and change logic or rename
+    getSemver() {
+        return effect_1.Effect.succeed(this.raw);
+    }
+    setSemver(version) {
+        return effect_1.Effect.succeed(_1.Specifier.create(this.instance, version));
+    }
+}
+exports.WorkspaceProtocolSpecifier = WorkspaceProtocolSpecifier;

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

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

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

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNonEmptyStringProp = void 0;
-const Function_1 = require("@effect/data/Function");
-const get_1 = require("tightrope/fn/get");
+const effect_1 = require("effect");
 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 get_1 = require("../../lib/get");
+const getOptionOfNonEmptyString = effect_1.Option.liftPredicate(is_non_empty_string_1.isNonEmptyString);
 function getNonEmptyStringProp(propPath, file) {
-    return (0, Function_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}`)));
+    return (0, effect_1.pipe)((0, get_1.get)(file.jsonFile.contents, ...propPath.split('.')), effect_1.Effect.flatMap((value) => getOptionOfNonEmptyString(value)), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`<${file.jsonFile.shortPath}>.${propPath} is not a non-empty string`)));
 }
 exports.getNonEmptyStringProp = getNonEmptyStringProp;

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

@@ -1,12 +1,12 @@
-import type { Result } from 'tightrope/result';
+import { Effect } from 'effect';
 import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
-import type { Delete } from '../get-version-groups/lib/delete';
+import type { Delete } from '../version-group/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>;
+    read(file: PackageJsonFile): Effect.Effect<never, never, [string, string][]>;
+    write(file: PackageJsonFile, [, version]: [string, string | Delete]): Effect.Effect<never, never, PackageJsonFile>;
 }

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

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NameAndVersionPropsStrategy = void 0;
-const Function_1 = require("@effect/data/Function");
-const get_1 = require("tightrope/fn/get");
-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 effect_1 = require("effect");
+const is_object_1 = require("tightrope/guard/is-object");
+const get_1 = require("../lib/get");
+const delete_1 = require("../version-group/lib/delete");
 const get_non_empty_string_prop_1 = require("./lib/get-non-empty-string-prop");
+const getOptionOfObject = effect_1.Option.liftPredicate((is_object_1.isObject));
 class NameAndVersionPropsStrategy {
     constructor(name, path, namePath) {
         this._tag = 'name~version';
@@ -17,33 +15,46 @@ class NameAndVersionPropsStrategy {
         this.namePath = namePath;
     }
     read(file) {
-        const path = this.path;
-        const namePath = this.namePath;
-        return (0, Function_1.pipe)(
-        // get name prop
-        (0, get_non_empty_string_prop_1.getNonEmptyStringProp)(namePath, file), 
+        return (0, effect_1.pipe)(effect_1.Effect.Do, 
+        // get the name prop
+        effect_1.Effect.bind('name', () => (0, get_non_empty_string_prop_1.getNonEmptyStringProp)(this.namePath, file)), 
         // add the version prop
-        (0, and_then_1.andThen)((name) => (0, Function_1.pipe)((0, get_non_empty_string_prop_1.getNonEmptyStringProp)(path, file), (0, map_1.map)((version) => ({ name, version })))), 
+        effect_1.Effect.bind('version', () => (0, effect_1.pipe)((0, get_non_empty_string_prop_1.getNonEmptyStringProp)(this.path, file), 
+        /**
+         * In order to report an `InstanceReport.MissingLocalVersion`, we need
+         * to ensure that a value is returned for `local` package .version
+         * properties so we can know that `this.name` is a package developed
+         * in this repo but that its version is missing.
+         *
+         * Not doing this results in the invalid local package being ignored
+         * and each installation of it being checked for mismatches amongst
+         * themselves.
+         */
+        this.name === 'local'
+            ? effect_1.Effect.catchAll(() => effect_1.Effect.succeed('PACKAGE_JSON_HAS_NO_VERSION'))
+            : effect_1.Effect.map(effect_1.identity))), 
         // if both are non empty strings, we can return them
-        (0, map_1.map)(({ name, version }) => [[name, version]]));
+        effect_1.Effect.map(({ name, version }) => [[name, version]]), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`NameAndVersionPropsStrategy#${this.name} found nothing at <${file.jsonFile.shortPath}>.${this.path} & .${this.namePath}`)), 
+        // if either are invalid, default to empty
+        effect_1.Effect.catchAll(() => effect_1.Effect.succeed([])));
     }
     write(file, [, version]) {
         const path = this.path;
-        const { contents } = file;
+        const { contents } = file.jsonFile;
         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, Function_1.pipe)((0, get_1.get)(contents, ...pathToParent.split('.')), (0, tap_1.tap)((parent) => {
-                parent[key] = version;
-            }), (0, map_1.map)(() => file));
+            return (0, effect_1.pipe)((0, get_1.get)(contents, ...pathToParent.split('.')), effect_1.Effect.flatMap(getOptionOfObject), effect_1.Effect.flatMap((parent) => effect_1.Effect.try(() => {
+                parent[key] = nextValue;
+            })), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), effect_1.Effect.catchAll(() => effect_1.Effect.succeed(file)), effect_1.Effect.map(() => file));
         }
         else {
-            return (0, Function_1.pipe)((0, from_try_1.fromTry)(() => {
-                contents[path] = nextValue;
-            }), (0, map_1.map)(() => file));
+            return (0, effect_1.pipe)(getOptionOfObject(contents), effect_1.Effect.flatMap((parent) => effect_1.Effect.try(() => {
+                parent[this.path] = nextValue;
+            })), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), effect_1.Effect.catchAll(() => effect_1.Effect.succeed(file)), effect_1.Effect.map(() => file));
         }
     }
 }

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

@@ -1,11 +1,11 @@
-import type { Result } from 'tightrope/result';
+import { Effect } from 'effect';
 import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
-import type { Delete } from '../get-version-groups/lib/delete';
+import type { Delete } from '../version-group/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>;
+    read(file: PackageJsonFile): Effect.Effect<never, never, [string, string][]>;
+    write(file: PackageJsonFile, [name, version]: [string, string | Delete]): Effect.Effect<never, never, PackageJsonFile>;
 }

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

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NamedVersionStringStrategy = void 0;
-const Function_1 = require("@effect/data/Function");
-const get_1 = require("tightrope/fn/get");
+const effect_1 = require("effect");
+const is_non_empty_object_1 = require("tightrope/guard/is-non-empty-object");
 const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
-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 tap_1 = require("tightrope/result/tap");
-const delete_1 = require("../get-version-groups/lib/delete");
+const get_1 = require("../lib/get");
+const delete_1 = require("../version-group/lib/delete");
 const get_non_empty_string_prop_1 = require("./lib/get-non-empty-string-prop");
+const getOptionOfNonEmptyString = effect_1.Option.liftPredicate(is_non_empty_string_1.isNonEmptyString);
+const getOptionOfNonEmptyObject = effect_1.Option.liftPredicate((is_non_empty_object_1.isNonEmptyObject));
 class NamedVersionStringStrategy {
     constructor(name, path) {
         this._tag = 'name@version';
@@ -19,34 +17,34 @@ class NamedVersionStringStrategy {
     }
     read(file) {
         const path = this.path;
-        return (0, Function_1.pipe)(
+        return (0, effect_1.pipe)(
         // get version prop
         (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(`Strategy<name@version> failed to get ${path} in ${file.shortPath}`));
-        }));
+        effect_1.Effect.map((value) => value.split(/@(.*)/)), 
+        // check the string was properly formed
+        effect_1.Effect.flatMap(([name, version]) => effect_1.Effect.all([getOptionOfNonEmptyString(name), getOptionOfNonEmptyString(version)])), 
+        // return an array of one entry if valid
+        effect_1.Effect.map(([name, version]) => [[name, version]]), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`NamedVersionStringStrategy#${this.name} found nothing at <${file.jsonFile.shortPath}>.${this.path}`)), 
+        // if value is invalid, default to empty
+        effect_1.Effect.catchAll(() => effect_1.Effect.succeed([])));
     }
     write(file, [name, version]) {
-        const { contents } = file;
-        const path = this.path;
-        const isNestedPath = path.includes('.');
+        const { contents } = file.jsonFile;
+        const isNestedPath = this.path.includes('.');
         const nextValue = version === delete_1.DELETE ? undefined : `${name}@${version}`;
         if (isNestedPath) {
-            const fullPath = path.split('.');
+            const fullPath = this.path.split('.');
             const pathToParent = fullPath.slice(0, fullPath.length - 1).join('.');
             const key = fullPath.slice(-1).join('');
-            return (0, Function_1.pipe)((0, get_1.get)(contents, ...pathToParent.split('.')), (0, tap_1.tap)((parent) => {
+            return (0, effect_1.pipe)((0, get_1.get)(contents, ...pathToParent.split('.')), effect_1.Effect.flatMap(getOptionOfNonEmptyObject), effect_1.Effect.flatMap((parent) => effect_1.Effect.try(() => {
                 parent[key] = nextValue;
-            }), (0, map_1.map)(() => file));
+            })), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), effect_1.Effect.catchAll(() => effect_1.Effect.succeed(file)), effect_1.Effect.map(() => file));
         }
         else {
-            return (0, Function_1.pipe)((0, from_try_1.fromTry)(() => {
-                contents[path] = nextValue;
-            }), (0, map_1.map)(() => file));
+            return (0, effect_1.pipe)(getOptionOfNonEmptyObject(contents), effect_1.Effect.flatMap((parent) => effect_1.Effect.try(() => {
+                parent[this.path] = nextValue;
+            })), effect_1.Effect.tapError(() => effect_1.Effect.logDebug(`strategy ${this._tag} with name ${this.name} failed to write to <${file.jsonFile.shortPath}>.${this.path}`)), effect_1.Effect.catchAll(() => effect_1.Effect.succeed(file)), effect_1.Effect.map(() => file));
         }
     }
 }

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

@@ -1,11 +1,11 @@
-import type { Result } from 'tightrope/result';
+import { Effect } from 'effect';
 import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
-import type { Delete } from '../get-version-groups/lib/delete';
+import type { Delete } from '../version-group/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>;
+    read(file: PackageJsonFile): Effect.Effect<never, never, [string, string][]>;
+    write(file: PackageJsonFile, [, version]: [string, string | Delete]): Effect.Effect<never, never, PackageJsonFile>;
 }