@luomus/laji-form 14.3.6

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

@@ -0,0 +1,18 @@
+export default class ImageDisplayField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                urls: PropTypes.Requireable<string | (string | null | undefined)[]>;
+                buttons: PropTypes.Requireable<(string | null | undefined)[]>;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: 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/ImageDisplayField.js

@@ -0,0 +1,44 @@
+"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 BaseComponent_1 = require("../BaseComponent");
+const utils_1 = require("../../utils");
+const immutability_helper_1 = require("immutability-helper");
+// TODO should work as widget also
+let ImageDisplayField = class ImageDisplayField extends React.Component {
+    render() {
+        const { SchemaField } = this.props.registry.fields;
+        let uiSchema = utils_1.getInnerUiSchema(this.props.uiSchema);
+        const { urls = [], buttons = [] } = utils_1.getUiOptions(this.props.uiSchema);
+        uiSchema = immutability_helper_1.default(uiSchema, { "ui:options": { buttons: { $set: [...buttons,
+                        { position: "left", render: () => React.createElement("div", { className: "laji-form-medias", key: "image-display" }, (Array.isArray(urls) ? urls : [urls]).map(url => React.createElement("div", { className: "media-container", key: url },
+                                React.createElement("img", { src: url }))))
+                        }
+                    ] } } });
+        return (React.createElement(React.Fragment, null,
+            React.createElement(SchemaField, Object.assign({}, this.props, { uiSchema: uiSchema }))));
+    }
+};
+ImageDisplayField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            urls: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]),
+            buttons: PropTypes.arrayOf(PropTypes.string),
+        }),
+    }),
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array", "object"])
+    }).isRequired,
+    formData: PropTypes.oneOfType([PropTypes.array, PropTypes.object])
+};
+ImageDisplayField = __decorate([
+    BaseComponent_1.default
+], ImageDisplayField);
+exports.default = ImageDisplayField;

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

@@ -0,0 +1,21 @@
+export default class InitiallyHiddenField 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<{
+                uiSchema: PropTypes.Requireable<object>;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Validator<object>;
+    };
+    constructor(props: any);
+    getStateFromProps(props: any): {
+        uiSchema: any;
+    };
+    toggleVisibility: () => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/InitiallyHiddenField.js

@@ -0,0 +1,58 @@
+"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");
+let InitiallyHiddenField = class InitiallyHiddenField extends React.Component {
+    constructor(props) {
+        super(props);
+        this.toggleVisibility = () => {
+            this.setState({ visible: !this.state.visible });
+        };
+        this.state = Object.assign({ visible: false }, this.getStateFromProps(props));
+    }
+    getStateFromProps(props) {
+        return { uiSchema: utils_1.getInnerUiSchema(props.uiSchema) };
+    }
+    render() {
+        let shouldShow = this.state.visible;
+        const SchemaField = this.props.registry.fields.SchemaField;
+        const { Row, Col, Collapse } = this.context.theme;
+        return (React.createElement("div", null,
+            React.createElement(Collapse, { in: !shouldShow },
+                React.createElement(Row, null,
+                    React.createElement(Col, { xs: 2, xsOffset: 10 },
+                        React.createElement(components_1.Button, { className: "button-right", onClick: this.toggleVisibility },
+                            this.props.schema.title || this.props.name,
+                            " ",
+                            React.createElement("span", { className: "caret" }))))),
+            React.createElement(Collapse, { in: shouldShow },
+                React.createElement("div", null,
+                    React.createElement(SchemaField, Object.assign({}, this.props, this.state))))));
+    }
+};
+InitiallyHiddenField.contextType = ReactContext_1.default;
+InitiallyHiddenField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            uiSchema: PropTypes.object
+        })
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object", "array"])
+    }).isRequired,
+    formData: PropTypes.oneOfType([PropTypes.object, PropTypes.array]).isRequired
+};
+InitiallyHiddenField = __decorate([
+    BaseComponent_1.default
+], InitiallyHiddenField);
+exports.default = InitiallyHiddenField;

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

@@ -0,0 +1,37 @@
+/**
+ * Injects given fields value as default value to target field.
+ * uiSchema = { "ui:options": {
+ *  "injections": [
+ *    {
+ *      "fields": [field1, field2...], (fields to inject from source field)
+ *      "target": fieldName (target field where default value is injected)
+ *      "source": fieldName (source field where default value is injected from. Must be object field)
+ *    }
+ *    ...
+ *  ]
+ * }}
+ */
+export default class InjectDefaultValueField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Validator<PropTypes.InferProps<{
+                fields: PropTypes.Validator<(string | null | undefined)[]>;
+                target: PropTypes.Validator<string>;
+                source: PropTypes.Validator<string>;
+            }>>;
+        }>>;
+        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(): {
+        onChange: (formData: any) => void;
+    };
+    onChange: (formData: any) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/InjectDefaultValueField.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 immutability_helper_1 = require("immutability-helper");
+const VirtualSchemaField_1 = require("../VirtualSchemaField");
+/**
+ * Injects given fields value as default value to target field.
+ * uiSchema = { "ui:options": {
+ *  "injections": [
+ *    {
+ *      "fields": [field1, field2...], (fields to inject from source field)
+ *      "target": fieldName (target field where default value is injected)
+ *      "source": fieldName (source field where default value is injected from. Must be object field)
+ *    }
+ *    ...
+ *  ]
+ * }}
+ */
+let InjectDefaultValueField = class InjectDefaultValueField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onChange = (formData) => {
+            let { schema } = this.props;
+            const options = this.getUiOptions();
+            const { fields, target } = options;
+            let source = options.source ? formData[options.source] : formData;
+            fields.forEach(field => {
+                if (schema.properties[target].type === "array") {
+                    if (formData && formData[target])
+                        formData[target].forEach((item, i) => {
+                            if (item[field] === this.props.formData[options.source][field]) {
+                                formData = immutability_helper_1.default(formData, { [target]: { $splice: [[i, 1, immutability_helper_1.default(item, { $merge: { [field]: source[field] } })]] } });
+                            }
+                        });
+                }
+            });
+            this.props.onChange(formData);
+        };
+    }
+    static getName() { return "InjectDefaultValueField"; }
+    getStateFromProps() {
+        return { onChange: this.onChange };
+    }
+};
+InjectDefaultValueField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            fields: PropTypes.arrayOf(PropTypes.string).isRequired,
+            target: PropTypes.string.isRequired,
+            source: PropTypes.string.isRequired
+        }).isRequired
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object", "array"])
+    }).isRequired,
+    formData: PropTypes.oneOfType([PropTypes.object, PropTypes.array]).isRequired
+};
+InjectDefaultValueField = __decorate([
+    VirtualSchemaField_1.default
+], InjectDefaultValueField);
+exports.default = InjectDefaultValueField;

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

@@ -0,0 +1,46 @@
+/**
+ * Inject a schema object property to nested schema.
+ * uiSchema = { "ui:options": {
+ *  "injections": [
+ *    {
+ *      "fields": [field1, field2...],
+ *      "target": fieldName
+ *    }
+ *    ...
+ *  ]
+ * }}
+ */
+export default class InjectField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Validator<PropTypes.InferProps<{
+                injections: PropTypes.Validator<PropTypes.InferProps<{
+                    fields: PropTypes.Validator<(string | null | undefined)[]>;
+                    target: PropTypes.Validator<string>;
+                }> | (PropTypes.InferProps<{
+                    fields: PropTypes.Validator<(string | null | undefined)[]>;
+                    target: 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): {
+        schema: any;
+        uiSchema: any;
+        idSchema: any;
+        formData: any;
+        errorSchema: any;
+        onChange: (formData: any) => void;
+    };
+    onChange: (formData: any) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/InjectField.js

@@ -0,0 +1,88 @@
+"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 injectionPropType = PropTypes.shape({
+    fields: PropTypes.arrayOf(PropTypes.string).isRequired,
+    target: PropTypes.string.isRequired
+});
+/**
+ * Inject a schema object property to nested schema.
+ * uiSchema = { "ui:options": {
+ *  "injections": [
+ *    {
+ *      "fields": [field1, field2...],
+ *      "target": fieldName
+ *    }
+ *    ...
+ *  ]
+ * }}
+ */
+let InjectField = class InjectField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onChange = (formData) => {
+            const options = this.getUiOptions();
+            (Array.isArray(options.injections) ? options.injections.slice(0).reverse() : [options.injections]).forEach((injection) => {
+                let { fields, target } = injection;
+                target = utils_1.toJSONPointer(target);
+                formData = fields.reduce((formData, fieldPointer) => {
+                    fieldPointer = utils_1.toJSONPointer(fieldPointer);
+                    const fieldName = fieldPointer.split("/").pop();
+                    formData = utils_1.updateFormDataWithJSONPointer(Object.assign(Object.assign({}, this.props), { formData }), utils_1.parseJSONPointer(formData, `${target}/${fieldName}`), fieldPointer);
+                    formData = utils_1.immutableDelete(formData, `${target}/${fieldName}`);
+                    return formData;
+                }, formData);
+            });
+            this.props.onChange(formData);
+        };
+    }
+    static getName() { return "InjectField"; }
+    getStateFromProps(props) {
+        const options = utils_1.getUiOptions(props.uiSchema);
+        const { injections } = options;
+        let { schema, uiSchema, idSchema, formData, errorSchema } = props;
+        (Array.isArray(injections) ? injections : [injections]).forEach((injection) => {
+            let { fields, target } = injection;
+            target = utils_1.toJSONPointer(target);
+            const origSchema = schema;
+            fields.forEach((fieldPath) => {
+                fieldPath = utils_1.toJSONPointer(fieldPath);
+                const fieldName = fieldPath.split("/").pop();
+                schema = utils_1.updateSafelyWithJSONPointer(schema, utils_1.parseJSONPointer(origSchema, utils_1.schemaJSONPointer(origSchema, fieldPath)), `${utils_1.schemaJSONPointer(origSchema, target)}/properties/${fieldName}`);
+                schema = utils_1.immutableDelete(schema, utils_1.schemaJSONPointer(origSchema, fieldPath));
+                uiSchema = utils_1.updateSafelyWithJSONPointer(uiSchema, utils_1.parseJSONPointer(uiSchema, utils_1.uiSchemaJSONPointer(origSchema, fieldPath)), `${utils_1.uiSchemaJSONPointer(origSchema, target)}/${fieldName}`);
+                uiSchema = utils_1.immutableDelete(uiSchema, utils_1.uiSchemaJSONPointer(origSchema, fieldPath));
+                const [_formData, _idSchema, _errorSchema] = [formData, idSchema, errorSchema].map(prop => utils_1.immutableDelete(utils_1.updateSafelyWithJSONPointer(prop, utils_1.parseJSONPointer(prop, fieldPath), `${target}/${fieldName}`), fieldPath));
+                formData = _formData;
+                errorSchema = _errorSchema;
+                idSchema = _idSchema;
+            });
+        });
+        return { schema, uiSchema, idSchema, formData, errorSchema, onChange: this.onChange };
+    }
+};
+InjectField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            injections: PropTypes.oneOfType([PropTypes.arrayOf(injectionPropType), injectionPropType]).isRequired,
+        }).isRequired,
+        uiSchema: PropTypes.object
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object"])
+    }).isRequired,
+    formData: PropTypes.object.isRequired
+};
+InjectField = __decorate([
+    VirtualSchemaField_1.default
+], InjectField);
+exports.default = InjectField;

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

@@ -0,0 +1,25 @@
+export default class InputWithDefaultValueButtonField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Validator<PropTypes.InferProps<{
+                buttonLabel: PropTypes.Validator<string>;
+                buttonField: PropTypes.Validator<string>;
+                valueFields: PropTypes.Requireable<PropTypes.InferProps<{
+                    field: PropTypes.Validator<string>;
+                    contextFieldForDefaultValue: PropTypes.Validator<string>;
+                }>[]>;
+            }>>;
+        }>>;
+        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): any;
+    onClick: () => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/InputWithDefaultValueButtonField.js

@@ -0,0 +1,61 @@
+"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");
+let InputWithDefaultValueButtonField = class InputWithDefaultValueButtonField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onClick = () => {
+            let { uiSchema, formData } = this.props;
+            const uiSchemaContext = this.props.formContext.uiSchemaContext || {};
+            const { valueFields } = utils_1.getUiOptions(uiSchema);
+            valueFields.forEach(({ field, contextFieldForDefaultValue }) => {
+                formData = utils_1.updateSafelyWithJSONPointer(formData, uiSchemaContext[contextFieldForDefaultValue], field);
+            });
+            this.props.onChange(formData);
+        };
+    }
+    static getName() { return "InputWithDefaultValueButtonField"; }
+    getStateFromProps(props) {
+        let { schema, uiSchema } = props;
+        const { buttonField, buttonLabel } = utils_1.getUiOptions(uiSchema);
+        const innerUiSchema = utils_1.getInnerUiSchema(uiSchema);
+        const _uiSchemaJSONPointer = utils_1.uiSchemaJSONPointer(schema, buttonField);
+        uiSchema = utils_1.updateSafelyWithJSONPointer(innerUiSchema, {
+            "ui:widget": "InputWithDefaultValueButtonWidget",
+            "ui:options": {
+                buttonLabel,
+                onClick: this.onClick
+            },
+        }, _uiSchemaJSONPointer);
+        return Object.assign(Object.assign({}, props), { uiSchema });
+    }
+};
+InputWithDefaultValueButtonField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            buttonLabel: PropTypes.string.isRequired,
+            buttonField: PropTypes.string.isRequired,
+            valueFields: PropTypes.arrayOf(PropTypes.shape({
+                field: PropTypes.string.isRequired,
+                contextFieldForDefaultValue: PropTypes.string.isRequired
+            }).isRequired)
+        }).isRequired
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object"])
+    }).isRequired,
+    formData: PropTypes.oneOfType([PropTypes.object]).isRequired
+};
+InputWithDefaultValueButtonField = __decorate([
+    VirtualSchemaField_1.default
+], InputWithDefaultValueButtonField);
+exports.default = InputWithDefaultValueButtonField;

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

@@ -0,0 +1,22 @@
+export default class LocalityField extends React.Component<any, any, any> {
+    static contextType: React.Context<import("../../ReactContext").ContextProps>;
+    static propTypes: {
+        uiSchema: PropTypes.Requireable<object>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Validator<object>;
+    };
+    constructor(props: any);
+    showEditor: () => void;
+    hideEditor: () => void;
+    setFormRef: (elem: any) => void;
+    lajiForm: any;
+    renderModal: () => JSX.Element;
+    onSubmitClick: (e: any) => void;
+    onSubmit: ({ formData }: {
+        formData: any;
+    }) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/LocalityField.js

@@ -0,0 +1,94 @@
+"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;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+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 components_1 = require("../components");
+const LajiForm_1 = require("../LajiForm");
+const MapField_1 = require("./MapField");
+const ReactContext_1 = require("../../ReactContext");
+let LocalityField = class LocalityField extends React.Component {
+    constructor(props) {
+        super(props);
+        this.showEditor = () => {
+            this.setState({ modal: true });
+        };
+        this.hideEditor = () => {
+            this.setState({ modal: false });
+        };
+        this.setFormRef = (elem) => {
+            this.lajiForm = elem;
+        };
+        this.renderModal = () => {
+            const _a = this.props, { onChange } = _a, props = __rest(_a, ["onChange"]); // eslint-disable-line @typescript-eslint/no-unused-vars
+            const { Modal } = this.context.theme;
+            return (React.createElement(Modal, { dialogClassName: "laji-form image-modal", show: true, onHide: this.hideEditor },
+                React.createElement(Modal.Header, { closeButton: true }),
+                React.createElement(Modal.Body, null,
+                    React.createElement(LajiForm_1.default, Object.assign({ ref: this.setFormRef }, props, { uiSchema: utils_1.getInnerUiSchema(this.props.uiSchema), onSubmit: this.onSubmit, lang: this.props.formContext.lang, showShortcutButton: false, renderSubmit: false, validators: {}, warnings: {}, apiClient: this.props.formContext.apiClient.apiClient, uiSchemaContext: this.props.formContext.uiSchemaContext })),
+                    React.createElement(components_1.Button, { block: true, onClick: this.onSubmitClick }, "OK"),
+                    React.createElement(components_1.Button, { block: true, onClick: this.hideEditor }, this.props.formContext.translations.Cancel))));
+        };
+        this.onSubmitClick = (e) => {
+            this.lajiForm._onDefaultSubmit(e);
+        };
+        this.onSubmit = ({ formData }) => {
+            this.props.onChange(formData);
+            this.hideEditor();
+        };
+        this.state = {};
+    }
+    render() {
+        const { radius: _radius, geometry } = utils_1.getUiOptions(this.props.uiSchema);
+        const fields = Object.keys(this.props.schema.properties);
+        const values = fields.filter(s => !utils_1.isEmptyString(this.props.formData[s])).map(f => this.props.formData[f]);
+        const radius = typeof _radius === "number"
+            ? _radius
+            : geometry
+                ? MapField_1.getCenterAndRadiusFromGeometry(geometry).radius
+                : undefined;
+        if (typeof radius === "number") {
+            values.push(`(${this.props.formContext.translations.accuracy}: ${parseInt(radius)}m)`);
+        }
+        const { Panel, Row, Col } = this.context.theme;
+        return (React.createElement(Row, null,
+            React.createElement(Col, { xs: 12 },
+                React.createElement(Panel, { className: utils_1.getUiOptions(this.props.uiSchema).panelClassName },
+                    React.createElement(Panel.Body, null,
+                        values.map((v, i) => (React.createElement("span", { key: i },
+                            v,
+                            i < values.length - 1 ? ", " : ""))),
+                        React.createElement(components_1.GlyphButton, { onClick: this.showEditor, glyph: "pencil", variant: "default", className: "pull-right" })))),
+            this.state.modal && this.renderModal()));
+    }
+};
+LocalityField.contextType = ReactContext_1.default;
+LocalityField.propTypes = {
+    uiSchema: PropTypes.object,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["object"])
+    }).isRequired,
+    formData: PropTypes.object.isRequired
+};
+LocalityField = __decorate([
+    BaseComponent_1.default
+], LocalityField);
+exports.default = LocalityField;

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

@@ -0,0 +1,27 @@
+export default class LocationChooserField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                uiSchema: PropTypes.Requireable<object>;
+                taxonField: PropTypes.Requireable<string>;
+                geometryField: PropTypes.Requireable<string>;
+                strategy: PropTypes.Requireable<string>;
+                mapOptions: PropTypes.Requireable<object>;
+                maxShapes: PropTypes.Requireable<number>;
+                preselectMarker: PropTypes.Requireable<boolean>;
+                color: PropTypes.Requireable<string>;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Validator<object>;
+    };
+    constructor(props: any);
+    constructor(props: any, context: any);
+    getStateFromProps(props: any): {
+        uiSchema: any;
+    };
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";