syncpack 8.4.11 → 9.0.0

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

@@ -0,0 +1,72 @@
+"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.");
+};
+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.getVersionGroups = void 0;
+var version_group_1 = require("./version-group");
+var instance_group_1 = require("./version-group/instance-group");
+function getVersionGroups(input, instances) {
+    var versionGroups = input.versionGroups.map(function (versionGroup) { return new version_group_1.VersionGroup(input, versionGroup); });
+    instances.forEach(function (instance) {
+        var e_1, _a;
+        var _b;
+        var name = instance.name, pkgName = instance.pkgName;
+        try {
+            for (var versionGroups_1 = __values(versionGroups), versionGroups_1_1 = versionGroups_1.next(); !versionGroups_1_1.done; versionGroups_1_1 = versionGroups_1.next()) {
+                var versionGroup = versionGroups_1_1.value;
+                if (instance.matchesGroup(versionGroup)) {
+                    if (!versionGroup.instancesByName[name]) {
+                        versionGroup.instancesByName[name] = [];
+                    }
+                    (_b = versionGroup.instancesByName[name]) === null || _b === void 0 ? void 0 : _b.push(instance);
+                    versionGroup.instances.push(instance);
+                    return;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (versionGroups_1_1 && !versionGroups_1_1.done && (_a = versionGroups_1["return"])) _a.call(versionGroups_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        throw new Error("".concat(name, " in ").concat(pkgName, " did not match any versionGroups"));
+    });
+    versionGroups.forEach(function (versionGroup) {
+        versionGroup.instanceGroups = getInstanceGroups(versionGroup);
+    });
+    return versionGroups;
+}
+exports.getVersionGroups = getVersionGroups;
+function getInstanceGroups(versionGroup) {
+    return Object.entries(versionGroup.instancesByName).map(function (_a) {
+        var _b = __read(_a, 2), name = _b[0], instances = _b[1];
+        return new instance_group_1.InstanceGroup(versionGroup, name, instances);
+    });
+}

package/dist/get-context/get-groups/semver-group/index.d.ts

@@ -0,0 +1,29 @@
+import type { Syncpack } from '../../../types';
+import type { Instance } from '../../get-package-json-files/package-json-file/instance';
+export declare class SemverGroup {
+    /** */
+    dependencies: string[];
+    /** Optionally limit this group to dependencies at these named paths */
+    dependencyTypes: Syncpack.TypeName[];
+    /** */
+    input: Syncpack.Config.Private;
+    /** */
+    instances: Instance[];
+    /** */
+    instancesByName: Record<string, Instance[]>;
+    /** */
+    isDefault: boolean;
+    /** Optionally force syncpack to ignore all dependencies in this group */
+    isIgnored: boolean;
+    /** */
+    packages: string[];
+    /** The semver range which dependencies in this group should use */
+    range: Syncpack.Config.SemverRange.Value;
+    constructor(input: Syncpack.Config.Private, semverGroup: Syncpack.Config.SemverGroup.Any);
+    /** Does this `Instance` not follow the rules of this group? */
+    isMismatch(instance: Instance): boolean;
+    /** 1+ `Instance` has a version which does not follow the rules */
+    hasMismatches(): boolean;
+    /** Get every `Instance` with a version which does not follow the rules */
+    getMismatches(): [string, Instance[]][];
+}

package/dist/get-context/get-groups/semver-group/index.js

@@ -0,0 +1,56 @@
+"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.SemverGroup = void 0;
+var SemverGroup = /** @class */ (function () {
+    function SemverGroup(input, semverGroup) {
+        this.dependencies = semverGroup.dependencies;
+        this.dependencyTypes = semverGroup.dependencyTypes;
+        this.input = input;
+        this.instances = [];
+        this.instancesByName = {};
+        this.isDefault = semverGroup === input.defaultSemverGroup;
+        this.isIgnored = semverGroup.isIgnored === true;
+        this.packages = semverGroup.packages;
+        this.range = semverGroup.range;
+        this.isMismatch = this.isMismatch.bind(this);
+    }
+    /** Does this `Instance` not follow the rules of this group? */
+    SemverGroup.prototype.isMismatch = function (instance) {
+        return !instance.hasRange(this.range);
+    };
+    /** 1+ `Instance` has a version which does not follow the rules */
+    SemverGroup.prototype.hasMismatches = function () {
+        return !this.isIgnored && this.instances.some(this.isMismatch);
+    };
+    /** Get every `Instance` with a version which does not follow the rules */
+    SemverGroup.prototype.getMismatches = function () {
+        var _this = this;
+        return Object.entries(this.instancesByName)
+            .filter(function (_a) {
+            var _b = __read(_a, 2), instances = _b[1];
+            return instances.some(_this.isMismatch);
+        })
+            .map(function (_a) {
+            var _b = __read(_a, 2), name = _b[0], instances = _b[1];
+            return [name, instances.filter(_this.isMismatch)];
+        });
+    };
+    return SemverGroup;
+}());
+exports.SemverGroup = SemverGroup;

package/dist/get-context/get-groups/version-group/index.d.ts

@@ -0,0 +1,29 @@
+import type { Syncpack } from '../../../types';
+import type { Instance } from '../../get-package-json-files/package-json-file/instance';
+import type { InstanceGroup } from './instance-group';
+export declare class VersionGroup {
+    /** */
+    dependencies: string[];
+    /** Optionally limit this group to dependencies at these named paths */
+    dependencyTypes: Syncpack.TypeName[];
+    /** */
+    input: Syncpack.Config.Private;
+    /** */
+    instanceGroups: InstanceGroup[];
+    /** */
+    instances: Instance[];
+    /** */
+    instancesByName: Record<string, Instance[]>;
+    /** */
+    isBanned: boolean;
+    /** */
+    isDefault: boolean;
+    /** */
+    isIgnored: boolean;
+    /** */
+    packages: string[];
+    /** Optionally force all dependencies in this group to have this version */
+    pinVersion?: string;
+    constructor(input: Syncpack.Config.Private, versionGroup: Syncpack.Config.VersionGroup.Any);
+    getInvalidInstanceGroups(): InstanceGroup[];
+}

package/dist/get-context/get-groups/version-group/index.js

@@ -0,0 +1,23 @@
+"use strict";
+exports.__esModule = true;
+exports.VersionGroup = void 0;
+var VersionGroup = /** @class */ (function () {
+    function VersionGroup(input, versionGroup) {
+        this.dependencies = versionGroup.dependencies;
+        this.dependencyTypes = versionGroup.dependencyTypes;
+        this.input = input;
+        this.instanceGroups = [];
+        this.instances = [];
+        this.instancesByName = {};
+        this.isBanned = versionGroup.isBanned === true;
+        this.isDefault = versionGroup === input.defaultVersionGroup;
+        this.isIgnored = versionGroup.isIgnored === true;
+        this.packages = versionGroup.packages;
+        this.pinVersion = versionGroup.pinVersion;
+    }
+    VersionGroup.prototype.getInvalidInstanceGroups = function () {
+        return this.instanceGroups.filter(function (group) { return group.isInvalid; });
+    };
+    return VersionGroup;
+}());
+exports.VersionGroup = VersionGroup;

package/dist/{bin-fix-mismatches/get-expected-version → get-context/get-groups/version-group/instance-group}/get-highest-version.js

@@ -2,8 +2,8 @@
 exports.__esModule = true;
 exports.getHighestVersion = void 0;
 var semver_1 = require("semver");
-var constants_1 = require("../../constants");
-var is_semver_1 = require("../../lib/is-semver");
+var constants_1 = require("../../../../constants");
+var is_semver_1 = require("../../../../lib/is-semver");
 function getHighestVersion(versions) {
     return versions.reduce(function (rawHighest, raw) {
         var version = (0, semver_1.valid)((0, semver_1.coerce)(raw)) || '';
@@ -25,24 +25,24 @@ exports.getHighestVersion = getHighestVersion;
 function getRangeScore(version) {
     if (version === '')
         return 0;
-    if (version === constants_1.RANGE_ANY)
+    if (version === constants_1.RANGE.ANY)
         return 8;
     var range = getRange(version);
-    if (range === constants_1.RANGE_GT)
+    if (range === constants_1.RANGE.GT)
         return 7;
-    if (range === constants_1.RANGE_GTE)
+    if (range === constants_1.RANGE.GTE)
         return 6;
-    if (range === constants_1.RANGE_MINOR)
+    if (range === constants_1.RANGE.MINOR)
         return 5;
     if (version.indexOf('.x') !== -1)
         return 4;
-    if (range === constants_1.RANGE_PATCH)
+    if (range === constants_1.RANGE.PATCH)
         return 3;
-    if (range === constants_1.RANGE_EXACT)
+    if (range === constants_1.RANGE.EXACT)
         return 2;
-    if (range === constants_1.RANGE_LTE)
+    if (range === constants_1.RANGE.LTE)
         return 1;
-    if (range === constants_1.RANGE_LT)
+    if (range === constants_1.RANGE.LT)
         return 0;
     return 0;
 }

package/dist/get-context/get-groups/version-group/instance-group/index.d.ts

@@ -0,0 +1,34 @@
+import type { VersionGroup } from '..';
+import type { Instance } from '../../../get-package-json-files/package-json-file/instance';
+/** Every `Instance` of eg `"lodash"` for a given `VersionGroup` */
+export declare class InstanceGroup {
+    /** 1+ `Instance` has a version which does not follow the rules */
+    hasMismatches: boolean;
+    /** Every package/pathName location where this dependency was found */
+    instances: Instance[];
+    /**  */
+    hasWorkspaceInstance: boolean;
+    /** Syncpack must report or fix this groups mismatches */
+    isInvalid: boolean;
+    /** 1+ `Instance` has a version not matching `VersionGroup.pinVersion` */
+    isUnpinned: boolean;
+    /** @example `"lodash"` */
+    name: string;
+    /** All `Instance` versions, with duplicates removed */
+    uniques: string[];
+    /** The `VersionGroup` which this `InstanceGroup` belongs to */
+    versionGroup: VersionGroup;
+    constructor(versionGroup: VersionGroup, name: string, instances: Instance[]);
+    getExpectedVersion(): string | undefined;
+    getPinnedVersion(): string;
+    /**
+     * If this dependency is a package developed locally, we should use its
+     * version as the source of truth.
+     */
+    getWorkspaceVersion(): string;
+    /**
+     * Find instance of this dependency which is a package developed locally in
+     * this monorepo.
+     */
+    getWorkspaceInstance(): Instance | undefined;
+}

package/dist/get-context/get-groups/version-group/instance-group/index.js

@@ -0,0 +1,80 @@
+"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.InstanceGroup = void 0;
+var expect_more_1 = require("expect-more");
+var get_highest_version_1 = require("./get-highest-version");
+/** Every `Instance` of eg `"lodash"` for a given `VersionGroup` */
+var InstanceGroup = /** @class */ (function () {
+    function InstanceGroup(versionGroup, name, instances) {
+        var pinnedVersion = versionGroup.pinVersion;
+        var isBanned = versionGroup.isBanned === true;
+        var isIgnored = versionGroup.isIgnored === true;
+        var hasPinnedVersion = (0, expect_more_1.isNonEmptyString)(pinnedVersion);
+        var versions = instances.map(function (_a) {
+            var version = _a.version;
+            return version;
+        });
+        var uniques = Array.from(new Set(versions)).sort();
+        var _a = __read(uniques, 1), version = _a[0];
+        var isUnpinned = hasPinnedVersion && version !== pinnedVersion;
+        var hasMismatches = isBanned || isUnpinned || uniques.length > 1;
+        var isInvalid = !isIgnored && hasMismatches;
+        this.instances = instances;
+        this.hasMismatches = hasMismatches;
+        this.hasWorkspaceInstance = Boolean(this.getWorkspaceVersion());
+        this.isInvalid = isInvalid;
+        this.isUnpinned = isUnpinned;
+        this.name = name;
+        this.uniques = uniques;
+        this.versionGroup = versionGroup;
+    }
+    InstanceGroup.prototype.getExpectedVersion = function () {
+        // remove this dependency
+        if (this.versionGroup.isBanned)
+            return undefined;
+        if (this.isUnpinned)
+            return this.getPinnedVersion();
+        if (this.hasWorkspaceInstance)
+            return this.getWorkspaceVersion();
+        return (0, get_highest_version_1.getHighestVersion)(this.uniques);
+    };
+    InstanceGroup.prototype.getPinnedVersion = function () {
+        return this.versionGroup.pinVersion || '';
+    };
+    /**
+     * If this dependency is a package developed locally, we should use its
+     * version as the source of truth.
+     */
+    InstanceGroup.prototype.getWorkspaceVersion = function () {
+        var _a;
+        return ((_a = this.getWorkspaceInstance()) === null || _a === void 0 ? void 0 : _a.packageJsonFile.contents.version) || '';
+    };
+    /**
+     * Find instance of this dependency which is a package developed locally in
+     * this monorepo.
+     */
+    InstanceGroup.prototype.getWorkspaceInstance = function () {
+        return this.instances.find(function (_a) {
+            var pathDef = _a.pathDef;
+            return pathDef.name === 'workspace';
+        });
+    };
+    return InstanceGroup;
+}());
+exports.InstanceGroup = InstanceGroup;

package/dist/{lib/get-input/get-wrappers → get-context/get-package-json-files}/get-file-paths.d.ts

@@ -1,7 +1,8 @@
-import * as E from 'fp-ts/lib/Either';
-import * as O from 'fp-ts/lib/Option';
-import type { SyncpackConfig } from '../../../types';
-import type { Disk } from '../../../lib/disk';
+import { R } from '@mobily/ts-belt';
+import type { Disk } from '../../lib/disk';
+import { BaseError } from '../../lib/error';
+import type { Syncpack } from '../../types';
+type SafeFilePaths = R.Result<string[], BaseError>;
 /**
  * Using --source options and/or config files on disk from npm/pnpm/yarn/lerna,
  * return an array of absolute paths to every package.json file the user is
@@ -9,4 +10,5 @@ import type { Disk } from '../../../lib/disk';
  *
  * @returns Array of absolute file paths to package.json files
  */
-export declare function getFilePaths(disk: Disk, program: SyncpackConfig): E.Either<Error, O.Option<string[]>>;
+export declare function getFilePaths(disk: Disk, program: Syncpack.Config.SyncpackRc): SafeFilePaths;
+export {};

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

@@ -0,0 +1,40 @@
+"use strict";
+exports.__esModule = true;
+exports.getFilePaths = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var expect_more_1 = require("expect-more");
+var _R_1 = require("../$R");
+var error_1 = require("../../lib/error");
+var get_patterns_1 = require("./get-patterns");
+/**
+ * Using --source options and/or config files on disk from npm/pnpm/yarn/lerna,
+ * return an array of absolute paths to every package.json file the user is
+ * working with.
+ *
+ * @returns Array of absolute file paths to package.json files
+ */
+function getFilePaths(disk, program) {
+    return (0, ts_belt_1.pipe)(program, (0, get_patterns_1.getPatterns)(disk), ts_belt_1.R.flatMap(resolvePatterns));
+    function resolvePatterns(patterns) {
+        var quoted = patterns.map(function (p) { return "\"".concat(p, "\""); }).join(', ');
+        var ERR_NO_MATCH = "No package.json files matched the patterns: ".concat(quoted);
+        return (0, ts_belt_1.pipe)(patterns, _R_1.$R.onlyOk(resolvePattern), ts_belt_1.R.mapError(error_1.BaseError.map(ERR_NO_MATCH)), ts_belt_1.R.map((0, ts_belt_1.flow)(ts_belt_1.A.flat, ts_belt_1.A.uniq, removeReadonlyType)));
+    }
+    function resolvePattern(pattern) {
+        var ERR_GLOB_MISS = "No package.json files match pattern \"".concat(pattern, "\"");
+        var ERR_INVALID = "\"glob\" returned unexpected data on pattern \"".concat(pattern, "\"");
+        var ERR_GLOB_THROW = "\"glob\" threw on pattern \"".concat(pattern, "\"");
+        return (0, ts_belt_1.pipe)(ts_belt_1.R.fromExecution(function () { return disk.globSync(pattern); }), ts_belt_1.R.mapError(error_1.BaseError.map(ERR_GLOB_THROW)), ts_belt_1.R.flatMap(function (filePaths) {
+            return (0, expect_more_1.isEmptyArray)(filePaths)
+                ? ts_belt_1.R.Error(new error_1.BaseError(ERR_GLOB_MISS))
+                : (0, expect_more_1.isArrayOfStrings)(filePaths)
+                    ? ts_belt_1.R.Ok((0, ts_belt_1.pipe)(filePaths, ts_belt_1.A.flat, ts_belt_1.A.uniq, removeReadonlyType))
+                    : ts_belt_1.R.Error(new error_1.BaseError(ERR_INVALID));
+        }));
+    }
+    /** Remove unwanted readonly type */
+    function removeReadonlyType(value) {
+        return value;
+    }
+}
+exports.getFilePaths = getFilePaths;

package/dist/get-context/get-package-json-files/get-patterns/get-lerna-patterns.d.ts

@@ -0,0 +1,4 @@
+import { R } from '@mobily/ts-belt';
+import type { Disk } from '../../../lib/disk';
+import { BaseError } from '../../../lib/error';
+export declare function getLernaPatterns(disk: Disk): () => R.Result<string[], BaseError>;

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

@@ -0,0 +1,19 @@
+"use strict";
+exports.__esModule = true;
+exports.getLernaPatterns = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var path_1 = require("path");
+var constants_1 = require("../../../constants");
+var error_1 = require("../../../lib/error");
+var get_array_of_strings_1 = require("./lib/get-array-of-strings");
+var read_json_safe_1 = require("./read-json-safe");
+function getLernaPatterns(disk) {
+    var getPackages = (0, get_array_of_strings_1.getArrayOfStrings)('packages');
+    return function getLernaPatterns() {
+        return (0, ts_belt_1.pipe)((0, path_1.join)(constants_1.CWD, 'lerna.json'), (0, read_json_safe_1.readJsonSafe)(disk), ts_belt_1.R.flatMap(function (_a) {
+            var contents = _a.contents;
+            return (0, ts_belt_1.pipe)(getPackages(contents), ts_belt_1.O.toResult(new error_1.BaseError('no lerna patterns found')));
+        }));
+    };
+}
+exports.getLernaPatterns = getLernaPatterns;

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

@@ -0,0 +1,4 @@
+import { R } from '@mobily/ts-belt';
+import type { Disk } from '../../../lib/disk';
+import { BaseError } from '../../../lib/error';
+export declare function getPnpmPatterns(disk: Disk): () => R.Result<string[], BaseError>;

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

@@ -0,0 +1,23 @@
+"use strict";
+exports.__esModule = true;
+exports.getPnpmPatterns = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var path_1 = require("path");
+var constants_1 = require("../../../constants");
+var error_1 = require("../../../lib/error");
+var get_array_of_strings_1 = require("./lib/get-array-of-strings");
+var read_yaml_safe_1 = require("./read-yaml-safe");
+var getPackages = (0, get_array_of_strings_1.getArrayOfStrings)('packages');
+function getPnpmPatterns(disk) {
+    return function getPnpmPatterns() {
+        return (0, ts_belt_1.pipe)(
+        // packages:
+        //   - "packages/**"
+        //   - "components/**"
+        //   - "!**/test/**"
+        (0, path_1.join)(constants_1.CWD, 'pnpm-workspace.yaml'), (0, read_yaml_safe_1.readYamlSafe)(disk), ts_belt_1.R.flatMap(function (packageJson) {
+            return (0, ts_belt_1.pipe)(getPackages(packageJson), ts_belt_1.O.match(ts_belt_1.F.identity, function () { return getPackages(packageJson); }), ts_belt_1.O.toResult(new error_1.BaseError('no pnpm patterns found')));
+        }));
+    };
+}
+exports.getPnpmPatterns = getPnpmPatterns;

package/dist/get-context/get-package-json-files/get-patterns/get-yarn-patterns.d.ts

@@ -0,0 +1,4 @@
+import { R } from '@mobily/ts-belt';
+import type { Disk } from '../../../lib/disk';
+import { BaseError } from '../../../lib/error';
+export declare function getYarnPatterns(disk: Disk): () => R.Result<string[], BaseError>;

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

@@ -0,0 +1,20 @@
+"use strict";
+exports.__esModule = true;
+exports.getYarnPatterns = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var path_1 = require("path");
+var constants_1 = require("../../../constants");
+var error_1 = require("../../../lib/error");
+var get_array_of_strings_1 = require("./lib/get-array-of-strings");
+var read_json_safe_1 = require("./read-json-safe");
+function getYarnPatterns(disk) {
+    var getPackages = (0, get_array_of_strings_1.getArrayOfStrings)('workspaces');
+    var getPackagesNested = (0, get_array_of_strings_1.getArrayOfStrings)('workspaces.packages');
+    return function getYarnPatterns() {
+        return (0, ts_belt_1.pipe)((0, path_1.join)(constants_1.CWD, 'package.json'), (0, read_json_safe_1.readJsonSafe)(disk), ts_belt_1.R.flatMap(function (_a) {
+            var contents = _a.contents;
+            return (0, ts_belt_1.pipe)(getPackages(contents), ts_belt_1.O.match(ts_belt_1.F.identity, function () { return getPackagesNested(contents); }), ts_belt_1.O.toResult(new error_1.BaseError('no yarn patterns found')));
+        }));
+    };
+}
+exports.getYarnPatterns = getYarnPatterns;

package/dist/get-context/get-package-json-files/get-patterns/index.d.ts

@@ -0,0 +1,11 @@
+import { R } from '@mobily/ts-belt';
+import type { Disk } from '../../../lib/disk';
+import { BaseError } from '../../../lib/error';
+import type { Syncpack } from '../../../types';
+/**
+ * Find every glob pattern which should be used to find package.json files for
+ * this monorepo.
+ *
+ * @returns `['./package.json', './packages/* /package.json']`
+ */
+export declare function getPatterns(disk: Disk): (program: Syncpack.Config.SyncpackRc) => R.Result<string[], BaseError>;

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

@@ -0,0 +1,70 @@
+"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;
+};
+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.getPatterns = void 0;
+var ts_belt_1 = require("@mobily/ts-belt");
+var expect_more_1 = require("expect-more");
+var constants_1 = require("../../../constants");
+var error_1 = require("../../../lib/error");
+var get_lerna_patterns_1 = require("./get-lerna-patterns");
+var get_pnpm_patterns_1 = require("./get-pnpm-patterns");
+var get_yarn_patterns_1 = require("./get-yarn-patterns");
+/**
+ * Find every glob pattern which should be used to find package.json files for
+ * this monorepo.
+ *
+ * @returns `['./package.json', './packages/* /package.json']`
+ */
+function getPatterns(disk) {
+    return function getPatterns(program) {
+        var getters = [
+            getCliPatterns,
+            (0, get_yarn_patterns_1.getYarnPatterns)(disk),
+            (0, get_pnpm_patterns_1.getPnpmPatterns)(disk),
+            (0, get_lerna_patterns_1.getLernaPatterns)(disk),
+        ];
+        var initialResult = ts_belt_1.R.Error(new error_1.BaseError('getPatterns did not try any sources'));
+        var res = ts_belt_1.A.reduce(getters, initialResult, function (previousResult, getNextResult) {
+            if (ts_belt_1.R.isOk(previousResult))
+                return previousResult;
+            return getNextResult();
+        });
+        return (0, ts_belt_1.pipe)(res, ts_belt_1.R.map(addRootDir), ts_belt_1.R.map(limitToPackageJson), ts_belt_1.R.handleError(function () { return constants_1.DEFAULT_SOURCES; }), ts_belt_1.R.mapError(ts_belt_1.F.identity));
+        function getCliPatterns() {
+            return ts_belt_1.R.fromPredicate(program.source, expect_more_1.isArrayOfStrings, new error_1.BaseError('No --source options provided'));
+        }
+        function addRootDir(patterns) {
+            return __spreadArray(['package.json'], __read(patterns), false);
+        }
+        function limitToPackageJson(patterns) {
+            return patterns.map(function (pattern) {
+                return pattern.includes('package.json') ? pattern : "".concat(pattern, "/package.json");
+            });
+        }
+    };
+}
+exports.getPatterns = getPatterns;

package/dist/get-context/get-package-json-files/get-patterns/lib/get-array-of-strings.d.ts

@@ -0,0 +1 @@
+export declare const getArrayOfStrings: (path: string) => (obj: unknown) => import("@mobily/ts-belt").Option<string[]>;

package/dist/get-context/get-package-json-files/get-patterns/lib/get-array-of-strings.js

@@ -0,0 +1,10 @@
+"use strict";
+exports.__esModule = true;
+exports.getArrayOfStrings = void 0;
+var expect_more_1 = require("expect-more");
+var props_1 = require("../props");
+// Yarn's config for this can be in more than one place
+var getArrayOfStrings = function (path) {
+    return (0, props_1.props)(path, expect_more_1.isArrayOfStrings);
+};
+exports.getArrayOfStrings = getArrayOfStrings;

package/dist/get-context/get-package-json-files/get-patterns/props.d.ts

@@ -0,0 +1,6 @@
+import { O } from '@mobily/ts-belt';
+/**
+ * Safely read nested properties of any value.
+ * @param keys 'child.grandChild.greatGrandChild'
+ */
+export declare function props<T>(keys: string, predicate: (value: unknown) => value is T): (obj: unknown) => O.Option<T>;