payload 0.15.13 → 0.16.0

package/dist/admin/components/forms/Form/buildStateFromSchema/addFieldStatePromise.js

@@ -0,0 +1,158 @@
+/* eslint-disable no-param-reassign */
+import ObjectID from 'bson-objectid';
+import { fieldAffectsData, fieldHasSubFields } from '../../../../../fields/config/types';
+import getValueWithDefault from '../../../../../fields/getDefaultValue';
+import { iterateFields } from './iterateFields';
+export const addFieldStatePromise = async ({ field, locale, user, state, path, passesCondition, fullData, data, fieldPromises, id, operation, }) => {
+    var _a;
+    if (fieldAffectsData(field)) {
+        const fieldState = {
+            valid: true,
+            value: undefined,
+            initialValue: undefined,
+            validate: field.validate,
+            condition: (_a = field.admin) === null || _a === void 0 ? void 0 : _a.condition,
+            passesCondition,
+        };
+        const valueWithDefault = await getValueWithDefault({ value: data[field.name], defaultValue: field.defaultValue, locale, user });
+        data[field.name] = valueWithDefault;
+        let validationResult = true;
+        if (typeof fieldState.validate === 'function') {
+            validationResult = await fieldState.validate(data[field.name], {
+                ...field,
+                data: fullData,
+                user,
+                siblingData: data,
+                id,
+                operation,
+            });
+        }
+        if (typeof validationResult === 'string') {
+            fieldState.errorMessage = validationResult;
+            fieldState.valid = false;
+        }
+        else {
+            fieldState.valid = true;
+        }
+        switch (field.type) {
+            case 'array': {
+                const arrayValue = Array.isArray(valueWithDefault) ? valueWithDefault : [];
+                arrayValue.forEach((row, i) => {
+                    const rowPath = `${path}${field.name}.${i}.`;
+                    state[`${rowPath}id`] = {
+                        value: row.id,
+                        initialValue: row.id || new ObjectID().toHexString(),
+                        valid: true,
+                    };
+                    iterateFields({
+                        state,
+                        fields: field.fields,
+                        data: row,
+                        parentPassesCondition: passesCondition,
+                        path: rowPath,
+                        user,
+                        fieldPromises,
+                        fullData,
+                        id,
+                        locale,
+                        operation,
+                    });
+                });
+                // Add values to field state
+                fieldState.value = arrayValue.length;
+                fieldState.initialValue = arrayValue.length;
+                if (arrayValue.length > 0) {
+                    fieldState.disableFormData = true;
+                }
+                // Add field to state
+                state[`${path}${field.name}`] = fieldState;
+                break;
+            }
+            case 'blocks': {
+                const blocksValue = Array.isArray(valueWithDefault) ? valueWithDefault : [];
+                blocksValue.forEach((row, i) => {
+                    const block = field.blocks.find((blockType) => blockType.slug === row.blockType);
+                    const rowPath = `${path}${field.name}.${i}.`;
+                    if (block) {
+                        state[`${rowPath}id`] = {
+                            value: row.id,
+                            initialValue: row.id || new ObjectID().toHexString(),
+                            valid: true,
+                        };
+                        state[`${rowPath}blockType`] = {
+                            value: row.blockType,
+                            initialValue: row.blockType,
+                            valid: true,
+                        };
+                        state[`${rowPath}blockName`] = {
+                            value: row.blockName,
+                            initialValue: row.blockName,
+                            valid: true,
+                        };
+                        iterateFields({
+                            state,
+                            fields: block.fields,
+                            data: row,
+                            fullData,
+                            parentPassesCondition: passesCondition,
+                            path: rowPath,
+                            user,
+                            locale,
+                            operation,
+                            fieldPromises,
+                            id,
+                        });
+                    }
+                });
+                // Add values to field state
+                fieldState.value = blocksValue.length;
+                fieldState.initialValue = blocksValue.length;
+                if (blocksValue.length > 0) {
+                    fieldState.disableFormData = true;
+                }
+                // Add field to state
+                state[`${path}${field.name}`] = fieldState;
+                break;
+            }
+            case 'group': {
+                iterateFields({
+                    state,
+                    id,
+                    operation,
+                    fieldPromises,
+                    fields: field.fields,
+                    data: data === null || data === void 0 ? void 0 : data[field.name],
+                    fullData,
+                    parentPassesCondition: passesCondition,
+                    path: `${path}${field.name}.`,
+                    locale,
+                    user,
+                });
+                break;
+            }
+            default: {
+                fieldState.value = valueWithDefault;
+                fieldState.initialValue = valueWithDefault;
+                // Add field to state
+                state[`${path}${field.name}`] = fieldState;
+                break;
+            }
+        }
+    }
+    else if (fieldHasSubFields(field)) {
+        // Handle field types that do not use names (row, etc)
+        iterateFields({
+            state,
+            fields: field.fields,
+            data,
+            parentPassesCondition: passesCondition,
+            path,
+            user,
+            fieldPromises,
+            fullData,
+            id,
+            locale,
+            operation,
+        });
+    }
+};

package/dist/admin/components/forms/Form/{buildStateFromSchema.d.ts → buildStateFromSchema/index.d.ts}

@@ -1,13 +1,14 @@
-import { User } from '../../../../auth';
-import { Field as FieldSchema } from '../../../../fields/config/types';
-import { Fields, Data } from './types';
-declare type Args = {
-    fieldSchema: FieldSchema[];
-    data?: Data;
-    siblingData?: Data;
-    user?: User;
-    id?: string | number;
-    operation?: 'create' | 'update';
-};
-declare const buildStateFromSchema: (args: Args) => Promise<Fields>;
-export default buildStateFromSchema;
+import { User } from '../../../../../auth';
+import { Field as FieldSchema } from '../../../../../fields/config/types';
+import { Fields, Data } from '../types';
+declare type Args = {
+    fieldSchema: FieldSchema[];
+    data?: Data;
+    siblingData?: Data;
+    user?: User;
+    id?: string | number;
+    operation?: 'create' | 'update';
+    locale: string;
+};
+declare const buildStateFromSchema: (args: Args) => Promise<Fields>;
+export default buildStateFromSchema;

package/dist/admin/components/forms/Form/buildStateFromSchema/index.js

@@ -0,0 +1,25 @@
+import { iterateFields } from './iterateFields';
+const buildStateFromSchema = async (args) => {
+    const { fieldSchema, data: fullData = {}, user, id, operation, locale, } = args;
+    if (fieldSchema) {
+        const fieldPromises = [];
+        const state = {};
+        iterateFields({
+            state,
+            fields: fieldSchema,
+            id,
+            locale,
+            operation,
+            path: '',
+            user,
+            fieldPromises,
+            data: fullData,
+            fullData,
+            parentPassesCondition: true,
+        });
+        await Promise.all(fieldPromises);
+        return state;
+    }
+    return {};
+};
+export default buildStateFromSchema;

package/dist/admin/components/forms/Form/buildStateFromSchema/iterateFields.d.ts

@@ -0,0 +1,18 @@
+import { User } from '../../../../../auth';
+import { Field as FieldSchema } from '../../../../../fields/config/types';
+import { Fields, Data } from '../types';
+declare type Args = {
+    state: Fields;
+    fields: FieldSchema[];
+    data: Data;
+    fullData: Data;
+    parentPassesCondition: boolean;
+    path: string;
+    user: User;
+    locale: string;
+    fieldPromises: Promise<void>[];
+    id: string | number;
+    operation: 'create' | 'update';
+};
+export declare const iterateFields: ({ fields, data, parentPassesCondition, path, fullData, user, locale, operation, fieldPromises, id, state, }: Args) => void;
+export {};

package/dist/admin/components/forms/Form/buildStateFromSchema/iterateFields.js

@@ -0,0 +1,24 @@
+import { fieldIsPresentationalOnly, } from '../../../../../fields/config/types';
+import { addFieldStatePromise } from './addFieldStatePromise';
+export const iterateFields = ({ fields, data, parentPassesCondition, path = '', fullData, user, locale, operation, fieldPromises, id, state, }) => {
+    fields.forEach((field) => {
+        var _a, _b;
+        const initialData = data;
+        if (!fieldIsPresentationalOnly(field) && !((_a = field === null || field === void 0 ? void 0 : field.admin) === null || _a === void 0 ? void 0 : _a.disabled)) {
+            const passesCondition = Boolean((((_b = field === null || field === void 0 ? void 0 : field.admin) === null || _b === void 0 ? void 0 : _b.condition) ? field.admin.condition(fullData || {}, initialData || {}) : true) && parentPassesCondition);
+            fieldPromises.push(addFieldStatePromise({
+                fullData,
+                id,
+                locale,
+                operation,
+                path,
+                state,
+                user,
+                fieldPromises,
+                field,
+                passesCondition,
+                data,
+            }));
+        }
+    });
+};

package/dist/admin/components/forms/Form/context.d.ts

@@ -1,13 +1,13 @@
-/// <reference types="react" />
-import { Context } from './types';
-declare const FormContext: import("react").Context<Context>;
-declare const FormWatchContext: import("react").Context<Context>;
-declare const SubmittedContext: import("react").Context<boolean>;
-declare const ProcessingContext: import("react").Context<boolean>;
-declare const ModifiedContext: import("react").Context<boolean>;
-declare const useForm: () => Context;
-declare const useWatchForm: () => Context;
-declare const useFormSubmitted: () => boolean;
-declare const useFormProcessing: () => boolean;
-declare const useFormModified: () => boolean;
-export { FormContext, FormWatchContext, SubmittedContext, ProcessingContext, ModifiedContext, useForm, useWatchForm, useFormSubmitted, useFormProcessing, useFormModified, };
+/// <reference types="react" />
+import { Context } from './types';
+declare const FormContext: import("react").Context<Context>;
+declare const FormWatchContext: import("react").Context<Context>;
+declare const SubmittedContext: import("react").Context<boolean>;
+declare const ProcessingContext: import("react").Context<boolean>;
+declare const ModifiedContext: import("react").Context<boolean>;
+declare const useForm: () => Context;
+declare const useWatchForm: () => Context;
+declare const useFormSubmitted: () => boolean;
+declare const useFormProcessing: () => boolean;
+declare const useFormModified: () => boolean;
+export { FormContext, FormWatchContext, SubmittedContext, ProcessingContext, ModifiedContext, useForm, useWatchForm, useFormSubmitted, useFormProcessing, useFormModified, };

package/dist/admin/components/forms/Form/context.js

@@ -1,12 +1,12 @@
-import { createContext, useContext } from 'react';
-const FormContext = createContext({});
-const FormWatchContext = createContext({});
-const SubmittedContext = createContext(false);
-const ProcessingContext = createContext(false);
-const ModifiedContext = createContext(false);
-const useForm = () => useContext(FormContext);
-const useWatchForm = () => useContext(FormWatchContext);
-const useFormSubmitted = () => useContext(SubmittedContext);
-const useFormProcessing = () => useContext(ProcessingContext);
-const useFormModified = () => useContext(ModifiedContext);
-export { FormContext, FormWatchContext, SubmittedContext, ProcessingContext, ModifiedContext, useForm, useWatchForm, useFormSubmitted, useFormProcessing, useFormModified, };
+import { createContext, useContext } from 'react';
+const FormContext = createContext({});
+const FormWatchContext = createContext({});
+const SubmittedContext = createContext(false);
+const ProcessingContext = createContext(false);
+const ModifiedContext = createContext(false);
+const useForm = () => useContext(FormContext);
+const useWatchForm = () => useContext(FormWatchContext);
+const useFormSubmitted = () => useContext(SubmittedContext);
+const useFormProcessing = () => useContext(ProcessingContext);
+const useFormModified = () => useContext(ModifiedContext);
+export { FormContext, FormWatchContext, SubmittedContext, ProcessingContext, ModifiedContext, useForm, useWatchForm, useFormSubmitted, useFormProcessing, useFormModified, };

package/dist/admin/components/forms/Form/errorMessages.d.ts

@@ -1,4 +1,4 @@
-declare const _default: {
-    413: string;
-};
-export default _default;
+declare const _default: {
+    413: string;
+};
+export default _default;

package/dist/admin/components/forms/Form/errorMessages.js

@@ -1,3 +1,3 @@
-export default {
-    413: 'Your request was too large to submit successfully.',
-};
+export default {
+    413: 'Your request was too large to submit successfully.',
+};

package/dist/admin/components/forms/Form/fieldReducer.d.ts

@@ -1,3 +1,3 @@
-import { Fields } from './types';
-declare function fieldReducer(state: Fields, action: any): Fields;
-export default fieldReducer;
+import { Fields } from './types';
+declare function fieldReducer(state: Fields, action: any): Fields;
+export default fieldReducer;

package/dist/admin/components/forms/Form/fieldReducer.js

@@ -1,147 +1,147 @@
-import equal from 'deep-equal';
-import { unflatten, flatten } from 'flatley';
-import flattenFilters from './flattenFilters';
-import getSiblingData from './getSiblingData';
-import reduceFieldsToValues from './reduceFieldsToValues';
-const unflattenRowsFromState = (state, path) => {
-    // Take a copy of state
-    const remainingFlattenedState = { ...state };
-    const rowsFromStateObject = {};
-    const pathPrefixToRemove = path.substring(0, path.lastIndexOf('.') + 1);
-    // Loop over all keys from state
-    // If the key begins with the name of the parent field,
-    // Add value to rowsFromStateObject and delete it from remaining state
-    Object.keys(state).forEach((key) => {
-        if (key.indexOf(`${path}.`) === 0) {
-            if (!state[key].disableFormData) {
-                const name = key.replace(pathPrefixToRemove, '');
-                rowsFromStateObject[name] = state[key];
-                rowsFromStateObject[name].initialValue = rowsFromStateObject[name].value;
-            }
-            delete remainingFlattenedState[key];
-        }
-    });
-    const unflattenedRows = unflatten(rowsFromStateObject);
-    return {
-        unflattenedRows: unflattenedRows[path.replace(pathPrefixToRemove, '')] || [],
-        remainingFlattenedState,
-    };
-};
-function fieldReducer(state, action) {
-    switch (action.type) {
-        case 'REPLACE_STATE': {
-            const newState = {};
-            // Only update fields that have changed
-            // by comparing old value / initialValue to new
-            // ..
-            // This is a performance enhancement for saving
-            // large documents with hundreds of fields
-            Object.entries(action.state).forEach(([path, field]) => {
-                const oldField = state[path];
-                const newField = field;
-                if (!equal(oldField, newField)) {
-                    newState[path] = newField;
-                }
-                else if (oldField) {
-                    newState[path] = oldField;
-                }
-            });
-            return newState;
-        }
-        case 'REMOVE': {
-            const newState = { ...state };
-            delete newState[action.path];
-            return newState;
-        }
-        case 'REMOVE_ROW': {
-            const { rowIndex, path } = action;
-            const { unflattenedRows, remainingFlattenedState } = unflattenRowsFromState(state, path);
-            unflattenedRows.splice(rowIndex, 1);
-            const flattenedRowState = unflattenedRows.length > 0 ? flatten({ [path]: unflattenedRows }, { filters: flattenFilters }) : {};
-            return {
-                ...remainingFlattenedState,
-                ...flattenedRowState,
-            };
-        }
-        case 'ADD_ROW': {
-            const { rowIndex, path, subFieldState, blockType, } = action;
-            const { unflattenedRows, remainingFlattenedState } = unflattenRowsFromState(state, path);
-            if (blockType) {
-                subFieldState.blockType = {
-                    value: blockType,
-                    initialValue: blockType,
-                    valid: true,
-                };
-            }
-            // If there are subfields
-            if (Object.keys(subFieldState).length > 0) {
-                // Add new object containing subfield names to unflattenedRows array
-                unflattenedRows.splice(rowIndex + 1, 0, subFieldState);
-            }
-            const newState = {
-                ...remainingFlattenedState,
-                ...(flatten({ [path]: unflattenedRows }, { filters: flattenFilters })),
-            };
-            return newState;
-        }
-        case 'MOVE_ROW': {
-            const { moveFromIndex, moveToIndex, path } = action;
-            const { unflattenedRows, remainingFlattenedState } = unflattenRowsFromState(state, path);
-            // copy the row to move
-            const copyOfMovingRow = unflattenedRows[moveFromIndex];
-            // delete the row by index
-            unflattenedRows.splice(moveFromIndex, 1);
-            // insert row copyOfMovingRow back in
-            unflattenedRows.splice(moveToIndex, 0, copyOfMovingRow);
-            const newState = {
-                ...remainingFlattenedState,
-                ...(flatten({ [path]: unflattenedRows }, { filters: flattenFilters })),
-            };
-            return newState;
-        }
-        case 'MODIFY_CONDITION': {
-            const { path, result } = action;
-            return Object.entries(state).reduce((newState, [fieldPath, field]) => {
-                if (fieldPath === path || fieldPath.indexOf(`${path}.`) === 0) {
-                    let passesCondition = result;
-                    // If a condition is being set to true,
-                    // Set all conditions to true
-                    // Besides those who still fail their own conditions
-                    if (passesCondition && field.condition) {
-                        passesCondition = field.condition(reduceFieldsToValues(state), getSiblingData(state, path));
-                    }
-                    return {
-                        ...newState,
-                        [fieldPath]: {
-                            ...field,
-                            passesCondition,
-                        },
-                    };
-                }
-                return {
-                    ...newState,
-                    [fieldPath]: {
-                        ...field,
-                    },
-                };
-            }, {});
-        }
-        default: {
-            const newField = {
-                value: action.value,
-                valid: action.valid,
-                errorMessage: action.errorMessage,
-                disableFormData: action.disableFormData,
-                initialValue: action.initialValue,
-                validate: action.validate,
-                condition: action.condition,
-                passesCondition: action.passesCondition,
-            };
-            return {
-                ...state,
-                [action.path]: newField,
-            };
-        }
-    }
-}
-export default fieldReducer;
+import equal from 'deep-equal';
+import { unflatten, flatten } from 'flatley';
+import flattenFilters from './flattenFilters';
+import getSiblingData from './getSiblingData';
+import reduceFieldsToValues from './reduceFieldsToValues';
+const unflattenRowsFromState = (state, path) => {
+    // Take a copy of state
+    const remainingFlattenedState = { ...state };
+    const rowsFromStateObject = {};
+    const pathPrefixToRemove = path.substring(0, path.lastIndexOf('.') + 1);
+    // Loop over all keys from state
+    // If the key begins with the name of the parent field,
+    // Add value to rowsFromStateObject and delete it from remaining state
+    Object.keys(state).forEach((key) => {
+        if (key.indexOf(`${path}.`) === 0) {
+            if (!state[key].disableFormData) {
+                const name = key.replace(pathPrefixToRemove, '');
+                rowsFromStateObject[name] = state[key];
+                rowsFromStateObject[name].initialValue = rowsFromStateObject[name].value;
+            }
+            delete remainingFlattenedState[key];
+        }
+    });
+    const unflattenedRows = unflatten(rowsFromStateObject);
+    return {
+        unflattenedRows: unflattenedRows[path.replace(pathPrefixToRemove, '')] || [],
+        remainingFlattenedState,
+    };
+};
+function fieldReducer(state, action) {
+    switch (action.type) {
+        case 'REPLACE_STATE': {
+            const newState = {};
+            // Only update fields that have changed
+            // by comparing old value / initialValue to new
+            // ..
+            // This is a performance enhancement for saving
+            // large documents with hundreds of fields
+            Object.entries(action.state).forEach(([path, field]) => {
+                const oldField = state[path];
+                const newField = field;
+                if (!equal(oldField, newField)) {
+                    newState[path] = newField;
+                }
+                else if (oldField) {
+                    newState[path] = oldField;
+                }
+            });
+            return newState;
+        }
+        case 'REMOVE': {
+            const newState = { ...state };
+            delete newState[action.path];
+            return newState;
+        }
+        case 'REMOVE_ROW': {
+            const { rowIndex, path } = action;
+            const { unflattenedRows, remainingFlattenedState } = unflattenRowsFromState(state, path);
+            unflattenedRows.splice(rowIndex, 1);
+            const flattenedRowState = unflattenedRows.length > 0 ? flatten({ [path]: unflattenedRows }, { filters: flattenFilters }) : {};
+            return {
+                ...remainingFlattenedState,
+                ...flattenedRowState,
+            };
+        }
+        case 'ADD_ROW': {
+            const { rowIndex, path, subFieldState, blockType, } = action;
+            const { unflattenedRows, remainingFlattenedState } = unflattenRowsFromState(state, path);
+            if (blockType) {
+                subFieldState.blockType = {
+                    value: blockType,
+                    initialValue: blockType,
+                    valid: true,
+                };
+            }
+            // If there are subfields
+            if (Object.keys(subFieldState).length > 0) {
+                // Add new object containing subfield names to unflattenedRows array
+                unflattenedRows.splice(rowIndex + 1, 0, subFieldState);
+            }
+            const newState = {
+                ...remainingFlattenedState,
+                ...(flatten({ [path]: unflattenedRows }, { filters: flattenFilters })),
+            };
+            return newState;
+        }
+        case 'MOVE_ROW': {
+            const { moveFromIndex, moveToIndex, path } = action;
+            const { unflattenedRows, remainingFlattenedState } = unflattenRowsFromState(state, path);
+            // copy the row to move
+            const copyOfMovingRow = unflattenedRows[moveFromIndex];
+            // delete the row by index
+            unflattenedRows.splice(moveFromIndex, 1);
+            // insert row copyOfMovingRow back in
+            unflattenedRows.splice(moveToIndex, 0, copyOfMovingRow);
+            const newState = {
+                ...remainingFlattenedState,
+                ...(flatten({ [path]: unflattenedRows }, { filters: flattenFilters })),
+            };
+            return newState;
+        }
+        case 'MODIFY_CONDITION': {
+            const { path, result } = action;
+            return Object.entries(state).reduce((newState, [fieldPath, field]) => {
+                if (fieldPath === path || fieldPath.indexOf(`${path}.`) === 0) {
+                    let passesCondition = result;
+                    // If a condition is being set to true,
+                    // Set all conditions to true
+                    // Besides those who still fail their own conditions
+                    if (passesCondition && field.condition) {
+                        passesCondition = field.condition(reduceFieldsToValues(state), getSiblingData(state, path));
+                    }
+                    return {
+                        ...newState,
+                        [fieldPath]: {
+                            ...field,
+                            passesCondition,
+                        },
+                    };
+                }
+                return {
+                    ...newState,
+                    [fieldPath]: {
+                        ...field,
+                    },
+                };
+            }, {});
+        }
+        default: {
+            const newField = {
+                value: action.value,
+                valid: action.valid,
+                errorMessage: action.errorMessage,
+                disableFormData: action.disableFormData,
+                initialValue: action.initialValue,
+                validate: action.validate,
+                condition: action.condition,
+                passesCondition: action.passesCondition,
+            };
+            return {
+                ...state,
+                [action.path]: newField,
+            };
+        }
+    }
+}
+export default fieldReducer;

package/dist/admin/components/forms/Form/flattenFilters.d.ts

@@ -1,4 +1,4 @@
-declare const flattenFilters: {
-    test: (_: string, value: unknown) => boolean;
-}[];
-export default flattenFilters;
+declare const flattenFilters: {
+    test: (_: string, value: unknown) => boolean;
+}[];
+export default flattenFilters;

package/dist/admin/components/forms/Form/flattenFilters.js

@@ -1,8 +1,8 @@
-const flattenFilters = [{
-        test: (_, value) => {
-            const hasValidProperty = Object.prototype.hasOwnProperty.call(value, 'valid');
-            const hasValueProperty = Object.prototype.hasOwnProperty.call(value, 'value');
-            return (hasValidProperty && hasValueProperty);
-        },
-    }];
-export default flattenFilters;
+const flattenFilters = [{
+        test: (_, value) => {
+            const hasValidProperty = Object.prototype.hasOwnProperty.call(value, 'valid');
+            const hasValueProperty = Object.prototype.hasOwnProperty.call(value, 'value');
+            return (hasValidProperty && hasValueProperty);
+        },
+    }];
+export default flattenFilters;