@marcoappio/marco-config 4.0.10 → 4.0.12

package/dist/schemas/index.d.ts

@@ -11,9 +11,6 @@ export declare const marcoSchemas: {
             readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
         }, undefined>;
     };
-    boolean: {
-        fromString: () => import("valibot").SchemaWithPipe<readonly [import("valibot").PicklistSchema<["true", "false"], undefined>, import("valibot").TransformAction<"true" | "false", boolean>, import("valibot").BooleanSchema<undefined>]>;
-    };
     emailAccount: {
         connectionConfigImapRaw: () => import("valibot").ObjectSchema<{
             readonly imapHost: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -89,9 +86,6 @@ export declare const marcoSchemas: {
             required: (maxLength?: number) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "ViewId">]>, undefined>;
         };
     };
-    labels: {
-        specialUse: () => import("valibot").PicklistSchema<readonly ["ARCHIVE", "INBOX", "SENT", "SPAM", "TRASH"], undefined>;
-    };
     models: {
         accountAliasSchema: import("valibot").ObjectSchema<{
             readonly accountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>, import("valibot").BrandAction<string, "AccountId">]>, undefined>;
@@ -320,11 +314,8 @@ export declare const marcoSchemas: {
         }, undefined>;
     };
     number: {
-        fromString: () => import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").TransformAction<string, number>, import("valibot").NumberSchema<undefined>, import("valibot").FiniteAction<number, undefined>]>;
         minMax: (min: number, max: number) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, number, undefined>, import("valibot").MaxValueAction<number, number, undefined>]>, undefined>;
-        nullable: () => import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
         positiveInteger: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
-        positiveIntegerFromString: () => import("valibot").SchemaWithPipe<readonly [import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").TransformAction<string, number>, import("valibot").NumberSchema<undefined>, import("valibot").FiniteAction<number, undefined>]>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>;
     };
     oauth: {
         provider: () => import("valibot").PicklistSchema<readonly ["GOOGLE", "OUTLOOK"], undefined>;
@@ -340,11 +331,8 @@ export declare const marcoSchemas: {
     };
     string: {
         email: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
-        enum: (values: Record<string, string>) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").EnumSchema<Record<string, string>, undefined>]>, undefined>;
         mailboxAddress: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 320, undefined>]>, undefined>;
-        matches: (regex: RegExp) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, undefined>]>, undefined>;
         nullable: (maxLength?: number) => import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-        optional: (maxLength?: number) => import("valibot").UndefinedableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
         required: (maxLength?: number) => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
     };
 };

package/dist/schemas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AA2BA,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC3K,YAAY,EACV,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,OAAO,EACP,KAAK,EACL,eAAe,EACf,SAAS,EACT,MAAM,EACN,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,QAAQ,GACT,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BxB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAyBA,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC3K,YAAY,EACV,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,OAAO,EACP,KAAK,EACL,eAAe,EACf,SAAS,EACT,MAAM,EACN,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,QAAQ,GACT,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAA"}

package/dist/schemas/index.js

@@ -1,9 +1,7 @@
 import { app } from './app';
 import { auth } from './auth';
-import { boolean } from './boolean';
 import { emailAccount } from './emailAccount';
 import { id } from './id';
-import { labels } from './labels';
 import { accountAliasSchema, accountLabelSchema, accountSchema, contactSchema, draftAttachmentSchema, draftBodySchema, draftSchema, threadFullSchema, threadListSchema, threadMessageAttachmentSchema, threadMessageRecipientSchema, threadMessageSchema, threadSchema, userViewSchema, } from './models';
 import { number } from './number';
 import { oauth } from './oauth';
@@ -12,10 +10,8 @@ import { string } from './string';
 export const marcoSchemas = {
     app,
     auth,
-    boolean,
     emailAccount,
     id,
-    labels,
     models: {
         accountAliasSchema,
         accountLabelSchema,

package/dist/schemas/number.d.ts

@@ -1,9 +1,6 @@
 import * as v from 'valibot';
 export declare const number: {
-    fromString: () => v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.TransformAction<string, number>, v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
     minMax: (min: number, max: number) => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
-    nullable: () => v.NullableSchema<v.NumberSchema<undefined>, undefined>;
     positiveInteger: () => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-    positiveIntegerFromString: () => v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.TransformAction<string, number>, v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
 };
 //# sourceMappingURL=number.d.ts.map

package/dist/schemas/number.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../src/schemas/number.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,MAAM;;kBASH,MAAM,OAAO,MAAM;;;;CAIlC,CAAA"}
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../src/schemas/number.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,MAAM;kBACH,MAAM,OAAO,MAAM;;CAElC,CAAA"}

package/dist/schemas/number.js

@@ -1,8 +1,5 @@
 import * as v from 'valibot';
 export const number = {
-    fromString: () => v.pipe(v.string(), v.nonEmpty(), v.transform(value => Number(value)), v.number(), v.finite()),
     minMax: (min, max) => v.nonOptional(v.pipe(v.number(), v.minValue(min), v.maxValue(max))),
-    nullable: () => v.nullable(v.number()),
     positiveInteger: () => v.nonOptional(v.pipe(v.number(), v.integer(), v.minValue(0))),
-    positiveIntegerFromString: () => v.pipe(number.fromString(), v.integer(), v.minValue(0)),
 };

package/dist/schemas/string.d.ts

@@ -1,11 +1,8 @@
 import * as v from 'valibot';
 export declare const string: {
     email: () => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;
-    enum: (values: Record<string, string>) => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<Record<string, string>, undefined>]>, undefined>;
     mailboxAddress: () => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>, v.MaxLengthAction<string, 320, undefined>]>, undefined>;
-    matches: (regex: RegExp) => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>;
     nullable: (maxLength?: number) => v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    optional: (maxLength?: number) => v.UndefinedableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
     required: (maxLength?: number) => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
 };
 //# sourceMappingURL=string.d.ts.map

package/dist/schemas/string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/schemas/string.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,MAAM;;mBAEF,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;qBAEpB,MAAM;;;;CAIxB,CAAA"}
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/schemas/string.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,MAAM;;;;;CAKlB,CAAA"}

package/dist/schemas/string.js

@@ -1,10 +1,7 @@
 import * as v from 'valibot';
 export const string = {
     email: () => v.nonOptional(v.pipe(v.string(), v.rfcEmail())),
-    enum: (values) => v.nonOptional(v.pipe(v.string(), v.enum(values))),
     mailboxAddress: () => v.nonOptional(v.pipe(v.string(), v.rfcEmail(), v.maxLength(320))),
-    matches: (regex) => v.nonOptional(v.pipe(v.string(), v.regex(regex))),
     nullable: (maxLength = 255) => v.nullable(v.pipe(v.string(), v.nonEmpty(), v.maxLength(maxLength))),
-    optional: (maxLength = 255) => v.undefinedable(v.pipe(v.string(), v.nonEmpty(), v.maxLength(maxLength))),
     required: (maxLength = 255) => v.nonOptional(v.pipe(v.string(), v.nonEmpty(), v.maxLength(maxLength))),
 };

package/dist/utils/index.d.ts

@@ -1,5 +1,4 @@
 export { accountUtils } from './accounts';
 export { labelUtils } from './labels';
 export { threadsUtils } from './threads';
-export { flattenRequirements, type SchemaRequirements } from './validation';
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA"}

package/dist/utils/index.js

@@ -1,4 +1,3 @@
 export { accountUtils } from './accounts';
 export { labelUtils } from './labels';
 export { threadsUtils } from './threads';
-export { flattenRequirements } from './validation';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marcoappio/marco-config",
-  "version": "4.0.10",
+  "version": "4.0.12",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",

package/dist/schemas/boolean.d.ts

@@ -1,5 +0,0 @@
-import * as v from 'valibot';
-export declare const boolean: {
-    fromString: () => v.SchemaWithPipe<readonly [v.PicklistSchema<["true", "false"], undefined>, v.TransformAction<"true" | "false", boolean>, v.BooleanSchema<undefined>]>;
-};
-//# sourceMappingURL=boolean.d.ts.map

package/dist/schemas/boolean.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../src/schemas/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,OAAO;;CAOnB,CAAA"}

package/dist/schemas/boolean.js

@@ -1,4 +0,0 @@
-import * as v from 'valibot';
-export const boolean = {
-    fromString: () => v.pipe(v.picklist(['true', 'false']), v.transform(value => value === 'true'), v.boolean()),
-};

package/dist/schemas/labels.d.ts

@@ -1,5 +0,0 @@
-import * as v from 'valibot';
-export declare const labels: {
-    specialUse: () => v.PicklistSchema<readonly ["ARCHIVE", "INBOX", "SENT", "SPAM", "TRASH"], undefined>;
-};
-//# sourceMappingURL=labels.d.ts.map

package/dist/schemas/labels.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../src/schemas/labels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B,eAAO,MAAM,MAAM;;CAElB,CAAA"}

package/dist/schemas/labels.js

@@ -1,5 +0,0 @@
-import * as v from 'valibot';
-import { LABEL_SPECIAL_USES } from '../types';
-export const labels = {
-    specialUse: () => v.picklist(LABEL_SPECIAL_USES),
-};

package/dist/schemas/paginatedResponse.d.ts

@@ -1,10 +0,0 @@
-import * as v from 'valibot';
-export declare const paginatedResponseSchema: <T extends v.GenericSchema>(itemSchema: T) => v.ObjectSchema<{
-    readonly items: v.ArraySchema<T, undefined>;
-    readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-}, undefined>;
-export type PaginatedResponse<T> = {
-    items: T[];
-    nextCursor: string | null;
-};
-//# sourceMappingURL=paginatedResponse.d.ts.map

package/dist/schemas/paginatedResponse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"paginatedResponse.d.ts","sourceRoot":"","sources":["../../src/schemas/paginatedResponse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,uBAAuB,GAAI,CAAC,SAAS,CAAC,CAAC,aAAa,cAAc,CAAC;;;aAI5E,CAAA;AAEJ,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;IACjC,KAAK,EAAE,CAAC,EAAE,CAAA;IACV,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1B,CAAA"}

package/dist/schemas/paginatedResponse.js

@@ -1,5 +0,0 @@
-import * as v from 'valibot';
-export const paginatedResponseSchema = (itemSchema) => v.object({
-    items: v.array(itemSchema),
-    nextCursor: v.nullable(v.string()),
-});

package/dist/utils/validation/flattenRequirements/flattenRequirements.d.ts

@@ -1,8 +0,0 @@
-import type { ReadonlyDeep } from 'type-fest';
-import * as v from 'valibot';
-export type SchemaRequirements = ReadonlyDeep<{
-    maxLength?: number;
-    minLength?: number;
-}>;
-export declare const flattenRequirements: <TEntries extends v.ObjectEntries>(schema: Pick<v.ObjectSchema<TEntries, v.ErrorMessage<v.ObjectIssue> | undefined>, "entries">) => ReadonlyDeep<Record<string, SchemaRequirements>>;
-//# sourceMappingURL=flattenRequirements.d.ts.map

package/dist/utils/validation/flattenRequirements/flattenRequirements.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flattenRequirements.d.ts","sourceRoot":"","sources":["../../../../src/utils/validation/flattenRequirements/flattenRequirements.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAC7C,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,kBAAkB,GAAG,YAAY,CAAC;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAC,CAAA;AAsDF,eAAO,MAAM,mBAAmB,GAAI,QAAQ,SAAS,CAAC,CAAC,aAAa,UAC1D,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,SAAS,CAAC,EAAE,SAAS,CAAC,KAC3F,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAA4G,CAAA"}

package/dist/utils/validation/flattenRequirements/flattenRequirements.js

@@ -1,37 +0,0 @@
-import * as v from 'valibot';
-const pipeSchema = v.array(v.unknown());
-const directFieldSchema = v.looseObject({ pipe: pipeSchema });
-const wrappedFieldSchema = v.looseObject({ wrapped: v.looseObject({ pipe: pipeSchema }) });
-const requirementSchema = v.looseObject({
-    requirement: v.number(),
-    type: v.picklist(['max_length', 'min_length']),
-});
-const getPipe = (field) => {
-    const directResult = v.safeParse(directFieldSchema, field);
-    if (directResult.success) {
-        return directResult.output.pipe;
-    }
-    const wrappedResult = v.safeParse(wrappedFieldSchema, field);
-    if (wrappedResult.success) {
-        return wrappedResult.output.wrapped.pipe;
-    }
-    return [];
-};
-const getRequirements = (field) => Object.fromEntries(getPipe(field)
-    .reduce(([maxLength, minLength], item) => {
-    const result = v.safeParse(requirementSchema, item);
-    if (result.success && result.output.type === 'max_length') {
-        return [Math.min(maxLength ?? result.output.requirement, result.output.requirement), minLength];
-    }
-    if (result.success) {
-        return [maxLength, Math.max(minLength ?? result.output.requirement, result.output.requirement)];
-    }
-    return [maxLength, minLength];
-}, [null, null])
-    .flatMap((requirement, index) => {
-    if (requirement !== null) {
-        return [[index === 0 ? 'maxLength' : 'minLength', requirement]];
-    }
-    return [];
-}));
-export const flattenRequirements = (schema) => Object.fromEntries(Object.entries(schema.entries).map(([key, field]) => [key, getRequirements(field)]));

package/dist/utils/validation/flattenRequirements/flattenRequirements.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=flattenRequirements.test.d.ts.map

package/dist/utils/validation/flattenRequirements/flattenRequirements.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flattenRequirements.test.d.ts","sourceRoot":"","sources":["../../../../src/utils/validation/flattenRequirements/flattenRequirements.test.ts"],"names":[],"mappings":""}

package/dist/utils/validation/flattenRequirements/flattenRequirements.test.js

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import * as v from 'valibot';
-import { flattenRequirements } from './flattenRequirements';
-describe('flattenRequirements', () => {
-    it('retains direct, wrapped, and unconstrained field requirements', () => {
-        const schema = v.object({
-            direct: v.pipe(v.string(), v.minLength(2), v.maxLength(64)),
-            plain: v.string(),
-            wrapped: v.optional(v.pipe(v.string(), v.minLength(3), v.maxLength(128))),
-        });
-        expect(flattenRequirements(schema)).toEqual({
-            direct: { maxLength: 64, minLength: 2 },
-            plain: {},
-            wrapped: { maxLength: 128, minLength: 3 },
-        });
-    });
-    it('retains the strictest repeated length requirements', () => {
-        const schema = v.object({
-            value: v.pipe(v.string(), v.minLength(8), v.minLength(2), v.maxLength(32), v.maxLength(128)),
-        });
-        expect(flattenRequirements(schema)).toEqual({
-            value: { maxLength: 32, minLength: 8 },
-        });
-    });
-});

package/dist/utils/validation/flattenRequirements/index.d.ts

@@ -1,2 +0,0 @@
-export { flattenRequirements, type SchemaRequirements } from './flattenRequirements';
-//# sourceMappingURL=index.d.ts.map

package/dist/utils/validation/flattenRequirements/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/validation/flattenRequirements/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/utils/validation/flattenRequirements/index.js

@@ -1 +0,0 @@
-export { flattenRequirements } from './flattenRequirements';

package/dist/utils/validation/index.d.ts

@@ -1,2 +0,0 @@
-export { flattenRequirements, type SchemaRequirements } from './flattenRequirements';
-//# sourceMappingURL=index.d.ts.map

package/dist/utils/validation/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/validation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/utils/validation/index.js

@@ -1 +0,0 @@
-export { flattenRequirements } from './flattenRequirements';