payload 0.20.0 → 0.20.3-beta.0

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

@@ -0,0 +1,177 @@
+/* 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 === null || data === void 0 ? void 0 : data[field.name], defaultValue: field.defaultValue, locale, user });
+        if (data === null || data === void 0 ? void 0 : data[field.name]) {
+            data[field.name] = valueWithDefault;
+        }
+        let validationResult = true;
+        if (typeof fieldState.validate === 'function') {
+            validationResult = await fieldState.validate(data === null || data === void 0 ? void 0 : 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,
+        });
+    }
+    else if (field.type === 'tabs') {
+        field.tabs.forEach((tab) => {
+            iterateFields({
+                state,
+                fields: tab.fields,
+                data,
+                parentPassesCondition: passesCondition,
+                path,
+                user,
+                fieldPromises,
+                fullData,
+                id,
+                locale,
+                operation,
+            });
+        });
+    }
+};

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

@@ -0,0 +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';
+    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

@@ -0,0 +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, };

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFormModified = exports.useFormProcessing = exports.useFormSubmitted = exports.useWatchForm = exports.useForm = exports.ModifiedContext = exports.ProcessingContext = exports.SubmittedContext = exports.FormWatchContext = exports.FormContext = void 0;
+const react_1 = require("react");
+const FormContext = (0, react_1.createContext)({});
+exports.FormContext = FormContext;
+const FormWatchContext = (0, react_1.createContext)({});
+exports.FormWatchContext = FormWatchContext;
+const SubmittedContext = (0, react_1.createContext)(false);
+exports.SubmittedContext = SubmittedContext;
+const ProcessingContext = (0, react_1.createContext)(false);
+exports.ProcessingContext = ProcessingContext;
+const ModifiedContext = (0, react_1.createContext)(false);
+exports.ModifiedContext = ModifiedContext;
+const useForm = () => (0, react_1.useContext)(FormContext);
+exports.useForm = useForm;
+const useWatchForm = () => (0, react_1.useContext)(FormWatchContext);
+exports.useWatchForm = useWatchForm;
+const useFormSubmitted = () => (0, react_1.useContext)(SubmittedContext);
+exports.useFormSubmitted = useFormSubmitted;
+const useFormProcessing = () => (0, react_1.useContext)(ProcessingContext);
+exports.useFormProcessing = useFormProcessing;
+const useFormModified = () => (0, react_1.useContext)(ModifiedContext);
+exports.useFormModified = useFormModified;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hZG1pbi9jb21wb25lbnRzL2Zvcm1zL0Zvcm0vY29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpQ0FBa0Q7QUFHbEQsTUFBTSxXQUFXLEdBQUcsSUFBQSxxQkFBYSxFQUFDLEVBQWEsQ0FBQyxDQUFDO0FBYS9DLGtDQUFXO0FBWmIsTUFBTSxnQkFBZ0IsR0FBRyxJQUFBLHFCQUFhLEVBQUMsRUFBYSxDQUFDLENBQUM7QUFhcEQsNENBQWdCO0FBWmxCLE1BQU0sZ0JBQWdCLEdBQUcsSUFBQSxxQkFBYSxFQUFDLEtBQUssQ0FBQyxDQUFDO0FBYTVDLDRDQUFnQjtBQVpsQixNQUFNLGlCQUFpQixHQUFHLElBQUEscUJBQWEsRUFBQyxLQUFLLENBQUMsQ0FBQztBQWE3Qyw4Q0FBaUI7QUFabkIsTUFBTSxlQUFlLEdBQUcsSUFBQSxxQkFBYSxFQUFDLEtBQUssQ0FBQyxDQUFDO0FBYTNDLDBDQUFlO0FBWGpCLE1BQU0sT0FBTyxHQUFHLEdBQVksRUFBRSxDQUFDLElBQUEsa0JBQVUsRUFBQyxXQUFXLENBQUMsQ0FBQztBQVlyRCwwQkFBTztBQVhULE1BQU0sWUFBWSxHQUFHLEdBQVksRUFBRSxDQUFDLElBQUEsa0JBQVUsRUFBQyxnQkFBZ0IsQ0FBQyxDQUFDO0FBWS9ELG9DQUFZO0FBWGQsTUFBTSxnQkFBZ0IsR0FBRyxHQUFZLEVBQUUsQ0FBQyxJQUFBLGtCQUFVLEVBQUMsZ0JBQWdCLENBQUMsQ0FBQztBQVluRSw0Q0FBZ0I7QUFYbEIsTUFBTSxpQkFBaUIsR0FBRyxHQUFZLEVBQUUsQ0FBQyxJQUFBLGtCQUFVLEVBQUMsaUJBQWlCLENBQUMsQ0FBQztBQVlyRSw4Q0FBaUI7QUFYbkIsTUFBTSxlQUFlLEdBQUcsR0FBWSxFQUFFLENBQUMsSUFBQSxrQkFBVSxFQUFDLGVBQWUsQ0FBQyxDQUFDO0FBWWpFLDBDQUFlIn0=

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

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

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

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

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

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

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

@@ -0,0 +1,165 @@
+import equal from 'deep-equal';
+import { unflatten, flatten } from 'flatley';
+import flattenFilters from './flattenFilters';
+import getSiblingData from './getSiblingData';
+import reduceFieldsToValues from './reduceFieldsToValues';
+import deepCopyObject from '../../../../utilities/deepCopyObject';
+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 'DUPLICATE_ROW': {
+            const { rowIndex, path, } = action;
+            const { unflattenedRows, remainingFlattenedState } = unflattenRowsFromState(state, path);
+            const duplicate = deepCopyObject(unflattenedRows[rowIndex]);
+            if (duplicate.id)
+                delete duplicate.id;
+            // If there are subfields
+            if (Object.keys(duplicate).length > 0) {
+                // Add new object containing subfield names to unflattenedRows array
+                unflattenedRows.splice(rowIndex + 1, 0, duplicate);
+            }
+            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

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

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

@@ -0,0 +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;

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

@@ -0,0 +1,3 @@
+import { Fields } from './types';
+declare const getDataByPath: <T = unknown>(fields: Fields, path: string) => T;
+export default getDataByPath;

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

@@ -0,0 +1,14 @@
+import { unflatten } from 'flatley';
+const getDataByPath = (fields, path) => {
+    const pathPrefixToRemove = path.substring(0, path.lastIndexOf('.') + 1);
+    const name = path.split('.').pop();
+    const data = {};
+    Object.keys(fields).forEach((key) => {
+        if (!fields[key].disableFormData && (key.indexOf(`${path}.`) === 0 || key === path)) {
+            data[key.replace(pathPrefixToRemove, '')] = fields[key].value;
+        }
+    });
+    const unflattenedData = unflatten(data);
+    return unflattenedData === null || unflattenedData === void 0 ? void 0 : unflattenedData[name];
+};
+export default getDataByPath;

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

@@ -0,0 +1,3 @@
+import { Fields, Data } from './types';
+declare const getSiblingData: (fields: Fields, path: string) => Data;
+export default getSiblingData;

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

@@ -0,0 +1,18 @@
+import { unflatten } from 'flatley';
+import reduceFieldsToValues from './reduceFieldsToValues';
+const getSiblingData = (fields, path) => {
+    if (path.indexOf('.') === -1) {
+        return reduceFieldsToValues(fields, true);
+    }
+    const siblingFields = {};
+    // If this field is nested
+    // We can provide a list of sibling fields
+    const parentFieldPath = path.substring(0, path.lastIndexOf('.') + 1);
+    Object.keys(fields).forEach((fieldKey) => {
+        if (!fields[fieldKey].disableFormData && fieldKey.indexOf(parentFieldPath) === 0) {
+            siblingFields[fieldKey.replace(parentFieldPath, '')] = fields[fieldKey].value;
+        }
+    });
+    return unflatten(siblingFields, { safe: true });
+};
+export default getSiblingData;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { Props } from './types';
+declare const Form: React.FC<Props>;
+export default Form;