payload 0.15.6 → 0.15.9

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

@@ -1,148 +1,148 @@
-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].ignoreWhileFlattening) {
-                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,
-                ignoreWhileFlattening: action.ignoreWhileFlattening,
-                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].ignoreWhileFlattening) {
+                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,
+                ignoreWhileFlattening: action.ignoreWhileFlattening,
+                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;

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

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

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

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

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

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

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