@sanity/schema 5.0.0-next.0-9b570ece82-202507150640 → 5.0.0-next.7

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016 - 2024 Sanity.io
+Copyright (c) 2016 - 2025 Sanity.io
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/{index.mjs → _chunks-es/Rule.js}

@@ -1,15 +1,33 @@
+import startCase from "lodash/startCase.js";
 import omit from "lodash/omit.js";
 import pick from "lodash/pick.js";
-import { DEFAULT_OVERRIDEABLE_FIELDS, OWN_PROPS_NAME, resolveSearchConfigForBaseFieldPaths, resolveSearchConfig } from "./_chunks-es/resolve.mjs";
 import arrify from "arrify";
 import isUndefined from "lodash/isUndefined.js";
 import omitBy from "lodash/omitBy.js";
 import capitalize from "lodash/capitalize.js";
+import isFinite from "lodash/isFinite.js";
+import uniqBy from "lodash/uniqBy.js";
 import castArray from "lodash/castArray.js";
 import flatMap from "lodash/flatMap.js";
-import startCase from "lodash/startCase.js";
 import isPlainObject from "lodash/isPlainObject.js";
 import toPath from "lodash/toPath.js";
+import cloneDeep from "lodash/cloneDeep.js";
+const DEFAULT_OVERRIDEABLE_FIELDS = [
+  "jsonType",
+  "type",
+  "name",
+  "title",
+  "description",
+  "options",
+  "fieldsets",
+  "validation",
+  "readOnly",
+  "hidden",
+  "components",
+  "diffComponent",
+  "initialValue",
+  "deprecated"
+], OWN_PROPS_NAME = "_internal_ownProps", ALL_FIELDS_GROUP_NAME = "all-fields";
 function lazyGetter(target, key, getter, config = {}) {
   return Object.defineProperty(target, key, {
     configurable: !0,
@@ -80,7 +98,7 @@ const OVERRIDABLE_FIELDS$f = [...DEFAULT_OVERRIDEABLE_FIELDS], ANY_CORE = {
     const parsed = Object.assign(pick(ARRAY_CORE, OVERRIDABLE_FIELDS$e), subTypeDef, {
       type: ARRAY_CORE
     });
-    return lazyGetter(parsed, "of", () => subTypeDef.of.map((ofTypeDef) => createMemberType(ofTypeDef))), lazyGetter(parsed, OWN_PROPS_NAME, () => ({ ...subTypeDef, of: parsed.of }), {
+    return lazyGetter(parsed, "of", () => subTypeDef.of.map((ofTypeDef) => createMemberType.cached(ofTypeDef))), lazyGetter(parsed, OWN_PROPS_NAME, () => ({ ...subTypeDef, of: parsed.of }), {
       enumerable: !1,
       writable: !1
     }), subtype(parsed);
@@ -253,7 +271,7 @@ const DEFAULT_LINK_ANNOTATION = {
       type: "url",
       title: "Link",
       description: "A valid web, email, phone, or relative link.",
-      validation: (Rule) => Rule.uri({
+      validation: (Rule3) => Rule3.uri({
         scheme: ["http", "https", "tel", "mailto"],
         allowRelative: !0
       })
@@ -366,13 +384,7 @@ const DEFAULT_LINK_ANNOTATION = {
     ), ownProps = { ...rest, options }, parsed = Object.assign(pick(BLOCK_CORE, INHERITED_FIELDS$1), ownProps, {
       type: BLOCK_CORE
     });
-    return lazyGetter(parsed, "fields", () => fields.map((fieldDef) => {
-      const { name, ...type } = fieldDef;
-      return {
-        name,
-        type: extendMember(type)
-      };
-    })), lazyGetter(parsed, "preview", createPreviewGetter(subTypeDef)), lazyGetter(
+    return lazyGetter(parsed, "fields", () => fields.map((fieldDef) => extendMember.cachedField(fieldDef))), lazyGetter(parsed, "preview", createPreviewGetter(subTypeDef)), lazyGetter(
       parsed,
       OWN_PROPS_NAME,
       () => ({
@@ -470,13 +482,7 @@ const INHERITED_FIELDS = [
     const options = { ...subTypeDef.options || DEFAULT_OPTIONS$2 }, { annotations = [], marks = [] } = subTypeDef, fields = [MARKS_FIELD, TEXT_FIELD], ownProps = { ...subTypeDef, options }, parsed = Object.assign(pick(SPAN_CORE, INHERITED_FIELDS), ownProps, {
       type: SPAN_CORE
     });
-    return lazyGetter(parsed, "fields", () => fields.map((fieldDef) => {
-      const { name, ...type } = fieldDef;
-      return {
-        name,
-        type: extendMember(type)
-      };
-    })), lazyGetter(parsed, "annotations", () => annotations.map(extendMember)), lazyGetter(parsed, "marks", () => marks.map(extendMember)), lazyGetter(parsed, "preview", createPreviewGetter(subTypeDef)), lazyGetter(
+    return lazyGetter(parsed, "fields", () => fields.map((fieldDef) => extendMember.cachedField(fieldDef))), lazyGetter(parsed, "annotations", () => annotations.map(extendMember)), lazyGetter(parsed, "marks", () => marks.map(extendMember)), lazyGetter(parsed, "preview", createPreviewGetter(subTypeDef)), lazyGetter(
       parsed,
       OWN_PROPS_NAME,
       () => ({
@@ -539,7 +545,91 @@ const OVERRIDABLE_FIELDS$d = [...DEFAULT_OVERRIDEABLE_FIELDS], BOOLEAN_CORE = {
       };
     }
   }
-}, REF_FIELD$2 = {
+}, DEFAULT_MAX_FIELD_DEPTH = 5, stringFieldsSymbols = {}, getStringFieldSymbol = (maxDepth) => (stringFieldsSymbols[maxDepth] || (stringFieldsSymbols[maxDepth] = /* @__PURE__ */ Symbol(`__cachedStringFields_${maxDepth}`)), stringFieldsSymbols[maxDepth]), isReference = (type) => type.type && type.type.name === "reference", portableTextFields = ["style", "list"], isPortableTextBlock = (type) => type.name === "block" || type.type && isPortableTextBlock(type.type), isPortableTextArray = (type) => type.jsonType === "array" && Array.isArray(type.of) && type.of.some(isPortableTextBlock);
+function reduceType(type, reducer, acc, path = [], maxDepth) {
+  if (maxDepth < 0)
+    return acc;
+  const accumulator = reducer(acc, type, path);
+  return type.jsonType === "array" && Array.isArray(type.of) ? reduceArray(type, reducer, accumulator, path, maxDepth) : type.jsonType === "object" && Array.isArray(type.fields) && !isReference(type) ? reduceObject(type, reducer, accumulator, path, maxDepth) : accumulator;
+}
+function reduceArray(arrayType, reducer, accumulator, path, maxDepth) {
+  return arrayType.of.reduce(
+    (acc, ofType) => reduceType(ofType, reducer, acc, path, maxDepth - 1),
+    accumulator
+  );
+}
+function reduceObject(objectType, reducer, accumulator, path, maxDepth) {
+  const isPtBlock = isPortableTextBlock(objectType);
+  return objectType.fields.reduce((acc, field) => {
+    if (isPtBlock && portableTextFields.includes(field.name))
+      return acc;
+    const segment = [field.name].concat(field.type.jsonType === "array" ? [[]] : []);
+    return reduceType(field.type, reducer, acc, path.concat(segment), maxDepth - 1);
+  }, accumulator);
+}
+const BASE_WEIGHTS = [
+  { weight: 1, path: ["_id"] },
+  { weight: 1, path: ["_type"] }
+], PREVIEW_FIELD_WEIGHT_MAP = {
+  title: 10,
+  subtitle: 5,
+  description: 1.5
+};
+function deriveFromPreview(type, maxDepth) {
+  const select = type?.preview?.select;
+  if (!select)
+    return [];
+  const fields = [];
+  for (const fieldName of Object.keys(select)) {
+    if (!(fieldName in PREVIEW_FIELD_WEIGHT_MAP))
+      continue;
+    const path = select[fieldName].split(".");
+    maxDepth > -1 && path.length - 1 > maxDepth || fields.push({
+      weight: PREVIEW_FIELD_WEIGHT_MAP[fieldName],
+      path
+    });
+  }
+  return fields;
+}
+function getCachedStringFieldPaths(type, maxDepth) {
+  const symbol = getStringFieldSymbol(maxDepth);
+  return type[symbol] || (type[symbol] = uniqBy(
+    [
+      ...BASE_WEIGHTS,
+      ...deriveFromPreview(type, maxDepth),
+      ...getStringFieldPaths(type, maxDepth).map((path) => ({ weight: 1, path })),
+      ...getPortableTextFieldPaths(type, maxDepth).map((path) => ({
+        weight: 1,
+        path,
+        mapWith: "pt::text"
+      }))
+    ],
+    (spec) => spec.path.join(".")
+  )), type[symbol];
+}
+function getCachedBaseFieldPaths(type, maxDepth) {
+  const symbol = getStringFieldSymbol(maxDepth);
+  return type[symbol] || (type[symbol] = uniqBy(
+    [...BASE_WEIGHTS, ...deriveFromPreview(type, maxDepth)],
+    (spec) => spec.path.join(".")
+  )), type[symbol];
+}
+function getStringFieldPaths(type, maxDepth) {
+  return reduceType(type, (accumulator, childType, path) => childType.jsonType === "string" ? [...accumulator, path] : accumulator, [], [], maxDepth);
+}
+function getPortableTextFieldPaths(type, maxDepth) {
+  return reduceType(type, (accumulator, childType, path) => isPortableTextArray(childType) ? [...accumulator, path] : accumulator, [], [], maxDepth);
+}
+function resolveSearchConfigForBaseFieldPaths(type, maxDepth) {
+  return getCachedBaseFieldPaths(type, normalizeMaxDepth(maxDepth));
+}
+function resolveSearchConfig(type, maxDepth) {
+  return getCachedStringFieldPaths(type, normalizeMaxDepth(maxDepth));
+}
+function normalizeMaxDepth(maxDepth) {
+  return !isFinite(maxDepth) || maxDepth < 1 || maxDepth > DEFAULT_MAX_FIELD_DEPTH ? DEFAULT_MAX_FIELD_DEPTH - 1 : maxDepth - 1;
+}
+const REF_FIELD$2 = {
   name: "_ref",
   title: "Referenced document ID",
   type: "string"
@@ -590,13 +680,7 @@ const CrossDatasetReferenceType = {
         type: CROSS_DATASET_REFERENCE_CORE
       }
     );
-    return lazyGetter(parsed, "fields", () => REFERENCE_FIELDS$2.map((fieldDef) => {
-      const { name, ...type } = fieldDef;
-      return {
-        name,
-        type: createMemberType(type)
-      };
-    })), lazyGetter(parsed, "to", () => arrify(subTypeDef.to).map((toType) => ({
+    return lazyGetter(parsed, "fields", () => REFERENCE_FIELDS$2.map((fieldDef) => createMemberType.cachedField(fieldDef))), lazyGetter(parsed, "to", () => arrify(subTypeDef.to).map((toType) => ({
       ...toType,
       // eslint-disable-next-line camelcase
       __experimental_search: resolveSearchConfigForBaseFieldPaths(toType)
@@ -743,17 +827,9 @@ const OVERRIDABLE_FIELDS$9 = [
       title: subTypeDef.title || (subTypeDef.name ? startCase(subTypeDef.name) : "Object"),
       options,
       orderings: subTypeDef.orderings || guessOrderingConfig(subTypeDef),
-      fields: subTypeDef.fields.map((fieldDef) => {
-        const { name, fieldset, group, ...rest } = fieldDef;
-        return lazyGetter({
-          name,
-          group,
-          fieldset
-        }, "type", () => createMemberType({
-          ...rest,
-          title: fieldDef.title || startCase(name)
-        }));
-      })
+      fields: subTypeDef.fields.map(
+        (fieldDef) => createMemberType.cachedObjectField(fieldDef)
+      )
     }, parsed = Object.assign(pick(this.get(), OVERRIDABLE_FIELDS$9), ownProps, {
       type: this.get()
     });
@@ -844,7 +920,11 @@ function createFieldsGroups(typeDef, fields) {
         );
       currentGroup.fields.push(field);
     });
-  }), flatMap(groupsByName).filter((group) => group.fields.length > 0);
+  }), flatMap(groupsByName).filter(
+    // All fields group is added by default in structure.
+    // To pass the properties from the schema to the form state, we need to include it in the list of groups.
+    (group) => group.fields.length > 0 || group.name === ALL_FIELDS_GROUP_NAME
+  );
 }
 const DOCUMENT_CORE = {
   name: "document",
@@ -867,7 +947,7 @@ lazyGetter(
   OWN_PROPS_NAME,
   () => ({
     ...EMAIL_CORE,
-    validation: (Rule) => Rule.email()
+    validation: (Rule3) => Rule3.email()
   }),
   { enumerable: !1 }
 );
@@ -1006,13 +1086,7 @@ const GlobalDocumentReferenceType = {
         type: GLOBAL_DOCUMENT_REFERENCE_CORE
       }
     );
-    return lazyGetter(parsed, "fields", () => REFERENCE_FIELDS$1.map((fieldDef) => {
-      const { name, ...type } = fieldDef;
-      return {
-        name,
-        type: createMemberType(type)
-      };
-    })), lazyGetter(parsed, "to", () => arrify(subTypeDef.to).map((toType) => ({
+    return lazyGetter(parsed, "fields", () => REFERENCE_FIELDS$1.map((fieldDef) => createMemberType.cachedField(fieldDef))), lazyGetter(parsed, "to", () => arrify(subTypeDef.to).map((toType) => ({
       ...toType
     }))), lazyGetter(parsed, "title", () => subTypeDef.title || buildTitle$1(parsed)), lazyGetter(
       parsed,
@@ -1189,13 +1263,7 @@ const ReferenceType = {
     const parsed = Object.assign(pick(REFERENCE_CORE, OVERRIDABLE_FIELDS$3), subTypeDef, {
       type: REFERENCE_CORE
     });
-    return lazyGetter(parsed, "fields", () => REFERENCE_FIELDS.map((fieldDef) => {
-      const { name, ...type } = fieldDef;
-      return {
-        name,
-        type: createMemberType(type)
-      };
-    })), lazyGetter(parsed, "fieldsets", () => createFieldsets(subTypeDef, parsed.fields)), lazyGetter(parsed, "to", () => arrify(subTypeDef.to).map((toType) => createMemberType(toType))), lazyGetter(parsed, "title", () => subTypeDef.title || buildTitle(parsed)), lazyGetter(
+    return lazyGetter(parsed, "fields", () => REFERENCE_FIELDS.map((fieldDef) => createMemberType.cachedField(fieldDef))), lazyGetter(parsed, "fieldsets", () => createFieldsets(subTypeDef, parsed.fields)), lazyGetter(parsed, "to", () => arrify(subTypeDef.to).map((toType) => createMemberType(toType))), lazyGetter(parsed, "title", () => subTypeDef.title || buildTitle(parsed)), lazyGetter(
       parsed,
       OWN_PROPS_NAME,
       () => ({
@@ -1347,7 +1415,38 @@ function compileRegistry(schemaDef) {
     if (acc[def.name])
       throw new Error(`Duplicate type name added to schema: ${def.name}`);
     return acc[def.name] = def, acc;
-  }, {});
+  }, {}), memberCache = /* @__PURE__ */ new Map(), fieldCache = /* @__PURE__ */ new Map(), objectFieldCache = /* @__PURE__ */ new Map(), extendHelper = Object.assign(extendMember, {
+    cached(def) {
+      let member = memberCache.get(def);
+      return member || (member = extendMember(def), memberCache.set(def, member)), member;
+    },
+    cachedField(fieldDef) {
+      let field = fieldCache.get(fieldDef);
+      if (!field) {
+        const { name, ...type } = fieldDef;
+        field = {
+          name,
+          type: extendMember(type)
+        }, fieldCache.set(fieldDef, field);
+      }
+      return field;
+    },
+    cachedObjectField(fieldDef) {
+      let field = objectFieldCache.get(fieldDef);
+      if (!field) {
+        const { name, fieldset, group, ...rest } = fieldDef;
+        field = {
+          name,
+          group,
+          fieldset
+        }, lazyGetter(field, "type", () => extendMember({
+          ...rest,
+          title: fieldDef.title || startCase(name)
+        })), objectFieldCache.set(fieldDef, field);
+      }
+      return field;
+    }
+  });
   return schemaDef.types.forEach(add), {
     registry,
     localTypeNames
@@ -1360,13 +1459,13 @@ function compileRegistry(schemaDef) {
     }
   }
   function extendMember(memberDef) {
-    return ensure(memberDef.type), registry[memberDef.type].extend(memberDef, extendMember).get();
+    return ensure(memberDef.type), registry[memberDef.type].extend(memberDef, extendHelper).get();
   }
   function add(typeDef) {
     ensure(typeDef.type), !registry[typeDef.name] && (localTypeNames.push(typeDef.name), registry[typeDef.name] = registry[typeDef.type].extend(typeDef, extendMember));
   }
 }
-let Schema$1 = class Schema {
+class Schema {
   _original;
   _registry;
   #localTypeNames;
@@ -1399,8 +1498,8 @@ let Schema$1 = class Schema {
   getLocalTypeNames() {
     return this.#localTypeNames;
   }
-};
-class DeprecatedDefaultSchema extends Schema$1 {
+}
+class DeprecatedDefaultSchema extends Schema {
   static compile(schemaDef) {
     return new DeprecatedDefaultSchema(schemaDef);
   }
@@ -1412,9 +1511,216 @@ class DeprecatedDefaultSchema extends Schema$1 {
     console.warn(stack);
   }
 }
-const Schema2 = Schema$1;
+const FIELD_REF = /* @__PURE__ */ Symbol("FIELD_REF"), ruleConstraintTypes = [
+  "Array",
+  "Boolean",
+  "Date",
+  "Number",
+  "Object",
+  "String"
+], Rule = class Rule2 {
+  static FIELD_REF = FIELD_REF;
+  static array = (def) => new Rule2(def).type("Array");
+  static object = (def) => new Rule2(def).type("Object");
+  static string = (def) => new Rule2(def).type("String");
+  static number = (def) => new Rule2(def).type("Number");
+  static boolean = (def) => new Rule2(def).type("Boolean");
+  static dateTime = (def) => new Rule2(def).type("Date");
+  static valueOfField = (path) => ({
+    type: FIELD_REF,
+    path
+  });
+  _type = void 0;
+  _level = void 0;
+  _required = void 0;
+  _typeDef = void 0;
+  _message = void 0;
+  _rules = [];
+  _fieldRules = void 0;
+  constructor(typeDef) {
+    this._typeDef = typeDef, this.reset();
+  }
+  _mergeRequired(next) {
+    if (this._required === "required" || next._required === "required") return "required";
+    if (this._required === "optional" || next._required === "optional") return "optional";
+  }
+  // Alias to static method, since we often have access to an _instance_ of a rule but not the actual Rule class
+  valueOfField = Rule2.valueOfField.bind(Rule2);
+  error(message) {
+    const rule = this.clone();
+    return rule._level = "error", rule._message = message || void 0, rule;
+  }
+  warning(message) {
+    const rule = this.clone();
+    return rule._level = "warning", rule._message = message || void 0, rule;
+  }
+  info(message) {
+    const rule = this.clone();
+    return rule._level = "info", rule._message = message || void 0, rule;
+  }
+  reset() {
+    return this._type = this._type || void 0, this._rules = (this._rules || []).filter((rule) => rule.flag === "type"), this._message = void 0, this._required = void 0, this._level = "error", this._fieldRules = void 0, this;
+  }
+  isRequired() {
+    return this._required === "required";
+  }
+  clone() {
+    const rule = new Rule2();
+    return rule._type = this._type, rule._message = this._message, rule._required = this._required, rule._rules = cloneDeep(this._rules), rule._level = this._level, rule._fieldRules = this._fieldRules, rule._typeDef = this._typeDef, rule;
+  }
+  cloneWithRules(rules) {
+    const rule = this.clone(), newRules = /* @__PURE__ */ new Set();
+    return rules.forEach((curr) => {
+      curr.flag === "type" && (rule._type = curr.constraint), newRules.add(curr.flag);
+    }), rule._rules = rule._rules.filter((curr) => {
+      const disallowDuplicate = ["type", "uri", "email"].includes(curr.flag), isDuplicate = newRules.has(curr.flag);
+      return !(disallowDuplicate && isDuplicate);
+    }).concat(rules), rule;
+  }
+  merge(rule) {
+    if (this._type && rule._type && this._type !== rule._type)
+      throw new Error("merge() failed: conflicting types");
+    const newRule = this.cloneWithRules(rule._rules);
+    return newRule._type = this._type || rule._type, newRule._message = this._message || rule._message, newRule._required = this._mergeRequired(rule), newRule._level = this._level === "error" ? rule._level : this._level, newRule;
+  }
+  // Validation flag setters
+  type(targetType) {
+    const type = `${targetType.slice(0, 1).toUpperCase()}${targetType.slice(1)}`;
+    if (!ruleConstraintTypes.includes(type))
+      throw new Error(`Unknown type "${targetType}"`);
+    const rule = this.cloneWithRules([{ flag: "type", constraint: type }]);
+    return rule._type = type, rule;
+  }
+  all(children) {
+    return this.cloneWithRules([{ flag: "all", constraint: children }]);
+  }
+  either(children) {
+    return this.cloneWithRules([{ flag: "either", constraint: children }]);
+  }
+  // Shared rules
+  optional() {
+    const rule = this.cloneWithRules([{ flag: "presence", constraint: "optional" }]);
+    return rule._required = "optional", rule;
+  }
+  required() {
+    const rule = this.cloneWithRules([{ flag: "presence", constraint: "required" }]);
+    return rule._required = "required", rule;
+  }
+  custom(fn, options = {}) {
+    return options.bypassConcurrencyLimit && Object.assign(fn, { bypassConcurrencyLimit: !0 }), this.cloneWithRules([{ flag: "custom", constraint: fn }]);
+  }
+  min(len) {
+    return this.cloneWithRules([{ flag: "min", constraint: len }]);
+  }
+  max(len) {
+    return this.cloneWithRules([{ flag: "max", constraint: len }]);
+  }
+  length(len) {
+    return this.cloneWithRules([{ flag: "length", constraint: len }]);
+  }
+  valid(value) {
+    const values = Array.isArray(value) ? value : [value];
+    return this.cloneWithRules([{ flag: "valid", constraint: values }]);
+  }
+  // Numbers only
+  integer() {
+    return this.cloneWithRules([{ flag: "integer" }]);
+  }
+  precision(limit) {
+    return this.cloneWithRules([{ flag: "precision", constraint: limit }]);
+  }
+  positive() {
+    return this.cloneWithRules([{ flag: "min", constraint: 0 }]);
+  }
+  negative() {
+    return this.cloneWithRules([{ flag: "lessThan", constraint: 0 }]);
+  }
+  greaterThan(num) {
+    return this.cloneWithRules([{ flag: "greaterThan", constraint: num }]);
+  }
+  lessThan(num) {
+    return this.cloneWithRules([{ flag: "lessThan", constraint: num }]);
+  }
+  // String only
+  uppercase() {
+    return this.cloneWithRules([{ flag: "stringCasing", constraint: "uppercase" }]);
+  }
+  lowercase() {
+    return this.cloneWithRules([{ flag: "stringCasing", constraint: "lowercase" }]);
+  }
+  regex(pattern, a, b) {
+    const name = typeof a == "string" ? a : a?.name ?? b?.name, invert = typeof a == "string" ? !1 : a?.invert ?? b?.invert, constraint = {
+      pattern,
+      name,
+      invert: invert || !1
+    };
+    return this.cloneWithRules([{ flag: "regex", constraint }]);
+  }
+  email() {
+    return this.cloneWithRules([{ flag: "email" }]);
+  }
+  uri(opts) {
+    const optsScheme = opts?.scheme || ["http", "https"], schemes = Array.isArray(optsScheme) ? optsScheme : [optsScheme];
+    if (!schemes.length)
+      throw new Error("scheme must have at least 1 scheme specified");
+    const constraint = {
+      options: {
+        scheme: schemes.map((scheme) => {
+          if (!(scheme instanceof RegExp) && typeof scheme != "string")
+            throw new Error("scheme must be a RegExp or a String");
+          return typeof scheme == "string" ? new RegExp(`^${escapeRegex(scheme)}$`) : scheme;
+        }),
+        allowRelative: opts?.allowRelative || !1,
+        relativeOnly: opts?.relativeOnly || !1,
+        allowCredentials: opts?.allowCredentials || !1
+      }
+    };
+    return this.cloneWithRules([{ flag: "uri", constraint }]);
+  }
+  // Array only
+  unique() {
+    return this.cloneWithRules([{ flag: "unique" }]);
+  }
+  // Objects only
+  reference() {
+    return this.cloneWithRules([{ flag: "reference" }]);
+  }
+  fields(rules) {
+    if (this._type !== "Object")
+      throw new Error("fields() can only be called on an object type");
+    const rule = this.cloneWithRules([]);
+    return rule._fieldRules = rules, rule;
+  }
+  assetRequired() {
+    const base = getBaseType(this._typeDef);
+    let assetType;
+    return base && ["image", "file"].includes(base.name) ? assetType = base.name === "image" ? "image" : "file" : assetType = "asset", this.cloneWithRules([{ flag: "assetRequired", constraint: { assetType } }]);
+  }
+  media(fn) {
+    return this.cloneWithRules([{ flag: "media", constraint: fn }]);
+  }
+  /**
+   * The validate method is not implemented in the base Rule class.
+   * It should be implemented by extending this class or injecting validation logic.
+   */
+  async validate(value, options) {
+    throw new Error("validate() method must be implemented by extending Rule class");
+  }
+};
+function getBaseType(type) {
+  return type && type.type ? getBaseType(type.type) : type;
+}
+function escapeRegex(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 export {
-  Schema2 as Schema,
-  DeprecatedDefaultSchema as default
+  ALL_FIELDS_GROUP_NAME,
+  DEFAULT_MAX_FIELD_DEPTH,
+  DeprecatedDefaultSchema,
+  OWN_PROPS_NAME,
+  Rule,
+  Schema,
+  resolveSearchConfig,
+  resolveSearchConfigForBaseFieldPaths
 };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=Rule.js.map