@luomus/laji-form 15.1.4 → 15.1.6

package/lib/components/fields/AnnotationField.js

@@ -0,0 +1,242 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const PropTypes = require("prop-types");
+const utils_1 = require("../../utils");
+const LajiForm_1 = require("../LajiForm");
+const BaseComponent_1 = require("../BaseComponent");
+const Context_1 = require("../../Context");
+const ReactContext_1 = require("../../ReactContext");
+const components_1 = require("../components");
+const Spinner = require("react-spinner");
+const utils_2 = require("@luomus/laji-map/lib/utils");
+let AnnotationField = class AnnotationField extends React.Component {
+    constructor(props) {
+        super(props);
+        this.getButton = () => {
+            const annotations = this.getAnnotations();
+            return {
+                glyph: "comment",
+                tooltip: this.props.formContext.translations.ShowAnnotations,
+                tooltipPlacement: "left",
+                fn: this.onClick,
+                variant: annotations && annotations.length ? "primary" : "default"
+            };
+        };
+        this.onClick = () => () => {
+            this.setState({ show: !this.state.show });
+        };
+        this.onHide = () => {
+            this.setState({ show: false });
+        };
+        this.getAnnotations = () => {
+            const { annotations = {} } = this.props.formContext.uiSchemaContext;
+            const { id } = this.props.formData;
+            return Context_1.default(`${this.props.formContext.contextId}_ANNOTATIONS`)[id] || annotations[id];
+        };
+        this.state = { show: false };
+    }
+    render() {
+        const { adminOnly, container, add, filter, uiSchema: annotationUiSchema, buttonsPath = "/", formId } = utils_1.getUiOptions(this.props.uiSchema);
+        const innerUiSchema = utils_1.getInnerUiSchema(this.props.uiSchema);
+        let uiSchema = adminOnly && !this.props.formContext.uiSchemaContext.isAdmin
+            || !this.props.formContext.uiSchemaContext.isEdit
+            || !this.props.formData.id
+            ? innerUiSchema
+            : utils_1.injectButtons(innerUiSchema, [this.getButton()], buttonsPath);
+        let Container = undefined;
+        const { Modal } = this.context.theme;
+        switch (container) {
+            case "modal":
+                Container = ({ children }) => {
+                    return (React.createElement(Modal, { show: true, dialogClassName: "laji-form", onHide: this.onHide },
+                        React.createElement(Modal.Header, { closeButton: true }),
+                        React.createElement(Modal.Body, null, children)));
+                };
+                break;
+            default:
+                Container = ({ children }) => React.createElement("div", null, children);
+        }
+        const { SchemaField } = this.props.registry.fields;
+        return (React.createElement("div", null,
+            React.createElement(SchemaField, Object.assign({}, this.props, { uiSchema: uiSchema })),
+            (this.props.formData.id && (container !== "modal" || this.state.show)) &&
+                React.createElement(Container, null,
+                    React.createElement(AnnotationBox, { id: this.props.formData.id, annotations: this.getAnnotations(), lang: this.props.formContext.lang, formContext: this.props.formContext, add: add, uiSchema: annotationUiSchema, filter: filter, formId: formId }))));
+    }
+};
+AnnotationField.contextType = ReactContext_1.default;
+AnnotationField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            adminOnly: PropTypes.bool,
+            container: PropTypes.oneOf(["modal"]),
+            add: PropTypes.object,
+            filter: PropTypes.object,
+            uiSchema: PropTypes.object,
+            buttonsPath: PropTypes.string,
+            formId: PropTypes.string
+        }),
+        uiSchema: PropTypes.object
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object"])
+    }).isRequired,
+    formData: PropTypes.object.isRequired
+};
+AnnotationField = __decorate([
+    BaseComponent_1.default
+], AnnotationField);
+exports.default = AnnotationField;
+Context_1.default("SCHEMA_FIELD_WRAPPERS").AnnotationField = true;
+class AnnotationBox extends React.Component {
+    constructor(props) {
+        super(props);
+        this.onAnnotationSubmit = ({ formData }) => {
+            const { type } = this.getAddOptions();
+            const rootID = this.props.formContext.services.rootInstance.getFormData().id;
+            this.props.formContext.services.blocker.push();
+            this.props.formContext.apiClient.fetchRaw("/annotations", undefined, {
+                method: "POST",
+                body: JSON.stringify(Object.assign(Object.assign({}, formData), { targetID: this.props.id, rootID, type, byRole: "MMAN.formAdmin" }))
+            }).then(response => {
+                if (response.status >= 400) {
+                    throw new Error("Request failed");
+                }
+                return response.json();
+            }).then(annotation => {
+                this.props.formContext.services.blocker.pop();
+                const annotationContext = Context_1.default(`${this.props.formContext.contextId}_ANNOTATIONS`);
+                const annotations = [annotation];
+                annotationContext[this.props.id] = annotations;
+                this.setState({ annotations: annotations, fail: false });
+            }).catch(() => {
+                this.props.formContext.services.blocker.pop();
+                this.setState({ fail: true });
+            });
+        };
+        this.onAnnotationChange = (formData) => {
+            let state = {};
+            if (this.state.fail !== undefined) {
+                state.fail = undefined;
+            }
+            const { submitOnChange } = this.getAddOptions();
+            if (submitOnChange) {
+                this.onAnnotationSubmit({ formData });
+            }
+            state.addFormData = formData;
+            this.setState(state);
+        };
+        this.getAddOptions = () => {
+            const { add, formContext: { uiSchemaContext: { isAdmin } } } = this.props;
+            let addOptions = utils_2.isObject(add) ? add : {};
+            const submitOnChange = "submitOnChange" in addOptions ? addOptions.submitOnChange : false;
+            const type = isAdmin ? "MAN.typeAdmin" : addOptions.type;
+            return Object.assign(Object.assign({}, addOptions), { submitOnChange, type });
+        };
+        this.renderAdd = () => {
+            const { formContext, add } = this.props;
+            const { lang, translations } = formContext;
+            const { metadataForm } = this.state;
+            const { Alert } = this.context.theme;
+            if (!metadataForm) {
+                return null;
+            }
+            const _uiSchema = this.getUiSchema();
+            let addSchema = undefined;
+            let addUiSchema = undefined;
+            let submitOnChange = undefined;
+            let addFormData = undefined;
+            if (add && metadataForm && metadataForm.schema) {
+                const { adminOnly, filter: _filter, uiSchema: _addUiSchema, _submitOnChange, formData } = this.getAddOptions();
+                if (adminOnly && !formContext.uiSchemaContext.isAdmin) {
+                    return null;
+                }
+                let propArray = Object.keys(metadataForm.schema.properties);
+                propArray = utils_1.filter(propArray, ["created", "annotationByPerson"], "blacklist");
+                if (_filter)
+                    propArray = utils_1.filter(propArray, _filter.filter, _filter.filterType);
+                const addSchemaProperties = propArray.reduce((properties, prop) => {
+                    properties[prop] = metadataForm.schema.properties[prop];
+                    return properties;
+                }, {});
+                addSchema = Object.assign(Object.assign({}, metadataForm.schema), { properties: addSchemaProperties });
+                addUiSchema = _addUiSchema || Object.assign(Object.assign({}, _uiSchema), { "ui:readonly": false });
+                submitOnChange = _submitOnChange;
+                addFormData = this.state.addFormData || (formData
+                    ? utils_1.getDefaultFormState(addSchema, formData)
+                    : undefined);
+            }
+            const renderSubmit = !submitOnChange;
+            return add && addSchema ? (React.createElement(LajiForm_1.default, Object.assign({}, metadataForm, { schema: addSchema, uiSchema: addUiSchema || _uiSchema, onSubmit: this.onAnnotationSubmit, onChange: this.onAnnotationChange, renderSubmit: renderSubmit, formData: addFormData, lang: lang, apiClient: this.props.formContext.apiClient.apiClient, uiSchemaContext: this.props.formContext.uiSchemaContext }), React.createElement("div", null,
+                this.state.fail !== undefined &&
+                    React.createElement(Alert, { variant: this.state.fail ? "danger" : "success" }, translations[this.state.fail ? "SaveFail" : "SaveSuccess"]),
+                renderSubmit && React.createElement(components_1.Button, { id: "submit", type: "submit" }, translations.Submit)))) : null;
+        };
+        this.getUiSchema = () => {
+            const { uiSchema } = this.props;
+            const { metadataForm = {} } = this.state;
+            return uiSchema || Object.assign(Object.assign({}, metadataForm.uiSchema), { "ui:shortcuts": Object.assign(Object.assign({}, ((metadataForm.uiSchema || {})["ui:shorcuts"] || {})), (this.props.formContext.services.keyHandler.shortcuts)), "ui:showShortcutsButton": false });
+        };
+        this.onDelete = (id) => () => {
+            this.props.formContext.apiClient.fetchRaw(`/annotations/${id}`, undefined, {
+                method: "DELETE"
+            }).then(() => {
+                const annotationContext = Context_1.default(`${this.props.formContext.contextId}_ANNOTATIONS`);
+                const annotations = this.state.annotations.filter(({ id: _id }) => _id !== id);
+                annotationContext[this.props.id] = annotations;
+                this.setState({ deleteFail: false, annotations });
+            }).catch(() => {
+                this.setState({ deleteFail: true });
+            });
+        };
+        this.state = { annotations: props.annotations || [] };
+    }
+    componentDidMount() {
+        this.mounted = true;
+        this.props.formContext.apiClient.fetchCached(`/forms/${this.props.formId}`, { lang: this.props.lang, format: "schema" })
+            .then(metadataForm => {
+            if (!this.mounted)
+                return;
+            const { filter: _filter } = this.props;
+            let propArray = Object.keys(metadataForm.schema.properties);
+            if (_filter)
+                propArray = utils_1.filter(propArray, _filter.filter, _filter.filterType);
+            const schemaProperties = propArray.reduce((properties, prop) => {
+                properties[prop] = metadataForm.schema.properties[prop];
+                return properties;
+            }, {});
+            const schema = Object.assign(Object.assign({}, metadataForm.schema), { properties: schemaProperties });
+            this.setState({ metadataForm: Object.assign(Object.assign({}, metadataForm), { schema }) });
+        });
+    }
+    componentWillUnmount() {
+        this.mounted = false;
+    }
+    render() {
+        const { formContext: { translations, lang, apiClient } } = this.props;
+        const { metadataForm = {}, annotations = [] } = this.state;
+        const _uiSchema = Object.assign(Object.assign({}, this.getUiSchema()), { "ui:readonly": true });
+        const { Panel, ListGroup, ListGroupItem, Alert } = this.context.theme;
+        return (React.createElement(Panel, null,
+            React.createElement(Panel.Heading, null,
+                React.createElement("strong", null, translations.Comments)),
+            React.createElement(Panel.Body, null,
+                this.renderAdd(),
+                React.createElement(ListGroup, null, this.state.metadataForm ? annotations.slice(0).reverse().map((annotation, idx) => React.createElement(ListGroupItem, { key: idx, className: `annotation-list${idx % 2 === 0 ? "" : "-odd"}` },
+                    React.createElement("div", null,
+                        React.createElement(LajiForm_1.default, Object.assign({}, metadataForm, { uiSchema: _uiSchema, lang: lang, formData: annotation, renderSubmit: false, apiClient: apiClient.apiClient, uiSchemaContext: this.props.formContext.uiSchemaContext }))))) : React.createElement(Spinner, null)),
+                this.state.deleteFail &&
+                    React.createElement(Alert, { variant: "danger" }, translations["DeleteFail"]))));
+    }
+}
+AnnotationBox.contextType = ReactContext_1.default;
+AnnotationBox.defaultProps = {
+    formId: "MHL.15"
+};

package/lib/components/fields/AnyToBooleanField.d.ts

@@ -0,0 +1,18 @@
+export default _anyToBoolean;
+declare function _anyToBoolean(props: any): JSX.Element;
+declare namespace _anyToBoolean {
+    namespace propTypes {
+        const uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                trueValue: PropTypes.Validator<object>;
+                falseValue: PropTypes.Requireable<object>;
+                allowUndefined: PropTypes.Requireable<boolean>;
+            }>>;
+        }>>;
+        const schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        const formData: PropTypes.Requireable<object>;
+    }
+}
+import * as PropTypes from "prop-types";

package/lib/components/fields/AnyToBooleanField.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const AnyToBooleanWidget_1 = require("../widgets/AnyToBooleanWidget");
+const PropTypes = require("prop-types");
+const _anyToBoolean = (props) => React.createElement(AnyToBooleanWidget_1.AnyToBoolean, Object.assign({}, props));
+_anyToBoolean.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            trueValue: PropTypes.oneOfType([PropTypes.array, PropTypes.object]).isRequired,
+            falseValue: PropTypes.oneOfType([PropTypes.array, PropTypes.object]),
+            allowUndefined: PropTypes.bool
+        })
+    }),
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array", "object"])
+    }).isRequired,
+    formData: PropTypes.oneOfType([PropTypes.array, PropTypes.object])
+};
+exports.default = _anyToBoolean;

package/lib/components/fields/ArrayBulkField.d.ts

@@ -0,0 +1,23 @@
+export default class ArrayBulkField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                rowAddAmount: PropTypes.Requireable<number>;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Validator<any[]>;
+    };
+    constructor(props: any);
+    getStateFromProps: (props: any) => {
+        rowAddAmount: any;
+        rowAmount: number;
+    };
+    renderItems: () => any[];
+    onChangeForIdx: (idx: any) => (itemFormData: any) => void;
+    onAddClick: (event: any) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/ArrayBulkField.js

@@ -0,0 +1,82 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const PropTypes = require("prop-types");
+const utils_1 = require("../../utils");
+const components_1 = require("../components");
+const BaseComponent_1 = require("../BaseComponent");
+const utils_2 = require("@rjsf/utils");
+let ArrayBulkField = class ArrayBulkField extends React.Component {
+    constructor(props) {
+        super(props);
+        this.getStateFromProps = (props) => {
+            let state = {};
+            const { rowAddAmount } = utils_1.getUiOptions(props.uiSchema);
+            state.rowAddAmount = 10;
+            if (rowAddAmount > 0)
+                state.rowAddAmount = rowAddAmount;
+            if (props.formData && props.formData.length > this.state.rowAmount) {
+                state.rowAmount = props.formData.length + state.rowAddAmount - (props.formData.length % state.rowAddAmount);
+            }
+            return state;
+        };
+        this.renderItems = () => {
+            let rows = [];
+            let idx = 0;
+            let data = this.props.formData || [];
+            while (data.length < this.state.rowAmount) {
+                data.push({});
+            }
+            const SchemaField = this.props.registry.fields.SchemaField;
+            if (data)
+                data.forEach((item) => {
+                    rows.push(React.createElement(SchemaField, { key: idx, formData: item, onChange: this.onChangeForIdx(idx), schema: this.props.schema.items, uiSchema: this.props.uiSchema.items, idSchema: { $id: this.props.idSchema.$id + "_" + idx }, registry: this.props.registry, errorSchema: this.props.errorSchema[idx] }));
+                    idx++;
+                });
+            return rows;
+        };
+        this.onChangeForIdx = (idx) => {
+            return (itemFormData) => {
+                let formData = this.props.formData;
+                if (!formData)
+                    formData = [];
+                formData[idx] = itemFormData;
+                this.props.onChange(formData.filter(item => { return Object.keys(item).length; }));
+            };
+        };
+        this.onAddClick = (event) => {
+            event.preventDefault();
+            this.setState({ rowAmount: this.state.rowAmount + this.state.rowAddAmount });
+        };
+        this.state = Object.assign({ rowAmount: 0 }, this.getStateFromProps(props));
+    }
+    render() {
+        const TitleFieldTemplate = utils_2.getTemplate("TitleFieldTemplate", this.props.registry, utils_1.getUiOptions(this.props.uiSchema));
+        return (React.createElement("fieldset", null,
+            React.createElement(TitleFieldTemplate, { title: this.props.schema.title || this.props.name, schema: this.props.schema, uiSchema: this.props.uiSchema, registry: this.props.registry }),
+            this.renderItems(),
+            React.createElement(components_1.Button, { onClick: this.onAddClick }, "Lis\u00E4\u00E4 havaintorivej\u00E4"),
+            React.createElement("br", null)));
+    }
+};
+ArrayBulkField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            rowAddAmount: PropTypes.number
+        })
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array"])
+    }).isRequired,
+    formData: PropTypes.array.isRequired
+};
+ArrayBulkField = __decorate([
+    BaseComponent_1.default
+], ArrayBulkField);
+exports.default = ArrayBulkField;

package/lib/components/fields/ArrayCombinerField.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Transforms an object schema containing arrays to an array schema containing objects.
+ *
+ * uischema = {"ui:options": {
+ *  uiSchema: <uiSchema> (uiSchema which is passed to array items)
+ * }
+ */
+export default class ArrayCombinerField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                additionalItemsAmount: PropTypes.Requireable<number>;
+            }>>;
+            uiSchema: PropTypes.Requireable<object>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Validator<object>;
+    };
+    static getName(): string;
+    constructor(props: any);
+    constructor(props: any, context: any);
+    getStateFromProps(props: any): {
+        schema: {
+            type: string;
+        };
+        errorSchema: any;
+        formData: any;
+        uiSchema: any;
+        onChange: (formData: any) => void;
+    };
+    onChange: (formData: any) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/ArrayCombinerField.js

@@ -0,0 +1,138 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const PropTypes = require("prop-types");
+const utils_1 = require("../../utils");
+const merge = require("deepmerge");
+const VirtualSchemaField_1 = require("../VirtualSchemaField");
+/**
+ * Transforms an object schema containing arrays to an array schema containing objects.
+ *
+ * uischema = {"ui:options": {
+ *  uiSchema: <uiSchema> (uiSchema which is passed to array items)
+ * }
+ */
+let ArrayCombinerField = class ArrayCombinerField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onChange = (formData) => {
+            let origArraysContainer = {};
+            if (!formData || formData.length === 0) {
+                Object.keys(this.props.schema.properties).forEach((prop) => {
+                    origArraysContainer[prop] = [];
+                });
+            }
+            else {
+                formData.forEach((obj) => {
+                    Object.keys(this.props.schema.properties).forEach((arrName) => {
+                        origArraysContainer[arrName] ?
+                            origArraysContainer[arrName].push(obj[arrName]) :
+                            (origArraysContainer[arrName] = [obj[arrName]]);
+                    });
+                });
+            }
+            this.props.onChange(origArraysContainer);
+        };
+    }
+    static getName() { return "ArrayCombinerField"; }
+    getStateFromProps(props) {
+        const { additionalItemsAmount } = this.getUiOptions();
+        let itemSchema = { type: "object", properties: {}, required: props.schema.required };
+        let schema = { type: "array" };
+        if (additionalItemsAmount)
+            schema.additionalItems = itemSchema;
+        if ("title" in props.schema)
+            schema.title = props.schema.title;
+        Object.keys(props.schema.properties).forEach((propertyName) => {
+            let propertyOrigin = props.schema.properties[propertyName];
+            let property = propertyOrigin.items;
+            if (property.type === "object" || property.type === "array")
+                throw "items properties can't be objects or arrays";
+            if (propertyOrigin.title)
+                property.title = propertyOrigin.title;
+            itemSchema.properties[propertyName] = property;
+        });
+        schema.items = itemSchema;
+        if (additionalItemsAmount) {
+            schema.items = Array(additionalItemsAmount).fill(itemSchema);
+            schema.additionalItems = itemSchema;
+        }
+        const uiSchema = Object.keys(props.schema.properties).reduce((_uiSchema, field) => {
+            if (field in _uiSchema) {
+                _uiSchema = Object.assign(Object.assign({}, _uiSchema), { items: Object.assign(Object.assign({}, (_uiSchema.items || {})), { [field]: _uiSchema[field] }) });
+                utils_1.immutableDelete(_uiSchema, field);
+            }
+            return _uiSchema;
+        }, props.uiSchema);
+        function objectsToArray(array, objects) {
+            if (objects)
+                Object.keys(objects).forEach(dataCol => {
+                    if (objects[dataCol])
+                        for (var row in objects[dataCol]) {
+                            let val = objects[dataCol][row];
+                            if (!array[row])
+                                array[row] = {};
+                            array[row][dataCol] = val;
+                        }
+                });
+            return array;
+        }
+        function rotateErrorSchema(rotatedErrorSchema, errorSchema) {
+            if (errorSchema)
+                Object.keys(errorSchema).forEach(property => {
+                    const error = errorSchema[property];
+                    if (property === "__errors") {
+                        rotatedErrorSchema.__errors = error;
+                    }
+                    else {
+                        if (error)
+                            Object.keys(error).forEach(idx => {
+                                if (idx === "__errors") {
+                                    rotatedErrorSchema.__errors = rotatedErrorSchema.__errors ?
+                                        [...rotatedErrorSchema.__errors, ...error.__errors] :
+                                        error.__errors;
+                                }
+                                else {
+                                    const propertyError = { [property]: error[idx] };
+                                    rotatedErrorSchema[idx] = rotatedErrorSchema[idx] ?
+                                        merge(rotatedErrorSchema[idx], propertyError) : propertyError;
+                                }
+                            });
+                    }
+                });
+            return rotatedErrorSchema;
+        }
+        let errorSchema = rotateErrorSchema({}, props.errorSchema);
+        let formData = objectsToArray([], props.formData);
+        formData.forEach((obj) => {
+            Object.keys(itemSchema.properties).forEach((prop) => {
+                if (!(prop in obj)) {
+                    obj[prop] = utils_1.getDefaultFormState(itemSchema.properties[prop]);
+                }
+            });
+        });
+        return { schema, errorSchema, formData, uiSchema, onChange: this.onChange };
+    }
+};
+ArrayCombinerField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            additionalItemsAmount: PropTypes.number
+        }),
+        uiSchema: PropTypes.object
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object"])
+    }).isRequired,
+    formData: PropTypes.object.isRequired
+};
+ArrayCombinerField = __decorate([
+    VirtualSchemaField_1.default
+], ArrayCombinerField);
+exports.default = ArrayCombinerField;

package/lib/components/fields/ArrayField.d.ts

@@ -0,0 +1,39 @@
+export function onArrayFieldChange(formData: any, props: any): any;
+export function copyItemFunction(that: any, copyItem: any): (props: any, { type, filter }: {
+    type: any;
+    filter: any;
+}) => any;
+export class ArrayFieldPatched {
+    constructor(...params: any[]);
+    _getNewFormDataRow: () => any;
+    onDropIndexClick: (index: any) => (event: any) => void;
+    renderArrayFieldItem(props: any): any;
+    getIdSchema(props: any, _index: any): any;
+}
+export default class _ArrayField extends React.Component<any, any, any> {
+    static contextType: React.Context<import("../../ReactContext").ContextProps>;
+    constructor(props: any);
+    constructor(props: any, context: any);
+    onChange: (formData: any) => void;
+    buttonDefinitions: {
+        copy: {
+            glyph: string;
+            fn: () => (...params: any[]) => void;
+            rules: {
+                minLength: number;
+                canAdd: boolean;
+            };
+            changesFormData: boolean;
+        };
+        addPredefined: {
+            fn: () => (onClickProps: any, { default: _default }: {
+                default: any;
+            }) => void;
+            rules: {
+                canAdd: boolean;
+            };
+            changesFormData: boolean;
+        };
+    };
+}
+import * as React from "react";