@warlock.js/seal 4.0.174 → 4.1.2

package/esm/rules/string/pattern.mjs

@@ -0,0 +1,20 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/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/rules/string/pattern.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.mjs","names":[],"sources":["../../../../../../../@warlock.js/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/rules/string/string-comparison.d.mts

@@ -0,0 +1,30 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/string-comparison.d.ts
+/**
+ * Starts with rule
+ */
+declare const startsWithRule: SchemaRule<{
+  value: string;
+}>;
+/**
+ * Ends with rule
+ */
+declare const endsWithRule: SchemaRule<{
+  value: string;
+}>;
+/**
+ * Contains rule
+ */
+declare const containsRule: SchemaRule<{
+  value: string;
+}>;
+/**
+ * Not contains rule
+ */
+declare const notContainsRule: SchemaRule<{
+  value: string;
+}>;
+//#endregion
+export { containsRule, endsWithRule, notContainsRule, startsWithRule };
+//# sourceMappingURL=string-comparison.d.mts.map

package/esm/rules/string/string-comparison.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-comparison.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/string-comparison.ts"],"mappings":";;;;;AAMA;cAAa,cAAA,EAAgB,UAAU;EAAG,KAAK;AAAA;AAAA;AAiB/C;;AAjB+C,cAiBlC,YAAA,EAAc,UAAU;EAAG,KAAK;AAAA;AAiB7C;;;AAAA,cAAa,YAAA,EAAc,UAAU;EAAG,KAAK;AAAA;;;;cAiBhC,eAAA,EAAiB,UAAU;EAAG,KAAK;AAAA"}

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

@@ -0,0 +1,56 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/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/rules/string/string-comparison.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-comparison.mjs","names":[],"sources":["../../../../../../../@warlock.js/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,EAAE,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,EAAE,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,EAAE,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,EAAE,SAAS,KAAK,QAAQ,QAAQ,KAAK,GACpD,OAAO;EAGT,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/string/strong-password-rule.d.mts

@@ -0,0 +1,18 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/strong-password-rule.d.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
+ */
+declare const strongPasswordRule: SchemaRule<{
+  minLength?: number;
+}>;
+//#endregion
+export { strongPasswordRule };
+//# sourceMappingURL=strong-password-rule.d.mts.map

package/esm/rules/string/strong-password-rule.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strong-password-rule.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/strong-password-rule.ts"],"mappings":";;;;;AAYA;;;;AAAuD;;;cAA1C,kBAAA,EAAoB,UAAU;EAAG,SAAS;AAAA"}

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

@@ -0,0 +1,31 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/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/rules/string/strong-password-rule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"strong-password-rule.mjs","names":[],"sources":["../../../../../../../@warlock.js/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/rules/string/url.d.mts

@@ -0,0 +1,10 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/url.d.ts
+/**
+ * URL rule - validates URL format
+ */
+declare const urlRule: SchemaRule;
+//#endregion
+export { urlRule };
+//# sourceMappingURL=url.d.mts.map

package/esm/rules/string/url.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/url.ts"],"mappings":";;;;;AAMA;cAAa,OAAA,EAAS,UAWrB"}

package/esm/rules/string/url.mjs

@@ -0,0 +1,23 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/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/rules/string/url.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.mjs","names":[],"sources":["../../../../../../../@warlock.js/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/rules/string/without-whitespace.d.mts

@@ -0,0 +1,10 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/string/without-whitespace.d.ts
+/**
+ * Without whitespace rule - value must not contain whitespace
+ */
+declare const withoutWhitespaceRule: SchemaRule;
+//#endregion
+export { withoutWhitespaceRule };
+//# sourceMappingURL=without-whitespace.d.mts.map

package/esm/rules/string/without-whitespace.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"without-whitespace.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/string/without-whitespace.ts"],"mappings":";;;;;AAMA;cAAa,qBAAA,EAAuB,UASnC"}

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

@@ -0,0 +1,19 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/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/rules/string/without-whitespace.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"without-whitespace.mjs","names":[],"sources":["../../../../../../../@warlock.js/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/standard-schema/json-schema.d.mts

@@ -0,0 +1,65 @@
+import { StandardJSONSchemaV1 } from "./types.mjs";
+
+//#region ../../@warlock.js/seal/src/standard-schema/json-schema.d.ts
+/**
+ * Supported JSON Schema generation targets.
+ */
+type JsonSchemaTarget = StandardJSONSchemaV1.Target;
+/**
+ * The result shape for a generated JSON Schema.
+ */
+type JsonSchemaResult = Record<string, unknown>;
+/**
+ * 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"] }
+ * ```
+ */
+declare function applyNullable(schema: JsonSchemaResult, target: JsonSchemaTarget): void;
+/**
+ * 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" }] }
+ * ```
+ */
+declare function wrapNullableStrict(schema: JsonSchemaResult): JsonSchemaResult;
+/**
+ * Find the first rule matching the given name in a rules array,
+ * and return its options bag.
+ */
+declare function getRuleOptions(rules: Array<{
+  name: string;
+  context: {
+    options: Record<string, unknown>;
+  };
+}>, ruleName: string): Record<string, unknown> | undefined;
+//#endregion
+export { JsonSchemaResult, JsonSchemaTarget, applyNullable, getRuleOptions, wrapNullableStrict };
+//# sourceMappingURL=json-schema.d.mts.map

package/esm/standard-schema/json-schema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/standard-schema/json-schema.ts"],"mappings":";;;;;AAKA;KAAY,gBAAA,GAAmB,oBAAA,CAAqB,MAAM;;;AAAA;KAK9C,gBAAA,GAAmB,MAAM;;;;AAAA;AAmBrC;;;;;;;;;AAAgF;AA4ChF;;;iBA5CgB,aAAA,CAAc,MAAA,EAAQ,gBAAA,EAAkB,MAAA,EAAQ,gBAAgB;;;;;AA4CF;AA2B9E;;;;;;;;;;;;;;;;;iBA3BgB,kBAAA,CAAmB,MAAA,EAAQ,gBAAA,GAAmB,gBAAgB;;;;;iBA2B9D,cAAA,CACd,KAAA,EAAO,KAAA;EAAQ,IAAA;EAAc,OAAA;IAAW,OAAA,EAAS,MAAA;EAAA;AAAA,IACjD,QAAA,WACC,MAAA"}

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

@@ -0,0 +1,81 @@
+//#region ../../@warlock.js/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/standard-schema/json-schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.mjs","names":[],"sources":["../../../../../../@warlock.js/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,GAAG,SAAS;AACxB"}

package/esm/standard-schema/map-result.d.mts

@@ -0,0 +1,22 @@
+import { StandardSchemaV1 } from "./types.mjs";
+import { ValidationResult } from "../types/result-types.mjs";
+
+//#region ../../@warlock.js/seal/src/standard-schema/map-result.d.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: "..." }] }] }
+ * ```
+ */
+declare function mapToStandardResult(result: ValidationResult): StandardSchemaV1.Result<unknown>;
+//#endregion
+export { mapToStandardResult };
+//# sourceMappingURL=map-result.d.mts.map

package/esm/standard-schema/map-result.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-result.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/standard-schema/map-result.ts"],"mappings":";;;;;;AAiBA;;;;;;;;;AAE0B;;;iBAFV,mBAAA,CACd,MAAA,EAAQ,gBAAA,GACP,gBAAA,CAAiB,MAAM"}

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

@@ -0,0 +1,26 @@
+//#region ../../@warlock.js/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/standard-schema/map-result.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-result.mjs","names":[],"sources":["../../../../../../@warlock.js/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,EAAE,KAAI,SAAQ,EAAE,IAAI,EAAE,IACvC;CACN,EAAE,EACJ;AACF"}

package/esm/standard-schema/types.d.mts

@@ -0,0 +1,96 @@
+//#region ../../@warlock.js/seal/src/standard-schema/types.d.ts
+/**
+ * Standard Schema Spec Types
+ *
+ * Copied from @standard-schema/spec to avoid a runtime dependency.
+ * Source: https://standardschema.dev
+ *
+ * Implements:
+ *  - StandardSchemaV1  — for validation interop (OpenAI, LangGraph, TanStack Form, Conform, etc.)
+ *  - StandardJSONSchemaV1 — for JSON Schema generation (OpenAPI, draft-07, draft-2020-12)
+ */
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** Success result. */
+  interface SuccessResult<Output> {
+    readonly value: Output;
+    readonly issues?: undefined;
+  }
+  /** Options passed to validate. */
+  interface Options {
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** Failure result. */
+  interface FailureResult {
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** Issue in a failed result. */
+  interface Issue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** A single segment in an issue path. */
+  interface PathSegment {
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    readonly input: Input;
+    readonly output: Output;
+  }
+  /** Infer the input type of a Standard Schema. */
+  type InferInput<S extends StandardSchemaV1> = NonNullable<S["~standard"]["types"]>["input"];
+  /** Infer the output type of a Standard Schema. */
+  type InferOutput<S extends StandardSchemaV1> = NonNullable<S["~standard"]["types"]>["output"];
+}
+/** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+  interface Props<Input = unknown, Output = Input> extends Omit<StandardSchemaV1.Props<Input, Output>, never> {
+    readonly jsonSchema: Converter;
+  }
+  /** Methods for generating JSON Schema. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. */
+    readonly input: (options: Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. */
+    readonly output: (options: Options) => Record<string, unknown>;
+  }
+  /**
+   * Supported JSON Schema targets.
+   * Libraries should throw if a target is not supported.
+   *
+   * - `draft-2020-12`  — JSON Schema 2020-12 (default, recommended)
+   * - `draft-07`       — JSON Schema draft-07 (Swagger 2.0, older tooling)
+   * - `openapi-3.0`    — OpenAPI 3.0 extensions (nullable: true)
+   * - `openai-strict`  — OpenAI Structured Outputs strict mode.
+   *                      All fields listed in required; optional fields
+   *                      expressed as `{ type: ["T", "null"] }` instead
+   *                      of being omitted from required.
+   */
+  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | "openai-strict" | ({} & string);
+  interface Options {
+    readonly target: Target;
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+}
+//#endregion
+export { StandardJSONSchemaV1, StandardSchemaV1 };
+//# sourceMappingURL=types.d.mts.map

package/esm/standard-schema/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/standard-schema/types.ts"],"mappings":";;AAgBA;;;;;;;;;;UAAiB,gBAAA,2BAA2C,KAAA;EAAA,SACjD,WAAA,EAAa,gBAAA,CAAiB,KAAA,CAAM,KAAA,EAAO,MAAA;AAAA;AAAA,kBAG7B,gBAAA;EAHgB;EAAA,UAKtB,KAAA,2BAAgC,KAAA;IALG;IAAA,SAOzC,OAAA;IAP+C;IAAA,SAS/C,MAAA;IAN4B;IAAA,SAQ5B,KAAA,GAAQ,KAAA,CAAM,KAAA,EAAO,MAAA;IANiB;IAAA,SAQtC,QAAA,GACP,KAAA,WACA,OAAA,GAAU,OAAA,iBACP,MAAA,CAAO,MAAA,IAAU,OAAA,CAAQ,MAAA,CAAO,MAAA;EAAA;EALpB;EAAA,UASF,aAAA;IAAA,SACN,KAAA,EAAO,MAAA;IAAA,SACP,MAAA;EAAA;EANqB;EAAA,UAUf,OAAA;IAAA,SACN,cAAA,GAAiB,MAAA;EAAA;EAKK;EAAA,UADhB,aAAA;IAAA,SACN,MAAA,EAAQ,aAAA,CAAc,KAAA;EAAA;EAAA,KAGrB,MAAA,WAAiB,aAAA,CAAc,MAAA,IAAU,aAAA;EAKrB;EAAA,UAFf,KAAA;IAAA,SACN,OAAA;IAAA,SACA,IAAA,GAAO,aAAA,CAAc,WAAA,GAAc,WAAA;EAAA;EAU5B;EAAA,UAND,WAAA;IAAA,SACN,GAAA,EAAK,WAAA;EAAA;EAUqC;EAAA,UANpC,KAAA,2BAAgC,KAAA;IAAA,SACtC,KAAA,EAAO,KAAA;IAAA,SACP,MAAA,EAAQ,MAAA;EAAA;EAS8C;EAAA,KALrD,UAAA,WAAqB,gBAAA,IAAoB,WAAA,CACnD,CAAA;EAnDqB;EAAA,KAuDX,WAAA,WAAsB,gBAAA,IAAoB,WAAA,CACpD,CAAA;AAAA;;UASa,oBAAA,2BAA+C,KAAA;EAAA,SACrD,WAAA,EAAa,oBAAA,CAAqB,KAAA,CAAM,KAAA,EAAO,MAAA;AAAA;AAAA,kBAGjC,oBAAA;EAAA,UACN,KAAA,2BAAgC,KAAA,UACvC,IAAA,CAAK,gBAAA,CAAiB,KAAA,CAAM,KAAA,EAAO,MAAA;IAAA,SAClC,UAAA,EAAY,SAAA;EAAA;EA9DT;EAAA,UAkEG,SAAA;IAjEV;IAAA,SAmEI,KAAA,GAAQ,OAAA,EAAS,OAAA,KAAY,MAAA;IAnEhB;IAAA,SAqEb,MAAA,GAAS,OAAA,EAAS,OAAA,KAAY,MAAA;EAAA;EAjExB;;;;;;;;;;;;EAAA,KAgFL,MAAA;EAAA,UAOK,OAAA;IAAA,SACN,MAAA,EAAQ,MAAA;IAAA,SACR,cAAA,GAAiB,MAAA;EAAA;AAAA"}

package/esm/types/conditional-types.d.mts

@@ -0,0 +1,15 @@
+import { BaseValidator } from "../validators/base-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/types/conditional-types.d.ts
+/**
+ * Options for conditional when rule
+ */
+type WhenRuleOptions = {
+  /** Field name to check */field: string; /** Map of field values to validators */
+  is: Record<string, BaseValidator>; /** Fallback validator if no condition matches */
+  otherwise?: BaseValidator; /** Whether to check in global context or sibling context (default: "global") */
+  scope?: "global" | "sibling";
+};
+//#endregion
+export { WhenRuleOptions };
+//# sourceMappingURL=conditional-types.d.mts.map

package/esm/types/conditional-types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-types.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/types/conditional-types.ts"],"mappings":";;;;;AAKA;KAAY,eAAA;4BAEV,KAAA,UAEI;EAAJ,EAAA,EAAI,MAAA,SAAe,aAAA,GAEM;EAAzB,SAAA,GAAY,aAAA,EAJZ;EAMA,KAAA;AAAA"}