@luomus/laji-form 14.3.6

package/lib/components/fields/DependentBooleanField.js

@@ -0,0 +1,87 @@
+"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 immutability_helper_1 = require("immutability-helper");
+const VirtualSchemaField_1 = require("../VirtualSchemaField");
+/**
+ * Transforms an array field to o boolean field, where each value is true/false according to another array field.
+ * Each value is true, if formData[booleanDefiner] == formData[booleanField].
+ * uiSchema = { "ui:options": {
+ *  booleanField: <array field name>,
+ *  booleanDefiner: <array field name>,
+ *  uiSchema: <uiSchema> (uiSchema used for each object).
+ * }}
+ */
+let DependentBooleanField = class DependentBooleanField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onChange = (formData) => {
+            const { booleanField, booleanDefiner } = this.getUiOptions();
+            const propsFormData = this.props.formData;
+            let newData = this.props.formData[booleanField];
+            // if the change happened in booleanField data, reflect the changes to all booleanField items with same data.
+            if (JSON.stringify(propsFormData[booleanDefiner]) === JSON.stringify(formData[booleanDefiner])) {
+                let dictionarifiedOrigData = this.getDictionarifiedFormData(propsFormData, booleanField);
+                formData[booleanDefiner].forEach((definerItem, i) => {
+                    if (dictionarifiedOrigData[definerItem] && !formData[booleanField][i]) {
+                        newData = immutability_helper_1.default(newData, { $splice: [[newData.indexOf(definerItem), 1]] });
+                    }
+                    else if (!dictionarifiedOrigData[definerItem] && formData[booleanField][i]) {
+                        newData = newData ? [...newData, definerItem] : [definerItem];
+                    }
+                });
+            }
+            if (newData)
+                newData = newData.filter(item => formData[booleanDefiner].includes(item));
+            formData = Object.assign(Object.assign({}, formData), { [booleanField]: newData });
+            this.props.onChange(formData);
+        };
+        this.getDictionarifiedFormData = (formData, field) => {
+            let formDataDictionarified = {};
+            (formData[field] || []).forEach((value) => {
+                formDataDictionarified[value] = true;
+            });
+            return formDataDictionarified;
+        };
+        this.getDictionarifiedBooleanFieldData = (formData) => {
+            return this.getDictionarifiedFormData(formData, this.getUiOptions().booleanField);
+        };
+    }
+    static getName() { return "DependentBooleanField"; }
+    getStateFromProps(props) {
+        let { uiSchema, formData } = props;
+        const { booleanField, booleanDefiner } = this.getUiOptions();
+        let schema = immutability_helper_1.default(props.schema, { properties: { [booleanField]: { items: { $merge: { type: "boolean" } } } } });
+        let booleanFieldDataDictionarified = this.getDictionarifiedBooleanFieldData(formData);
+        let booleanFieldData = [];
+        (formData[booleanDefiner] || []).forEach((definerItem) => {
+            booleanFieldData.push(!!booleanFieldDataDictionarified[definerItem]);
+        });
+        formData = Object.assign(Object.assign({}, props.formData), { [booleanField]: booleanFieldData });
+        return { schema, uiSchema, formData, onChange: this.onChange };
+    }
+};
+DependentBooleanField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            booleanField: PropTypes.string.isRequired,
+            booleanDefiner: PropTypes.string.isRequired,
+        }).isRequired,
+        uiSchema: PropTypes.object
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object"])
+    }).isRequired,
+    formData: PropTypes.object.isRequired
+};
+DependentBooleanField = __decorate([
+    VirtualSchemaField_1.default
+], DependentBooleanField);
+exports.default = DependentBooleanField;

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

@@ -0,0 +1,35 @@
+/**
+ * Disables object field's value according a regexp rule that is matched against another field's value.
+ * uiSchema = { "ui:options": {
+ *  disableField: <object field name>, (field to disable if disableDefiner's value doesn't match the regexp)
+ *  disableDefiner: <object field name>, (field that the regexp is matched against)
+ *  uiSchema: <uiSchema> (uiSchema used for each object).
+ * }}
+ */
+export default class DependentDisableField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                rules: PropTypes.Validator<(PropTypes.InferProps<{
+                    disableField: PropTypes.Validator<string>;
+                    disableDefiner: PropTypes.Validator<string>;
+                    regexp: PropTypes.Validator<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(props: any): {
+        uiSchema: any;
+        formData: any;
+    };
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/DependentDisableField.js

@@ -0,0 +1,71 @@
+"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 immutability_helper_1 = require("immutability-helper");
+const utils_1 = require("../../utils");
+const VirtualSchemaField_1 = require("../VirtualSchemaField");
+/**
+ * Disables object field's value according a regexp rule that is matched against another field's value.
+ * uiSchema = { "ui:options": {
+ *  disableField: <object field name>, (field to disable if disableDefiner's value doesn't match the regexp)
+ *  disableDefiner: <object field name>, (field that the regexp is matched against)
+ *  uiSchema: <uiSchema> (uiSchema used for each object).
+ * }}
+ */
+let DependentDisableField = class DependentDisableField extends React.Component {
+    static getName() { return "DependentDisableField"; }
+    getStateFromProps(props) {
+        let { uiSchema, formData } = props;
+        let newFormData = formData;
+        this.getUiOptions().rules.forEach(rule => {
+            const { disableField, disableDefiner, regexp } = rule;
+            const { formData } = props;
+            const fieldToMatch = (formData && !utils_1.isNullOrUndefined(formData[disableDefiner])) ?
+                formData[disableDefiner] : "";
+            if (fieldToMatch.match(regexp)) {
+                if (!uiSchema[disableField]) {
+                    uiSchema = Object.assign(Object.assign({}, uiSchema), { [disableField]: {} });
+                }
+                uiSchema = immutability_helper_1.default(uiSchema, {
+                    [disableField]: {
+                        $merge: {
+                            "ui:disabled": true,
+                            "ui:inlineHelp": rule.inlineHelp
+                        }
+                    }
+                });
+                if ("disabledValueToDisplay" in rule) {
+                    newFormData = Object.assign(Object.assign({}, formData), { [disableField]: rule.disabledValueToDisplay });
+                }
+            }
+        });
+        return { uiSchema, formData: newFormData };
+    }
+};
+DependentDisableField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            rules: PropTypes.arrayOf(PropTypes.shape({
+                disableField: PropTypes.string.isRequired,
+                disableDefiner: PropTypes.string.isRequired,
+                regexp: PropTypes.string.isRequired,
+            })).isRequired
+        }),
+        uiSchema: PropTypes.object
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object"])
+    }).isRequired,
+    formData: PropTypes.object.isRequired
+};
+DependentDisableField = __decorate([
+    VirtualSchemaField_1.default
+], DependentDisableField);
+exports.default = DependentDisableField;

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

@@ -0,0 +1,27 @@
+export default class EnumRangeArrayField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                range: PropTypes.Requireable<string>;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Requireable<any[]>;
+    };
+    static getName(): string;
+    constructor(props: any);
+    setRef: (elem: any) => void;
+    autosuggestRef: any;
+    onInputChange: ({ target: { value } }: {
+        target: {
+            value: any;
+        };
+    }, reason: any, callback: any) => any;
+    onSuggestionSelected: (suggestion: any) => void;
+    onUnsuggestedSelected: (value: any) => void;
+    onChange: (formData: any, reason: any) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/EnumRangeArrayField.js

@@ -0,0 +1,115 @@
+"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 react_dom_1 = require("react-dom");
+const BaseComponent_1 = require("../BaseComponent");
+const utils_1 = require("../../utils");
+const AutosuggestWidget_1 = require("../widgets/AutosuggestWidget");
+const TagArrayField_1 = require("./TagArrayField");
+let EnumRangeArrayField = class EnumRangeArrayField extends React.Component {
+    constructor(props) {
+        super(props);
+        this.setRef = (elem) => {
+            this.autosuggestRef = elem;
+        };
+        this.onInputChange = ({ target: { value } }, reason, callback) => {
+            this.setState({ value }, callback);
+            if (reason === "click") {
+                const tagComponent = this.autosuggestRef.autosuggestRef.inputElem;
+                const tagComponentElem = react_dom_1.findDOMNode(tagComponent);
+                const input = tagComponentElem.querySelector("input");
+                if (input) {
+                    input.focus();
+                }
+            }
+            return value;
+        };
+        this.onSuggestionSelected = (suggestion) => {
+            this.setState({ value: "" }, () => {
+                this.onChange([...(this.props.formData || []), suggestion.value], "suggestion selected");
+            });
+        };
+        this.onUnsuggestedSelected = (value) => {
+            this.setState({ value: "" }, () => {
+                this.onChange([...(this.props.formData || []), value], "unsuggested selected");
+            });
+        };
+        this.onChange = (formData, reason) => {
+            function onlyUnique(value, index, self) {
+                return self.indexOf(value) === index;
+            }
+            formData = formData.filter(onlyUnique);
+            if (reason !== "remove" && reason !== "suggestion selected" && reason !== "unsuggested selected") {
+                this.setState({ value: "" });
+                return;
+            }
+            this.setState({ value: "" }, () => {
+                this.props.onChange(formData);
+            });
+        };
+        this.state = { value: "" };
+    }
+    static getName() { return "EnumRangeArrayField"; }
+    render() {
+        const { range } = utils_1.getUiOptions(this.props.uiSchema);
+        const autosuggestOptions = {
+            autosuggestField: range,
+            onSuggestionSelected: this.onSuggestionSelected,
+            onConfirmUnsuggested: this.onConfirmUnsuggested,
+            id: this.props.idSchema.$id,
+            value: this.state.value,
+            controlledValue: true,
+            minFetchLength: 0,
+            wrapperClassName: "laji-form-enum-range",
+            inputProps: {
+                value: this.state.value,
+                that: this,
+                InputComponent: EnumRangeInputInjection,
+                onChange: this.onInputChange,
+                tags: this.props.formData,
+                id: this.props.idSchema.$id
+            },
+            allowNonsuggestedValue: false
+        };
+        const { Label } = this.props.formContext;
+        return (React.createElement(React.Fragment, null,
+            React.createElement(Label, { label: this.props.schema.title, id: this.props.idSchema.$id }),
+            React.createElement(AutosuggestWidget_1.Autosuggest, Object.assign({}, this.props, { onChange: undefined }, autosuggestOptions, { ref: this.setRef }))));
+    }
+};
+EnumRangeArrayField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            range: PropTypes.string
+        })
+    }),
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array"])
+    }).isRequired,
+    formData: PropTypes.array
+};
+EnumRangeArrayField = __decorate([
+    BaseComponent_1.default
+], EnumRangeArrayField);
+exports.default = EnumRangeArrayField;
+class EnumRangeInputInjection extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onInputChange = e => {
+            this.props.onChange(e);
+        };
+        this.onChange = (tags, reason) => {
+            this.props.that.onChange(tags, reason);
+        };
+    }
+    render() {
+        return React.createElement(TagArrayField_1.TagInputComponent, Object.assign({}, this.props, { formContext: this.props.that.props.formContext, onChange: this.onChange, onInputChange: this.onInputChange }));
+    }
+}

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

@@ -0,0 +1,38 @@
+export default class ExtraLabelRowField extends React.Component<any, any, any> {
+    static contextType: React.Context<import("../../ReactContext").ContextProps>;
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                labels: PropTypes.Validator<(object | null | undefined)[]>;
+                lg: PropTypes.Requireable<number | object>;
+                md: PropTypes.Requireable<number | object>;
+                sm: PropTypes.Requireable<number | object>;
+                xs: PropTypes.Requireable<number | object>;
+                hiddenXs: any;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Validator<object>;
+    };
+    constructor(props: any);
+    constructor(props: any, context: any);
+    getStateFromProps(props: any): {
+        schema: any;
+        uiSchema: any;
+        options: any;
+    };
+    setContainerRef: (elem: any) => void;
+    containerElem: any;
+    getContainerRef: () => any;
+    getColContent: (label: any, i: any) => JSX.Element;
+    getCols: (property: any) => {
+        lg: number;
+        md: number;
+        sm: number;
+        xs: number;
+    };
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/ExtraLabelRowField.js

@@ -0,0 +1,100 @@
+"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 ReactContext_1 = require("../../ReactContext");
+const utils_2 = require("@rjsf/utils");
+let ExtraLabelRowField = class ExtraLabelRowField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.setContainerRef = (elem) => {
+            this.containerElem = elem;
+        };
+        this.getContainerRef = () => {
+            return this.containerElem;
+        };
+        this.getColContent = (label, i) => {
+            const cols = this.getCols(label.size);
+            const { Label } = this.props.formContext;
+            const { Col } = this.context.theme;
+            return (React.createElement(Col, Object.assign({}, cols, { key: i }),
+                React.createElement(Label, { label: label.label, id: this.props.idSchema.$id, uiSchema: { "ui:help": label.help } })));
+        };
+        this.getCols = (property) => {
+            const cols = { lg: 12, md: 12, sm: 12, xs: 12 };
+            const options = utils_1.getUiOptions(this.props.uiSchema);
+            Object.keys(cols).forEach(col => {
+                const optionCol = options[col];
+                if (typeof optionCol === "object") {
+                    let selector = undefined;
+                    if (optionCol[property])
+                        selector = property;
+                    else if (optionCol["*"])
+                        selector = "*";
+                    cols[col] = optionCol[selector];
+                }
+                else {
+                    cols[col] = optionCol;
+                }
+            });
+            return cols;
+        };
+    }
+    getStateFromProps(props) {
+        return {
+            schema: Object.assign(Object.assign({}, props.schema), { title: "" }),
+            uiSchema: utils_1.getInnerUiSchema(props.uiSchema),
+            options: utils_1.getUiOptions(props.uiSchema)
+        };
+    }
+    render() {
+        const { SchemaField } = this.props.registry.fields;
+        const TitleFieldTemplate = utils_2.getTemplate("TitleFieldTemplate", this.props.registry, utils_1.getUiOptions(this.props.uiSchema));
+        const { labels, hiddenXs, affixed } = utils_1.getUiOptions(this.props.uiSchema);
+        const cols = [];
+        labels.forEach((label, i) => {
+            cols.push(this.getColContent(label, i));
+        });
+        const title = this.props.schema.title !== undefined ? this.props.schema.title : this.props.name;
+        const { Row } = this.context.theme;
+        let labelRow = React.createElement(Row, { className: "laji-form-label-row" + (hiddenXs ? " hidden-xs" : "") + (affixed ? " affixed-labels" : "") }, cols);
+        if (affixed) {
+            labelRow = (React.createElement(components_1.Affix, { getContainer: this.getContainerRef, style: affixed ? { position: "relative", zIndex: 1 } : undefined, topOffset: this.props.formContext.topOffset, bottomOffset: this.props.formContext.bottomOffset }, labelRow));
+        }
+        return (React.createElement("div", { ref: this.setContainerRef },
+            title
+                ? (React.createElement(TitleFieldTemplate, { title: title, schema: this.props.schema, uiSchema: this.props.uiSchema, id: this.props.idSchema.$id, registry: this.props.registry })) : null,
+            labelRow,
+            React.createElement(SchemaField, Object.assign({}, this.props, this.state))));
+    }
+};
+ExtraLabelRowField.contextType = ReactContext_1.default;
+ExtraLabelRowField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            labels: PropTypes.arrayOf(PropTypes.object).isRequired,
+            lg: PropTypes.oneOfType([PropTypes.number, PropTypes.object]),
+            md: PropTypes.oneOfType([PropTypes.number, PropTypes.object]),
+            sm: PropTypes.oneOfType([PropTypes.number, PropTypes.object]),
+            xs: PropTypes.oneOfType([PropTypes.number, PropTypes.object]),
+            hiddenXs: PropTypes.boolean
+        })
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object", "array"])
+    }).isRequired,
+    formData: PropTypes.oneOfType([PropTypes.object, PropTypes.array]).isRequired
+};
+ExtraLabelRowField = __decorate([
+    BaseComponent_1.default
+], ExtraLabelRowField);
+exports.default = ExtraLabelRowField;

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

@@ -0,0 +1,18 @@
+export default class FakePropertyField extends React.Component<any, any, any> {
+    static propTypes: {
+        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: any;
+        uiSchema: any;
+        formData: any;
+    };
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/FakePropertyField.js

@@ -0,0 +1,48 @@
+"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 utils_1 = require("../../utils");
+const utils_2 = require("../../utils");
+let FakePropertyField = class FakePropertyField extends React.Component {
+    static getName() { return "FakePropertyField"; }
+    getStateFromProps(props) {
+        const { fields } = this.getUiOptions();
+        let properties = props.schema.properties;
+        let uiSchema = props.uiSchema;
+        let formData = props.formData;
+        Object.keys(fields).forEach((prop) => {
+            const { schema, uiSchema: _uiSchema, formData: _formData, skipIfEmpty = false } = fields[prop];
+            if (skipIfEmpty && !utils_2.hasData(_formData) && !utils_2.hasData(formData[prop])) {
+                return false;
+            }
+            properties = utils_1.updateSafelyWithJSONPointer(properties, schema, prop);
+            uiSchema = utils_1.updateSafelyWithJSONPointer(uiSchema, _uiSchema, prop);
+            formData = _formData
+                ? utils_1.updateSafelyWithJSONPointer(formData, _formData, prop)
+                : formData;
+        });
+        return {
+            schema: Object.assign(Object.assign({}, props.schema), { properties }),
+            uiSchema,
+            formData
+        };
+    }
+};
+FakePropertyField.propTypes = {
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object"])
+    }).isRequired,
+    formData: PropTypes.object.isRequired
+};
+FakePropertyField = __decorate([
+    VirtualSchemaField_1.default
+], FakePropertyField);
+exports.default = FakePropertyField;

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

@@ -0,0 +1,73 @@
+export const arrayRulesPropType: PropTypes.Requireable<string | PropTypes.InferProps<{
+    container: PropTypes.Requireable<string>;
+    field: PropTypes.Validator<string>;
+    regexp: PropTypes.Requireable<string>;
+    valueIn: PropTypes.Requireable<(string | null | undefined)[]>;
+    valueLengthLessThan: PropTypes.Requireable<number>;
+    complement: PropTypes.Requireable<boolean>;
+}> | PropTypes.InferProps<{
+    idx: PropTypes.Requireable<number>;
+    isLast: PropTypes.Requireable<number>;
+    complement: PropTypes.Requireable<boolean>;
+}> | (string | PropTypes.InferProps<{
+    container: PropTypes.Requireable<string>;
+    field: PropTypes.Validator<string>;
+    regexp: PropTypes.Requireable<string>;
+    valueIn: PropTypes.Requireable<(string | null | undefined)[]>;
+    valueLengthLessThan: PropTypes.Requireable<number>;
+    complement: PropTypes.Requireable<boolean>;
+}> | PropTypes.InferProps<{
+    idx: PropTypes.Requireable<number>;
+    isLast: PropTypes.Requireable<number>;
+    complement: PropTypes.Requireable<boolean>;
+}> | null | undefined)[]>;
+export default class FilterArrayField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                rules: PropTypes.Requireable<string | PropTypes.InferProps<{
+                    container: PropTypes.Requireable<string>;
+                    field: PropTypes.Validator<string>;
+                    regexp: PropTypes.Requireable<string>;
+                    valueIn: PropTypes.Requireable<(string | null | undefined)[]>;
+                    valueLengthLessThan: PropTypes.Requireable<number>;
+                    complement: PropTypes.Requireable<boolean>;
+                }> | PropTypes.InferProps<{
+                    idx: PropTypes.Requireable<number>;
+                    isLast: PropTypes.Requireable<number>;
+                    complement: PropTypes.Requireable<boolean>;
+                }> | (string | PropTypes.InferProps<{
+                    container: PropTypes.Requireable<string>;
+                    field: PropTypes.Validator<string>;
+                    regexp: PropTypes.Requireable<string>;
+                    valueIn: PropTypes.Requireable<(string | null | undefined)[]>;
+                    valueLengthLessThan: PropTypes.Requireable<number>;
+                    complement: PropTypes.Requireable<boolean>;
+                }> | PropTypes.InferProps<{
+                    idx: PropTypes.Requireable<number>;
+                    isLast: PropTypes.Requireable<number>;
+                    complement: PropTypes.Requireable<boolean>;
+                }> | null | undefined)[]>;
+                cache: any;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Requireable<any[]>;
+    };
+    constructor(props: any);
+    constructor(props: any, context: any);
+    getStateFromProps(props: any): any;
+    cache: any;
+    filteredIdxs: {} | undefined;
+    filteredToOffsets: {} | undefined;
+    idxToOffsets: {} | undefined;
+    filteredTotal: number | undefined;
+    getActiveProps(options: any): any;
+    cachedOnActiveChange: any;
+    getOnActiveChange: (idx: any, prop: any, callback: any) => void;
+    onChange: (formData: any) => void;
+}
+import * as PropTypes from "prop-types";
+import * as React from "react";