syncpack 8.4.11 → 9.0.0

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/get-context/get-groups/get-semver-groups.js

@@ -0,0 +1,46 @@
+"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.getSemverGroups = void 0;
+var semver_group_1 = require("./semver-group");
+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()) {
+                var semverGroup = semverGroups_1_1.value;
+                if (instance.matchesGroup(semverGroup)) {
+                    if (!semverGroup.instancesByName[name]) {
+                        semverGroup.instancesByName[name] = [];
+                    }
+                    (_b = semverGroup.instancesByName[name]) === null || _b === void 0 ? void 0 : _b.push(instance);
+                    semverGroup.instances.push(instance);
+                    return;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (semverGroups_1_1 && !semverGroups_1_1.done && (_a = semverGroups_1["return"])) _a.call(semverGroups_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        throw new Error("".concat(name, " in ").concat(pkgName, " did not match any semverGroups"));
+    });
+    return semverGroups;
+}
+exports.getSemverGroups = getSemverGroups;

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[];