@luomus/laji-form 14.3.6

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

@@ -0,0 +1,35 @@
+export default class SumField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                sums: PropTypes.Validator<PropTypes.InferProps<{
+                    resultField: PropTypes.Validator<string>;
+                    summedFields: PropTypes.Validator<(string | null | undefined)[]>;
+                    summedProperty: PropTypes.Requireable<string>;
+                }> | (PropTypes.InferProps<{
+                    resultField: PropTypes.Validator<string>;
+                    summedFields: PropTypes.Validator<(string | null | undefined)[]>;
+                    summedProperty: PropTypes.Requireable<string>;
+                }> | null | undefined)[]>;
+            }>>;
+            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({ formData }: {
+        formData: any;
+    }): {
+        prevResult: {};
+        onChange: (formData: any) => void;
+    };
+    onChange: (formData: any) => void;
+    getSums: (formData: any) => {};
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/SumField.js

@@ -0,0 +1,83 @@
+"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 VirtualSchemaField_1 = require("../VirtualSchemaField");
+const sumPropType = PropTypes.shape({
+    resultField: PropTypes.string.isRequired,
+    summedFields: PropTypes.arrayOf(PropTypes.string).isRequired,
+    summedProperty: PropTypes.string
+});
+let SumField = class SumField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onChange = (formData) => {
+            let { sums } = this.getUiOptions();
+            sums = Array.isArray(sums) ? sums : [sums];
+            const newSums = this.getSums(formData);
+            sums.forEach(options => {
+                if (newSums[options.resultField] !== this.state.prevResult[options.resultField]) {
+                    formData = Object.assign(Object.assign({}, formData), { [options.resultField]: newSums[options.resultField] });
+                }
+            });
+            this.props.onChange(formData);
+        };
+        this.getSums = (formData) => {
+            let { sums } = this.getUiOptions();
+            sums = Array.isArray(sums) ? sums : [sums];
+            const results = {};
+            sums.forEach(options => {
+                const { resultField, summedFields, summedProperty } = options;
+                const resultType = this.props.schema.properties[resultField].type;
+                let result = 0;
+                let allEmpty = true;
+                summedFields.forEach(field => {
+                    if (formData[field] !== undefined) {
+                        if (summedProperty === "arrayLength") {
+                            result += formData[field].length;
+                        }
+                        else {
+                            result += Number(formData[field]);
+                        }
+                        allEmpty = false;
+                    }
+                });
+                result = allEmpty || isNaN(result) ? undefined : result;
+                if (result !== undefined && resultType !== "number" && resultType !== "integer") {
+                    result = result + "";
+                }
+                results[resultField] = result;
+            });
+            return results;
+        };
+    }
+    static getName() { return "SumField"; }
+    getStateFromProps({ formData }) {
+        return { prevResult: this.getSums(formData), onChange: this.onChange };
+    }
+};
+SumField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            "sums": PropTypes.oneOfType([
+                sumPropType,
+                PropTypes.arrayOf(sumPropType)
+            ]).isRequired
+        }),
+        uiSchema: PropTypes.object
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object"])
+    }).isRequired,
+    formData: PropTypes.object.isRequired
+};
+SumField = __decorate([
+    VirtualSchemaField_1.default
+], SumField);
+exports.default = SumField;

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

@@ -0,0 +1,18 @@
+export default class TableField extends React.Component<any, any, any> {
+    static contextType: React.Context<import("../../ReactContext").ContextProps>;
+    static propTypes: {
+        uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                specialRules: PropTypes.Requireable<string | (string | null | undefined)[]>;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+            items: PropTypes.Requireable<object>;
+        }>>;
+    };
+    constructor(props: any);
+    constructor(props: any, context: any);
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/TableField.js

@@ -0,0 +1,136 @@
+"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 utils_2 = require("@rjsf/utils");
+const components_1 = require("../components");
+const ArrayFieldTemplate_1 = require("../templates/ArrayFieldTemplate");
+const BaseComponent_1 = require("../BaseComponent");
+const ReactContext_1 = require("../../ReactContext");
+const specialRules = {
+    legEditors: {
+        filterProperties: ({ properties, formData, uiSchemaContext }) => {
+            if (!uiSchemaContext)
+                return properties;
+            const { creator } = uiSchemaContext;
+            return (!formData ||
+                formData.some(item => item && item.leg && item.leg.match(/MA\.\d+/) && item.leg !== creator)) ? properties : properties.filter(field => field !== "editors");
+        }
+    }
+};
+const specialRulesPropTypes = PropTypes.oneOf(["legEditors"]);
+let TableField = class TableField extends React.Component {
+    render() {
+        const { schema, uiSchema = {}, formData, registry: { fields: { ArrayField } }, formContext } = this.props;
+        const { uiSchemaContext } = formContext;
+        const schemaProps = schema.additionalItems ? schema.additionalItems.properties : schema.items.properties;
+        const options = utils_1.getUiOptions(uiSchema);
+        let schemaPropsArray = Object.keys(schemaProps);
+        const optionsSpecialRules = options.specialRules;
+        if (optionsSpecialRules) {
+            (Array.isArray(optionsSpecialRules) ? optionsSpecialRules : [optionsSpecialRules]).forEach(specialRule => {
+                schemaPropsArray = specialRules[specialRule].filterProperties({
+                    properties: schemaPropsArray, uiSchema, uiSchemaContext, formData
+                });
+            });
+        }
+        const schemaLength = schemaPropsArray.filter(col => !utils_1.isHidden(uiSchema.items, col)).length;
+        const defaultCol = parseInt(12 / schemaLength);
+        const defaultWrapperCol = parseInt(12 / (1 + (Object.keys(schemaProps).filter(col => !utils_1.isHidden(uiSchema.items, col)).length - schemaLength)));
+        const cols = { xs: undefined, sm: undefined, md: undefined, lg: undefined };
+        const wrapperCols = Object.assign({}, cols);
+        Object.keys(cols).forEach(col => {
+            cols[col] = options[col] ? Math.min(options[col], defaultCol) : defaultCol;
+            wrapperCols[col] = options[col] ? Math.min(options[col], defaultWrapperCol) : defaultWrapperCol;
+        });
+        const itemsSchema = schemaPropsArray.reduce((constructedSchema, prop) => {
+            constructedSchema.properties[prop] = schema.items.properties[prop];
+            return constructedSchema;
+        }, Object.assign(Object.assign({}, schema.items), { properties: {} }));
+        const itemsUiSchema = {
+            "ui:field": "GridLayoutField",
+            "ui:options": Object.assign(Object.assign({}, cols), { label: false }),
+        };
+        let _uiSchema = uiSchema;
+        if (uiSchema.items) {
+            if (uiSchema.items.uiSchema) {
+                _uiSchema = Object.assign(Object.assign({}, _uiSchema), { items: utils_1.updateTailUiSchema(uiSchema.items, { $merge: { uiSchema: itemsUiSchema } }) });
+            }
+            else if (uiSchema.items["ui:field"] || uiSchema.items["ui:functions"]) {
+                _uiSchema = Object.assign(Object.assign({}, _uiSchema), { items: Object.assign(Object.assign({}, _uiSchema.items), { uiSchema: itemsUiSchema }) });
+            }
+            else {
+                _uiSchema = Object.assign(Object.assign({}, _uiSchema), { items: Object.assign(Object.assign(Object.assign({}, (uiSchema.items || {})), itemsUiSchema), { "ui:options": Object.assign(Object.assign({}, utils_1.getUiOptions(uiSchema.items)), utils_1.getUiOptions(itemsUiSchema)) }) });
+            }
+        }
+        _uiSchema["ui:ArrayFieldTemplate"] = TableArrayFieldTemplate;
+        const _formContext = Object.assign(Object.assign({}, formContext), { cols,
+            wrapperCols,
+            schemaPropsArray });
+        return (React.createElement(ArrayField, Object.assign({}, this.props, { schema: Object.assign(Object.assign({}, schema), { items: itemsSchema }), uiSchema: _uiSchema, registry: Object.assign(Object.assign({}, this.props.registry), { formContext: _formContext }), formContext: _formContext })));
+    }
+};
+TableField.contextType = ReactContext_1.default;
+TableField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            specialRules: PropTypes.oneOfType([
+                specialRulesPropTypes,
+                PropTypes.arrayOf(specialRulesPropTypes)
+            ])
+        })
+    }),
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array"]),
+        items: PropTypes.oneOfType([PropTypes.object, PropTypes.array])
+    }).isRequired
+};
+TableField = __decorate([
+    BaseComponent_1.default
+], TableField);
+exports.default = TableField;
+let TableArrayFieldTemplate = class TableArrayFieldTemplate extends React.Component {
+    render() {
+        const { props } = this;
+        const { schema, uiSchema, formContext: { cols, wrapperCols, schemaPropsArray }, idSchema, readonly, disabled } = props;
+        const schemaProps = schema.additionalItems ? schema.additionalItems.properties : schema.items.properties;
+        const { Label } = this.props.formContext;
+        const { Row, Col } = this.context.theme;
+        const labels = utils_2.orderProperties(schemaPropsArray.filter(col => !utils_1.isHidden(uiSchema.items, col)), (uiSchema.items || {})["ui:order"]).map(propName => {
+            const propUiSchema = uiSchema && uiSchema.items && uiSchema.items[propName] || {};
+            return (React.createElement(Col, Object.assign({}, cols, { key: propName + "-label" }),
+                React.createElement(Label, { label: "title" in schemaProps[propName] ? schemaProps[propName].title : propName, disabled: false, id: idSchema[propName].$id, required: (schema.items.required && schema.items.required.indexOf(propName) > -1)
+                        || propUiSchema["ui:required"], uiSchema: propUiSchema })));
+        });
+        const options = utils_1.getUiOptions(props.uiSchema);
+        const { confirmDelete, deleteCorner, removable = true, nonRemovables = [], buttons, "ui:deleteHelp": deleteHelp } = options;
+        if (!this.deleteButtonRefs)
+            this.deleteButtonRefs = [];
+        const getRefFor = i => elem => { this.deleteButtonRefs[i] = elem; };
+        return (React.createElement("div", { className: "table-field" },
+            React.createElement(Row, null,
+                React.createElement("div", { className: "laji-form-field-template-item" },
+                    React.createElement("div", { className: "laji-form-field-template-schema" }, labels),
+                    React.createElement("div", { className: "laji-form-field-template-buttons" }))),
+            props.items.map((item, i) => {
+                const deleteButton = (React.createElement(components_1.DeleteButton, { ref: getRefFor(i), id: `${props.idSchema.$id}_${i}`, disabled: readonly || disabled, onClick: item.onDropIndexClick(item.index), confirm: confirmDelete, corner: deleteCorner, tooltip: deleteHelp, translations: props.formContext.translations }));
+                return (React.createElement(Row, { key: utils_1.getUUID(props.formData[item.index]) || item.key },
+                    React.createElement(Col, Object.assign({}, wrapperCols),
+                        React.createElement("div", { className: "laji-form-field-template-item keep-vertical" },
+                            React.createElement("div", { className: "laji-form-field-template-schema" }, item.children),
+                            item.hasRemove && !nonRemovables.includes(item.index) && removable && deleteButton))));
+            }),
+            ArrayFieldTemplate_1.getButtonElems(buttons, props)));
+    }
+};
+TableArrayFieldTemplate.contextType = ReactContext_1.default;
+TableArrayFieldTemplate = __decorate([
+    ArrayFieldTemplate_1.handlesArrayKeys
+], TableArrayFieldTemplate);

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

@@ -0,0 +1,38 @@
+export default class TagArrayField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                separatorKeys: PropTypes.Requireable<(string | null | undefined)[]>;
+                showDeleteButton: PropTypes.Requireable<boolean>;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Requireable<any[]>;
+    };
+    constructor(props: any);
+    constructor(props: any, context: any);
+}
+export class TagInputComponent extends React.Component<any, any, any> {
+    constructor(props: any);
+    getStateFromProps: ({ value }: {
+        value: any;
+    }) => {
+        value: any;
+    };
+    getSeparatorKeys: (uiSchema: any) => any;
+    onKeyDown: (e: any) => void;
+    onRemove: ((idx: any) => () => void) & memoize.Memoized<(idx: any) => () => void>;
+    onFocus: (e: any) => void;
+    onBlur: (e: any) => void;
+    setInputRef: (ref: any) => void;
+    inputRef: any;
+    onClick: () => void;
+    onInputChange: (e: any) => void;
+    onTagClick: ((idx: any) => () => void) & memoize.Memoized<(idx: any) => () => void>;
+    getTrimmedValue(): any;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";
+import * as memoize from "memoizee";

package/lib/components/fields/TagArrayField.js

@@ -0,0 +1,128 @@
+"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 });
+exports.TagInputComponent = void 0;
+const React = require("react");
+const react_dom_1 = require("react-dom");
+const PropTypes = require("prop-types");
+const utils_1 = require("../../utils");
+const BaseComponent_1 = require("../BaseComponent");
+const memoize = require("memoizee");
+let TagArrayField = class TagArrayField extends React.Component {
+    render() {
+        const { FieldTemplate } = this.props.registry.templates;
+        const { uiSchema } = this.props;
+        return (React.createElement(FieldTemplate, Object.assign({}, this.props, { forceDisplayLabel: true, rawHelp: uiSchema["ui:help"], description: uiSchema["ui:description"], rawErrors: [] }),
+            React.createElement(TagInputComponent, Object.assign({}, this.props, { id: this.props.idSchema.$id, tags: this.props.formData }))));
+    }
+};
+TagArrayField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            separatorKeys: PropTypes.arrayOf(PropTypes.string),
+            showDeleteButton: PropTypes.bool
+        })
+    }),
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array"])
+    }).isRequired,
+    formData: PropTypes.array
+};
+TagArrayField = __decorate([
+    BaseComponent_1.default
+], TagArrayField);
+exports.default = TagArrayField;
+class TagInputComponent extends React.Component {
+    constructor(props) {
+        super(props);
+        this.getStateFromProps = ({ value }) => {
+            return { value };
+        };
+        this.getSeparatorKeys = (uiSchema) => {
+            const { separatorKeys = ["Enter", ",", ";"] } = utils_1.getUiOptions(uiSchema);
+            return separatorKeys;
+        };
+        this.onKeyDown = (e) => {
+            const value = this.getTrimmedValue();
+            const { tags = [] } = this.props;
+            const separatorKeys = this.getSeparatorKeys(this.props.uiSchema);
+            if (separatorKeys.includes(e.key) && !utils_1.isEmptyString(value)) {
+                this.props.onChange([...tags, value], "enter");
+                e.stopPropagation();
+                e.preventDefault();
+            }
+            else if (e.key === "Backspace" && utils_1.isEmptyString(value) && tags.length) {
+                this.onRemove(tags.length - 1)();
+            }
+            utils_1.triggerParentComponent("onKeyDown", e, this.props);
+        };
+        this.onRemove = memoize((idx) => () => {
+            const tags = [...(this.props.tags || [])];
+            tags.splice(idx, 1);
+            this.props.onChange(tags, "remove");
+        });
+        this.onFocus = (e) => {
+            this.setState({ focused: true }, () => {
+                utils_1.triggerParentComponent("onFocus", e, this.props);
+            });
+        };
+        this.onBlur = (e) => {
+            this.setState({ focused: false });
+            utils_1.triggerParentComponent("onBlur", e, this.props);
+            const value = this.getTrimmedValue();
+            if (!utils_1.isEmptyString(value)) {
+                this.props.onChange([...(this.props.tags || []), value], "blur");
+            }
+        };
+        this.setInputRef = (ref) => {
+            this.inputRef = ref;
+        };
+        this.onClick = () => {
+            react_dom_1.findDOMNode(this.inputRef).focus();
+        };
+        this.onInputChange = (e) => {
+            const { onInputChange } = this.props;
+            onInputChange && e.persist();
+            const { target: { value } } = e;
+            const separatorKeys = this.getSeparatorKeys(this.props.uiSchema);
+            const splitted = separatorKeys.reduce((splitted, separator) => splitted.reduce((_splitted, i) => ([..._splitted, ...i.split(separator)]), []), [value]).map(s => s.trim()).filter(s => !utils_1.isEmptyString(s));
+            this.setState({ value }, () => {
+                onInputChange && this.props.onInputChange(e);
+                if (splitted.length > 1) {
+                    this.props.onChange([...(this.props.tags || []), ...splitted]);
+                }
+            });
+        };
+        this.onTagClick = memoize((idx) => () => {
+            const { onTagClick } = utils_1.getUiOptions(this.props.uiSchema);
+            onTagClick === null || onTagClick === void 0 ? void 0 : onTagClick(idx);
+        });
+        this.state = this.getStateFromProps(props);
+    }
+    UNSAFE_componentWillReceiveProps(props) {
+        this.setState(this.getStateFromProps(props));
+    }
+    getTrimmedValue() {
+        const { value } = this.state;
+        return value === null || value === void 0 ? void 0 : value.trim();
+    }
+    render() {
+        let { tags = [], InputComponent, readonly, disabled, uiSchema } = this.props;
+        tags = tags.filter(s => !utils_1.isEmptyString(s));
+        const { value = "" } = this.state;
+        const inputProps = Object.assign(Object.assign({ type: "text", className: "rw-input-reset", ref: this.setInputRef, value: value, onChange: this.onInputChange, id: this.props.id }, this.props.inputProps), { onFocus: this.onFocus, onBlur: this.onBlur, onKeyDown: this.onKeyDown });
+        const { showDeleteButton = true } = utils_1.getUiOptions(uiSchema);
+        return (React.createElement("div", { className: `rw-multiselect rw-widget${this.state.focused ? " rw-state-focus" : ""}${readonly || disabled ? " rw-state-disabled" : ""}`, onClick: this.onClick },
+            React.createElement("div", { className: "rw-widget-input rw-widget-picked rw-widget-container" },
+                React.createElement("ul", { className: "rw-multiselect-taglist" }, tags.map((item, idx) => React.createElement("li", { key: idx, className: "rw-multiselect-tag", onClick: this.onTagClick(idx) },
+                    item,
+                    showDeleteButton ? React.createElement("span", { className: "rw-tag-btn", onClick: this.onRemove(idx), tabIndex: 0, onKeyDown: this.props.formContext.utils.keyboardClick(this.onRemove(idx)) }, "\u00D7") : ""))),
+                InputComponent ? React.createElement(InputComponent, Object.assign({}, inputProps)) : React.createElement("input", Object.assign({}, inputProps, { disabled: disabled || readonly })))));
+    }
+}
+exports.TagInputComponent = TagInputComponent;

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

@@ -0,0 +1,26 @@
+export default class ToggleAdditionalArrayFieldsField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                additionalFields: PropTypes.Validator<(string | null | undefined)[]>;
+                toggleLabel: PropTypes.Requireable<string>;
+                toggleClassName: PropTypes.Requireable<string>;
+                toggleHelp: PropTypes.Requireable<string>;
+            }>>;
+            uiSchema: PropTypes.Requireable<object>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Validator<any[]>;
+    };
+    constructor(props: any);
+    getTogglePersistenceContextKey: (props: any) => string;
+    getInitialVisible(props: any): unknown;
+    getStateFromProps(props: any): {
+        uiSchema: any;
+    };
+    toggleVisibility: () => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/ToggleAdditionalArrayFieldsField.js

@@ -0,0 +1,81 @@
+"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 BaseComponent_1 = require("../BaseComponent");
+const Context_1 = require("../../Context");
+let ToggleAdditionalArrayFieldsField = class ToggleAdditionalArrayFieldsField extends React.Component {
+    constructor(props) {
+        super(props);
+        this.getTogglePersistenceContextKey = (props) => `$additional_toggle_persistence_${props.idSchema.$id}`;
+        this.toggleVisibility = () => {
+            const visible = !this.state.visible;
+            const context = Context_1.default(this.props.formContext.contextId);
+            context[this.getTogglePersistenceContextKey(this.props)] = visible;
+            this.setState({ visible });
+        };
+        this.state = Object.assign({ visible: this.getInitialVisible(props) }, this.getStateFromProps(props));
+    }
+    getInitialVisible(props) {
+        const { additionalFields } = utils_1.getUiOptions(props.uiSchema);
+        const context = Context_1.default(props.formContext.contextId);
+        let visible = context[this.getTogglePersistenceContextKey(props)] || false;
+        if (!visible) {
+            for (const data of props.formData) {
+                for (const field of additionalFields) {
+                    if (!utils_1.isDefaultData(utils_1.parseJSONPointer(data, field), utils_1.parseSchemaFromFormDataPointer(props.schema, field))) {
+                        visible = true;
+                        break;
+                    }
+                }
+            }
+        }
+        return visible;
+    }
+    getStateFromProps(props) {
+        const innerUiSchema = utils_1.getInnerUiSchema(props.uiSchema);
+        return { uiSchema: innerUiSchema };
+    }
+    render() {
+        const { CheckboxWidget } = this.props.registry.widgets;
+        const { SchemaField } = this.props.registry.fields;
+        const { additionalFields = [], toggleLabel, toggleClassName, toggleHelp } = utils_1.getUiOptions(this.props.uiSchema);
+        const shouldShow = Object.values(this.props.errorSchema || {}).some(error => additionalFields.some(field => utils_1.parseJSONPointer(error, field))) || this.state.visible;
+        let _uiSchema = this.state.uiSchema;
+        if (!shouldShow) {
+            additionalFields.forEach(field => {
+                _uiSchema = utils_1.updateSafelyWithJSONPointer(_uiSchema, { "ui:field": "HiddenField" }, "items/" + field);
+            });
+        }
+        return (React.createElement(React.Fragment, null,
+            React.createElement(SchemaField, Object.assign({}, this.props, { uiSchema: _uiSchema })),
+            React.createElement("div", { className: toggleClassName },
+                React.createElement(CheckboxWidget, Object.assign({}, this.props, { id: this.props.idSchema.$id + "_toggle", schema: { type: "boolean" }, value: this.state.visible, onChange: this.toggleVisibility, label: toggleLabel || "", options: { allowUndefined: false, help: toggleHelp }, required: false })))));
+    }
+};
+ToggleAdditionalArrayFieldsField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            additionalFields: PropTypes.arrayOf(PropTypes.string).isRequired,
+            toggleLabel: PropTypes.string,
+            toggleClassName: PropTypes.string,
+            toggleHelp: PropTypes.string
+        }),
+        uiSchema: PropTypes.object
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array"])
+    }).isRequired,
+    formData: PropTypes.oneOfType([PropTypes.array]).isRequired
+};
+ToggleAdditionalArrayFieldsField = __decorate([
+    BaseComponent_1.default
+], ToggleAdditionalArrayFieldsField);
+exports.default = ToggleAdditionalArrayFieldsField;

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

@@ -0,0 +1,30 @@
+export default class UiFieldApplierField extends React.Component<any, any, any> {
+    static propTypes: {
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                field: PropTypes.Requireable<string>;
+                functions: PropTypes.Requireable<PropTypes.InferProps<{
+                    "ui:field": PropTypes.Validator<string>;
+                    "ui:options": PropTypes.Requireable<object>;
+                }> | (PropTypes.InferProps<{
+                    "ui:field": PropTypes.Validator<string>;
+                    "ui:options": PropTypes.Requireable<object>;
+                }> | null | undefined)[]>;
+            }>>;
+        }>>;
+        formData: PropTypes.Requireable<object>;
+    };
+    static getName(): string;
+    constructor(props: any);
+    functions: any[];
+    getFunctions: () => any;
+    getStateFromProps(props: any): any;
+    onChange: (formData: any) => void;
+    onChangeFormData: any;
+    combinedOnChange(formData: any): void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";