@luomus/laji-form 15.1.4 → 15.1.6

package/lib/components/fields/ConditionalOnChangeField.js

@@ -0,0 +1,107 @@
+"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");
+window.PropTypes = PropTypes;
+const conditionPropType = {
+    regexp: PropTypes.string,
+    length: PropTypes.number,
+    reverse: PropTypes.bool,
+};
+const rulePropType = PropTypes.shape({
+    transformations: PropTypes.object.isRequired,
+    conditions: (props, propName, componentName) => Object.keys(props[propName]).every(prop => PropTypes.checkPropTypes(conditionPropType, props[propName][prop], propName, componentName))
+}).isRequired;
+/**
+ * Changes formData on onChange event according to conditional rules.
+ * uiSchema = {
+ *   "ui:options": {
+ *     rules: { // Can also be an array of rules
+ *       transformations: {
+ *        <field name to change if conditions met>: <new value>
+ *       },
+ *       conditions: {
+ *         <conditional field name>: { // Note that regexp and length must both pass for this rule to pass.
+ *           regexp: <string> <if the conditional field value matches this regexp, this condition will pass>
+ *           length: <number> <if the conditional field value length is equal or more, this conndition will pass>
+ *           reverse: <boolean> <Reverses the passing value>
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ */
+let ConditionalOnChangeField = class ConditionalOnChangeField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onChange = (formData) => {
+            const { rules } = this.getUiOptions();
+            (Array.isArray(rules) ? rules : [rules]).forEach(({ conditions, transformations }) => {
+                let passes = true;
+                // If transforming field is updated, do nothing
+                // (If a transforming field is also a condition field, the field would take the conditional value always when updated).
+                if (Object.keys(transformations).some(field => formData && formData[field] && formData[field] !== this.props.formData[field])) {
+                    return;
+                }
+                // If condition fields didn't change, do nothing.
+                if (Object.keys(conditions).every(field => formData && formData[field] && formData[field] === this.props.formData[field])) {
+                    return;
+                }
+                for (let field in conditions) {
+                    const condition = conditions[field];
+                    const { regexp, length, reverse } = condition;
+                    if (passes && regexp !== undefined) {
+                        const regexp = new RegExp(condition.regexp.replace("%default", this.props.schema.properties[field].default));
+                        const result = `${formData[field]}`.match(regexp);
+                        passes = reverse ? !result : result;
+                    }
+                    if (passes && length !== undefined) {
+                        const result = (formData[field] || []).length >= length;
+                        passes = reverse ? !result : result;
+                    }
+                    if (!passes)
+                        break;
+                }
+                if (passes) {
+                    let formDataChange = {};
+                    if (transformations)
+                        for (let transformField in transformations) {
+                            formDataChange[transformField] = transformations[transformField];
+                        }
+                    formData = Object.assign(Object.assign({}, formData), formDataChange);
+                }
+            });
+            this.props.onChange(formData);
+        };
+    }
+    static getName() { return "ConditionalOnChangeField"; }
+    getStateFromProps() {
+        return { onChange: this.onChange };
+    }
+};
+ConditionalOnChangeField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            rules: PropTypes.oneOfType([
+                rulePropType,
+                PropTypes.arrayOf(rulePropType)
+            ]).isRequired
+        }).isRequired,
+        uiSchema: PropTypes.object
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object"])
+    }).isRequired,
+    formData: PropTypes.object.isRequired
+};
+ConditionalOnChangeField = __decorate([
+    VirtualSchemaField_1.default
+], ConditionalOnChangeField);
+exports.default = ConditionalOnChangeField;

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

@@ -0,0 +1,123 @@
+export const rulePropType: 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>;
+}>>;
+export const operationPropType: PropTypes.Requireable<PropTypes.InferProps<{
+    type: PropTypes.Requireable<string>;
+    uiSchema: PropTypes.Validator<object>;
+}>>;
+export const rulesPropType: 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>;
+}> | (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>;
+}> | null | undefined)[]>;
+/**
+ * Transforms uiSchema according to conditional cases. Cases are not mutually exclusive.
+ * uiSchema = {"ui:options": {
+ *	cases: [
+ *		rules: [
+ *			{
+ *				regexp: The regexp that the field must match.
+ *				valueIn: An array that the field must be in.
+ *				field: The field that the rule is being checked on (can be a JSON pointer or a field name)
+ *			}
+ *		],
+ *		operations: [ // All the operations are performed if all rules pass.
+ *			{
+ *				type: "merge" or "wrap" "replace". "merge" deeply merges the conditional uiSchema to the nested uiSchema.
+ *				                                   "wrap" sets the nested uiSchema inside conditional uiSchema.
+ *				                                   "replace" (default) replaces nested uiSchema with conditional uiSchema.
+ *				uiSchema: conditional uiSchema to use.
+ *			}
+ *		],
+ *		else: [<same as operations>] // Operations performed if the rules do not pass.
+ *		cache: <boolean> true by default. If you know the cases will cache, set this to false.
+ *		       There will be a performance penalty on valueIn rule, as they are not indexed without caching.
+ *	]
+ * }
+ * uiSchema: nested uiSchema
+ * }
+ */
+export default class ConditionalUiSchemaField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                cases: 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>;
+                    }> | (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>;
+                    }> | null | undefined)[]>;
+                    operations: PropTypes.Requireable<PropTypes.InferProps<{
+                        type: PropTypes.Requireable<string>;
+                        uiSchema: PropTypes.Validator<object>;
+                    }> | (PropTypes.InferProps<{
+                        type: PropTypes.Requireable<string>;
+                        uiSchema: PropTypes.Validator<object>;
+                    }> | null | undefined)[]>;
+                }> | (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>;
+                    }> | (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>;
+                    }> | null | undefined)[]>;
+                    operations: PropTypes.Requireable<PropTypes.InferProps<{
+                        type: PropTypes.Requireable<string>;
+                        uiSchema: PropTypes.Validator<object>;
+                    }> | (PropTypes.InferProps<{
+                        type: PropTypes.Requireable<string>;
+                        uiSchema: PropTypes.Validator<object>;
+                    }> | null | undefined)[]>;
+                }> | null | undefined)[]>;
+                cache: any;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+    };
+    static getName(): string;
+    constructor(props: any);
+    constructor(props: any, context: any);
+    cache: {};
+    getStateFromProps(props: any): {
+        uiSchema: any;
+    };
+}
+export function computeUiSchema(uiSchema: any, operations: any, arrayMerge?: string): any;
+import * as PropTypes from "prop-types";
+import * as React from "react";

package/lib/components/fields/ConditionalUiSchemaField.js

@@ -0,0 +1,143 @@
+"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.computeUiSchema = exports.rulesPropType = exports.operationPropType = exports.rulePropType = void 0;
+const React = require("react");
+const PropTypes = require("prop-types");
+const VirtualSchemaField_1 = require("../VirtualSchemaField");
+const deepmerge = require("deepmerge");
+const utils_1 = require("../../utils");
+exports.rulePropType = PropTypes.oneOfType([
+    PropTypes.shape({
+        container: PropTypes.string,
+        field: PropTypes.string.isRequired,
+        regexp: PropTypes.string,
+        valueIn: PropTypes.arrayOf(PropTypes.string),
+        valueLengthLessThan: PropTypes.number,
+        complement: PropTypes.bool
+    }),
+    PropTypes.oneOf(["isAdmin", "isEdit"])
+]);
+exports.operationPropType = PropTypes.shape({
+    type: PropTypes.oneOf(["merge", "wrap"]),
+    uiSchema: PropTypes.object.isRequired,
+});
+exports.rulesPropType = PropTypes.oneOfType([
+    exports.rulePropType,
+    PropTypes.arrayOf(exports.rulePropType)
+]);
+const casePropType = PropTypes.shape({
+    rules: exports.rulesPropType,
+    operations: PropTypes.oneOfType([
+        exports.operationPropType,
+        PropTypes.arrayOf(exports.operationPropType)
+    ])
+});
+/**
+ * Transforms uiSchema according to conditional cases. Cases are not mutually exclusive.
+ * uiSchema = {"ui:options": {
+ *	cases: [
+ *		rules: [
+ *			{
+ *				regexp: The regexp that the field must match.
+ *				valueIn: An array that the field must be in.
+ *				field: The field that the rule is being checked on (can be a JSON pointer or a field name)
+ *			}
+ *		],
+ *		operations: [ // All the operations are performed if all rules pass.
+ *			{
+ *				type: "merge" or "wrap" "replace". "merge" deeply merges the conditional uiSchema to the nested uiSchema.
+ *				                                   "wrap" sets the nested uiSchema inside conditional uiSchema.
+ *				                                   "replace" (default) replaces nested uiSchema with conditional uiSchema.
+ *				uiSchema: conditional uiSchema to use.
+ *			}
+ *		],
+ *		else: [<same as operations>] // Operations performed if the rules do not pass.
+ *		cache: <boolean> true by default. If you know the cases will cache, set this to false.
+ *		       There will be a performance penalty on valueIn rule, as they are not indexed without caching.
+ *	]
+ * }
+ * uiSchema: nested uiSchema
+ * }
+ */
+let ConditionalUiSchemaField = class ConditionalUiSchemaField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.cache = {};
+    }
+    static getName() { return "ConditionalUiSchemaField"; }
+    getStateFromProps(props) {
+        const { cases = [], cache = true, arrayMerge } = this.getUiOptions();
+        const { uiSchema } = props;
+        let computedUiSchema = uiSchema;
+        (Array.isArray(cases) ? cases : [cases]).forEach(({ rules = [], operations = [], else: _else, arrayMerge: _arrayMerge }, idx) => {
+            let passes;
+            if (cache) {
+                if (!this.cache[idx]) {
+                    this.cache[idx] = {};
+                }
+                const check = utils_1.checkRules(rules, props, this.cache[idx]);
+                const { cache } = check;
+                passes = check.passes;
+                this.cache = cache;
+            }
+            else {
+                passes = utils_1.checkRules(rules, props);
+            }
+            if (passes) {
+                computedUiSchema = exports.computeUiSchema(computedUiSchema, operations, _arrayMerge || arrayMerge);
+            }
+            else if (_else) {
+                computedUiSchema = exports.computeUiSchema(computedUiSchema, _else, _arrayMerge || arrayMerge);
+            }
+        });
+        return { uiSchema: computedUiSchema };
+    }
+};
+ConditionalUiSchemaField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            cases: PropTypes.oneOfType([
+                casePropType,
+                PropTypes.arrayOf(casePropType)
+            ]),
+            cache: PropTypes.boolean
+        })
+    }),
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array", "object", "string", "integer", "number", "boolean"])
+    }).isRequired,
+};
+ConditionalUiSchemaField = __decorate([
+    VirtualSchemaField_1.default
+], ConditionalUiSchemaField);
+exports.default = ConditionalUiSchemaField;
+const computeUiSchema = (uiSchema, operations, arrayMerge = "replace") => {
+    if (!operations)
+        return uiSchema;
+    return (Array.isArray(operations) ? operations : [operations]).reduce((_uiSchema, op) => {
+        switch (op.type) {
+            case "merge":
+                uiSchema = deepmerge(uiSchema, op.uiSchema, { arrayMerge: arrayMerge === "replace"
+                        ? (a1, a2) => a2
+                        : (a1, a2) => [...a1, ...a2] });
+                break;
+            case "wrap":
+                uiSchema = Object.assign(Object.assign({}, op.uiSchema), { uiSchema });
+                break;
+            case "jsonPointer":
+                uiSchema = utils_1.updateSafelyWithJSONPointer(uiSchema, op.value, op.pointer);
+                break;
+            case "replace":
+            default:
+                uiSchema = op.uiSchema;
+        }
+        return uiSchema;
+    }, uiSchema);
+};
+exports.computeUiSchema = computeUiSchema;

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

@@ -0,0 +1,24 @@
+export function getInjectedUiSchema(uiSchema: any, injections: any, uiSchemaContext: any): any;
+export default class ContextInjectionField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Validator<PropTypes.InferProps<{
+                injections: PropTypes.Validator<object>;
+                target: PropTypes.Requireable<string>;
+            }>>;
+            uiSchema: PropTypes.Requireable<object>;
+        }>>;
+        formData: PropTypes.Requireable<string | number | boolean | object>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+    };
+    static getName(): string;
+    constructor(props: any);
+    constructor(props: any, context: any);
+    getStateFromProps(props: any): {
+        [x: number]: any;
+    };
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/ContextInjectionField.js

@@ -0,0 +1,68 @@
+"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.getInjectedUiSchema = void 0;
+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");
+let ContextInjectionField = class ContextInjectionField extends React.Component {
+    static getName() { return "ContextInjectionField"; }
+    getStateFromProps(props) {
+        const { injections, target = "uiSchema" } = this.getUiOptions();
+        const container = props[target];
+        return { [target]: getInjectedUiSchema(container, injections, props.formContext.uiSchemaContext) };
+    }
+};
+ContextInjectionField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            injections: PropTypes.object.isRequired,
+            target: PropTypes.oneOf(["uiSchema", "schema"]),
+        }).isRequired,
+        uiSchema: PropTypes.object
+    }).isRequired,
+    formData: PropTypes.oneOfType([PropTypes.object, PropTypes.array, PropTypes.string, PropTypes.number, PropTypes.bool]),
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array", "object", "string", "integer", "number", "boolean"])
+    }).isRequired,
+};
+ContextInjectionField = __decorate([
+    VirtualSchemaField_1.default
+], ContextInjectionField);
+exports.default = ContextInjectionField;
+function getInjectedUiSchema(uiSchema, injections, uiSchemaContext) {
+    let injected = false;
+    const updateObject = {};
+    for (let injectionPath in injections) {
+        const splitted = injectionPath.substring(1).split("/");
+        const last = splitted.pop();
+        const tail = splitted.reduce((pointer, path) => {
+            if (!pointer[path])
+                pointer[path] = {};
+            return pointer[path];
+        }, updateObject);
+        let value = injections[injectionPath];
+        if (value.match(/%{.*}/)) {
+            while (value.match(/%{.*}/)) {
+                const [match, innerValue] = value.match(/%{(.*)}/);
+                value = value.replace(match, utils_1.parseJSONPointer(uiSchemaContext, innerValue));
+            }
+        }
+        else {
+            value = utils_1.parseJSONPointer(uiSchemaContext, value);
+        }
+        tail[last] = { $set: value };
+        injected = true;
+    }
+    if (injected)
+        uiSchema = immutability_helper_1.default(uiSchema, updateObject);
+    return uiSchema;
+}
+exports.getInjectedUiSchema = getInjectedUiSchema;

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

@@ -0,0 +1,40 @@
+/**
+ * Enables leaking any prop to any other prop container.
+ *
+ * uiSchema = {"ui:options": {
+ *	props: [
+ *		{
+ *			from: If a regular string, a property to copy from formData. If a JSON pointer, the root will be this.props.
+ *			target: Target where to copy the 'from'. If a regular string, it will be copied to /uischema/ui:options. If a JSON pointer, the root will be this.props.
+ *		}
+ */
+export default class DataLeakerField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                props: PropTypes.Requireable<PropTypes.InferProps<{
+                    from: PropTypes.Validator<string>;
+                    fromArrayKey: PropTypes.Requireable<string>;
+                    target: PropTypes.Requireable<string>;
+                    joinArray: PropTypes.Requireable<boolean>;
+                }> | (PropTypes.InferProps<{
+                    from: PropTypes.Validator<string>;
+                    fromArrayKey: PropTypes.Requireable<string>;
+                    target: PropTypes.Requireable<string>;
+                    joinArray: PropTypes.Requireable<boolean>;
+                }> | null | undefined)[]>;
+            }>>;
+            uiSchema: PropTypes.Requireable<object>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Requireable<object>;
+    };
+    static getName(): string;
+    constructor(props: any);
+    constructor(props: any, context: any);
+    getStateFromProps(props: any): any;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/DataLeakerField.js

@@ -0,0 +1,68 @@
+"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 VirtualSchemaField_1 = require("../VirtualSchemaField");
+const propsPropType = PropTypes.shape({
+    from: PropTypes.string.isRequired,
+    fromArrayKey: PropTypes.string,
+    target: PropTypes.string,
+    joinArray: PropTypes.bool
+});
+/**
+ * Enables leaking any prop to any other prop container.
+ *
+ * uiSchema = {"ui:options": {
+ *	props: [
+ *		{
+ *			from: If a regular string, a property to copy from formData. If a JSON pointer, the root will be this.props.
+ *			target: Target where to copy the 'from'. If a regular string, it will be copied to /uischema/ui:options. If a JSON pointer, the root will be this.props.
+ *		}
+ */
+let DataLeakerField = class DataLeakerField extends React.Component {
+    static getName() { return "DataLeakerField"; }
+    getStateFromProps(props) {
+        const { props: _props = [] } = this.getUiOptions(props.uiSchema);
+        return (Array.isArray(_props) ? _props : [_props]).reduce((props, strOrObjProp) => {
+            const [fromPath, fromArrayKey, targetPath, joinArray] = ["from", "fromArrayKey", "target", "joinArray"]
+                .map(p => strOrObjProp[p]);
+            let from = fromPath[0] === "/"
+                ? utils_1.parseJSONPointer(props, fromPath)
+                : utils_1.parseJSONPointer(props.formData, fromPath);
+            if (fromArrayKey) {
+                from = (from || []).map(obj => obj[fromArrayKey]);
+            }
+            if (joinArray && Array.isArray(from)) {
+                from = from.join(",");
+            }
+            const _targetPath = targetPath[0] === "/"
+                ? targetPath
+                : `/uiSchema/ui:options/${targetPath}`;
+            props = utils_1.updateSafelyWithJSONPointer(props, from, _targetPath);
+            return props;
+        }, props);
+    }
+};
+DataLeakerField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            props: PropTypes.oneOfType([PropTypes.arrayOf(propsPropType), propsPropType])
+        }),
+        uiSchema: PropTypes.object
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array", "object"])
+    }).isRequired,
+    formData: PropTypes.oneOfType([PropTypes.array, PropTypes.object])
+};
+DataLeakerField = __decorate([
+    VirtualSchemaField_1.default
+], DataLeakerField);
+exports.default = DataLeakerField;

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

@@ -0,0 +1,34 @@
+/**
+ * Sets given default values to target fields.
+ * uiSchema = { "ui:options": {
+ *  "default": [
+ *    {
+ *      field1: defaultValue1,
+ *      field2: defaultValue2
+ *    }
+ *    ...
+ *  ]
+ * }}
+ */
+export default class DefaultValueArrayField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Validator<PropTypes.InferProps<{
+                default: PropTypes.Validator<object>;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Validator<any[]>;
+    };
+    static getName(): string;
+    constructor(props: any);
+    constructor(props: any, context: any);
+    getStateFromProps(): {
+        onChange: (formData: any) => void;
+    };
+    onChange: (formData: any) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/DefaultValueArrayField.js

@@ -0,0 +1,59 @@
+"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");
+/**
+ * Sets given default values to target fields.
+ * uiSchema = { "ui:options": {
+ *  "default": [
+ *    {
+ *      field1: defaultValue1,
+ *      field2: defaultValue2
+ *    }
+ *    ...
+ *  ]
+ * }}
+ */
+let DefaultValueArrayField = class DefaultValueArrayField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onChange = (formData) => {
+            const options = this.getUiOptions();
+            const _default = options.default;
+            Object.keys(_default).forEach(field => {
+                if (formData)
+                    formData.forEach((item, i) => {
+                        formData = immutability_helper_1.default(formData, { $splice: [[i, 1, immutability_helper_1.default(item, { $merge: { [field]: _default[field] } })]] });
+                    });
+            });
+            this.props.onChange(formData);
+        };
+    }
+    static getName() { return "DefaultValueArrayField"; }
+    getStateFromProps() {
+        return { onChange: this.onChange };
+    }
+};
+DefaultValueArrayField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            default: PropTypes.object.isRequired
+        }).isRequired
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array"])
+    }).isRequired,
+    formData: PropTypes.oneOfType([PropTypes.array]).isRequired
+};
+DefaultValueArrayField = __decorate([
+    VirtualSchemaField_1.default
+], DefaultValueArrayField);
+exports.default = DefaultValueArrayField;