@sanity/validation 3.14.4 → 6.12.0-next.32

package/lib/validateDocument-il4G-TLy.js

@@ -0,0 +1,828 @@
+import { isArrayOfBlocksSchemaType, isKeyedObject, isReference, isSlug, isTypedObject } from "@sanity/types";
+import { createClientConcurrencyLimiter } from "@sanity/util/client";
+import { ConcurrencyLimiter } from "@sanity/util/concurrency-limiter";
+import flatten from "lodash-es/flatten.js";
+import uniqBy from "lodash-es/uniqBy.js";
+import { Observable, Subject, bufferTime, concat, defer, filter, finalize, firstValueFrom, from, lastValueFrom, map, merge, mergeMap, of, share, switchMap } from "rxjs";
+import { catchError, map as map$1, mergeAll, mergeMap as mergeMap$1, switchMap as switchMap$1, toArray } from "rxjs/operators";
+import { createInstance } from "i18next";
+import isEqual from "lodash-es/isEqual.js";
+import { Rule as Rule$1 } from "@sanity/schema";
+import get from "lodash-es/get.js";
+import isPlainObject from "lodash-es/isPlainObject.js";
+import * as legacyDateFormat from "@sanity/util/legacyDateFormat";
+import { getPublishedId } from "@sanity/id-utils";
+import memoize from "lodash-es/memoize.js";
+const validationLocaleStrings = {
+	"array.exact-length": "Must have exactly {{wantedLength}} items",
+	"array.exact-length_blocks": "Must have exactly {{wantedLength}} blocks",
+	"array.item-duplicate": "Can't be a duplicate",
+	"array.maximum-length": "Must have at most {{maxLength}} items",
+	"array.maximum-length_blocks": "Must have at most {{maxLength}} blocks",
+	"array.minimum-length": "Must have at least {{minLength}} items",
+	"array.minimum-length_blocks": "Must have at least {{minLength}} blocks",
+	"date.invalid-format": "Must be a valid ISO-8601 formatted date string",
+	"date.maximum": "Must be at or before {{maxDate}}",
+	"date.minimum": "Must be at or after {{minDate}}",
+	"generic.incorrect-type": "Expected type \"{{expectedType}}\", got \"{{actualType}}\"",
+	"generic.not-allowed": "Value did not match any allowed values",
+	"generic.not-allowed_hint": "Value \"{{hint}}\" did not match any allowed values",
+	"generic.required": "Required",
+	"number.greater-than": "Must be greater than {{threshold}}",
+	"number.less-than": "Must be less than {{threshold}}",
+	"number.maximum": "Must be lower than or equal to {{maxNumber}}",
+	"number.maximum-precision": "Max precision is {{limit}}",
+	"number.minimum": "Must be greater than or equal to {{minNumber}}",
+	"number.non-integer": "Must be an integer",
+	"object.asset-required": "Asset is required",
+	"object.asset-required_file": "File is required",
+	"object.asset-required_image": "Image is required",
+	"object.media-not-found": "The asset could not be found in the Media Library",
+	"object.not-media-library-asset": "Must be a reference to a Media Library asset",
+	"object.not-reference": "Must be a reference to a document",
+	"object.reference-not-published": "Referenced document must be published",
+	"slug.missing-current": "Slug must have a value",
+	"slug.not-object": "Slug must be an object",
+	"slug.not-unique": "Slug is already in use",
+	"string.email": "Must be a valid email address",
+	"string.exact-length": "Must be exactly {{wantedLength}} characters long",
+	"string.lowercase": "Must be all lowercase characters",
+	"string.maximum-length": "Must be at most {{maxLength}} characters long",
+	"string.minimum-length": "Must be at least {{minLength}} characters long",
+	"string.regex-does-not-match": "Does not match \"{{name}}\"-pattern",
+	"string.regex-match": "Should not match \"{{name}}\"-pattern",
+	"string.uppercase": "Must be all uppercase characters",
+	"string.url.disallowed-scheme": "Does not match allowed protocols/schemes",
+	"string.url.includes-credentials": "Username/password not allowed",
+	"string.url.invalid": "Not a valid URL",
+	"string.url.not-absolute": "Relative URLs are not allowed",
+	"string.url.not-relative": "Only relative URLs are allowed"
+};
+let fallbackLocaleSource;
+function getFallbackLocaleSource() {
+	if (fallbackLocaleSource) return fallbackLocaleSource;
+	let i18n = createInstance({
+		defaultNS: "validation",
+		fallbackLng: "en-US",
+		initAsync: !1,
+		interpolation: { escapeValue: !1 },
+		lng: "en-US",
+		ns: ["validation"],
+		resources: { "en-US": { validation: validationLocaleStrings } },
+		supportedLngs: ["en-US"]
+	});
+	return i18n.init(), fallbackLocaleSource = {
+		currentLocale: { id: "en-US" },
+		loadNamespaces: (namespaces) => i18n.loadNamespaces(namespaces),
+		t: i18n.t
+	}, fallbackLocaleSource;
+}
+function resolveConditionalProperty(property, context) {
+	let { currentUser, document, parent, value, path } = context;
+	return typeof property == "boolean" || property === void 0 ? !!property : property({
+		document,
+		parent,
+		value,
+		currentUser,
+		path
+	}) === !0;
+}
+function createBatchedGetDocumentExists(client) {
+	let id$ = new Subject(), limiter = new ConcurrencyLimiter(1), existence$ = id$.pipe(bufferTime(250, null, 100), map((ids) => Array.from(new Set(ids))), mergeMap((ids) => from(limiter.ready()).pipe(switchMap(() => client.observable.request({
+		url: client.getDataUrl("doc", ids.join(",")),
+		query: { excludeContent: "true" },
+		tag: "documents-availability"
+	}).pipe(map((availability) => ({
+		availability,
+		ids
+	})))), finalize(limiter.release))), mergeMap(({ availability, ids }) => ids.map((id) => {
+		let omittedIds = availability.omitted.reduce((acc, next) => (acc[next.id] = next.reason, acc), {});
+		return omittedIds[id] && omittedIds[id] === "existence" ? {
+			id,
+			exists: !1
+		} : {
+			id,
+			exists: !0
+		};
+	})), share());
+	return async function getDocumentExists(options) {
+		let result = firstValueFrom(existence$.pipe(filter(({ id }) => id === options.id)));
+		id$.next(options.id);
+		let { exists } = await result;
+		return exists;
+	};
+}
+function pathToString(path = []) {
+	return path.reduce((target, segment, i) => {
+		let segmentType = typeof segment;
+		if (segmentType === "number") return `${target}[${segment}]`;
+		if (segmentType === "string") return `${target}${i === 0 ? "" : "."}${segment}`;
+		if (isKeyedObject(segment)) return `${target}[_key=="${segment._key}"]`;
+		throw Error(`Unsupported path segment "${segment}"`);
+	}, "");
+}
+function isNonNullable(t) {
+	return t !== null || t !== void 0;
+}
+function convertToValidationMarker(validatorResult, level, context) {
+	if (!context) throw Error("missing context");
+	if (validatorResult === !0) return [];
+	if (Array.isArray(validatorResult)) return validatorResult.flatMap((child) => convertToValidationMarker(child, level, context)).filter(isNonNullable);
+	if (typeof validatorResult == "string") return convertToValidationMarker({ message: validatorResult }, level, context);
+	if (typeof validatorResult.message != "string") throw Error(`${pathToString(context.path)}: Validator must return 'true' if valid or an error message as a string on errors`);
+	let { message, __internal_metadata } = validatorResult, normalizedPaths = [];
+	validatorResult.path && normalizedPaths.push(validatorResult.path);
+	for (let path of validatorResult.paths || []) normalizedPaths.push(path);
+	return normalizedPaths.length ? normalizedPaths.map((path) => ({
+		path: (context.path || []).concat(path),
+		level: level || "error",
+		item: { message },
+		message,
+		__internal_metadata
+	})) : [{
+		level: level || "error",
+		item: { message },
+		message,
+		path: context.path || [],
+		__internal_metadata
+	}];
+}
+/**
+* Extracts the correct localized validation message based on given locale source
+*
+* @param message - Localized messages to extract string from
+* @param i18n - Locale source, holding the current locale
+* @returns The localized string, or a fallback "Unknown error" if not found
+* @internal
+*/
+function localizeMessage(message, i18n) {
+	let { currentLocale } = i18n, locale = currentLocale.id;
+	if (message[locale]) return message[locale];
+	if (locale.includes("-")) {
+		let language = locale.split("-", 1)[0];
+		if (message[language]) return message[language];
+	}
+	return message["en-US"] || message["en-GB"] || message.en || "Unknown validation error (not localized)";
+}
+/**
+* Check if passed message/result is a localized message object
+*
+* @param message - Message to check
+* @returns True if message is a localized message object, false otherwise
+* @internal
+*/
+function isLocalizedMessages(message) {
+	return message !== !0 && message !== void 0 && typeof message != "string" && isPlainObject(message) && !("message" in message);
+}
+/**
+* Modified version of fast-deep-equal (https://github.com/epoberezkin/fast-deep-equal)
+* MIT-licensed, copyright (c) 2017 Evgeny Poberezkin
+**/
+function deepEqualsIgnoreKey(a, b) {
+	if (a === b) return !0;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length != b.length) return !1;
+		for (let i = 0; i < a.length; i++) if (!deepEqualsIgnoreKey(a[i], b[i])) return !1;
+		return !0;
+	}
+	if (Array.isArray(a) != Array.isArray(b)) return !1;
+	if (a && b && typeof a == "object" && typeof b == "object") {
+		let keys = Object.keys(a);
+		if (keys.length !== Object.keys(b).length) return !1;
+		if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+		if (a instanceof Date != b instanceof Date) return !1;
+		if (a instanceof RegExp && b instanceof RegExp) return a.toString() == b.toString();
+		if (a instanceof RegExp != b instanceof RegExp) return !1;
+		for (let i = 0; i < keys.length; i++) if (keys[i] !== "_key" && !Object.prototype.hasOwnProperty.call(b, keys[i])) return !1;
+		for (let i = 0; i < keys.length; i++) {
+			let key = keys[i];
+			if (key !== "_key" && !deepEqualsIgnoreKey(a[key], b[key])) return !1;
+		}
+		return !0;
+	}
+	return !1;
+}
+const _toString = {}.toString, builtIns = [
+	Object,
+	Function,
+	Array,
+	String,
+	Boolean,
+	Number,
+	Date,
+	RegExp,
+	Error
+];
+function isBuiltIn(_constructor) {
+	for (let i = 0; i < builtIns.length; i++) if (builtIns[i] === _constructor) return !0;
+	return !1;
+}
+function typeString(obj) {
+	let stringType = _toString.call(obj).slice(8, -1);
+	if (obj == null) return stringType.toLowerCase();
+	let constructorType = obj.constructor;
+	return constructorType && !isBuiltIn(constructorType) ? constructorType.name : stringType;
+}
+const SLOW_VALIDATOR_TIMEOUT = 5e3, formatValidationErrors = (options) => options.message ? options.message : options.results.length === 1 ? options.results[0]?.message : options.i18n.t("{{messages, list}}", {
+	messages: options.results.map((err) => err.message || err.item?.message),
+	formatParams: { messages: {
+		style: "long",
+		type: options.operation
+	} }
+}), genericValidators = {
+	type: (expectedType, value, message, { i18n }) => {
+		let actualType = typeString(value);
+		return actualType !== expectedType && actualType !== "undefined" ? message || i18n.t("validation:generic.incorrect-type", {
+			actualType,
+			expectedType
+		}) : !0;
+	},
+	presence: (expected, value, message, { i18n }) => value === void 0 && expected === "required" ? message || i18n.t("validation:generic.required") : !0,
+	all: async (children, value, message, context) => {
+		let results = (await Promise.all(children.map((child) => child.validate(value, context)))).flat();
+		return results.length === 0 || formatValidationErrors({
+			message,
+			results,
+			operation: "conjunction",
+			i18n: context.i18n
+		});
+	},
+	either: async (children, value, message, context) => {
+		let resolved = await Promise.all(children.map((child) => child.validate(value, context))), results = resolved.flat();
+		return resolved.find((result) => !result.length) ? !0 : formatValidationErrors({
+			message,
+			results,
+			operation: "disjunction",
+			i18n: context.i18n
+		});
+	},
+	valid: (allowedValues, actual, message, { i18n }) => {
+		let valueType = typeof actual;
+		if (valueType === "undefined") return !0;
+		let value = (valueType === "number" || valueType === "string") && `${actual}`, strValue = value && value.length > 30 ? `${value.slice(0, 30)}…` : value;
+		return allowedValues.some((expected) => deepEqualsIgnoreKey(expected, actual)) ? !0 : message || i18n.t("validation:generic.not-allowed", value ? {
+			context: "hint",
+			replace: { hint: strValue }
+		} : {});
+	},
+	custom: async (fn, value, message, context) => {
+		let slowTimer = setTimeout(() => {
+			context.environment === "studio" && console.warn(`Custom validator at ${pathToString(context.path)} has taken more than ${SLOW_VALIDATOR_TIMEOUT}ms to respond`);
+		}, SLOW_VALIDATOR_TIMEOUT), result;
+		try {
+			result = await fn(value, context);
+		} finally {
+			clearTimeout(slowTimer);
+		}
+		return isLocalizedMessages(result) ? localizeMessage(result, context.i18n) : typeof result == "string" && message || result;
+	}
+}, arrayValidators = {
+	...genericValidators,
+	min: (minLength, value, message, { i18n, type }) => {
+		if (!value || value.length >= minLength) return !0;
+		let context = isArrayOfBlocksSchemaType(type) ? "blocks" : void 0;
+		return message || i18n.t("validation:array.minimum-length", {
+			minLength,
+			context
+		});
+	},
+	max: (maxLength, value, message, { i18n, type }) => {
+		if (!value || value.length <= maxLength) return !0;
+		let context = isArrayOfBlocksSchemaType(type) ? "blocks" : void 0;
+		return message || i18n.t("validation:array.maximum-length", {
+			maxLength,
+			context
+		});
+	},
+	length: (wantedLength, value, message, { i18n, type }) => {
+		if (!value || value.length === wantedLength) return !0;
+		let context = isArrayOfBlocksSchemaType(type) ? "blocks" : void 0;
+		return message || i18n.t("validation:array.exact-length", {
+			wantedLength,
+			context
+		});
+	},
+	presence: (flag, value, message, { i18n }) => flag === "required" && !value ? message || i18n.t("validation:generic.required", { context: "array" }) : !0,
+	valid: (allowedValues, values, message, { i18n }) => {
+		if (values === void 0) return !0;
+		let paths = [];
+		for (let i = 0; i < values.length; i++) {
+			let value = values[i];
+			if (allowedValues.some((expected) => deepEqualsIgnoreKey(expected, value))) continue;
+			let pathSegment = value && value._key ? { _key: value._key } : i;
+			paths.push([pathSegment]);
+		}
+		let sharedMessage = message || i18n.t("validation:generic.not-allowed");
+		return paths.map((path) => ({
+			message: sharedMessage,
+			path
+		}));
+	},
+	unique: (_unused, value, message, { i18n }) => {
+		let dupeIndices = [];
+		if (!value) return !0;
+		for (let x = 0; x < value.length; x++) for (let y = x + 1; y < value.length; y++) {
+			let itemA = value[x], itemB = value[y];
+			deepEqualsIgnoreKey(itemA, itemB) && (dupeIndices.indexOf(x) === -1 && dupeIndices.push(x), dupeIndices.indexOf(y) === -1 && dupeIndices.push(y));
+		}
+		let paths = dupeIndices.map((idx) => {
+			let item = value[idx];
+			return [item && item._key ? { _key: item._key } : idx];
+		}), sharedMessage = message || i18n.t("validation:array.item-duplicate");
+		return paths.map((path) => ({
+			message: sharedMessage,
+			path
+		}));
+	}
+}, booleanValidators = {
+	...genericValidators,
+	presence: (flag, value, message, { i18n }) => flag === "required" && typeof value != "boolean" ? message || i18n.t("validation:generic.required", { context: "boolean" }) : !0
+};
+function isRecord$1(obj) {
+	return typeof obj == "object" && !!obj && !Array.isArray(obj);
+}
+const isoDate = /^(?:[-+]\d{2})?(?:\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?![T]$|[T][\d]+Z$)(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24:?00)(?:[.,]\d+(?!:))?)(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[Z]|(?:[+-])(?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?)?$/, getFormattedDate = (type = "", value, options) => {
+	let dateFormat = options?.dateFormat || legacyDateFormat.DEFAULT_DATE_FORMAT, timeFormat = options?.timeFormat || legacyDateFormat.DEFAULT_TIME_FORMAT;
+	return legacyDateFormat.format(value, type === "date" ? dateFormat : `${dateFormat} ${timeFormat}`, { useUTC: type === "date" });
+};
+function parseDate(date, throwOnError = !1) {
+	if (!date) return null;
+	if (date === "now") return /* @__PURE__ */ new Date();
+	let parsed = new Date(date), isInvalid = isNaN(parsed.getTime());
+	if (isInvalid && throwOnError) throw Error(`Unable to parse "${date}" to a date`);
+	return isInvalid ? null : parsed;
+}
+const dateValidators = {
+	...genericValidators,
+	type: (_unused, value, message, { i18n }) => value === void 0 || isoDate.test(`${value}`) ? !0 : message || i18n.t("validation:date.invalid-format"),
+	min: (minDate, value, message, { type, i18n }) => {
+		let dateVal = parseDate(value), minDateVal = parseDate(minDate, !0);
+		if (!dateVal || !value || dateVal >= minDateVal) return !0;
+		if (!type) throw Error("`type` was not provided in validation context.");
+		let dateTimeOptions = isRecord$1(type.options) ? type.options : {};
+		return message || i18n.t("validation:date.minimum", {
+			minDate: getFormattedDate(type.name, minDateVal, dateTimeOptions),
+			providedMinDate: minDate
+		});
+	},
+	max: (maxDate, value, message, { type, i18n }) => {
+		let dateVal = parseDate(value), maxDateVal = parseDate(maxDate, !0);
+		if (!dateVal || !value || dateVal <= maxDateVal) return !0;
+		if (!type) throw Error("`type` was not provided in validation context.");
+		let dateTimeOptions = isRecord$1(type.options) ? type.options : {};
+		return message || i18n.t("validation:date.maximum", {
+			maxDate: getFormattedDate(type.name, maxDateVal, dateTimeOptions),
+			providedMaxDate: maxDate
+		});
+	}
+}, precisionRx = /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/, numberValidators = {
+	...genericValidators,
+	integer: (_unused, value, message, { i18n }) => Number.isInteger(value) ? !0 : message || i18n.t("validation:number.non-integer"),
+	precision: (limit, value, message, { i18n }) => {
+		if (value === void 0) return !0;
+		let places = value.toString().match(precisionRx);
+		return Math.max((places[1] ? places[1].length : 0) - (places[2] ? parseInt(places[2], 10) : 0), 0) > limit ? message || i18n.t("validation:number.maximum-precision", { limit }) : !0;
+	},
+	min: (minNumber, value, message, { i18n }) => value >= minNumber || message || i18n.t("validation:number.minimum", { minNumber }),
+	max: (maxNumber, value, message, { i18n }) => value <= maxNumber || message || i18n.t("validation:number.maximum", { maxNumber }),
+	greaterThan: (threshold, value, message, { i18n }) => value > threshold || message || i18n.t("validation:number.greater-than", { threshold }),
+	lessThan: (threshold, value, message, { i18n }) => value < threshold || message || i18n.t("validation:number.less-than", { threshold })
+}, metaKeys = [
+	"_key",
+	"_type",
+	"_weak"
+], objectValidators = {
+	...genericValidators,
+	presence: (expected, value, message, { i18n }) => {
+		if (expected !== "required") return !0;
+		let keys = value && Object.keys(value).filter((key) => !metaKeys.includes(key));
+		return value === void 0 || keys && keys.length === 0 ? message || i18n.t("validation:generic.required", { context: "object" }) : !0;
+	},
+	reference: async (_unused, value, message, context) => {
+		if (!value) return !0;
+		let { type, document, getDocumentExists, i18n } = context;
+		if (!isReference(value)) return message || i18n.t("validation:object.not-reference");
+		if (!type) throw Error("`type` was not provided in validation context");
+		if ("weak" in type && type.weak) return !0;
+		if (!getDocumentExists) throw Error("`getDocumentExists` was not provided in validation context");
+		let documentId = document?._id;
+		return documentId && value._ref == getPublishedId(documentId) || await getDocumentExists({ id: value._ref }) ? !0 : i18n.t("validation:object.reference-not-published", { documentId: value._ref });
+	},
+	assetRequired: (flag, value, message, { i18n }) => !value || !value.asset || !value.asset._ref ? {
+		__internal_metadata: { name: "assetRequired" },
+		message: message || i18n.t("validation:object.asset-required", { context: flag.assetType || "" })
+	} : !0,
+	media: async (fn, value, message, context) => {
+		let slowTimer = setTimeout(() => {
+			context.environment === "studio" && console.warn(`Media validator at ${pathToString(context.path)} has taken more than ${SLOW_VALIDATOR_TIMEOUT}ms to respond`);
+		}, SLOW_VALIDATOR_TIMEOUT);
+		if (!value) return !0;
+		if (!value || !value.media || !value.media._ref) return context.i18n.t("validation:object.not-media-library-asset");
+		let result = !0;
+		try {
+			let [type, libraryId, documentId] = value.media._ref.split(":", 3), resourceConfig = { resource: {
+				type,
+				id: libraryId
+			} }, asset = await context.getClient({ apiVersion: "2025-02-19" }).withConfig(resourceConfig).fetch("*[_id == $id] { ..., 'currentVersion': @.currentVersion-> { ... }  }[0]", { id: documentId });
+			if (!asset) return console.warn(`${context.i18n.t("validation:object.media-not-found")}\nAsset ID: ${value.media._ref}`), context.i18n.t("validation:object.media-not-found");
+			result = await fn({
+				media: { asset },
+				value
+			}, context);
+		} catch (err) {
+			throw Error(`Media validator at ${pathToString(context.path)} failed with an error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+		} finally {
+			clearTimeout(slowTimer);
+		}
+		let validationErrorMetadata = { __internal_metadata: { name: "media" } };
+		return result === !0 || Array.isArray(result) ? result : [result].map((res) => typeof res == "string" ? {
+			...validationErrorMetadata,
+			message: message || res
+		} : isLocalizedMessages(res) ? {
+			...validationErrorMetadata,
+			message: message || localizeMessage(res, context.i18n)
+		} : {
+			...validationErrorMetadata,
+			...res,
+			message: message || res.message
+		});
+	}
+}, DUMMY_ORIGIN = "http://sanity", isRelativeUrl = (url) => /^\.*\//.test(url), emailRegex = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/, typeValidators = {
+	Boolean: booleanValidators,
+	Number: numberValidators,
+	String: {
+		...genericValidators,
+		min: (minLength, value, message, { i18n }) => !value || value.length >= minLength || message || i18n.t("validation:string.minimum-length", { minLength }),
+		max: (maxLength, value, message, { i18n }) => !value || value.length <= maxLength || message || i18n.t("validation:string.maximum-length", { maxLength }),
+		length: (wantedLength, value, message, { i18n }) => (value || "").length === wantedLength || message || i18n.t("validation:string.exact-length", { wantedLength }),
+		uri: (constraints, value, message, { i18n }) => {
+			let strValue = value || "";
+			if (!strValue) return !0;
+			let { options } = constraints, { allowCredentials, relativeOnly } = options, allowRelative = options.allowRelative || relativeOnly, url;
+			try {
+				url = allowRelative ? new URL(strValue, DUMMY_ORIGIN) : new URL(strValue);
+			} catch {
+				return message || i18n.t("validation:string.url.invalid");
+			}
+			if (relativeOnly && url.origin !== DUMMY_ORIGIN) return message || i18n.t("validation:string.url.not-relative");
+			if (!allowRelative && url.origin === DUMMY_ORIGIN && isRelativeUrl(strValue)) return message || i18n.t("validation:string.url.not-absolute");
+			if (!allowCredentials && (url.username || url.password)) return message || i18n.t("validation:string.url.includes-credentials");
+			let urlScheme = url.protocol.replace(/:$/, "");
+			return isRelativeUrl(strValue) || options.scheme.some((scheme) => scheme.test(urlScheme)) ? !0 : message || i18n.t("validation:string.url.disallowed-scheme", { scheme: urlScheme });
+		},
+		stringCasing: (casing, value, message, { i18n }) => {
+			let strValue = value || "";
+			return casing === "uppercase" && strValue !== strValue.toLocaleUpperCase() ? message || i18n.t("validation:string.uppercase") : casing === "lowercase" && strValue !== strValue.toLocaleLowerCase() ? message || i18n.t("validation:string.lowercase") : !0;
+		},
+		presence: (flag, value, message, { i18n }) => flag === "required" && !value ? message || i18n.t("validation:generic.required", { context: "string" }) : !0,
+		regex: (options, value, message, { i18n }) => {
+			let { pattern, name, invert } = options, regName = name || `${pattern.toString()}`, strValue = value || "";
+			pattern.lastIndex = 0;
+			let matches = pattern.test(strValue);
+			return !invert && !matches || invert && matches ? message || (invert ? i18n.t("validation:string.regex-match", { name: regName }) : i18n.t("validation:string.regex-does-not-match", { name: regName })) : !0;
+		},
+		email: (_unused, value, message, { i18n }) => {
+			let strValue = `${value || ""}`.trim();
+			return !strValue || emailRegex.test(strValue) ? !0 : message || i18n.t("validation:string.email");
+		}
+	},
+	Array: arrayValidators,
+	Object: objectValidators,
+	Date: dateValidators
+}, isFieldRef = (constraint) => typeof constraint != "object" || !constraint ? !1 : constraint.type === Rule$2.FIELD_REF, EMPTY_ARRAY = [], Rule$2 = class Rule extends Rule$1 {
+	static array = (def) => new Rule(def).type("Array");
+	static object = (def) => new Rule(def).type("Object");
+	static string = (def) => new Rule(def).type("String");
+	static number = (def) => new Rule(def).type("Number");
+	static boolean = (def) => new Rule(def).type("Boolean");
+	static dateTime = (def) => new Rule(def).type("Date");
+	clone() {
+		let rule = new Rule();
+		return rule._type = this._type, rule._message = this._message, rule._required = this._required, rule._rules = [...this._rules], rule._level = this._level, rule._fieldRules = this._fieldRules, rule._typeDef = this._typeDef, rule;
+	}
+	async validate(value, { __internal = {}, ...context }) {
+		let { customValidationConcurrencyLimiter } = __internal, valueIsEmpty = value == null;
+		if (valueIsEmpty && this._required === "optional") return EMPTY_ARRAY;
+		let rules = this._required === void 0 && valueIsEmpty ? this._rules.filter((curr) => curr.flag === "custom") : this._rules, validators = this._type && typeValidators[this._type] || genericValidators;
+		return (await Promise.all(rules.map(async (curr) => {
+			if (curr.flag === void 0) throw Error("Invalid rule, did not contain \"flag\"-property");
+			let validator = validators[curr.flag];
+			if (!validator) {
+				let forType = this._type ? `type "${this._type}"` : "rule without declared type";
+				throw Error(`Validator for flag "${curr.flag}" not found for ${forType}`);
+			}
+			let specConstraint = "constraint" in curr ? curr.constraint : null;
+			if (isFieldRef(specConstraint) && (specConstraint = get(context.parent, specConstraint.path)), curr.flag === "custom" && customValidationConcurrencyLimiter && !specConstraint?.bypassConcurrencyLimit) {
+				let customValidator = specConstraint;
+				specConstraint = async (...args) => {
+					await customValidationConcurrencyLimiter.ready();
+					try {
+						return await customValidator(...args);
+					} finally {
+						customValidationConcurrencyLimiter.release();
+					}
+				};
+			}
+			let message = isLocalizedMessages(this._message) ? localizeMessage(this._message, context.i18n) : this._message;
+			try {
+				return convertToValidationMarker(await validator(specConstraint, value, message, context), this._level, context);
+			} catch (err) {
+				return convertToValidationMarker({ message: `${pathToString(context.path)}: Exception occurred while validating value: ${err.message}` }, "error", context);
+			}
+		}))).flat();
+	}
+}, memoizedWarnOnArraySlug = memoize(warnOnArraySlug);
+function serializePath(path) {
+	return path.reduce((target, part, i) => {
+		let isIndex = typeof part == "number", isKey = isKeyedObject(part);
+		return `${target}${isIndex || isKey ? "[]" : `${i === 0 ? "" : "."}${part}`}`;
+	}, "");
+}
+const defaultIsUnique = (slug, context) => {
+	let { getClient, document, path, type } = context, schemaOptions = type?.options;
+	if (!document) throw Error("`document` was not provided in validation context.");
+	if (!path) throw Error("`path` was not provided in validation context.");
+	let disableArrayWarning = schemaOptions?.disableArrayWarning || !1, docType = document._type, atPath = serializePath(path.concat("current"));
+	!disableArrayWarning && atPath.includes("[]") && context.environment === "studio" && memoizedWarnOnArraySlug(serializePath(path));
+	let constraints = [
+		"_type == $docType",
+		"!sanity::versionOf($published)",
+		`${atPath} == $slug`
+	].join(" && ");
+	return getClient({ apiVersion: "2025-02-19" }).withConfig({ perspective: "raw" }).fetch(`!defined(*[${constraints}][0]._id)`, {
+		docType,
+		published: getPublishedId(document._id),
+		slug
+	}, { tag: "validation.slug-is-unique" });
+};
+function warnOnArraySlug(serializedPath) {
+	console.warn([
+		`Slug field at path ${serializedPath} is within an array and cannot be automatically checked for uniqueness`,
+		"If you need to check for uniqueness, provide your own \"isUnique\" method",
+		"To disable this message, set `disableArrayWarning: true` on the slug `options` field"
+	].join("\n"));
+}
+/**
+* Validates slugs values by querying for uniqueness from the client.
+*
+* This is a custom rule implementation (e.g. `Rule.custom(slugValidator)`)
+* that's populated in `inferFromSchemaType` when the type name is `slug`
+*/
+const slugValidator = async (value, context) => {
+	if (!value) return !0;
+	let { i18n } = context;
+	if (typeof value != "object" || Array.isArray(value)) return i18n.t("validation:slug.not-object");
+	if (!isSlug(value) || value.current.trim().length === 0) return i18n.t("validation:slug.missing-current");
+	let isUnique = context?.type?.options?.isUnique || defaultIsUnique, slugContext = {
+		...context,
+		parent: context.parent,
+		type: context.type,
+		defaultIsUnique
+	};
+	return await isUnique(value.current, slugContext) ? !0 : i18n.t("validation:slug.not-unique", { slug: value.current });
+}, ruleConstraintTypes = {
+	array: !0,
+	boolean: !0,
+	date: !0,
+	number: !0,
+	object: !0,
+	string: !0
+}, isRuleConstraint = (typeString) => typeString in ruleConstraintTypes;
+function getTypeChain(type, visited = /* @__PURE__ */ new Set()) {
+	return !type || visited.has(type) ? [] : (visited.add(type), [...type.type ? getTypeChain(type.type, visited) : [], type]);
+}
+function baseRuleReducer(inputRule, type) {
+	let baseRule = inputRule;
+	isRuleConstraint(type.jsonType) && (baseRule = baseRule.type(type.jsonType));
+	let typeOptionsList = type?.options && typeof type.options == "object" && "list" in type.options && type.options.list;
+	return Array.isArray(typeOptionsList) && (baseRule = baseRule.valid(typeOptionsList.map((option) => extractValueFromListOption(option, type)))), type.name === "datetime" || type.name === "date" ? baseRule.type("Date") : type.name === "url" ? baseRule.uri() : type.name === "slug" ? baseRule.custom(slugValidator, { bypassConcurrencyLimit: !0 }) : type.name === "reference" ? baseRule.reference() : type.name === "email" ? baseRule.email() : baseRule;
+}
+function hasValueField(typeDef) {
+	return typeDef ? !("fields" in typeDef) && typeDef.type ? hasValueField(typeDef.type) : !("fields" in typeDef) || !Array.isArray(typeDef.fields) ? !1 : typeDef.fields.some((field) => field.name === "value") : !1;
+}
+function extractValueFromListOption(option, typeDef) {
+	return typeDef.jsonType === "object" && hasValueField(typeDef) || option.value === void 0 ? option : option.value;
+}
+const isUriSpec = (spec) => spec.flag === "uri";
+function omitLeakedDefaultUri(rules, typeDef) {
+	if (!getTypeChain(typeDef).some((type) => type.name === "url")) return rules;
+	let defaultUri = new Rule$2(typeDef).uri()._rules.find(isUriSpec)?.constraint, isDefaultUri = (spec) => isUriSpec(spec) && isEqual(spec.constraint, defaultUri), isCustomUri = (spec) => isUriSpec(spec) && !isEqual(spec.constraint, defaultUri);
+	return rules.some((rule) => rule._rules.some(isCustomUri)) ? rules.map((rule) => {
+		if (!rule._rules.some(isDefaultUri)) return rule;
+		let cleaned = rule.clone();
+		return cleaned._rules = rule._rules.filter((spec) => !isDefaultUri(spec)), cleaned;
+	}) : rules;
+}
+function normalizeValidationRules(typeDef, context) {
+	if (!typeDef) return [];
+	let validation = typeDef.validation;
+	if (Array.isArray(validation)) return omitLeakedDefaultUri(validation.flatMap((i) => normalizeValidationRules({
+		...typeDef,
+		validation: i
+	}, context)), typeDef);
+	let baseRule = Object.values(getTypeChain(typeDef).reduce((acc, type) => (acc[type.name] = type, acc), {})).reduce(baseRuleReducer, new Rule$2(typeDef));
+	return validation && typeof validation == "object" ? [validation] : validation && typeof validation == "function" ? normalizeValidationRules({
+		...typeDef,
+		validation: validation(baseRule, context)
+	}, context) : [baseRule];
+}
+/**
+* Simple requestIdleCallback polyfill
+* Can be removed when all browsers support requestIdleCallback: https://caniuse.com/requestidlecallback
+* @param callback -
+* @param options -
+*/
+const requestIdleCallbackShim = function requestIdleCallbackShim(callback, _options) {
+	let start = Date.now();
+	return globalThis.setTimeout(() => {
+		callback({
+			didTimeout: !1,
+			timeRemaining() {
+				return Math.max(0, Date.now() - start);
+			}
+		});
+	}, 0);
+}, cancelIdleCallbackShim = function cancelIdleCallbackShim(handle) {
+	return globalThis.clearTimeout(handle);
+}, win = typeof window > "u" ? void 0 : window, requestIdleCallback = win?.requestIdleCallback || requestIdleCallbackShim, cancelIdleCallback = win?.cancelIdleCallback || cancelIdleCallbackShim, unknownFieldsValidator = (type) => (value) => {
+	if (typeof value != "object" || !value) return !0;
+	let fieldNames = new Set(type.fields?.map((field) => field.name));
+	return Object.keys(value).filter((key) => !key.startsWith("_")).filter((key) => !fieldNames.has(key)).map((unknownField) => ({
+		message: `Field '${unknownField}' does not exist on type '${type.name}'`,
+		path: [unknownField]
+	}));
+}, DEFAULT_VALIDATION_CLIENT_OPTIONS = { apiVersion: "2025-02-19" }, isRecord = (maybeRecord) => typeof maybeRecord == "object" && !!maybeRecord && !Array.isArray(maybeRecord);
+/**
+* Recursively extracts all `_fieldRules` from a rule and its nested constraints.
+* This handles cases where `Rule.fields()` is used inside `Rule.all()` or `Rule.either()`.
+*/
+function extractFieldRulesFromRule(rule) {
+	let results = [];
+	rule._fieldRules && results.push(rule._fieldRules);
+	for (let ruleSpec of rule._rules) if (ruleSpec.flag === "all" || ruleSpec.flag === "either") {
+		let childRules = ruleSpec.constraint;
+		if (Array.isArray(childRules)) for (let childRule of childRules) results.push(...extractFieldRulesFromRule(childRule));
+	}
+	return results;
+}
+/**
+* @internal
+*/
+function resolveTypeForArrayItem(item, candidates) {
+	if (candidates.length === 1) return candidates[0];
+	let itemType = isTypedObject(item) && item._type, primitive = item == null || !itemType && typeString(item).toLowerCase();
+	return primitive && primitive !== "object" ? candidates.find((candidate) => candidate.jsonType === primitive) : candidates.find((candidate) => candidate.type?.name === itemType) || candidates.find((candidate) => candidate.name === itemType) || candidates.find((candidate) => candidate.name === "object" && primitive === "object");
+}
+/**
+* Validates a document against a compiled schema. Returns validation markers
+* without deciding whether the document may be edited or published.
+*
+* @beta
+*/
+function validateDocument({ client, document, schema, ...options }) {
+	return validateDocumentInternal({
+		...options,
+		document,
+		environment: "cli",
+		getClient: ({ apiVersion }) => client.withConfig({ apiVersion }),
+		i18n: getFallbackLocaleSource(),
+		schema
+	});
+}
+/** @internal */
+function validateDocumentInternal({ document, schema, getClient, getDocumentExists, i18n = getFallbackLocaleSource(), environment, maxCustomValidationConcurrency, maxFetchConcurrency, currentUser }) {
+	let limitConcurrency = createClientConcurrencyLimiter(maxFetchConcurrency ?? 25), getConcurrencyLimitedClient = (clientOptions) => limitConcurrency(getClient(clientOptions));
+	return lastValueFrom(validateDocumentObservable({
+		document,
+		getClient: getConcurrencyLimitedClient,
+		i18n,
+		schema,
+		getDocumentExists: getDocumentExists || createBatchedGetDocumentExists(getClient(DEFAULT_VALIDATION_CLIENT_OPTIONS)),
+		environment,
+		maxCustomValidationConcurrency,
+		currentUser
+	}));
+}
+const customValidationConcurrencyLimiters = /* @__PURE__ */ new WeakMap();
+/**
+* Validates a document against the given schema, returning an Observable
+* @internal
+*/
+function validateDocumentObservable({ document, getClient, i18n = getFallbackLocaleSource(), schema, getDocumentExists, environment, maxCustomValidationConcurrency, currentUser }) {
+	if (typeof document?._type != "string") throw Error("Tried to validate a value without a '_type'");
+	let documentType = schema.get(document._type);
+	if (!documentType) return environment === "studio" ? (console.warn("Schema type for object type \"%s\" not found, skipping validation", document._type), of([])) : of([{
+		level: "warning",
+		message: `Could not find schema type for type '${document._type}', skipping validation`,
+		path: []
+	}]);
+	let customValidationConcurrencyLimiter = customValidationConcurrencyLimiters.get(schema);
+	customValidationConcurrencyLimiter || (customValidationConcurrencyLimiter = new ConcurrencyLimiter(maxCustomValidationConcurrency ?? 5), customValidationConcurrencyLimiters.set(schema, customValidationConcurrencyLimiter));
+	let validationOptions = {
+		getClient,
+		schema,
+		parent: void 0,
+		value: document,
+		path: [],
+		document,
+		type: documentType,
+		i18n,
+		getDocumentExists,
+		environment,
+		customValidationConcurrencyLimiter,
+		currentUser
+	};
+	return from(i18n.loadNamespaces(["validation"])).pipe(switchMap$1(() => validateItemObservable(validationOptions)), catchError((err) => {
+		console.error(err);
+		let message = err?.message || "Unknown error";
+		return of([{
+			level: "error",
+			message,
+			item: { message },
+			path: []
+		}]);
+	}));
+}
+function validateItem(opts) {
+	return lastValueFrom(validateItemObservable(opts));
+}
+function validateItemObservable({ value, type, path = [], parent, customValidationConcurrencyLimiter, environment, ...restOfContext }) {
+	let ancestorHidden = restOfContext.hidden === !0, resolveHiddenForType = (schemaType, schemaValue, schemaParent, schemaPath, ancestorHiddenValue) => schemaType ? ancestorHiddenValue || resolveConditionalProperty(schemaType.hidden, {
+		...restOfContext,
+		parent: schemaParent,
+		value: schemaValue,
+		path: schemaPath || [],
+		currentUser: restOfContext.currentUser ?? null
+	}) : ancestorHiddenValue, hidden = resolveHiddenForType(type, value, parent, path, ancestorHidden), addUnknownFieldsValidator = (rule) => type?.jsonType === "object" && getTypeChain(type).find((t) => [
+		"object",
+		"document",
+		"file",
+		"image"
+	].includes(t.name)) && environment !== "studio" ? rule.custom(unknownFieldsValidator(type), { bypassConcurrencyLimit: !0 }).warning() : rule, rules = normalizeValidationRules(type, {
+		...restOfContext,
+		hidden,
+		environment,
+		parent,
+		path,
+		type
+	}), selfChecks = rules.map(addUnknownFieldsValidator).map((rule) => defer(() => rule.validate(value, {
+		...restOfContext,
+		environment,
+		hidden,
+		parent,
+		path,
+		type,
+		__internal: { customValidationConcurrencyLimiter }
+	}))), nestedChecks = [], selfIsRequired = rules.some((rule) => rule.isRequired());
+	if (type?.jsonType === "object" && (value || value == null && selfIsRequired)) {
+		let fieldTypes = type.fields.reduce((acc, field) => (acc[field.name] = field.type, acc), {});
+		nestedChecks = nestedChecks.concat(rules.flatMap((rule) => extractFieldRulesFromRule(rule)).flatMap((fieldResults) => Object.entries(fieldResults)).flatMap(([name, validation]) => {
+			let fieldType = fieldTypes[name];
+			return normalizeValidationRules({
+				...fieldType,
+				validation
+			}).map(addUnknownFieldsValidator).map((subRule) => {
+				let nestedValue = isRecord(value) ? value[name] : void 0, nestedHidden = resolveHiddenForType(fieldType, nestedValue, value, path.concat(name), hidden);
+				return defer(() => subRule.validate(nestedValue, {
+					...restOfContext,
+					parent: value,
+					path: path.concat(name),
+					type: fieldType,
+					environment,
+					hidden: nestedHidden,
+					__internal: { customValidationConcurrencyLimiter }
+				}));
+			});
+		})), nestedChecks = nestedChecks.concat(type.fields.map((field) => validateItemObservable({
+			...restOfContext,
+			hidden,
+			parent: value,
+			value: isRecord(value) ? value[field.name] : void 0,
+			path: path.concat(field.name),
+			type: field.type,
+			environment,
+			customValidationConcurrencyLimiter
+		})));
+	}
+	return type?.jsonType === "array" && Array.isArray(value) && (nestedChecks = nestedChecks.concat(value.map((item, index) => validateItemObservable({
+		...restOfContext,
+		hidden,
+		parent: value,
+		value: item,
+		path: path.concat(isKeyedObject(item) ? { _key: item._key } : index),
+		type: resolveTypeForArrayItem(item, type.of),
+		environment,
+		customValidationConcurrencyLimiter
+	})))), defer(() => merge([...selfChecks, ...nestedChecks])).pipe(mergeMap$1((validateNode) => concat(idle(), validateNode), 40), mergeAll(), toArray(), map$1(flatten), map$1((results) => rules.some((rule) => extractFieldRulesFromRule(rule).length > 0) ? uniqBy(results, (rule) => JSON.stringify(rule)) : results));
+}
+function idle(timeout) {
+	return new Observable((observer) => {
+		let handle = requestIdleCallback(() => {
+			observer.complete();
+		}, timeout ? { timeout } : void 0);
+		return () => cancelIdleCallback(handle);
+	});
+}
+export { validateItem as a, Rule$2 as c, pathToString as d, getFallbackLocaleSource as f, validateDocumentObservable as i, typeString as l, validateDocument as n, getTypeChain as o, validationLocaleStrings as p, validateDocumentInternal as r, normalizeValidationRules as s, resolveTypeForArrayItem as t, convertToValidationMarker as u };
+
+//# sourceMappingURL=validateDocument-il4G-TLy.js.map