@luomus/laji-form 15.1.4 → 15.1.6

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

@@ -0,0 +1,148 @@
+export function getPropsForFields({ schema, uiSchema, idSchema, errorSchema, formData, onChange }: {
+    schema: any;
+    uiSchema: any;
+    idSchema: any;
+    errorSchema: any;
+    formData: any;
+    onChange: any;
+}, fields: any, title: any): {
+    schema: {
+        type: string;
+        properties: {};
+        title: any;
+    };
+    uiSchema: {};
+    idSchema: {
+        $id: any;
+    };
+    errorSchema: {};
+    formData: {};
+    onChange: ((formData: any) => any) | undefined;
+};
+/**
+ * Makes it possible to extract fields from object schema and
+ * make them act like a nested schema without touching the form data structure.
+ *
+ * uiSchema = {
+ *  title: <string>,
+ *  ui:options: {
+ *    nests: {
+ *      fieldName: {
+ *       fields: [<string>],
+ *       title: <string>,
+ *      }
+ *    },
+ *    uiSchema: <uiSchema>
+ *  }
+ * }
+ *
+ * Example usage:
+ *
+ * schema = {
+ *  "type": "object",
+ *  "properties": {
+ *    "inner_1" { "type": "string" },
+ *    "inner_2": { "type": "string" },
+ *    "innerOfInner_1": { "type": "string" },
+ *    "innerOfInner_2": { "type": "string" },
+ *    "secondInner_1" { "type": "string" },
+ *    "secondInner_2": { "type": "string" },
+ *    "outer_2": { "type": "string" }
+ *  }
+ *
+ *  uiSchema = {
+ *    "ui:field": "nest",
+ *    "ui:options": {
+ *      "nests": {
+ *        "inner": {
+ *          "fields": ["inner_1", "inner_2"],
+ *          "title": "title of inner",
+ *          "uiSchema": {
+ *            "ui:field": "someField"
+ *            "inner_1": {
+ *              "ui:field": "someField2"
+ *            }
+ *          }
+ *        },
+ *        "secondInner": {
+ *          "fields": ["secondInner_1", "secondInner_2"],
+ *          "uiSchema": {
+ *            "ui:field": "someField3"
+ *          }
+ *        }
+ *      },
+ *      "uiSchema": {
+ *        "ui:field": "container"
+ *      }
+ *  }
+ *
+ *  would make the schemas look like this:
+ *
+ *  schema = {
+ *    "type": "object",
+ *    "properties": {
+ *      "inner": {
+ *        "type": "object",
+ *        "title": "title of inner",
+ *        "properties": {
+ *          "inner_1": {
+ *            "type": "string"
+ *          },
+ *          "inner_2": {
+ *            "type": "string"
+ *          }
+ *        }
+ *      },
+ *      "inner2": {
+ *        "type: "object",
+ *        "properties": {
+ *          "secondInner_1": {
+ *            "type": "string"
+ *          },
+ *          "secondInner_2": {
+ *            "type": "string"
+ *          }
+ *        }
+ *      },
+ *    }
+ *  }
+ *
+ *  uiSchema = {
+ *    "ui:field": "container",
+ *    "inner": {
+ *      "ui:field": "someField"
+ *      "inner_1": {
+ *        "ui:field": "someField2"
+ *      }
+ *    },
+ *    "inner2": {
+ *      "ui:field": "someField3"
+ *    }
+ *  }
+ *
+ */
+export default class NestField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<PropTypes.ValidationMap<any>>>;
+        }>>;
+        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, origProps: any): {
+        schema: any;
+        uiSchema: any;
+        idSchema: any;
+        errorSchema: any;
+        formData: any;
+        onChange: (formData?: {}) => void;
+    };
+    onChange: (formData?: {}) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/NestField.js

@@ -0,0 +1,289 @@
+"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.getPropsForFields = 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");
+const deepmerge = require("deepmerge");
+/**
+ * Makes it possible to extract fields from object schema and
+ * make them act like a nested schema without touching the form data structure.
+ *
+ * uiSchema = {
+ *  title: <string>,
+ *  ui:options: {
+ *    nests: {
+ *      fieldName: {
+ *       fields: [<string>],
+ *       title: <string>,
+ *      }
+ *    },
+ *    uiSchema: <uiSchema>
+ *  }
+ * }
+ *
+ * Example usage:
+ *
+ * schema = {
+ *  "type": "object",
+ *  "properties": {
+ *    "inner_1" { "type": "string" },
+ *    "inner_2": { "type": "string" },
+ *    "innerOfInner_1": { "type": "string" },
+ *    "innerOfInner_2": { "type": "string" },
+ *    "secondInner_1" { "type": "string" },
+ *    "secondInner_2": { "type": "string" },
+ *    "outer_2": { "type": "string" }
+ *  }
+ *
+ *  uiSchema = {
+ *    "ui:field": "nest",
+ *    "ui:options": {
+ *      "nests": {
+ *        "inner": {
+ *          "fields": ["inner_1", "inner_2"],
+ *          "title": "title of inner",
+ *          "uiSchema": {
+ *            "ui:field": "someField"
+ *            "inner_1": {
+ *              "ui:field": "someField2"
+ *            }
+ *          }
+ *        },
+ *        "secondInner": {
+ *          "fields": ["secondInner_1", "secondInner_2"],
+ *          "uiSchema": {
+ *            "ui:field": "someField3"
+ *          }
+ *        }
+ *      },
+ *      "uiSchema": {
+ *        "ui:field": "container"
+ *      }
+ *  }
+ *
+ *  would make the schemas look like this:
+ *
+ *  schema = {
+ *    "type": "object",
+ *    "properties": {
+ *      "inner": {
+ *        "type": "object",
+ *        "title": "title of inner",
+ *        "properties": {
+ *          "inner_1": {
+ *            "type": "string"
+ *          },
+ *          "inner_2": {
+ *            "type": "string"
+ *          }
+ *        }
+ *      },
+ *      "inner2": {
+ *        "type: "object",
+ *        "properties": {
+ *          "secondInner_1": {
+ *            "type": "string"
+ *          },
+ *          "secondInner_2": {
+ *            "type": "string"
+ *          }
+ *        }
+ *      },
+ *    }
+ *  }
+ *
+ *  uiSchema = {
+ *    "ui:field": "container",
+ *    "inner": {
+ *      "ui:field": "someField"
+ *      "inner_1": {
+ *        "ui:field": "someField2"
+ *      }
+ *    },
+ *    "inner2": {
+ *      "ui:field": "someField3"
+ *    }
+ *  }
+ *
+ */
+let NestField = class NestField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onChange = (formData = {}) => {
+            const { nests } = this.getUiOptions();
+            Object.keys(nests).reverse().forEach(nestName => {
+                if (formData[nestName]) {
+                    Object.keys(formData[nestName]).forEach(prop => {
+                        if (prop in formData[nestName])
+                            formData = Object.assign(Object.assign({}, formData), { [prop]: formData[nestName][prop] });
+                    });
+                    formData = utils_1.immutableDelete(formData, nestName);
+                }
+            });
+            this.props.onChange(formData);
+        };
+    }
+    static getName() { return "NestField"; }
+    getStateFromProps(props, origProps) {
+        let { schema, uiSchema, idSchema, errorSchema, formData = {} } = props;
+        const { nests, buttonsNest, buttons } = utils_1.getUiOptions(origProps.uiSchema);
+        const uiButtons = uiSchema["ui:buttons"];
+        const nestedPropsMap = {};
+        const nestNames = Object.keys(nests).reduce((names, name) => {
+            names[name] = true;
+            return names;
+        }, {});
+        Object.keys(nests).forEach((wrapperFieldName) => {
+            const nest = nests[wrapperFieldName];
+            const nestedProps = getPropsForFields({ schema, uiSchema, idSchema, errorSchema, formData }, nests[wrapperFieldName].fields, nest.title);
+            nestedPropsMap[wrapperFieldName] = nestedProps;
+            schema = Object.assign(Object.assign({}, schema), { properties: Object.assign(Object.assign({}, schema.properties), { [wrapperFieldName]: nestedProps.schema }) });
+            let nestedIdSchema = nestedProps.idSchema;
+            nest.fields.forEach(field => {
+                if (nestNames[field]) {
+                    nestedIdSchema[field] = nestedPropsMap[field].idSchema;
+                }
+            });
+            idSchema = Object.assign(Object.assign({}, idSchema), { [wrapperFieldName]: nestedIdSchema });
+            errorSchema = Object.assign(Object.assign({}, errorSchema), { [wrapperFieldName]: nestedProps.errorSchema });
+            formData = Object.assign(Object.assign({}, formData), { [wrapperFieldName]: nestedProps.formData });
+            uiSchema = Object.assign(Object.assign({}, uiSchema), { [wrapperFieldName]: Object.assign(Object.assign(Object.assign({}, nestedProps.uiSchema), (nests[wrapperFieldName] ? nests[wrapperFieldName].rootUiSchema : {} || {})), (uiSchema[wrapperFieldName] || {})) });
+            if (nest.rootUiSchema) {
+                uiSchema = Object.assign(Object.assign({}, uiSchema), { [wrapperFieldName]: Object.assign(Object.assign({}, (nest.rootUiSchema || {})), (uiSchema[wrapperFieldName] || {})) });
+            }
+            nest.fields.forEach(fieldName => {
+                if (uiSchema[fieldName]) {
+                    uiSchema[wrapperFieldName][fieldName] = deepmerge(uiSchema[wrapperFieldName][fieldName] || {}, uiSchema[fieldName], {
+                        arrayMerge: (a1, a2) => a2
+                    });
+                }
+                [schema.properties, errorSchema, idSchema, formData, uiSchema].forEach(container => {
+                    delete container[fieldName];
+                });
+                if (schema.required)
+                    schema.required = schema.required.filter(requiredField => requiredField !== fieldName);
+            });
+        });
+        if (buttonsNest && nests[buttonsNest]) {
+            if (uiButtons) {
+                uiSchema = {
+                    "ui:buttons": undefined,
+                    [buttonsNest]: Object.assign(Object.assign({}, (uiSchema[buttonsNest] || [])), { "ui:buttons": [
+                            ...uiSchema["ui:buttons"]
+                        ] })
+                };
+            }
+            if (buttons) {
+                let nestOptions = utils_1.getUiOptions(uiSchema[buttonsNest]);
+                let _buttons = nestOptions.buttons || [];
+                uiSchema = Object.assign(Object.assign({}, uiSchema), { "ui:options": Object.assign(Object.assign({}, uiSchema["ui:options"]), { buttons: undefined }), [buttonsNest]: Object.assign(Object.assign({}, uiSchema[buttonsNest]), { "ui:options": Object.assign(Object.assign({}, nestOptions), { buttons: [..._buttons, ...buttons] }) }) });
+            }
+        }
+        const { "ui:order": order = [] } = uiSchema;
+        const dictionarifiedOrder = order.reduce((dict, field, idx) => {
+            dict[field] = idx;
+            return dict;
+        }, {});
+        const splices = [];
+        if (order) {
+            Object.keys(nests).forEach(nestName => {
+                const { fields } = nests[nestName];
+                fields.forEach(field => {
+                    const idx = dictionarifiedOrder[field];
+                    if (idx !== undefined) {
+                        splices.push([idx, 1]);
+                    }
+                });
+            });
+            if (splices.length)
+                uiSchema = immutability_helper_1.default(uiSchema, { "ui:order": { $splice: splices.sort(([idx], [_idx]) => _idx - idx) } });
+        }
+        return { schema, uiSchema, idSchema, errorSchema, formData, onChange: this.onChange };
+    }
+};
+NestField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            "nests": function (props, propName, componentName) {
+                for (let optionProp in props["ui:options"]) {
+                    const prop = props["ui:options"][optionProp];
+                    if (!prop.fields || !Array.isArray(prop.fields)) {
+                        return new Error("Required prop '" + propName + "." + optionProp + ".fields' was not specified in '" + componentName + "'");
+                    }
+                }
+            }
+        }),
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object"])
+    }).isRequired,
+    formData: PropTypes.object
+};
+NestField = __decorate([
+    VirtualSchemaField_1.default
+], NestField);
+exports.default = NestField;
+function getPropsForFields({ schema, uiSchema, idSchema, errorSchema, formData, onChange }, fields, title) {
+    const newSchema = { type: "object", properties: {}, title };
+    const newErrorSchema = {};
+    const newFormData = {};
+    const newUiSchema = uiSchema
+        ? ["ui:classNames", "classNames"].reduce((_uiSchema, prop) => {
+            if (prop in uiSchema)
+                _uiSchema[prop] = uiSchema[prop];
+            return _uiSchema;
+        }, {})
+        : {};
+    const newIdSchema = { $id: idSchema.$id };
+    const fieldsDictionarified = {};
+    // For keeping field names compatible with idSchema.
+    const flattenPointerName = fieldName => fieldName[0] === "/" ? fieldName.replace(/(?!^)\//g, "_").substr(1) : fieldName;
+    fields.forEach(fieldName => {
+        [
+            [schema.properties, newSchema.properties, utils_1.schemaJSONPointer(schema.properties, fieldName)],
+            [uiSchema, newUiSchema, utils_1.uiSchemaJSONPointer(schema.properties, fieldName)],
+            [errorSchema, newErrorSchema, fieldName],
+            [formData, newFormData, fieldName],
+            [idSchema, newIdSchema, fieldName]
+        ].forEach(([originalPropContainer, newPropContainer, _fieldName]) => {
+            if (_fieldName !== undefined && utils_1.checkJSONPointer(originalPropContainer, _fieldName)) {
+                newPropContainer[flattenPointerName(fieldName)] = utils_1.parseJSONPointer(originalPropContainer, _fieldName);
+            }
+        });
+        fieldsDictionarified[fieldName] = true;
+    });
+    // TODO Doesn't work for JSON Pointer fields.
+    if (uiSchema["ui:order"])
+        newUiSchema["ui:order"] = uiSchema["ui:order"].filter(ord => fieldsDictionarified[ord] || ord === "*");
+    if (schema.required)
+        newSchema.required = schema.required.filter(req => fieldsDictionarified[req]);
+    const newOnChange = formData => {
+        let newFormData = fields.reduce((_formData, field) => {
+            _formData = utils_1.updateSafelyWithJSONPointer(_formData, _formData[flattenPointerName[field]], field, !!"immutably", (__formData, path) => {
+                const _schema = utils_1.parseJSONPointer(schema, utils_1.schemaJSONPointer(schema, path));
+                return utils_1.getDefaultFormState(_schema);
+            });
+            _formData = utils_1.immutableDelete(_formData, flattenPointerName(field));
+            return _formData;
+        }, formData);
+        return onChange(newFormData);
+    };
+    return {
+        schema: newSchema,
+        uiSchema: newUiSchema,
+        idSchema: newIdSchema,
+        errorSchema: newErrorSchema,
+        formData: newFormData,
+        onChange: onChange ? newOnChange : undefined
+    };
+}
+exports.getPropsForFields = getPropsForFields;

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

@@ -0,0 +1,2 @@
+declare function _default(props: any): JSX.Element;
+export default _default;

package/lib/components/fields/ObjectField.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const utils_1 = require("@rjsf/utils");
+const utils_2 = require("../../utils");
+const ArrayFieldTemplate_1 = require("../templates/ArrayFieldTemplate");
+const ReactContext_1 = require("../../ReactContext");
+const core_1 = require("@rjsf/core");
+const ObjectFieldTemplate_1 = require("../templates/ObjectFieldTemplate");
+exports.default = (props) => {
+    const id = utils_2.getUUID(props.formData);
+    const formContext = id
+        ? Object.assign(Object.assign({}, props.formContext), { _parentLajiFormId: id }) : props.formContext;
+    const uiSchema = props.uiSchema["ui:grid"] && !props.uiSchema["ui:ObjectFieldTemplate"]
+        ? Object.assign(Object.assign({}, props.uiSchema), { "ui:ObjectFieldTemplate": GridTemplate }) : props.uiSchema;
+    const { ObjectField } = core_1.getDefaultRegistry().fields;
+    return React.createElement(ObjectField, Object.assign({}, props, { uiSchema: uiSchema, registry: Object.assign(Object.assign({}, props.registry), { formContext }), formContext: formContext }));
+};
+function GridTemplate(props) {
+    const { schema, uiSchema, idSchema, properties } = props;
+    const TitleFieldTemplate = utils_1.getTemplate("TitleFieldTemplate", props.registry, utils_2.getUiOptions(props.uiSchema));
+    const gridOptions = props.uiSchema["ui:grid"] || {};
+    const { ButtonToolbar, Row, Col } = React.useContext(ReactContext_1.default).theme;
+    const rows = [];
+    const lastRow = [];
+    const colsToRows = {};
+    (gridOptions.rows || []).forEach((row, i) => {
+        row.forEach(col => {
+            colsToRows[col] = i;
+        });
+    });
+    const { rowTitles = [], classNames = {} } = gridOptions;
+    const { Label } = props.formContext;
+    const addRowTitles = (rows, rowTitles) => {
+        for (let i = 0; i < rowTitles.length; i++) {
+            rows[i] = [];
+            const titleCols = getCols(props, { type: "string" }, uiSchema["rowTitle"], "rowTitle");
+            rows[i].push(React.createElement(Col, Object.assign({}, titleCols, { key: "title_" + i, className: classNames["rowTitle"] }),
+                React.createElement(Label, { id: idSchema.$id + "_row_" + i, label: rowTitles[i].title, uiSchema: { "ui:help": rowTitles[i].help } })));
+        }
+    };
+    function getRow(col, colsToRows, rows) {
+        const colRow = colsToRows[col];
+        if (colRow !== undefined) {
+            if (!rows[colRow])
+                rows[colRow] = [];
+            return rows[colRow];
+        }
+        else {
+            return lastRow;
+        }
+    }
+    addRowTitles(rows, rowTitles);
+    utils_1.orderProperties(Object.keys(schema.properties), uiSchema["ui:order"]).forEach(propertyName => {
+        const property = schema.properties[propertyName];
+        if (!property)
+            return;
+        const uiSchemaProperty = uiSchema[propertyName];
+        const cols = getCols(props, property, uiSchemaProperty, propertyName);
+        const propertiesByName = properties.reduce((propertiesByName, _prop) => {
+            propertiesByName[_prop.name] = _prop;
+            return propertiesByName;
+        }, {});
+        if (!utils_2.isHidden(uiSchema, propertyName))
+            getRow(propertyName, colsToRows, rows).push(React.createElement(Col, Object.assign({}, cols, { className: classNames[propertyName], key: propertyName }), propertiesByName[propertyName].content));
+    });
+    if (lastRow.length > 0)
+        rows.push(lastRow);
+    const { title } = schema;
+    const { "ui:title": _title } = uiSchema;
+    let fieldTitle = _title || (title !== undefined ? title : props.name);
+    let buttons = ObjectFieldTemplate_1.getGlyphButtons(props);
+    const [topButtons, bottomButtons, leftButtons, rightButtons] = ["top", "bottom", "left", "right"].map(pos => {
+        const buttons = ArrayFieldTemplate_1.getButtonsForPosition(props, utils_2.getUiOptions(uiSchema).buttons, pos, "no default");
+        return buttons
+            ? (React.createElement(ButtonToolbar, { key: `buttons-${pos}` }, ArrayFieldTemplate_1.getButtonsForPosition(props, utils_2.getUiOptions(uiSchema).buttons, pos, "no default"))) : null;
+    });
+    const { containerClassName, schemaClassName, buttonsClassName } = ObjectFieldTemplate_1.getObjectTemplateClassNames(props, buttons);
+    buttons = React.createElement("div", { className: buttonsClassName }, buttons);
+    const titleUiSchema = Object.assign(Object.assign({}, uiSchema), { "ui:renderedButtons": buttons });
+    return (React.createElement("div", { className: containerClassName },
+        React.createElement("fieldset", { className: schemaClassName },
+            !utils_2.isEmptyString(fieldTitle) ?
+                React.createElement(TitleFieldTemplate, { title: fieldTitle, schema: schema, uiSchema: titleUiSchema, registry: props.registry, id: idSchema.$id }) : null,
+            topButtons,
+            leftButtons && React.createElement("div", { className: "pull-left" }, leftButtons),
+            rows.map((row, i) => React.createElement(Row, { key: i }, row)),
+            rightButtons && React.createElement("div", { className: "pull-right" }, rightButtons),
+            bottomButtons),
+        !props.title && buttons ? buttons : null));
+}
+function getCols(props, schema, uiSchema, property) {
+    const options = props.uiSchema["ui:grid"];
+    const cols = { lg: 12, md: 12, sm: 12, xs: 12 };
+    const uiField = uiSchema && uiSchema["ui:field"] ? uiSchema["ui:field"] : undefined;
+    Object.keys(cols).forEach(col => {
+        const optionCol = options[col];
+        if ((!utils_2.isObject(optionCol) || !optionCol[property])
+            && schema.type === "array"
+            && !(schema.items && schema.items.enum && utils_2.isMultiSelect(schema, uiSchema)
+                || uiField === "SingleItemArrayField"
+                || (schema.items && schema.items.type === "string" && uiField !== "ImageArrayField" && uiField !== "AudioArrayField"))
+            || (schema.type === "string" && uiSchema && utils_2.getNestedUiFieldsList(uiSchema).includes("SelectTreeField"))) {
+            return cols;
+        }
+        if (utils_2.isObject(optionCol)) {
+            let selector = undefined;
+            if (optionCol[property])
+                selector = property;
+            else if (optionCol["*"])
+                selector = "*";
+            cols[col] = parseInt(optionCol[selector]);
+        }
+        else {
+            cols[col] = parseInt(optionCol);
+        }
+    });
+    return cols;
+}

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

@@ -0,0 +1,21 @@
+import * as React from "react";
+import { FieldProps } from "../LajiForm";
+import { MediaArrayState } from "./ImageArrayField";
+export default class PdfArrayField extends React.Component<FieldProps, MediaArrayState> {
+    ALLOWED_FILE_TYPES: string[];
+    ACCEPT_FILE_TYPES: string[];
+    MAX_FILE_SIZE: number;
+    KEY: string;
+    ENDPOINT: string;
+    GLYPH: string;
+    TRANSLATION_TAKE_NEW: string;
+    TRANSLATION_SELECT_FILE: string;
+    TRANSLATION_NO_MEDIA: string;
+    CONTAINER_CLASS: string;
+    METADATA_FORM_ID: string;
+    renderMedia: (id: string) => JSX.Element;
+    renderLoadingMedia: (id: string) => JSX.Element;
+    onMediaClick: (i: number) => any;
+    renderModalMedia: () => JSX.Element;
+    formatValue(value: string[], options: any, props: FieldProps): string | null;
+}

package/lib/components/fields/PdfArrayField.js

@@ -0,0 +1,40 @@
+"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 ImageArrayField_1 = require("./ImageArrayField");
+let PdfArrayField = class PdfArrayField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.ALLOWED_FILE_TYPES = ["application/pdf"];
+        this.ACCEPT_FILE_TYPES = ["application/pdf"];
+        this.MAX_FILE_SIZE = 20000000;
+        this.KEY = "PDF";
+        this.ENDPOINT = "pdf";
+        this.GLYPH = "paperclip";
+        this.TRANSLATION_TAKE_NEW = "";
+        this.TRANSLATION_SELECT_FILE = "";
+        this.TRANSLATION_NO_MEDIA = "";
+        this.CONTAINER_CLASS = "pdf-container";
+        this.METADATA_FORM_ID = "MHL.1070";
+        this.renderMedia = (id) => React.createElement(ImageArrayField_1.Thumbnail, { id: id, apiClient: this.props.formContext.apiClient, apiEndpoint: this.ENDPOINT });
+        this.renderLoadingMedia = (id) => React.createElement(ImageArrayField_1.Thumbnail, { dataURL: id, loading: true, apiClient: this.props.formContext.apiClient, apiEndpoint: this.ENDPOINT });
+        this.onMediaClick = (i) => this.openModalFor(i);
+        this.renderModalMedia = () => React.createElement("img", { src: this.state.modalMediaSrc });
+    }
+    formatValue(value, options, props) {
+        const { translations } = props.formContext;
+        return value && value.length
+            ? `${value.length} ${translations.HowManyFiles}`
+            : null;
+    }
+};
+PdfArrayField = __decorate([
+    ImageArrayField_1.MediaArrayField
+], PdfArrayField);
+exports.default = PdfArrayField;

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

@@ -0,0 +1,22 @@
+export default class PrefillingArrayField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                field: PropTypes.Requireable<string>;
+                uiSchema: PropTypes.Requireable<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(props: any): any;
+    mapFormData: (formData: any) => any;
+    onChange: (formData: any) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";