payload 1.15.7 → 1.15.9

package/packages/payload/dist/fields/validations.js

@@ -0,0 +1,543 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    array: function() {
+        return array;
+    },
+    blocks: function() {
+        return blocks;
+    },
+    checkbox: function() {
+        return checkbox;
+    },
+    code: function() {
+        return code;
+    },
+    date: function() {
+        return date;
+    },
+    default: function() {
+        return _default;
+    },
+    email: function() {
+        return email;
+    },
+    json: function() {
+        return json;
+    },
+    number: function() {
+        return number;
+    },
+    password: function() {
+        return password;
+    },
+    point: function() {
+        return point;
+    },
+    radio: function() {
+        return radio;
+    },
+    relationship: function() {
+        return relationship;
+    },
+    richText: function() {
+        return richText;
+    },
+    select: function() {
+        return select;
+    },
+    text: function() {
+        return text;
+    },
+    textarea: function() {
+        return textarea;
+    },
+    upload: function() {
+        return upload;
+    }
+});
+const _ajv = /*#__PURE__*/ _interop_require_default(require("ajv"));
+const _bsonobjectid = /*#__PURE__*/ _interop_require_default(require("bson-objectid"));
+const _canUseDOM = /*#__PURE__*/ _interop_require_default(require("../utilities/canUseDOM"));
+const _getIDType = require("../utilities/getIDType");
+const _isNumber = require("../utilities/isNumber");
+const _isValidID = require("../utilities/isValidID");
+const _types = require("./config/types");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const text = (value, { config, hasMany, maxLength: fieldMaxLength, maxRows, minLength, minRows, required, t })=>{
+    let maxLength;
+    if (!required) {
+        if (!value) return true;
+    }
+    if (hasMany === true) {
+        const lengthValidationResult = validateArrayLength(value, {
+            maxRows,
+            minRows,
+            required,
+            t
+        });
+        if (typeof lengthValidationResult === 'string') return lengthValidationResult;
+    }
+    if (typeof config?.defaultMaxTextLength === 'number') maxLength = config.defaultMaxTextLength;
+    if (typeof fieldMaxLength === 'number') maxLength = fieldMaxLength;
+    const stringsToValidate = Array.isArray(value) ? value : [
+        value
+    ];
+    for (const stringValue of stringsToValidate){
+        const length = stringValue?.length || 0;
+        if (typeof maxLength === 'number' && length > maxLength) {
+            return t('validation:shorterThanMax', {
+                label: t('value'),
+                maxLength,
+                stringValue
+            });
+        }
+        if (typeof minLength === 'number' && length < minLength) {
+            return t('validation:longerThanMin', {
+                label: t('value'),
+                minLength,
+                stringValue
+            });
+        }
+    }
+    if (required) {
+        if (!(typeof value === 'string' || Array.isArray(value)) || value?.length === 0) {
+            return t('validation:required');
+        }
+    }
+    return true;
+};
+const password = (value, { config, maxLength: fieldMaxLength, minLength, payload, required, t })=>{
+    let maxLength;
+    if (typeof config?.defaultMaxTextLength === 'number') maxLength = config.defaultMaxTextLength;
+    if (typeof fieldMaxLength === 'number') maxLength = fieldMaxLength;
+    if (value && maxLength && value.length > maxLength) {
+        return t('validation:shorterThanMax', {
+            maxLength
+        });
+    }
+    if (value && minLength && value.length < minLength) {
+        return t('validation:longerThanMin', {
+            minLength
+        });
+    }
+    if (required && !value) {
+        return t('validation:required');
+    }
+    return true;
+};
+const email = (value, { required, t })=>{
+    if (value && !/\S[^\s@]*@\S+\.\S+/.test(value) || !value && required) {
+        return t('validation:emailAddress');
+    }
+    return true;
+};
+const textarea = (value, { config, maxLength: fieldMaxLength, minLength, payload, required, t })=>{
+    let maxLength;
+    if (typeof config?.defaultMaxTextLength === 'number') maxLength = config.defaultMaxTextLength;
+    if (typeof fieldMaxLength === 'number') maxLength = fieldMaxLength;
+    if (value && maxLength && value.length > maxLength) {
+        return t('validation:shorterThanMax', {
+            maxLength
+        });
+    }
+    if (value && minLength && value.length < minLength) {
+        return t('validation:longerThanMin', {
+            minLength
+        });
+    }
+    if (required && !value) {
+        return t('validation:required');
+    }
+    return true;
+};
+const code = (value, { required, t })=>{
+    if (required && value === undefined) {
+        return t('validation:required');
+    }
+    return true;
+};
+const json = async (value, { jsonError, jsonSchema, required, t })=>{
+    if (required && !value) {
+        return t('validation:required');
+    }
+    if (jsonError !== undefined) {
+        return t('validation:invalidInput');
+    }
+    const isNotEmpty = (value)=>{
+        if (value === undefined || value === null) {
+            return false;
+        }
+        if (Array.isArray(value) && value.length === 0) {
+            return false;
+        }
+        if (typeof value === 'object' && Object.keys(value).length === 0) {
+            return false;
+        }
+        return true;
+    };
+    const fetchSchema = ({ schema, uri })=>{
+        if (uri && schema) return schema;
+        return fetch(uri).then((response)=>{
+            if (!response.ok) {
+                throw new Error('Network response was not ok');
+            }
+            return response.json();
+        }).then((json)=>{
+            const jsonSchemaSanitizations = {
+                id: undefined,
+                $id: json.id,
+                $schema: 'http://json-schema.org/draft-07/schema#'
+            };
+            return Object.assign(json, jsonSchemaSanitizations);
+        });
+    };
+    if (!_canUseDOM.default && jsonSchema && isNotEmpty(value)) {
+        try {
+            jsonSchema.schema = await fetchSchema(jsonSchema);
+            const { schema } = jsonSchema;
+            const ajv = new _ajv.default();
+            if (!ajv.validate(schema, value)) {
+                return t(ajv.errorsText());
+            }
+        } catch (error) {
+            return t(error.message);
+        }
+    }
+    return true;
+};
+const checkbox = (value, { required, t })=>{
+    if (value && typeof value !== 'boolean' || required && typeof value !== 'boolean') {
+        return t('validation:trueOrFalse');
+    }
+    return true;
+};
+const date = (value, { required, t })=>{
+    if (value instanceof Date) {
+        return true;
+    }
+    if (value && !isNaN(Date.parse(value.toString()))) {
+        /* eslint-disable-line */ return true;
+    }
+    if (value) {
+        return t('validation:notValidDate', {
+            value
+        });
+    }
+    if (required) {
+        return t('validation:required');
+    }
+    return true;
+};
+const richText = async (value, options)=>{
+    const editor = options?.editor;
+    return await editor.validate(value, options);
+};
+const validateArrayLength = (value, options)=>{
+    const { maxRows, minRows, required, t } = options;
+    const arrayLength = Array.isArray(value) ? value.length : 0;
+    if (!required && arrayLength === 0) return true;
+    if (minRows && arrayLength < minRows) {
+        return t('validation:requiresAtLeast', {
+            count: minRows,
+            label: t('rows')
+        });
+    }
+    if (maxRows && arrayLength > maxRows) {
+        return t('validation:requiresNoMoreThan', {
+            count: maxRows,
+            label: t('rows')
+        });
+    }
+    if (required && !arrayLength) {
+        return t('validation:requiresAtLeast', {
+            count: 1,
+            label: t('row')
+        });
+    }
+    return true;
+};
+const number = (value, { hasMany, max, maxRows, min, minRows, required, t })=>{
+    if (hasMany === true) {
+        const lengthValidationResult = validateArrayLength(value, {
+            maxRows,
+            minRows,
+            required,
+            t
+        });
+        if (typeof lengthValidationResult === 'string') return lengthValidationResult;
+    }
+    if (!value && !(0, _isNumber.isNumber)(value)) {
+        // if no value is present, validate based on required
+        if (required) return t('validation:required');
+        if (!required) return true;
+    }
+    const numbersToValidate = Array.isArray(value) ? value : [
+        value
+    ];
+    for (const number of numbersToValidate){
+        if (!(0, _isNumber.isNumber)(number)) return t('validation:enterNumber');
+        const numberValue = parseFloat(number);
+        if (typeof max === 'number' && numberValue > max) {
+            return t('validation:greaterThanMax', {
+                label: t('value'),
+                max,
+                value
+            });
+        }
+        if (typeof min === 'number' && numberValue < min) {
+            return t('validation:lessThanMin', {
+                label: t('value'),
+                min,
+                value
+            });
+        }
+    }
+    return true;
+};
+const array = (value, { maxRows, minRows, required, t })=>{
+    return validateArrayLength(value, {
+        maxRows,
+        minRows,
+        required,
+        t
+    });
+};
+const blocks = (value, { maxRows, minRows, required, t })=>{
+    return validateArrayLength(value, {
+        maxRows,
+        minRows,
+        required,
+        t
+    });
+};
+const validateFilterOptions = async (value, { id, data, filterOptions, payload, relationTo, req, siblingData, t, user })=>{
+    if (!_canUseDOM.default && typeof filterOptions !== 'undefined' && value) {
+        const options = {};
+        const falseCollections = [];
+        const collections = typeof relationTo === 'string' ? [
+            relationTo
+        ] : relationTo;
+        const values = Array.isArray(value) ? value : [
+            value
+        ];
+        await Promise.all(collections.map(async (collection)=>{
+            try {
+                let optionFilter = typeof filterOptions === 'function' ? await filterOptions({
+                    id,
+                    data,
+                    relationTo: collection,
+                    siblingData,
+                    user
+                }) : filterOptions;
+                if (optionFilter === true) {
+                    optionFilter = null;
+                }
+                const valueIDs = [];
+                values.forEach((val)=>{
+                    if (typeof val === 'object') {
+                        if (val?.value) {
+                            valueIDs.push(val.value);
+                        } else if (_bsonobjectid.default.isValid(val)) {
+                            valueIDs.push(new _bsonobjectid.default(val).toHexString());
+                        }
+                    }
+                    if (typeof val === 'string' || typeof val === 'number') {
+                        valueIDs.push(val);
+                    }
+                });
+                if (valueIDs.length > 0) {
+                    const findWhere = {
+                        and: [
+                            {
+                                id: {
+                                    in: valueIDs
+                                }
+                            }
+                        ]
+                    };
+                    if (optionFilter) findWhere.and.push(optionFilter);
+                    if (optionFilter === false) {
+                        falseCollections.push(optionFilter);
+                    }
+                    const result = await payload.find({
+                        collection,
+                        depth: 0,
+                        limit: 0,
+                        pagination: false,
+                        req,
+                        where: findWhere
+                    });
+                    options[collection] = result.docs.map((doc)=>doc.id);
+                } else {
+                    options[collection] = [];
+                }
+            } catch (err) {
+                req.payload.logger.error({
+                    err,
+                    msg: `Error validating filter options for collection ${collection}`
+                });
+                options[collection] = [];
+            }
+        }));
+        const invalidRelationships = values.filter((val)=>{
+            let collection;
+            let requestedID;
+            if (typeof relationTo === 'string') {
+                collection = relationTo;
+                if (typeof val === 'string' || typeof val === 'number') {
+                    requestedID = val;
+                }
+                if (typeof val === 'object' && _bsonobjectid.default.isValid(val)) {
+                    requestedID = new _bsonobjectid.default(val).toHexString();
+                }
+            }
+            if (Array.isArray(relationTo) && typeof val === 'object' && val?.relationTo) {
+                collection = val.relationTo;
+                requestedID = val.value;
+            }
+            if (falseCollections.find((slug)=>relationTo === slug)) {
+                return true;
+            }
+            return options[collection].indexOf(requestedID) === -1;
+        });
+        if (invalidRelationships.length > 0) {
+            return invalidRelationships.reduce((err, invalid, i)=>{
+                return `${err} ${JSON.stringify(invalid)}${invalidRelationships.length === i + 1 ? ',' : ''} `;
+            }, t('validation:invalidSelections'));
+        }
+        return true;
+    }
+    return true;
+};
+const upload = (value, options)=>{
+    if (!value && options.required) {
+        return options.t('validation:required');
+    }
+    if (!_canUseDOM.default && typeof value !== 'undefined' && value !== null) {
+        const idField = options?.config?.collections?.find((collection)=>collection.slug === options.relationTo)?.fields?.find((field)=>(0, _types.fieldAffectsData)(field) && field.name === 'id');
+        const type = (0, _getIDType.getIDType)(idField, options?.payload?.db?.defaultIDType);
+        if (!(0, _isValidID.isValidID)(value, type)) {
+            return options.t('validation:validUploadID');
+        }
+    }
+    return validateFilterOptions(value, options);
+};
+const relationship = async (value, options)=>{
+    const { config, maxRows, minRows, payload, relationTo, required, t } = options;
+    if ((!value || Array.isArray(value) && value.length === 0) && required) {
+        return t('validation:required');
+    }
+    if (Array.isArray(value) && value.length > 0) {
+        if (minRows && value.length < minRows) {
+            return t('validation:lessThanMin', {
+                label: t('rows'),
+                min: minRows,
+                value: value.length
+            });
+        }
+        if (maxRows && value.length > maxRows) {
+            return t('validation:greaterThanMax', {
+                label: t('rows'),
+                max: maxRows,
+                value: value.length
+            });
+        }
+    }
+    if (!_canUseDOM.default && typeof value !== 'undefined' && value !== null) {
+        const values = Array.isArray(value) ? value : [
+            value
+        ];
+        const invalidRelationships = values.filter((val)=>{
+            let collectionSlug;
+            let requestedID;
+            if (typeof relationTo === 'string') {
+                collectionSlug = relationTo;
+                // custom id
+                if (val) {
+                    requestedID = val;
+                }
+            }
+            if (Array.isArray(relationTo) && typeof val === 'object' && val?.relationTo) {
+                collectionSlug = val.relationTo;
+                requestedID = val.value;
+            }
+            if (requestedID === null) return false;
+            const idField = config?.collections?.find((collection)=>collection.slug === collectionSlug)?.fields?.find((field)=>(0, _types.fieldAffectsData)(field) && field.name === 'id');
+            const type = (0, _getIDType.getIDType)(idField, payload?.db?.defaultIDType);
+            return !(0, _isValidID.isValidID)(requestedID, type);
+        });
+        if (invalidRelationships.length > 0) {
+            return `This relationship field has the following invalid relationships: ${invalidRelationships.map((err, invalid)=>{
+                return `${err} ${JSON.stringify(invalid)}`;
+            }).join(', ')}`;
+        }
+    }
+    return validateFilterOptions(value, options);
+};
+const select = (value, { hasMany, options, required, t })=>{
+    if (Array.isArray(value) && value.some((input)=>!options.some((option)=>option === input || typeof option !== 'string' && option?.value === input))) {
+        return t('validation:invalidSelection');
+    }
+    if (typeof value === 'string' && !options.some((option)=>option === value || typeof option !== 'string' && option.value === value)) {
+        return t('validation:invalidSelection');
+    }
+    if (required && (typeof value === 'undefined' || value === null || hasMany && Array.isArray(value) && value?.length === 0)) {
+        return t('validation:required');
+    }
+    return true;
+};
+const radio = (value, { options, required, t })=>{
+    if (value) {
+        const valueMatchesOption = options.some((option)=>option === value || typeof option !== 'string' && option.value === value);
+        return valueMatchesOption || t('validation:invalidSelection');
+    }
+    return required ? t('validation:required') : true;
+};
+const point = (value = [
+    '',
+    ''
+], { required, t })=>{
+    const lng = parseFloat(String(value[0]));
+    const lat = parseFloat(String(value[1]));
+    if (required && (value[0] && value[1] && typeof lng !== 'number' && typeof lat !== 'number' || Number.isNaN(lng) || Number.isNaN(lat) || Array.isArray(value) && value.length !== 2)) {
+        return t('validation:requiresTwoNumbers');
+    }
+    if (value[1] && Number.isNaN(lng) || value[0] && Number.isNaN(lat)) {
+        return t('validation:invalidInput');
+    }
+    return true;
+};
+const _default = {
+    array,
+    blocks,
+    checkbox,
+    code,
+    date,
+    email,
+    json,
+    number,
+    password,
+    point,
+    radio,
+    relationship,
+    richText,
+    select,
+    text,
+    textarea,
+    upload
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/fields/validations.ts"],"sourcesContent":["import Ajv from 'ajv'\nimport ObjectID from 'bson-objectid'\n\nimport type { RichTextAdapter } from '../exports/types'\nimport type {\n  ArrayField,\n  BlockField,\n  CheckboxField,\n  CodeField,\n  DateField,\n  EmailField,\n  JSONField,\n  NumberField,\n  PointField,\n  RadioField,\n  RelationshipField,\n  RelationshipValue,\n  RichTextField,\n  SelectField,\n  TextField,\n  TextareaField,\n  UploadField,\n  Validate,\n} from './config/types'\n\nimport canUseDOM from '../utilities/canUseDOM'\nimport { getIDType } from '../utilities/getIDType'\nimport { isNumber } from '../utilities/isNumber'\nimport { isValidID } from '../utilities/isValidID'\nimport { fieldAffectsData } from './config/types'\n\nexport const text: Validate<unknown, unknown, TextField> = (\n  value: string | string[],\n  { config, hasMany, maxLength: fieldMaxLength, maxRows, minLength, minRows, required, t },\n) => {\n  let maxLength: number\n\n  if (!required) {\n    if (!value) return true\n  }\n\n  if (hasMany === true) {\n    const lengthValidationResult = validateArrayLength(value, { maxRows, minRows, required, t })\n    if (typeof lengthValidationResult === 'string') return lengthValidationResult\n  }\n\n  if (typeof config?.defaultMaxTextLength === 'number') maxLength = config.defaultMaxTextLength\n  if (typeof fieldMaxLength === 'number') maxLength = fieldMaxLength\n\n  const stringsToValidate: string[] = Array.isArray(value) ? value : [value]\n\n  for (const stringValue of stringsToValidate) {\n    const length = stringValue?.length || 0\n\n    if (typeof maxLength === 'number' && length > maxLength) {\n      return t('validation:shorterThanMax', { label: t('value'), maxLength, stringValue })\n    }\n\n    if (typeof minLength === 'number' && length < minLength) {\n      return t('validation:longerThanMin', { label: t('value'), minLength, stringValue })\n    }\n  }\n\n  if (required) {\n    if (!(typeof value === 'string' || Array.isArray(value)) || value?.length === 0) {\n      return t('validation:required')\n    }\n  }\n\n  return true\n}\n\nexport const password: Validate<unknown, unknown, TextField> = (\n  value: string,\n  { config, maxLength: fieldMaxLength, minLength, payload, required, t },\n) => {\n  let maxLength: number\n\n  if (typeof config?.defaultMaxTextLength === 'number') maxLength = config.defaultMaxTextLength\n  if (typeof fieldMaxLength === 'number') maxLength = fieldMaxLength\n\n  if (value && maxLength && value.length > maxLength) {\n    return t('validation:shorterThanMax', { maxLength })\n  }\n\n  if (value && minLength && value.length < minLength) {\n    return t('validation:longerThanMin', { minLength })\n  }\n\n  if (required && !value) {\n    return t('validation:required')\n  }\n\n  return true\n}\n\nexport const email: Validate<unknown, unknown, EmailField> = (value: string, { required, t }) => {\n  if ((value && !/\\S[^\\s@]*@\\S+\\.\\S+/.test(value)) || (!value && required)) {\n    return t('validation:emailAddress')\n  }\n\n  return true\n}\n\nexport const textarea: Validate<unknown, unknown, TextareaField> = (\n  value: string,\n  { config, maxLength: fieldMaxLength, minLength, payload, required, t },\n) => {\n  let maxLength: number\n\n  if (typeof config?.defaultMaxTextLength === 'number') maxLength = config.defaultMaxTextLength\n  if (typeof fieldMaxLength === 'number') maxLength = fieldMaxLength\n  if (value && maxLength && value.length > maxLength) {\n    return t('validation:shorterThanMax', { maxLength })\n  }\n\n  if (value && minLength && value.length < minLength) {\n    return t('validation:longerThanMin', { minLength })\n  }\n\n  if (required && !value) {\n    return t('validation:required')\n  }\n\n  return true\n}\n\nexport const code: Validate<unknown, unknown, CodeField> = (value: string, { required, t }) => {\n  if (required && value === undefined) {\n    return t('validation:required')\n  }\n\n  return true\n}\n\nexport const json: Validate<unknown, unknown, JSONField & { jsonError?: string }> = async (\n  value: string,\n  { jsonError, jsonSchema, required, t },\n) => {\n  if (required && !value) {\n    return t('validation:required')\n  }\n\n  if (jsonError !== undefined) {\n    return t('validation:invalidInput')\n  }\n\n  const isNotEmpty = (value) => {\n    if (value === undefined || value === null) {\n      return false\n    }\n\n    if (Array.isArray(value) && value.length === 0) {\n      return false\n    }\n\n    if (typeof value === 'object' && Object.keys(value).length === 0) {\n      return false\n    }\n\n    return true\n  }\n\n  const fetchSchema = ({ schema, uri }) => {\n    if (uri && schema) return schema\n    return fetch(uri)\n      .then((response) => {\n        if (!response.ok) {\n          throw new Error('Network response was not ok')\n        }\n        return response.json()\n      })\n      .then((json) => {\n        const jsonSchemaSanitizations = {\n          id: undefined,\n          $id: json.id,\n          $schema: 'http://json-schema.org/draft-07/schema#',\n        }\n        return Object.assign(json, jsonSchemaSanitizations)\n      })\n  }\n\n  if (!canUseDOM && jsonSchema && isNotEmpty(value)) {\n    try {\n      jsonSchema.schema = await fetchSchema(jsonSchema)\n      const { schema } = jsonSchema\n      const ajv = new Ajv()\n\n      if (!ajv.validate(schema, value)) {\n        return t(ajv.errorsText())\n      }\n    } catch (error) {\n      return t(error.message)\n    }\n  }\n\n  return true\n}\n\nexport const checkbox: Validate<unknown, unknown, CheckboxField> = (\n  value: boolean,\n  { required, t },\n) => {\n  if ((value && typeof value !== 'boolean') || (required && typeof value !== 'boolean')) {\n    return t('validation:trueOrFalse')\n  }\n\n  return true\n}\n\nexport const date: Validate<unknown, unknown, DateField> = (value, { required, t }) => {\n  if (value instanceof Date) {\n    return true\n  }\n\n  if (value && !isNaN(Date.parse(value.toString()))) {\n    /* eslint-disable-line */\n    return true\n  }\n\n  if (value) {\n    return t('validation:notValidDate', { value })\n  }\n\n  if (required) {\n    return t('validation:required')\n  }\n\n  return true\n}\n\nexport const richText: Validate<object, unknown, RichTextField, RichTextField> = async (\n  value,\n  options,\n) => {\n  const editor: RichTextAdapter = options?.editor\n\n  return await editor.validate(value, options)\n}\n\nconst validateArrayLength: any = (\n  value,\n  options: {\n    maxRows?: number\n    minRows?: number\n    required?: boolean\n    t: (key: string, options?: { [key: string]: number | string }) => string\n  },\n) => {\n  const { maxRows, minRows, required, t } = options\n\n  const arrayLength = Array.isArray(value) ? value.length : 0\n\n  if (!required && arrayLength === 0) return true\n\n  if (minRows && arrayLength < minRows) {\n    return t('validation:requiresAtLeast', { count: minRows, label: t('rows') })\n  }\n\n  if (maxRows && arrayLength > maxRows) {\n    return t('validation:requiresNoMoreThan', { count: maxRows, label: t('rows') })\n  }\n\n  if (required && !arrayLength) {\n    return t('validation:requiresAtLeast', { count: 1, label: t('row') })\n  }\n\n  return true\n}\n\nexport const number: Validate<unknown, unknown, NumberField> = (\n  value: number | number[],\n  { hasMany, max, maxRows, min, minRows, required, t },\n) => {\n  if (hasMany === true) {\n    const lengthValidationResult = validateArrayLength(value, { maxRows, minRows, required, t })\n    if (typeof lengthValidationResult === 'string') return lengthValidationResult\n  }\n\n  if (!value && !isNumber(value)) {\n    // if no value is present, validate based on required\n    if (required) return t('validation:required')\n    if (!required) return true\n  }\n\n  const numbersToValidate: number[] = Array.isArray(value) ? value : [value]\n\n  for (const number of numbersToValidate) {\n    if (!isNumber(number)) return t('validation:enterNumber')\n\n    const numberValue = parseFloat(number as unknown as string)\n\n    if (typeof max === 'number' && numberValue > max) {\n      return t('validation:greaterThanMax', { label: t('value'), max, value })\n    }\n\n    if (typeof min === 'number' && numberValue < min) {\n      return t('validation:lessThanMin', { label: t('value'), min, value })\n    }\n  }\n\n  return true\n}\n\nexport const array: Validate<unknown, unknown, ArrayField> = (\n  value,\n  { maxRows, minRows, required, t },\n) => {\n  return validateArrayLength(value, { maxRows, minRows, required, t })\n}\n\nexport const blocks: Validate<unknown, unknown, BlockField> = (\n  value,\n  { maxRows, minRows, required, t },\n) => {\n  return validateArrayLength(value, { maxRows, minRows, required, t })\n}\n\nconst validateFilterOptions: Validate = async (\n  value,\n  { id, data, filterOptions, payload, relationTo, req, siblingData, t, user },\n) => {\n  if (!canUseDOM && typeof filterOptions !== 'undefined' && value) {\n    const options: {\n      [collection: string]: (number | string)[]\n    } = {}\n\n    const falseCollections: string[] = []\n    const collections = typeof relationTo === 'string' ? [relationTo] : relationTo\n    const values = Array.isArray(value) ? value : [value]\n\n    await Promise.all(\n      collections.map(async (collection) => {\n        try {\n          let optionFilter =\n            typeof filterOptions === 'function'\n              ? await filterOptions({\n                  id,\n                  data,\n                  relationTo: collection,\n                  siblingData,\n                  user,\n                })\n              : filterOptions\n\n          if (optionFilter === true) {\n            optionFilter = null\n          }\n\n          const valueIDs: (number | string)[] = []\n\n          values.forEach((val) => {\n            if (typeof val === 'object') {\n              if (val?.value) {\n                valueIDs.push(val.value)\n              } else if (ObjectID.isValid(val)) {\n                valueIDs.push(new ObjectID(val).toHexString())\n              }\n            }\n\n            if (typeof val === 'string' || typeof val === 'number') {\n              valueIDs.push(val)\n            }\n          })\n\n          if (valueIDs.length > 0) {\n            const findWhere = {\n              and: [{ id: { in: valueIDs } }],\n            }\n\n            if (optionFilter) findWhere.and.push(optionFilter)\n\n            if (optionFilter === false) {\n              falseCollections.push(optionFilter)\n            }\n\n            const result = await payload.find({\n              collection,\n              depth: 0,\n              limit: 0,\n              pagination: false,\n              req,\n              where: findWhere,\n            })\n\n            options[collection] = result.docs.map((doc) => doc.id)\n          } else {\n            options[collection] = []\n          }\n        } catch (err) {\n          req.payload.logger.error({\n            err,\n            msg: `Error validating filter options for collection ${collection}`,\n          })\n          options[collection] = []\n        }\n      }),\n    )\n\n    const invalidRelationships = values.filter((val) => {\n      let collection: string\n      let requestedID: number | string\n\n      if (typeof relationTo === 'string') {\n        collection = relationTo\n\n        if (typeof val === 'string' || typeof val === 'number') {\n          requestedID = val\n        }\n\n        if (typeof val === 'object' && ObjectID.isValid(val)) {\n          requestedID = new ObjectID(val).toHexString()\n        }\n      }\n\n      if (Array.isArray(relationTo) && typeof val === 'object' && val?.relationTo) {\n        collection = val.relationTo\n        requestedID = val.value\n      }\n\n      if (falseCollections.find((slug) => relationTo === slug)) {\n        return true\n      }\n\n      return options[collection].indexOf(requestedID) === -1\n    })\n\n    if (invalidRelationships.length > 0) {\n      return invalidRelationships.reduce((err, invalid, i) => {\n        return `${err} ${JSON.stringify(invalid)}${\n          invalidRelationships.length === i + 1 ? ',' : ''\n        } `\n      }, t('validation:invalidSelections')) as string\n    }\n\n    return true\n  }\n\n  return true\n}\n\nexport const upload: Validate<unknown, unknown, UploadField> = (value: string, options) => {\n  if (!value && options.required) {\n    return options.t('validation:required')\n  }\n\n  if (!canUseDOM && typeof value !== 'undefined' && value !== null) {\n    const idField = options?.config?.collections\n      ?.find((collection) => collection.slug === options.relationTo)\n      ?.fields?.find((field) => fieldAffectsData(field) && field.name === 'id')\n\n    const type = getIDType(idField, options?.payload?.db?.defaultIDType)\n\n    if (!isValidID(value, type)) {\n      return options.t('validation:validUploadID')\n    }\n  }\n\n  return validateFilterOptions(value, options)\n}\n\nexport const relationship: Validate<unknown, unknown, RelationshipField> = async (\n  value: RelationshipValue,\n  options,\n) => {\n  const { config, maxRows, minRows, payload, relationTo, required, t } = options\n\n  if ((!value || (Array.isArray(value) && value.length === 0)) && required) {\n    return t('validation:required')\n  }\n\n  if (Array.isArray(value) && value.length > 0) {\n    if (minRows && value.length < minRows) {\n      return t('validation:lessThanMin', { label: t('rows'), min: minRows, value: value.length })\n    }\n\n    if (maxRows && value.length > maxRows) {\n      return t('validation:greaterThanMax', { label: t('rows'), max: maxRows, value: value.length })\n    }\n  }\n\n  if (!canUseDOM && typeof value !== 'undefined' && value !== null) {\n    const values = Array.isArray(value) ? value : [value]\n\n    const invalidRelationships = values.filter((val) => {\n      let collectionSlug: string\n      let requestedID\n\n      if (typeof relationTo === 'string') {\n        collectionSlug = relationTo\n\n        // custom id\n        if (val) {\n          requestedID = val\n        }\n      }\n\n      if (Array.isArray(relationTo) && typeof val === 'object' && val?.relationTo) {\n        collectionSlug = val.relationTo\n        requestedID = val.value\n      }\n\n      if (requestedID === null) return false\n\n      const idField = config?.collections\n        ?.find((collection) => collection.slug === collectionSlug)\n        ?.fields?.find((field) => fieldAffectsData(field) && field.name === 'id')\n\n      const type = getIDType(idField, payload?.db?.defaultIDType)\n\n      return !isValidID(requestedID, type)\n    })\n\n    if (invalidRelationships.length > 0) {\n      return `This relationship field has the following invalid relationships: ${invalidRelationships\n        .map((err, invalid) => {\n          return `${err} ${JSON.stringify(invalid)}`\n        })\n        .join(', ')}`\n    }\n  }\n\n  return validateFilterOptions(value, options)\n}\n\nexport const select: Validate<unknown, unknown, SelectField> = (\n  value,\n  { hasMany, options, required, t },\n) => {\n  if (\n    Array.isArray(value) &&\n    value.some(\n      (input) =>\n        !options.some(\n          (option) => option === input || (typeof option !== 'string' && option?.value === input),\n        ),\n    )\n  ) {\n    return t('validation:invalidSelection')\n  }\n\n  if (\n    typeof value === 'string' &&\n    !options.some(\n      (option) => option === value || (typeof option !== 'string' && option.value === value),\n    )\n  ) {\n    return t('validation:invalidSelection')\n  }\n\n  if (\n    required &&\n    (typeof value === 'undefined' ||\n      value === null ||\n      (hasMany && Array.isArray(value) && (value as [])?.length === 0))\n  ) {\n    return t('validation:required')\n  }\n\n  return true\n}\n\nexport const radio: Validate<unknown, unknown, RadioField> = (value, { options, required, t }) => {\n  if (value) {\n    const valueMatchesOption = options.some(\n      (option) => option === value || (typeof option !== 'string' && option.value === value),\n    )\n    return valueMatchesOption || t('validation:invalidSelection')\n  }\n\n  return required ? t('validation:required') : true\n}\n\nexport const point: Validate<unknown, unknown, PointField> = (\n  value: [number | string, number | string] = ['', ''],\n  { required, t },\n) => {\n  const lng = parseFloat(String(value[0]))\n  const lat = parseFloat(String(value[1]))\n  if (\n    required &&\n    ((value[0] && value[1] && typeof lng !== 'number' && typeof lat !== 'number') ||\n      Number.isNaN(lng) ||\n      Number.isNaN(lat) ||\n      (Array.isArray(value) && value.length !== 2))\n  ) {\n    return t('validation:requiresTwoNumbers')\n  }\n\n  if ((value[1] && Number.isNaN(lng)) || (value[0] && Number.isNaN(lat))) {\n    return t('validation:invalidInput')\n  }\n\n  return true\n}\n\nexport default {\n  array,\n  blocks,\n  checkbox,\n  code,\n  date,\n  email,\n  json,\n  number,\n  password,\n  point,\n  radio,\n  relationship,\n  richText,\n  select,\n  text,\n  textarea,\n  upload,\n}\n"],"names":["array","blocks","checkbox","code","date","email","json","number","password","point","radio","relationship","richText","select","text","textarea","upload","value","config","hasMany","maxLength","fieldMaxLength","maxRows","minLength","minRows","required","t","lengthValidationResult","validateArrayLength","defaultMaxTextLength","stringsToValidate","Array","isArray","stringValue","length","label","payload","test","undefined","jsonError","jsonSchema","isNotEmpty","Object","keys","fetchSchema","schema","uri","fetch","then","response","ok","Error","jsonSchemaSanitizations","id","$id","$schema","assign","canUseDOM","ajv","Ajv","validate","errorsText","error","message","Date","isNaN","parse","toString","options","editor","arrayLength","count","max","min","isNumber","numbersToValidate","numberValue","parseFloat","validateFilterOptions","data","filterOptions","relationTo","req","siblingData","user","falseCollections","collections","values","Promise","all","map","collection","optionFilter","valueIDs","forEach","val","push","ObjectID","isValid","toHexString","findWhere","and","in","result","find","depth","limit","pagination","where","docs","doc","err","logger","msg","invalidRelationships","filter","requestedID","slug","indexOf","reduce","invalid","i","JSON","stringify","idField","fields","field","fieldAffectsData","name","type","getIDType","db","defaultIDType","isValidID","collectionSlug","join","some","input","option","valueMatchesOption","lng","String","lat","Number"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}