syncpack 8.5.14 → 9.0.2

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

@@ -0,0 +1,104 @@
+"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.Public = exports.Cli = exports.SyncpackRc = exports.Private = void 0;
+var zod_1 = require("zod");
+var constants_1 = require("../../../constants");
+var paths = __importStar(require("./paths"));
+var semverGroup = __importStar(require("./semver-group"));
+var semverRange = __importStar(require("./semver-range"));
+var versionGroup = __importStar(require("./version-group"));
+var nonEmptyString = zod_1.z.string().trim().min(1);
+var cliOnly = {
+    configPath: zod_1.z.string().optional(),
+    types: zod_1.z.string()["default"]('')
+};
+var syncpackRcOnly = {
+    customTypes: paths.pathConfigByName.optional(),
+    dependencyTypes: zod_1.z.array(nonEmptyString)["default"]([]),
+    semverGroups: zod_1.z
+        .array(semverGroup.any)["default"](__spreadArray([], __read(constants_1.DEFAULT_CONFIG.semverGroups), false)),
+    sortAz: zod_1.z.array(nonEmptyString)["default"](__spreadArray([], __read(constants_1.DEFAULT_CONFIG.sortAz), false)),
+    sortFirst: zod_1.z.array(nonEmptyString)["default"](__spreadArray([], __read(constants_1.DEFAULT_CONFIG.sortFirst), false)),
+    versionGroups: zod_1.z
+        .array(versionGroup.any)["default"](__spreadArray([], __read(constants_1.DEFAULT_CONFIG.versionGroups), false))
+};
+var cliAndRcFile = {
+    filter: nonEmptyString["default"](constants_1.DEFAULT_CONFIG.filter),
+    indent: zod_1.z.string()["default"](constants_1.DEFAULT_CONFIG.indent),
+    semverRange: semverRange.value["default"](constants_1.DEFAULT_CONFIG.semverRange),
+    source: zod_1.z.array(nonEmptyString)["default"](__spreadArray([], __read(constants_1.DEFAULT_CONFIG.source), false))
+};
+var privateOnly = {
+    allTypes: zod_1.z.array(paths.pathDefinition),
+    enabledTypes: zod_1.z.array(paths.pathDefinition),
+    defaultSemverGroup: semverGroup.base,
+    defaultVersionGroup: versionGroup.base
+};
+exports.Private = zod_1.z.object(__assign(__assign(__assign(__assign({}, privateOnly), cliOnly), syncpackRcOnly), cliAndRcFile));
+exports.SyncpackRc = zod_1.z.object(__assign(__assign({}, syncpackRcOnly), cliAndRcFile));
+exports.Cli = zod_1.z.object(__assign(__assign({}, cliOnly), cliAndRcFile));
+exports.Public = exports.Private.omit({
+    allTypes: true,
+    enabledTypes: true,
+    defaultSemverGroup: true,
+    defaultVersionGroup: true
+});

package/dist/get-context/get-config/schema/paths.d.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+/** config */
+export declare const pathConfigByName: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<"strategy", [z.ZodObject<{
+    namePath: z.ZodString;
+    path: z.ZodString;
+    strategy: z.ZodLiteral<"name~version">;
+}, "strip", z.ZodTypeAny, {
+    strategy: "name~version";
+    namePath: string;
+    path: string;
+}, {
+    strategy: "name~version";
+    namePath: string;
+    path: string;
+}>, z.ZodObject<{
+    path: z.ZodString;
+    strategy: z.ZodLiteral<"name@version">;
+}, "strip", z.ZodTypeAny, {
+    strategy: "name@version";
+    path: string;
+}, {
+    strategy: "name@version";
+    path: string;
+}>, z.ZodObject<{
+    path: z.ZodString;
+    strategy: z.ZodLiteral<"version">;
+}, "strip", z.ZodTypeAny, {
+    strategy: "version";
+    path: string;
+}, {
+    strategy: "version";
+    path: string;
+}>, z.ZodObject<{
+    path: z.ZodString;
+    strategy: z.ZodLiteral<"versionsByName">;
+}, "strip", z.ZodTypeAny, {
+    strategy: "versionsByName";
+    path: string;
+}, {
+    strategy: "versionsByName";
+    path: string;
+}>]>>;
+/** private */
+export declare const pathDefinition: z.ZodIntersection<z.ZodDiscriminatedUnion<"strategy", [z.ZodObject<{
+    namePath: z.ZodString;
+    path: z.ZodString;
+    strategy: z.ZodLiteral<"name~version">;
+}, "strip", z.ZodTypeAny, {
+    strategy: "name~version";
+    namePath: string;
+    path: string;
+}, {
+    strategy: "name~version";
+    namePath: string;
+    path: string;
+}>, z.ZodObject<{
+    path: z.ZodString;
+    strategy: z.ZodLiteral<"name@version">;
+}, "strip", z.ZodTypeAny, {
+    strategy: "name@version";
+    path: string;
+}, {
+    strategy: "name@version";
+    path: string;
+}>, z.ZodObject<{
+    path: z.ZodString;
+    strategy: z.ZodLiteral<"version">;
+}, "strip", z.ZodTypeAny, {
+    strategy: "version";
+    path: string;
+}, {
+    strategy: "version";
+    path: string;
+}>, z.ZodObject<{
+    path: z.ZodString;
+    strategy: z.ZodLiteral<"versionsByName">;
+}, "strip", z.ZodTypeAny, {
+    strategy: "versionsByName";
+    path: string;
+}, {
+    strategy: "versionsByName";
+    path: string;
+}>]>, z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name: string;
+}>>;

package/dist/get-context/get-config/schema/paths.js

@@ -0,0 +1,33 @@
+"use strict";
+exports.__esModule = true;
+exports.pathDefinition = exports.pathConfigByName = void 0;
+var zod_1 = require("zod");
+var namedVersionString = zod_1.z.object({
+    path: zod_1.z.string(),
+    strategy: zod_1.z.literal('name@version')
+});
+var nameAndVersionStrings = zod_1.z.object({
+    namePath: zod_1.z.string(),
+    path: zod_1.z.string(),
+    strategy: zod_1.z.literal('name~version')
+});
+var unnamedVersionString = zod_1.z.object({
+    path: zod_1.z.string(),
+    strategy: zod_1.z.literal('version')
+});
+var versionsByName = zod_1.z.object({
+    path: zod_1.z.string(),
+    strategy: zod_1.z.literal('versionsByName')
+});
+var pathConfig = zod_1.z.discriminatedUnion('strategy', [
+    nameAndVersionStrings,
+    namedVersionString,
+    unnamedVersionString,
+    versionsByName,
+]);
+/** config */
+exports.pathConfigByName = zod_1.z.record(pathConfig);
+/** private */
+exports.pathDefinition = pathConfig.and(zod_1.z.object({
+    name: zod_1.z.string().trim().min(1)
+}));

package/dist/get-context/get-config/schema/semver-group.d.ts

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+export declare const ignored: z.ZodObject<{
+    isIgnored: z.ZodLiteral<true>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    dependencies: string[];
+    isIgnored: true;
+    dependencyTypes: string[];
+    packages: string[];
+}, {
+    dependencyTypes?: string[] | undefined;
+    dependencies: string[];
+    isIgnored: true;
+    packages: string[];
+}>;
+export declare const withRange: z.ZodObject<{
+    range: z.ZodEnum<["*", "", ">", ">=", ".x", "<", "<=", "^", "~"]>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    dependencies: string[];
+    dependencyTypes: string[];
+    packages: string[];
+    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
+}, {
+    dependencyTypes?: string[] | undefined;
+    dependencies: string[];
+    packages: string[];
+    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
+}>;
+export declare const base: z.ZodObject<{
+    range: z.ZodEnum<["*", "", ">", ">=", ".x", "<", "<=", "^", "~"]>;
+    isDefault: z.ZodLiteral<true>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    isDefault: true;
+    dependencies: string[];
+    dependencyTypes: string[];
+    packages: string[];
+    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
+}, {
+    dependencyTypes?: string[] | undefined;
+    isDefault: true;
+    dependencies: string[];
+    packages: string[];
+    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
+}>;
+export declare const any: z.ZodUnion<[z.ZodObject<{
+    isIgnored: z.ZodLiteral<true>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    dependencies: string[];
+    isIgnored: true;
+    dependencyTypes: string[];
+    packages: string[];
+}, {
+    dependencyTypes?: string[] | undefined;
+    dependencies: string[];
+    isIgnored: true;
+    packages: string[];
+}>, z.ZodObject<{
+    range: z.ZodEnum<["*", "", ">", ">=", ".x", "<", "<=", "^", "~"]>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    dependencies: string[];
+    dependencyTypes: string[];
+    packages: string[];
+    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
+}, {
+    dependencyTypes?: string[] | undefined;
+    dependencies: string[];
+    packages: string[];
+    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
+}>, z.ZodObject<{
+    range: z.ZodEnum<["*", "", ">", ">=", ".x", "<", "<=", "^", "~"]>;
+    isDefault: z.ZodLiteral<true>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    isDefault: true;
+    dependencies: string[];
+    dependencyTypes: string[];
+    packages: string[];
+    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
+}, {
+    dependencyTypes?: string[] | undefined;
+    isDefault: true;
+    dependencies: string[];
+    packages: string[];
+    range: "" | "*" | ">" | ">=" | ".x" | "<" | "<=" | "^" | "~";
+}>]>;

package/dist/get-context/get-config/schema/semver-group.js

@@ -0,0 +1,50 @@
+"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;
+};
+exports.__esModule = true;
+exports.any = exports.base = exports.withRange = exports.ignored = void 0;
+var zod_1 = require("zod");
+var base_group_1 = require("./base-group");
+var SemverRangeSchema = __importStar(require("./semver-range"));
+exports.ignored = zod_1.z
+    .object(__assign(__assign({}, base_group_1.baseGroupFields), { isIgnored: zod_1.z.literal(true) }))
+    .strict();
+exports.withRange = zod_1.z
+    .object(__assign(__assign({}, base_group_1.baseGroupFields), { range: SemverRangeSchema.value }))
+    .strict();
+exports.base = zod_1.z
+    .object(__assign(__assign({}, base_group_1.baseGroupFields), { range: SemverRangeSchema.value, isDefault: zod_1.z.literal(true) }))
+    .strict();
+exports.any = zod_1.z.union([exports.ignored, exports.withRange, exports.base]);

package/dist/get-context/get-config/schema/semver-range.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare const value: z.ZodEnum<["*", "", ">", ">=", ".x", "<", "<=", "^", "~"]>;

package/dist/get-context/get-config/schema/semver-range.js

@@ -0,0 +1,16 @@
+"use strict";
+exports.__esModule = true;
+exports.value = void 0;
+var zod_1 = require("zod");
+var constants_1 = require("../../../constants");
+exports.value = zod_1.z["enum"]([
+    constants_1.RANGE.ANY,
+    constants_1.RANGE.EXACT,
+    constants_1.RANGE.GT,
+    constants_1.RANGE.GTE,
+    constants_1.RANGE.LOOSE,
+    constants_1.RANGE.LT,
+    constants_1.RANGE.LTE,
+    constants_1.RANGE.MINOR,
+    constants_1.RANGE.PATCH,
+]);

package/dist/get-context/get-config/schema/version-group.d.ts

@@ -0,0 +1,151 @@
+import { z } from 'zod';
+export declare const standard: z.ZodObject<{
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    dependencies: string[];
+    dependencyTypes: string[];
+    packages: string[];
+}, {
+    dependencyTypes?: string[] | undefined;
+    dependencies: string[];
+    packages: string[];
+}>;
+export declare const banned: z.ZodObject<{
+    isBanned: z.ZodLiteral<true>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    dependencies: string[];
+    dependencyTypes: string[];
+    packages: string[];
+    isBanned: true;
+}, {
+    dependencyTypes?: string[] | undefined;
+    dependencies: string[];
+    packages: string[];
+    isBanned: true;
+}>;
+export declare const ignored: z.ZodObject<{
+    isIgnored: z.ZodLiteral<true>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    dependencies: string[];
+    isIgnored: true;
+    dependencyTypes: string[];
+    packages: string[];
+}, {
+    dependencyTypes?: string[] | undefined;
+    dependencies: string[];
+    isIgnored: true;
+    packages: string[];
+}>;
+export declare const pinned: z.ZodObject<{
+    pinVersion: z.ZodString;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    dependencies: string[];
+    dependencyTypes: string[];
+    packages: string[];
+    pinVersion: string;
+}, {
+    dependencyTypes?: string[] | undefined;
+    dependencies: string[];
+    packages: string[];
+    pinVersion: string;
+}>;
+export declare const base: z.ZodObject<{
+    isDefault: z.ZodLiteral<true>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    isDefault: true;
+    dependencies: string[];
+    dependencyTypes: string[];
+    packages: string[];
+}, {
+    dependencyTypes?: string[] | undefined;
+    isDefault: true;
+    dependencies: string[];
+    packages: string[];
+}>;
+export declare const any: z.ZodUnion<[z.ZodObject<{
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    dependencies: string[];
+    dependencyTypes: string[];
+    packages: string[];
+}, {
+    dependencyTypes?: string[] | undefined;
+    dependencies: string[];
+    packages: string[];
+}>, z.ZodObject<{
+    isBanned: z.ZodLiteral<true>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    dependencies: string[];
+    dependencyTypes: string[];
+    packages: string[];
+    isBanned: true;
+}, {
+    dependencyTypes?: string[] | undefined;
+    dependencies: string[];
+    packages: string[];
+    isBanned: true;
+}>, z.ZodObject<{
+    isIgnored: z.ZodLiteral<true>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    dependencies: string[];
+    isIgnored: true;
+    dependencyTypes: string[];
+    packages: string[];
+}, {
+    dependencyTypes?: string[] | undefined;
+    dependencies: string[];
+    isIgnored: true;
+    packages: string[];
+}>, z.ZodObject<{
+    pinVersion: z.ZodString;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    dependencies: string[];
+    dependencyTypes: string[];
+    packages: string[];
+    pinVersion: string;
+}, {
+    dependencyTypes?: string[] | undefined;
+    dependencies: string[];
+    packages: string[];
+    pinVersion: string;
+}>, z.ZodObject<{
+    isDefault: z.ZodLiteral<true>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    dependencyTypes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    packages: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    isDefault: true;
+    dependencies: string[];
+    dependencyTypes: string[];
+    packages: string[];
+}, {
+    dependencyTypes?: string[] | undefined;
+    isDefault: true;
+    dependencies: string[];
+    packages: string[];
+}>]>;

package/dist/get-context/get-config/schema/version-group.js

@@ -0,0 +1,31 @@
+"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.any = exports.base = exports.pinned = exports.ignored = exports.banned = exports.standard = void 0;
+var zod_1 = require("zod");
+var base_group_1 = require("./base-group");
+var NonEmptyString = zod_1.z.string().trim().min(1);
+exports.standard = zod_1.z.object(base_group_1.baseGroupFields).strict();
+exports.banned = zod_1.z
+    .object(__assign(__assign({}, base_group_1.baseGroupFields), { isBanned: zod_1.z.literal(true) }))
+    .strict();
+exports.ignored = zod_1.z
+    .object(__assign(__assign({}, base_group_1.baseGroupFields), { isIgnored: zod_1.z.literal(true) }))
+    .strict();
+exports.pinned = zod_1.z
+    .object(__assign(__assign({}, base_group_1.baseGroupFields), { pinVersion: NonEmptyString }))
+    .strict();
+exports.base = zod_1.z
+    .object(__assign(__assign({}, base_group_1.baseGroupFields), { isDefault: zod_1.z.literal(true) }))
+    .strict();
+exports.any = zod_1.z.union([exports.standard, exports.banned, exports.ignored, exports.pinned, exports.base]);

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

@@ -0,0 +1,4 @@
+import type { Syncpack } from '../../types';
+import type { Instance } from '../get-package-json-files/package-json-file/instance';
+import { SemverGroup } from './semver-group';
+export declare function getSemverGroups(input: Syncpack.Config.Private, instances: Instance[]): SemverGroup[];

package/dist/{lib/get-context → get-context}/get-groups/get-semver-groups.js

@@ -17,6 +17,7 @@ function getSemverGroups(input, instances) {
     var semverGroups = input.semverGroups.map(function (semverGroup) { return new semver_group_1.SemverGroup(input, semverGroup); });
     instances.forEach(function (instance) {
         var e_1, _a;
+        var _b;
         var name = instance.name, pkgName = instance.pkgName;
         try {
             for (var semverGroups_1 = __values(semverGroups), semverGroups_1_1 = semverGroups_1.next(); !semverGroups_1_1.done; semverGroups_1_1 = semverGroups_1.next()) {
@@ -25,7 +26,7 @@ function getSemverGroups(input, instances) {
                     if (!semverGroup.instancesByName[name]) {
                         semverGroup.instancesByName[name] = [];
                     }
-                    semverGroup.instancesByName[name].push(instance);
+                    (_b = semverGroup.instancesByName[name]) === null || _b === void 0 ? void 0 : _b.push(instance);
                     semverGroup.instances.push(instance);
                     return;
                 }

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

@@ -0,0 +1,4 @@
+import type { Syncpack } from '../../types';
+import type { Instance } from '../get-package-json-files/package-json-file/instance';
+import { VersionGroup } from './version-group';
+export declare function getVersionGroups(input: Syncpack.Config.Private, instances: Instance[]): VersionGroup[];

package/dist/{lib/get-context → get-context}/get-groups/get-version-groups.js

@@ -34,6 +34,7 @@ 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()) {
@@ -42,7 +43,7 @@ function getVersionGroups(input, instances) {
                     if (!versionGroup.instancesByName[name]) {
                         versionGroup.instancesByName[name] = [];
                     }
-                    versionGroup.instancesByName[name].push(instance);
+                    (_b = versionGroup.instancesByName[name]) === null || _b === void 0 ? void 0 : _b.push(instance);
                     versionGroup.instances.push(instance);
                     return;
                 }

package/dist/{lib/get-context → get-context}/get-groups/semver-group/index.d.ts

@@ -1,13 +1,12 @@
-import type { Config, DependencyType, ValidRange } from '../../get-config/config';
-import type { InternalConfig } from '../../get-config/internal-config';
+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 of the provided types */
-    dependencyTypes?: DependencyType[];
+    /** Optionally limit this group to dependencies at these named paths */
+    dependencyTypes: Syncpack.TypeName[];
     /** */
-    input: InternalConfig;
+    input: Syncpack.Config.Private;
     /** */
     instances: Instance[];
     /** */
@@ -19,12 +18,12 @@ export declare class SemverGroup {
     /** */
     packages: string[];
     /** The semver range which dependencies in this group should use */
-    range: ValidRange;
-    constructor(input: InternalConfig, semverGroup: Config.SemverGroup.Any);
-    /** Syncpack must report or fix this group's mismatches */
-    isInvalid(): boolean;
+    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 */
-    hasInvalidInstances(): boolean;
+    hasMismatches(): boolean;
     /** Get every `Instance` with a version which does not follow the rules */
-    getInvalidInstances(): Instance[];
+    getMismatches(): [string, Instance[]][];
 }