@warlock.js/notifications 4.16.0 → 5.0.0

package/esm/seal/src/rules/string/id-formats.mjs

@@ -0,0 +1,104 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../seal/src/rules/string/id-formats.ts
+/**
+* Modern ID format validators — UUID, CUID, ULID, nanoid.
+*
+* Each rule asserts the value is a string in the canonical format for its
+* identifier scheme. Rules are intentionally strict (variant nibbles checked
+* for UUID, character classes enforced for ULID's Crockford base32, etc.)
+* so "looks-like-but-not-valid" inputs are rejected.
+*/
+const UUID_ANY = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_BY_VERSION = {
+	1: /^[0-9a-f]{8}-[0-9a-f]{4}-1[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+	3: /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+	4: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+	5: /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+	6: /^[0-9a-f]{8}-[0-9a-f]{4}-6[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+	7: /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+};
+/**
+* UUID rule — value must be a valid UUID. Optionally restrict to a specific version.
+*
+* @example
+* v.string().uuid()       // any RFC 4122 UUID
+* v.string().uuid(4)      // only v4 (random)
+* v.string().uuid(7)      // only v7 (timestamp-ordered)
+*/
+const uuidRule = {
+	name: "uuid",
+	defaultErrorMessage: "The :input must be a valid UUID",
+	async validate(value, context) {
+		if (typeof value !== "string") return invalidRule(this, context);
+		const version = this.context.options.version;
+		if ((version ? UUID_BY_VERSION[version] : UUID_ANY).test(value)) return VALID_RULE;
+		if (version !== void 0) this.context.translationParams.version = version;
+		return invalidRule(this, context);
+	}
+};
+/**
+* CUID rule — value must be a valid CUID.
+*
+* Defaults to CUID2 (24 chars, lowercase, starts with letter — see
+* https://github.com/paralleldrive/cuid2). Pass `{ version: 1 }` for legacy
+* CUID1 format (starts with "c", ≥25 chars).
+*
+* @example
+* v.string().cuid()                  // CUID2
+* v.string().cuid({ version: 1 })    // legacy CUID1
+*/
+const cuidRule = {
+	name: "cuid",
+	defaultErrorMessage: "The :input must be a valid CUID",
+	async validate(value, context) {
+		if (typeof value !== "string") return invalidRule(this, context);
+		const version = this.context.options.version ?? 2;
+		if ((version === 1 ? /^c[a-z0-9]{24,}$/ : /^[a-z][a-z0-9]{23}$/).test(value)) return VALID_RULE;
+		this.context.translationParams.version = version;
+		return invalidRule(this, context);
+	}
+};
+/**
+* ULID rule — value must be a valid ULID (26 chars, Crockford base32).
+*
+* Crockford base32 excludes the letters I, L, O, U to avoid ambiguity.
+*
+* @example
+* v.string().ulid()
+*/
+const ulidRule = {
+	name: "ulid",
+	defaultErrorMessage: "The :input must be a valid ULID",
+	async validate(value, context) {
+		if (typeof value !== "string") return invalidRule(this, context);
+		if (/^[0-9A-HJKMNP-TV-Z]{26}$/.test(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* nanoid rule — value must be a valid nanoid string.
+*
+* Default length is 21 (standard nanoid). URL-safe alphabet:
+* A–Z, a–z, 0–9, `_`, `-`.
+*
+* @example
+* v.string().nanoid()         // 21 chars (default)
+* v.string().nanoid(10)       // 10 chars
+*/
+const nanoidRule = {
+	name: "nanoid",
+	defaultErrorMessage: "The :input must be a valid nanoid",
+	async validate(value, context) {
+		if (typeof value !== "string") return invalidRule(this, context);
+		const length = this.context.options.length ?? 21;
+		if (new RegExp(`^[A-Za-z0-9_-]{${length}}$`).test(value)) return VALID_RULE;
+		this.context.translationParams.length = length;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { cuidRule, nanoidRule, ulidRule, uuidRule };
+//# sourceMappingURL=id-formats.mjs.map

package/esm/seal/src/rules/string/id-formats.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-formats.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/id-formats.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\nimport type { SchemaRule } from \"../../types\";\n\n/**\n * Modern ID format validators — UUID, CUID, ULID, nanoid.\n *\n * Each rule asserts the value is a string in the canonical format for its\n * identifier scheme. Rules are intentionally strict (variant nibbles checked\n * for UUID, character classes enforced for ULID's Crockford base32, etc.)\n * so \"looks-like-but-not-valid\" inputs are rejected.\n */\n\nconst UUID_ANY = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\nconst UUID_BY_VERSION: Record<1 | 3 | 4 | 5 | 6 | 7, RegExp> = {\n  1: /^[0-9a-f]{8}-[0-9a-f]{4}-1[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  3: /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  4: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  5: /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  6: /^[0-9a-f]{8}-[0-9a-f]{4}-6[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  7: /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n};\n\nexport type UUIDVersion = 1 | 3 | 4 | 5 | 6 | 7;\n\n/**\n * UUID rule — value must be a valid UUID. Optionally restrict to a specific version.\n *\n * @example\n * v.string().uuid()       // any RFC 4122 UUID\n * v.string().uuid(4)      // only v4 (random)\n * v.string().uuid(7)      // only v7 (timestamp-ordered)\n */\nexport const uuidRule: SchemaRule<{ version?: UUIDVersion }> = {\n  name: \"uuid\",\n  defaultErrorMessage: \"The :input must be a valid UUID\",\n  async validate(value, context) {\n    if (typeof value !== \"string\") return invalidRule(this, context);\n\n    const version = this.context.options.version;\n\n    const pattern = version ? UUID_BY_VERSION[version] : UUID_ANY;\n    if (pattern.test(value)) return VALID_RULE;\n\n    if (version !== undefined) {\n      this.context.translationParams.version = version;\n    }\n\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * CUID rule — value must be a valid CUID.\n *\n * Defaults to CUID2 (24 chars, lowercase, starts with letter — see\n * https://github.com/paralleldrive/cuid2). Pass `{ version: 1 }` for legacy\n * CUID1 format (starts with \"c\", ≥25 chars).\n *\n * @example\n * v.string().cuid()                  // CUID2\n * v.string().cuid({ version: 1 })    // legacy CUID1\n */\nexport const cuidRule: SchemaRule<{ version?: 1 | 2 }> = {\n  name: \"cuid\",\n  defaultErrorMessage: \"The :input must be a valid CUID\",\n  async validate(value, context) {\n    if (typeof value !== \"string\") return invalidRule(this, context);\n    const version = this.context.options.version ?? 2;\n    const pattern = version === 1 ? /^c[a-z0-9]{24,}$/ : /^[a-z][a-z0-9]{23}$/;\n    if (pattern.test(value)) return VALID_RULE;\n    this.context.translationParams.version = version;\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * ULID rule — value must be a valid ULID (26 chars, Crockford base32).\n *\n * Crockford base32 excludes the letters I, L, O, U to avoid ambiguity.\n *\n * @example\n * v.string().ulid()\n */\nexport const ulidRule: SchemaRule = {\n  name: \"ulid\",\n  defaultErrorMessage: \"The :input must be a valid ULID\",\n  async validate(value, context) {\n    if (typeof value !== \"string\") return invalidRule(this, context);\n    if (/^[0-9A-HJKMNP-TV-Z]{26}$/.test(value)) return VALID_RULE;\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * nanoid rule — value must be a valid nanoid string.\n *\n * Default length is 21 (standard nanoid). URL-safe alphabet:\n * A–Z, a–z, 0–9, `_`, `-`.\n *\n * @example\n * v.string().nanoid()         // 21 chars (default)\n * v.string().nanoid(10)       // 10 chars\n */\nexport const nanoidRule: SchemaRule<{ length?: number }> = {\n  name: \"nanoid\",\n  defaultErrorMessage: \"The :input must be a valid nanoid\",\n  async validate(value, context) {\n    if (typeof value !== \"string\") return invalidRule(this, context);\n    const length = this.context.options.length ?? 21;\n    const pattern = new RegExp(`^[A-Za-z0-9_-]{${length}}$`);\n    if (pattern.test(value)) return VALID_RULE;\n    this.context.translationParams.length = length;\n    return invalidRule(this, context);\n  },\n};\n"],"mappings":";;;;;;;;;;;;AAYA,MAAM,WAAW;AAEjB,MAAM,kBAAyD;CAC7D,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;AACL;;;;;;;;;AAYA,MAAa,WAAkD;CAC7D,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,YAAY,MAAM,OAAO;EAE/D,MAAM,UAAU,KAAK,QAAQ,QAAQ;EAGrC,KADgB,UAAU,gBAAgB,WAAW,SAC1C,CAAC,KAAK,KAAK,GAAG,OAAO;EAEhC,IAAI,YAAY,QACd,KAAK,QAAQ,kBAAkB,UAAU;EAG3C,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;;;;;;;;;AAaA,MAAa,WAA4C;CACvD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,YAAY,MAAM,OAAO;EAC/D,MAAM,UAAU,KAAK,QAAQ,QAAQ,WAAW;EAEhD,KADgB,YAAY,IAAI,qBAAqB,sBAC1C,CAAC,KAAK,KAAK,GAAG,OAAO;EAChC,KAAK,QAAQ,kBAAkB,UAAU;EACzC,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;;;;;;AAUA,MAAa,WAAuB;CAClC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,YAAY,MAAM,OAAO;EAC/D,IAAI,2BAA2B,KAAK,KAAK,GAAG,OAAO;EACnD,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;;;;;;;;AAYA,MAAa,aAA8C;CACzD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,YAAY,MAAM,OAAO;EAC/D,MAAM,SAAS,KAAK,QAAQ,QAAQ,UAAU;EAE9C,IAAI,IADgB,OAAO,kBAAkB,OAAO,GAC1C,CAAC,CAAC,KAAK,KAAK,GAAG,OAAO;EAChC,KAAK,QAAQ,kBAAkB,SAAS;EACxC,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/rules/string/index.mjs

@@ -0,0 +1,13 @@
+import { alphaNumericRule, alphaRule, isNumericRule } from "./alpha.mjs";
+import { isCreditCardRule } from "./credit-card.mjs";
+import { emailRule } from "./email.mjs";
+import { cuidRule, nanoidRule, ulidRule, uuidRule } from "./id-formats.mjs";
+import { ip4Rule, ip6Rule, ipRule, isIP, isIPv4, isIPv6 } from "./ip.mjs";
+import "./matches.mjs";
+import { patternRule } from "./pattern.mjs";
+import { containsRule, endsWithRule, notContainsRule, startsWithRule } from "./string-comparison.mjs";
+import { strongPasswordRule } from "./strong-password-rule.mjs";
+import { urlRule } from "./url.mjs";
+import { withoutWhitespaceRule } from "./without-whitespace.mjs";
+
+export {  };

package/esm/seal/src/rules/string/ip.mjs

@@ -0,0 +1,66 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../seal/src/rules/string/ip.ts
+/**
+* Pure, dependency-free re-implementation of Node's `net.isIP`/`isIPv4`/`isIPv6`.
+* Mirrors the exact regex Node uses internally (lib/internal/net.js) so that
+* behavior stays identical while remaining runnable in the browser (no `net` import).
+*/
+const v4Seg = "(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])";
+const v4Str = `(${v4Seg}[.]){3}${v4Seg}`;
+const IPv4Reg = new RegExp(`^${v4Str}$`);
+const v6Seg = "(?:[0-9a-fA-F]{1,4})";
+const IPv6Reg = new RegExp(`^((?:${v6Seg}:){7}(?:${v6Seg}|:)|(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:)))(%[0-9a-zA-Z-.:]{1,})?\$`);
+function isIPv4(value) {
+	return IPv4Reg.test(value);
+}
+function isIPv6(value) {
+	return IPv6Reg.test(value);
+}
+/**
+* Returns 4 or 6 when `value` is a valid IPv4/IPv6 address, otherwise 0.
+* Signature mirrors Node's `net.isIP` for drop-in behavior parity.
+*/
+function isIP(value) {
+	if (isIPv4(value)) return 4;
+	if (isIPv6(value)) return 6;
+	return 0;
+}
+/**
+* IP rule - validates IP address (v4 or v6)
+*/
+const ipRule = {
+	name: "ip",
+	defaultErrorMessage: "The :input must be a valid IP address",
+	async validate(value, context) {
+		if (isIP(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* IPv4 rule - validates IPv4 address
+*/
+const ip4Rule = {
+	name: "ip4",
+	defaultErrorMessage: "The :input must be a valid IPv4 address",
+	async validate(value, context) {
+		if (isIP(value) === 4) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* IPv6 rule - validates IPv6 address
+*/
+const ip6Rule = {
+	name: "ip6",
+	defaultErrorMessage: "The :input must be a valid IPv6 address",
+	async validate(value, context) {
+		if (isIP(value) === 6) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { ip4Rule, ip6Rule, ipRule, isIP, isIPv4, isIPv6 };
+//# sourceMappingURL=ip.mjs.map

package/esm/seal/src/rules/string/ip.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ip.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/ip.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\nimport type { SchemaRule } from \"../../types\";\n\n/**\n * Pure, dependency-free re-implementation of Node's `net.isIP`/`isIPv4`/`isIPv6`.\n * Mirrors the exact regex Node uses internally (lib/internal/net.js) so that\n * behavior stays identical while remaining runnable in the browser (no `net` import).\n */\nconst v4Seg = \"(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\";\nconst v4Str = `(${v4Seg}[.]){3}${v4Seg}`;\nconst IPv4Reg = new RegExp(`^${v4Str}$`);\n\nconst v6Seg = \"(?:[0-9a-fA-F]{1,4})\";\nconst IPv6Reg = new RegExp(\n  \"^(\" +\n    `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` +\n    `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` +\n    `(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` +\n    `(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` +\n    `(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` +\n    `(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` +\n    `(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` +\n    `(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` +\n    \")(%[0-9a-zA-Z-.:]{1,})?$\",\n);\n\nexport function isIPv4(value: string): boolean {\n  return IPv4Reg.test(value);\n}\n\nexport function isIPv6(value: string): boolean {\n  return IPv6Reg.test(value);\n}\n\n/**\n * Returns 4 or 6 when `value` is a valid IPv4/IPv6 address, otherwise 0.\n * Signature mirrors Node's `net.isIP` for drop-in behavior parity.\n */\nexport function isIP(value: string): 0 | 4 | 6 {\n  if (isIPv4(value)) return 4;\n  if (isIPv6(value)) return 6;\n  return 0;\n}\n\n/**\n * IP rule - validates IP address (v4 or v6)\n */\nexport const ipRule: SchemaRule = {\n  name: \"ip\",\n  defaultErrorMessage: \"The :input must be a valid IP address\",\n  async validate(value: any, context) {\n    if (isIP(value)) {\n      return VALID_RULE;\n    }\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * IPv4 rule - validates IPv4 address\n */\nexport const ip4Rule: SchemaRule = {\n  name: \"ip4\",\n  defaultErrorMessage: \"The :input must be a valid IPv4 address\",\n  async validate(value: any, context) {\n    if (isIP(value) === 4) {\n      return VALID_RULE;\n    }\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * IPv6 rule - validates IPv6 address\n */\nexport const ip6Rule: SchemaRule = {\n  name: \"ip6\",\n  defaultErrorMessage: \"The :input must be a valid IPv6 address\",\n  async validate(value: any, context) {\n    if (isIP(value) === 6) {\n      return VALID_RULE;\n    }\n    return invalidRule(this, context);\n  },\n};\n"],"mappings":";;;;;;;;;AAQA,MAAM,QAAQ;AACd,MAAM,QAAQ,IAAI,MAAM,SAAS;AACjC,MAAM,UAAU,IAAI,OAAO,IAAI,MAAM,EAAE;AAEvC,MAAM,QAAQ;AACd,MAAM,UAAU,IAAI,OAClB,QACQ,MAAM,UAAU,MAAM,SACtB,MAAM,UAAU,MAAM,IAAI,MAAM,SAChC,MAAM,WAAW,MAAM,KAAK,MAAM,eAClC,MAAM,YAAY,MAAM,SAAS,MAAM,KAAK,MAAM,eAClD,MAAM,YAAY,MAAM,SAAS,MAAM,KAAK,MAAM,eAClD,MAAM,YAAY,MAAM,SAAS,MAAM,KAAK,MAAM,eAClD,MAAM,YAAY,MAAM,SAAS,MAAM,KAAK,MAAM,qBAC5C,MAAM,SAAS,MAAM,OAAO,MAAM,oCAElD;AAEA,SAAgB,OAAO,OAAwB;CAC7C,OAAO,QAAQ,KAAK,KAAK;AAC3B;AAEA,SAAgB,OAAO,OAAwB;CAC7C,OAAO,QAAQ,KAAK,KAAK;AAC3B;;;;;AAMA,SAAgB,KAAK,OAA0B;CAC7C,IAAI,OAAO,KAAK,GAAG,OAAO;CAC1B,IAAI,OAAO,KAAK,GAAG,OAAO;CAC1B,OAAO;AACT;;;;AAKA,MAAa,SAAqB;CAChC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,KAAK,GACZ,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,UAAsB;CACjC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,KAAK,MAAM,GAClB,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,UAAsB;CACjC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,KAAK,MAAM,GAClB,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/rules/string/matches.mjs

@@ -0,0 +1,4 @@
+import "../../../../node_modules/@mongez/reinforcements/esm/index.mjs";
+import "../../helpers/index.mjs";
+
+export {  };

package/esm/seal/src/rules/string/pattern.mjs

@@ -0,0 +1,20 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../seal/src/rules/string/pattern.ts
+/**
+* Pattern rule - validates against regex pattern
+*/
+const patternRule = {
+	name: "pattern",
+	defaultErrorMessage: "The :input does not match the required pattern",
+	async validate(value, context) {
+		if (this.context.options.pattern.test(value)) return VALID_RULE;
+		this.context.translationParams.pattern = this.context.options.pattern.toString();
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { patternRule };
+//# sourceMappingURL=pattern.mjs.map

package/esm/seal/src/rules/string/pattern.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/pattern.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Pattern rule - validates against regex pattern\r\n */\r\nexport const patternRule: SchemaRule<{ pattern: RegExp }> = {\r\n  name: \"pattern\",\r\n  defaultErrorMessage: \"The :input does not match the required pattern\",\r\n  async validate(value: any, context) {\r\n    if (this.context.options.pattern.test(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    this.context.translationParams.pattern = this.context.options.pattern.toString();\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,cAA+C;CAC1D,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,QAAQ,QAAQ,QAAQ,KAAK,KAAK,GACzC,OAAO;EAGT,KAAK,QAAQ,kBAAkB,UAAU,KAAK,QAAQ,QAAQ,QAAQ,SAAS;EAC/E,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/rules/string/string-comparison.mjs

@@ -0,0 +1,56 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../seal/src/rules/string/string-comparison.ts
+/**
+* Starts with rule
+*/
+const startsWithRule = {
+	name: "startsWith",
+	defaultErrorMessage: "The :input must start with :value",
+	async validate(value, context) {
+		if (String(value).startsWith(this.context.options.value)) return VALID_RULE;
+		this.context.translatableParams.value = this.context.options.value;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Ends with rule
+*/
+const endsWithRule = {
+	name: "endsWith",
+	defaultErrorMessage: "The :input must end with :value",
+	async validate(value, context) {
+		if (String(value).endsWith(this.context.options.value)) return VALID_RULE;
+		this.context.translatableParams.value = this.context.options.value;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Contains rule
+*/
+const containsRule = {
+	name: "contains",
+	defaultErrorMessage: "The :input must contain :value",
+	async validate(value, context) {
+		if (String(value).includes(this.context.options.value)) return VALID_RULE;
+		this.context.translatableParams.value = this.context.options.value;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Not contains rule
+*/
+const notContainsRule = {
+	name: "notContains",
+	defaultErrorMessage: "The :input must not contain :value",
+	async validate(value, context) {
+		if (!String(value).includes(this.context.options.value)) return VALID_RULE;
+		this.context.translatableParams.value = this.context.options.value;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { containsRule, endsWithRule, notContainsRule, startsWithRule };
+//# sourceMappingURL=string-comparison.mjs.map

package/esm/seal/src/rules/string/string-comparison.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-comparison.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/string-comparison.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Starts with rule\r\n */\r\nexport const startsWithRule: SchemaRule<{ value: string }> = {\r\n  name: \"startsWith\",\r\n  defaultErrorMessage: \"The :input must start with :value\",\r\n  async validate(value: any, context) {\r\n    if (String(value).startsWith(this.context.options.value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Ends with rule\r\n */\r\nexport const endsWithRule: SchemaRule<{ value: string }> = {\r\n  name: \"endsWith\",\r\n  defaultErrorMessage: \"The :input must end with :value\",\r\n  async validate(value: any, context) {\r\n    if (String(value).endsWith(this.context.options.value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Contains rule\r\n */\r\nexport const containsRule: SchemaRule<{ value: string }> = {\r\n  name: \"contains\",\r\n  defaultErrorMessage: \"The :input must contain :value\",\r\n  async validate(value: any, context) {\r\n    if (String(value).includes(this.context.options.value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Not contains rule\r\n */\r\nexport const notContainsRule: SchemaRule<{ value: string }> = {\r\n  name: \"notContains\",\r\n  defaultErrorMessage: \"The :input must not contain :value\",\r\n  async validate(value: any, context) {\r\n    if (!String(value).includes(this.context.options.value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,iBAAgD;CAC3D,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,OAAO,KAAK,CAAC,CAAC,WAAW,KAAK,QAAQ,QAAQ,KAAK,GACrD,OAAO;EAGT,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,eAA8C;CACzD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,OAAO,KAAK,CAAC,CAAC,SAAS,KAAK,QAAQ,QAAQ,KAAK,GACnD,OAAO;EAGT,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,eAA8C;CACzD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,OAAO,KAAK,CAAC,CAAC,SAAS,KAAK,QAAQ,QAAQ,KAAK,GACnD,OAAO;EAGT,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,kBAAiD;CAC5D,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,CAAC,OAAO,KAAK,CAAC,CAAC,SAAS,KAAK,QAAQ,QAAQ,KAAK,GACpD,OAAO;EAGT,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/rules/string/strong-password-rule.mjs

@@ -0,0 +1,31 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../seal/src/rules/string/strong-password-rule.ts
+/**
+* Strong Password rule - validates password strength
+* Requirements:
+* - At least 8 characters
+* - At least 1 uppercase letter
+* - At least 1 lowercase letter
+* - At least 1 number
+* - At least 1 special character
+*/
+const strongPasswordRule = {
+	name: "strongPassword",
+	defaultErrorMessage: "The :input must be at least 8 characters and contain at least one uppercase letter, one lowercase letter, one number, and one special character",
+	async validate(value, context) {
+		const password = String(value);
+		const minLength = this.context.options.minLength ?? 8;
+		if (password.length < minLength) return invalidRule(this, context);
+		if (!/[A-Z]/.test(password)) return invalidRule(this, context);
+		if (!/[a-z]/.test(password)) return invalidRule(this, context);
+		if (!/[0-9]/.test(password)) return invalidRule(this, context);
+		if (!/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { strongPasswordRule };
+//# sourceMappingURL=strong-password-rule.mjs.map

package/esm/seal/src/rules/string/strong-password-rule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"strong-password-rule.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/strong-password-rule.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Strong Password rule - validates password strength\r\n * Requirements:\r\n * - At least 8 characters\r\n * - At least 1 uppercase letter\r\n * - At least 1 lowercase letter\r\n * - At least 1 number\r\n * - At least 1 special character\r\n */\r\nexport const strongPasswordRule: SchemaRule<{ minLength?: number }> = {\r\n  name: \"strongPassword\",\r\n  defaultErrorMessage:\r\n    \"The :input must be at least 8 characters and contain at least one uppercase letter, one lowercase letter, one number, and one special character\",\r\n  async validate(value: any, context) {\r\n    const password = String(value);\r\n    const minLength = this.context.options.minLength ?? 8;\r\n\r\n    // Check minimum length\r\n    if (password.length < minLength) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    // Check for at least one uppercase letter\r\n    if (!/[A-Z]/.test(password)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    // Check for at least one lowercase letter\r\n    if (!/[a-z]/.test(password)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    // Check for at least one number\r\n    if (!/[0-9]/.test(password)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    // Check for at least one special character\r\n    if (!/[!@#$%^&*()_+\\-=[\\]{};':\"\\\\|,.<>/?]/.test(password)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;;;;;;AAYA,MAAa,qBAAyD;CACpE,MAAM;CACN,qBACE;CACF,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,WAAW,OAAO,KAAK;EAC7B,MAAM,YAAY,KAAK,QAAQ,QAAQ,aAAa;EAGpD,IAAI,SAAS,SAAS,WACpB,OAAO,YAAY,MAAM,OAAO;EAIlC,IAAI,CAAC,QAAQ,KAAK,QAAQ,GACxB,OAAO,YAAY,MAAM,OAAO;EAIlC,IAAI,CAAC,QAAQ,KAAK,QAAQ,GACxB,OAAO,YAAY,MAAM,OAAO;EAIlC,IAAI,CAAC,QAAQ,KAAK,QAAQ,GACxB,OAAO,YAAY,MAAM,OAAO;EAIlC,IAAI,CAAC,sCAAsC,KAAK,QAAQ,GACtD,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}

package/esm/seal/src/rules/string/url.mjs

@@ -0,0 +1,23 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../seal/src/rules/string/url.ts
+/**
+* URL rule - validates URL format
+*/
+const urlRule = {
+	name: "url",
+	defaultErrorMessage: "The :input must be a valid URL",
+	async validate(value, context) {
+		try {
+			new URL(value);
+			return VALID_RULE;
+		} catch {
+			return invalidRule(this, context);
+		}
+	}
+};
+
+//#endregion
+export { urlRule };
+//# sourceMappingURL=url.mjs.map

package/esm/seal/src/rules/string/url.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/url.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * URL rule - validates URL format\r\n */\r\nexport const urlRule: SchemaRule = {\r\n  name: \"url\",\r\n  defaultErrorMessage: \"The :input must be a valid URL\",\r\n  async validate(value: any, context) {\r\n    try {\r\n      new URL(value);\r\n      return VALID_RULE;\r\n    } catch {\r\n      return invalidRule(this, context);\r\n    }\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,UAAsB;CACjC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI;GACF,IAAI,IAAI,KAAK;GACb,OAAO;EACT,QAAQ;GACN,OAAO,YAAY,MAAM,OAAO;EAClC;CACF;AACF"}

package/esm/seal/src/rules/string/without-whitespace.mjs

@@ -0,0 +1,19 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../seal/src/rules/string/without-whitespace.ts
+/**
+* Without whitespace rule - value must not contain whitespace
+*/
+const withoutWhitespaceRule = {
+	name: "withoutWhitespace",
+	defaultErrorMessage: "The :input must not contain whitespace",
+	async validate(value, context) {
+		if (!/\s/.test(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { withoutWhitespaceRule };
+//# sourceMappingURL=without-whitespace.mjs.map

package/esm/seal/src/rules/string/without-whitespace.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"without-whitespace.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/without-whitespace.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Without whitespace rule - value must not contain whitespace\r\n */\r\nexport const withoutWhitespaceRule: SchemaRule = {\r\n  name: \"withoutWhitespace\",\r\n  defaultErrorMessage: \"The :input must not contain whitespace\",\r\n  async validate(value: any, context) {\r\n    if (!/\\s/.test(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,wBAAoC;CAC/C,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,CAAC,KAAK,KAAK,KAAK,GAClB,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/standard-schema/json-schema.mjs

@@ -0,0 +1,81 @@
+//#region ../seal/src/standard-schema/json-schema.ts
+/**
+* Apply nullable to a JSON Schema object based on the target dialect.
+*
+* - draft-2020-12  : `type` becomes an array: `["string", "null"]`
+* - openai-strict  : same as draft-2020-12 (type array form)
+* - draft-07       : wraps in `oneOf: [{ ...schema }, { type: "null" }]`
+* - openapi-3.0    : adds `nullable: true` alongside the existing type
+*
+* Mutates the schema in-place.
+*
+* @example
+* ```ts
+* const schema = { type: "string" };
+* applyNullable(schema, "draft-2020-12");
+* // → { type: ["string", "null"] }
+* ```
+*/
+function applyNullable(schema, target) {
+	if (target === "openapi-3.0") {
+		schema.nullable = true;
+		return;
+	}
+	if (target === "draft-2020-12" || target === "openai-strict") {
+		const baseType = schema.type;
+		schema.type = Array.isArray(baseType) ? [...baseType, "null"] : [baseType, "null"];
+		return;
+	}
+	const copy = { ...schema };
+	for (const key of Object.keys(schema)) delete schema[key];
+	schema.oneOf = [copy, { type: "null" }];
+}
+/**
+* Wrap a field schema as nullable for OpenAI strict mode.
+*
+* OpenAI strict requires optional fields to be expressed as a nullable type
+* rather than being omitted from the `required` array. This helper wraps a
+* given schema into its nullable equivalent using the type-array form.
+*
+* Unlike `applyNullable()` (which mutates in-place), this returns a new
+* schema object to avoid side effects when wrapping child schemas.
+*
+* @example
+* ```ts
+* wrapNullableStrict({ type: "string", minLength: 3 })
+* // → { type: ["string", "null"], minLength: 3 }
+*
+* wrapNullableStrict({ type: "object", properties: {...} })
+* // → { type: ["object", "null"], properties: {...} }
+*
+* wrapNullableStrict({ oneOf: [...] })
+* // → { oneOf: [..., { type: "null" }] }
+* ```
+*/
+function wrapNullableStrict(schema) {
+	if (schema.oneOf) return {
+		...schema,
+		oneOf: [...schema.oneOf, { type: "null" }]
+	};
+	if (schema.anyOf) return {
+		...schema,
+		anyOf: [...schema.anyOf, { type: "null" }]
+	};
+	if (schema.type === void 0) return schema;
+	const baseType = schema.type;
+	return {
+		...schema,
+		type: Array.isArray(baseType) ? [...baseType, "null"] : [baseType, "null"]
+	};
+}
+/**
+* Find the first rule matching the given name in a rules array,
+* and return its options bag.
+*/
+function getRuleOptions(rules, ruleName) {
+	return rules.find((r) => r.name === ruleName)?.context?.options;
+}
+
+//#endregion
+export { applyNullable, getRuleOptions, wrapNullableStrict };
+//# sourceMappingURL=json-schema.mjs.map

package/esm/seal/src/standard-schema/json-schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.mjs","names":[],"sources":["../../../../../../../../../seal/src/standard-schema/json-schema.ts"],"sourcesContent":["import type { StandardJSONSchemaV1 } from \"./types\";\n\n/**\n * Supported JSON Schema generation targets.\n */\nexport type JsonSchemaTarget = StandardJSONSchemaV1.Target;\n\n/**\n * The result shape for a generated JSON Schema.\n */\nexport type JsonSchemaResult = Record<string, unknown>;\n\n/**\n * Apply nullable to a JSON Schema object based on the target dialect.\n *\n * - draft-2020-12  : `type` becomes an array: `[\"string\", \"null\"]`\n * - openai-strict  : same as draft-2020-12 (type array form)\n * - draft-07       : wraps in `oneOf: [{ ...schema }, { type: \"null\" }]`\n * - openapi-3.0    : adds `nullable: true` alongside the existing type\n *\n * Mutates the schema in-place.\n *\n * @example\n * ```ts\n * const schema = { type: \"string\" };\n * applyNullable(schema, \"draft-2020-12\");\n * // → { type: [\"string\", \"null\"] }\n * ```\n */\nexport function applyNullable(schema: JsonSchemaResult, target: JsonSchemaTarget): void {\n  if (target === \"openapi-3.0\") {\n    schema.nullable = true;\n    return;\n  }\n\n  if (target === \"draft-2020-12\" || target === \"openai-strict\") {\n    const baseType = schema.type as string | string[] | undefined;\n    schema.type = Array.isArray(baseType)\n      ? [...baseType, \"null\"]\n      : [baseType as string, \"null\"];\n    return;\n  }\n\n  // draft-07: oneOf wrapping\n  const copy = { ...schema };\n  for (const key of Object.keys(schema)) {\n    delete schema[key];\n  }\n  schema.oneOf = [copy, { type: \"null\" }];\n}\n\n/**\n * Wrap a field schema as nullable for OpenAI strict mode.\n *\n * OpenAI strict requires optional fields to be expressed as a nullable type\n * rather than being omitted from the `required` array. This helper wraps a\n * given schema into its nullable equivalent using the type-array form.\n *\n * Unlike `applyNullable()` (which mutates in-place), this returns a new\n * schema object to avoid side effects when wrapping child schemas.\n *\n * @example\n * ```ts\n * wrapNullableStrict({ type: \"string\", minLength: 3 })\n * // → { type: [\"string\", \"null\"], minLength: 3 }\n *\n * wrapNullableStrict({ type: \"object\", properties: {...} })\n * // → { type: [\"object\", \"null\"], properties: {...} }\n *\n * wrapNullableStrict({ oneOf: [...] })\n * // → { oneOf: [..., { type: \"null\" }] }\n * ```\n */\nexport function wrapNullableStrict(schema: JsonSchemaResult): JsonSchemaResult {\n  // If the schema uses oneOf/anyOf (e.g. union), append null to the list\n  if (schema.oneOf) {\n    return { ...schema, oneOf: [...(schema.oneOf as unknown[]), { type: \"null\" }] };\n  }\n\n  if (schema.anyOf) {\n    return { ...schema, anyOf: [...(schema.anyOf as unknown[]), { type: \"null\" }] };\n  }\n\n  // If there's no type at all (permissive `{}`), stay permissive\n  if (schema.type === undefined) {\n    return schema;\n  }\n\n  // Standard case: wrap type into array with null\n  const baseType = schema.type as string | string[];\n  return {\n    ...schema,\n    type: Array.isArray(baseType) ? [...baseType, \"null\"] : [baseType, \"null\"],\n  };\n}\n\n/**\n * Find the first rule matching the given name in a rules array,\n * and return its options bag.\n */\nexport function getRuleOptions(\n  rules: Array<{ name: string; context: { options: Record<string, unknown> } }>,\n  ruleName: string,\n): Record<string, unknown> | undefined {\n  const rule = rules.find(r => r.name === ruleName);\n  return rule?.context?.options as Record<string, unknown> | undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA6BA,SAAgB,cAAc,QAA0B,QAAgC;CACtF,IAAI,WAAW,eAAe;EAC5B,OAAO,WAAW;EAClB;CACF;CAEA,IAAI,WAAW,mBAAmB,WAAW,iBAAiB;EAC5D,MAAM,WAAW,OAAO;EACxB,OAAO,OAAO,MAAM,QAAQ,QAAQ,IAChC,CAAC,GAAG,UAAU,MAAM,IACpB,CAAC,UAAoB,MAAM;EAC/B;CACF;CAGA,MAAM,OAAO,EAAE,GAAG,OAAO;CACzB,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,GAClC,OAAO,OAAO;CAEhB,OAAO,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC;AACxC;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,mBAAmB,QAA4C;CAE7E,IAAI,OAAO,OACT,OAAO;EAAE,GAAG;EAAQ,OAAO,CAAC,GAAI,OAAO,OAAqB,EAAE,MAAM,OAAO,CAAC;CAAE;CAGhF,IAAI,OAAO,OACT,OAAO;EAAE,GAAG;EAAQ,OAAO,CAAC,GAAI,OAAO,OAAqB,EAAE,MAAM,OAAO,CAAC;CAAE;CAIhF,IAAI,OAAO,SAAS,QAClB,OAAO;CAIT,MAAM,WAAW,OAAO;CACxB,OAAO;EACL,GAAG;EACH,MAAM,MAAM,QAAQ,QAAQ,IAAI,CAAC,GAAG,UAAU,MAAM,IAAI,CAAC,UAAU,MAAM;CAC3E;AACF;;;;;AAMA,SAAgB,eACd,OACA,UACqC;CAErC,OADa,MAAM,MAAK,MAAK,EAAE,SAAS,QAC9B,CAAC,EAAE,SAAS;AACxB"}

package/esm/seal/src/standard-schema/map-result.mjs

@@ -0,0 +1,26 @@
+//#region ../seal/src/standard-schema/map-result.ts
+/**
+* Maps a Seal ValidationResult to a Standard Schema result shape.
+*
+* Seal error paths are dot-notation strings (e.g. "address.city").
+* Standard Schema expects an array of path segments: [{ key: "address" }, { key: "city" }].
+*
+* @example
+* ```ts
+* const result = await validator.validate(value, context);
+* return mapToStandardResult(result);
+* // Success → { value: <data> }
+* // Failure → { issues: [{ message: "...", path: [{ key: "..." }] }] }
+* ```
+*/
+function mapToStandardResult(result) {
+	if (result.isValid) return { value: result.data };
+	return { issues: result.errors.map((e) => ({
+		message: e.error,
+		path: e.input ? e.input.split(".").map((key) => ({ key })) : void 0
+	})) };
+}
+
+//#endregion
+export { mapToStandardResult };
+//# sourceMappingURL=map-result.mjs.map

package/esm/seal/src/standard-schema/map-result.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-result.mjs","names":[],"sources":["../../../../../../../../../seal/src/standard-schema/map-result.ts"],"sourcesContent":["import type { ValidationResult } from \"../types\";\nimport type { StandardSchemaV1 } from \"./types\";\n\n/**\n * Maps a Seal ValidationResult to a Standard Schema result shape.\n *\n * Seal error paths are dot-notation strings (e.g. \"address.city\").\n * Standard Schema expects an array of path segments: [{ key: \"address\" }, { key: \"city\" }].\n *\n * @example\n * ```ts\n * const result = await validator.validate(value, context);\n * return mapToStandardResult(result);\n * // Success → { value: <data> }\n * // Failure → { issues: [{ message: \"...\", path: [{ key: \"...\" }] }] }\n * ```\n */\nexport function mapToStandardResult(\n  result: ValidationResult,\n): StandardSchemaV1.Result<unknown> {\n  if (result.isValid) {\n    return { value: result.data };\n  }\n\n  return {\n    issues: result.errors.map(e => ({\n      message: e.error,\n      path: e.input\n        ? e.input.split(\".\").map(key => ({ key }))\n        : undefined,\n    })),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAiBA,SAAgB,oBACd,QACkC;CAClC,IAAI,OAAO,SACT,OAAO,EAAE,OAAO,OAAO,KAAK;CAG9B,OAAO,EACL,QAAQ,OAAO,OAAO,KAAI,OAAM;EAC9B,SAAS,EAAE;EACX,MAAM,EAAE,QACJ,EAAE,MAAM,MAAM,GAAG,CAAC,CAAC,KAAI,SAAQ,EAAE,IAAI,EAAE,IACvC;CACN,EAAE,EACJ;AACF"}

package/esm/seal/src/types/date-types.mjs

@@ -0,0 +1,17 @@
+//#region ../seal/src/types/date-types.ts
+/**
+* Week day numbers mapping
+*/
+const WEEK_DAYS = {
+	sunday: 0,
+	monday: 1,
+	tuesday: 2,
+	wednesday: 3,
+	thursday: 4,
+	friday: 5,
+	saturday: 6
+};
+
+//#endregion
+export { WEEK_DAYS };
+//# sourceMappingURL=date-types.mjs.map

package/esm/seal/src/types/date-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-types.mjs","names":[],"sources":["../../../../../../../../../seal/src/types/date-types.ts"],"sourcesContent":["/**\r\n * Week day names for validation\r\n */\r\nexport type WeekDay =\r\n  | \"sunday\"\r\n  | \"monday\"\r\n  | \"tuesday\"\r\n  | \"wednesday\"\r\n  | \"thursday\"\r\n  | \"friday\"\r\n  | \"saturday\";\r\n\r\n/**\r\n * Week day numbers mapping\r\n */\r\nexport const WEEK_DAYS: Record<WeekDay, number> = {\r\n  sunday: 0,\r\n  monday: 1,\r\n  tuesday: 2,\r\n  wednesday: 3,\r\n  thursday: 4,\r\n  friday: 5,\r\n  saturday: 6,\r\n};\r\n"],"mappings":";;;;AAeA,MAAa,YAAqC;CAChD,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,WAAW;CACX,UAAU;CACV,QAAQ;CACR,UAAU;AACZ"}

package/esm/seal/src/validators/any-validator.mjs

@@ -0,0 +1,38 @@
+import { applyNullable } from "../standard-schema/json-schema.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+
+//#region ../seal/src/validators/any-validator.ts
+/**
+* Any validator - accepts any value
+*/
+var AnyValidator = class extends BaseValidator {
+	/**
+	* Any validator means any value, so we disable the default required requirement.
+	*/
+	requiredRule = null;
+	/**
+	* Set is optional to be true
+	*/
+	isOptional = true;
+	/**
+	* @inheritdoc
+	*
+	* Any validator accepts anything. In JSON Schema, an empty object `{}`
+	* is the permissive schema that accepts any valid JSON value.
+	*
+	* @example
+	* ```ts
+	* v.any().toJsonSchema("draft-2020-12")
+	* // → {}
+	* ```
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		const schema = {};
+		if (this.isNullable) applyNullable(schema, target);
+		return schema;
+	}
+};
+
+//#endregion
+export { AnyValidator };
+//# sourceMappingURL=any-validator.mjs.map

package/esm/seal/src/validators/any-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"any-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/any-validator.ts"],"sourcesContent":["import type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\r\nimport { applyNullable } from \"../standard-schema/json-schema\";\r\nimport { BaseValidator } from \"./base-validator\";\r\n\r\n/**\r\n * Any validator - accepts any value\r\n */\r\nexport class AnyValidator extends BaseValidator {\r\n  /**\r\n   * Any validator means any value, so we disable the default required requirement.\r\n   */\r\n  public override requiredRule = null;\r\n\r\n  /**\r\n   * Set is optional to be true\r\n   */\r\n  public override isOptional = true;\r\n\r\n  /**\r\n   * @inheritdoc\r\n   *\r\n   * Any validator accepts anything. In JSON Schema, an empty object `{}`\r\n   * is the permissive schema that accepts any valid JSON value.\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * v.any().toJsonSchema(\"draft-2020-12\")\r\n   * // → {}\r\n   * ```\r\n   */\r\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\r\n    const schema: JsonSchemaResult = {};\r\n    if (this.isNullable) applyNullable(schema, target);\r\n    return schema;\r\n  }\r\n}\r\n"],"mappings":";;;;;;;AAOA,IAAa,eAAb,cAAkC,cAAc;;;;CAI9C,AAAgB,eAAe;;;;CAK/B,AAAgB,aAAa;;;;;;;;;;;;;CAc7B,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,MAAM,SAA2B,CAAC;EAClC,IAAI,KAAK,YAAY,cAAc,QAAQ,MAAM;EACjD,OAAO;CACT;AACF"}