@luomus/laji-form 15.1.4 → 15.1.6

package/lib/components/widgets/SelectWidget.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const PropTypes = require("prop-types");
+const Combobox = require("react-widgets/lib/Combobox");
+const Multiselect = require("react-widgets/lib/Multiselect");
+const components_1 = require("../components");
+const Context_1 = require("../../Context");
+const ReactContext_1 = require("../../ReactContext");
+const utils_1 = require("../../utils");
+class SelectWidget extends React.Component {
+    constructor(props) {
+        super(props);
+        this.multiSelectOnChange = (values) => {
+            const lengthBeforeFiltering = values.length;
+            values = values.filter(v => v.value !== "");
+            if (this.props.value.length === lengthBeforeFiltering) {
+                return;
+            }
+            this.props.onChange(values.map(({ value }) => this.getEnum(value)));
+        };
+        this.selectOnChange = (item) => {
+            this.props.onChange(this.getEnum(item.value));
+        };
+        this.onClick = () => {
+            !this.props.disabled && !this.props.readonly && this.setState({ open: true });
+        };
+        this.onFocus = () => this.setState({ open: true });
+        this.onBlur = () => this.setState({ open: false });
+        this.onSelect = (item) => {
+            this.state.open && this.props.formContext.setTimeout(() => this.mounted && this.setState({ open: false, value: item.value }));
+            const value = this.getEnum(item.value);
+            (!this.state.value || value !== this.state.value.value) && this.props.onChange(value);
+        };
+        // Quelch a warning from react-widgets with noop handler.
+        this.onToggle = () => { };
+        this.onKeyDown = (e) => {
+            if (e.key !== "Tab") {
+                return;
+            }
+            const item = this.elemRef.state.focusedItem;
+            item && this.elemRef.handleSelect(item, e);
+        };
+        this.setRef = elem => {
+            this.elemRef = elem;
+        };
+        this.getEnum = val => utils_1.isEmptyString(val) ? undefined : val;
+        this.state = this.getStateFromProps(props);
+        this._context = Context_1.default(this.props.formContext.contextId);
+    }
+    componentDidMount() {
+        this.mounted = true;
+        this.props.formContext.services.focus.addFocusHandler(this.props.id, this.onFocus);
+    }
+    componentWillUnmount() {
+        this.mounted = false;
+        this.props.formContext.services.focus.removeFocusHandler(this.props.id, this.onFocus);
+    }
+    UNSAFE_componentWillReceiveProps(props) {
+        this.setState(this.getStateFromProps(props));
+    }
+    getEnumOptions(props) {
+        return utils_1.getUiOptions(props.uiSchema).enumOptions || props.options.enumOptions;
+    }
+    getStateFromProps(props) {
+        let { multiple, value } = props;
+        let enumOptions = this.getEnumOptions(props);
+        function sort(enumOptions, order) {
+            if (!Array.isArray(order))
+                return enumOptions;
+            const idxs = order.reduce((idxs, _enum, i) => {
+                idxs[_enum] = i;
+                return idxs;
+            }, {});
+            return enumOptions.slice(0).sort((a, b) => {
+                return idxs[a.value] - idxs[b.value];
+            });
+        }
+        const { filter: _filter, filterType, labels, order } = utils_1.getUiOptions(props);
+        if (_filter) {
+            enumOptions = utils_1.filter(enumOptions, _filter, filterType, item => item.value);
+        }
+        if (labels) {
+            enumOptions = enumOptions.map(({ value, label }) => {
+                return { value, label: value in labels ? labels[value] : label };
+            });
+        }
+        if (enumOptions.every(({ value: _value }) => value !== _value)) {
+            const _enum = this.getEnumOptions(props).find(({ value: _value }) => value === _value);
+            if (_enum) {
+                enumOptions.push(_enum);
+            }
+        }
+        if (order)
+            enumOptions = sort(enumOptions, order);
+        const valsToItems = enumOptions.reduce((map, item) => {
+            map[item.value] = item;
+            return map;
+        }, {});
+        return {
+            valsToItems,
+            enumOptions,
+            value: multiple ? value : valsToItems[value]
+        };
+    }
+    render() {
+        const { id, disabled, readonly, multiple, formContext, } = this.props;
+        const { enumOptions } = this.state;
+        const commonOptions = {
+            id,
+            value: this.state.value,
+            placeholder: utils_1.getUiOptions(this.props).placeholder,
+            data: enumOptions,
+            valueField: "value",
+            textField: "label",
+            disabled: disabled || readonly,
+            filter: "contains",
+            messages: {
+                open: formContext.translations.Open,
+                emptyList: formContext.translations.NoResults,
+                emptyFilter: formContext.translations.NoResults
+            },
+            onFocus: this.onFocus,
+            onBlur: this.onBlur,
+            onToggle: this.onToggle,
+            open: this.state.open,
+            onKeyDown: this.onKeyDown
+        };
+        const selectComponent = multiple ? (React.createElement(Multiselect, Object.assign({}, commonOptions, { onChange: this.multiSelectOnChange, ref: this.setRef }))) : (React.createElement(Combobox, Object.assign({}, commonOptions, { onChange: this.selectOnChange, ref: this.setRef, onClick: this.onClick, onSelect: this.onSelect })));
+        return (React.createElement(components_1.TooltipComponent, { placement: "top", trigger: "hover", tooltip: (multiple || utils_1.isEmptyString(this.props.value)) ? undefined : this.state.valsToItems[this.props.value].label },
+            React.createElement("div", null, selectComponent)));
+    }
+}
+SelectWidget.contextType = ReactContext_1.default;
+SelectWidget.defaultProps = {
+    autofocus: false,
+};
+SelectWidget.propTypes = {
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["string", "array"])
+    }),
+    id: PropTypes.string.isRequired,
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            enumOptions: PropTypes.array,
+            order: PropTypes.array,
+            filter: PropTypes.array,
+            filterType: PropTypes.string,
+            labels: PropTypes.object,
+        })
+    }),
+    value: PropTypes.oneOfType([PropTypes.string, PropTypes.array]),
+    required: PropTypes.bool,
+    multiple: PropTypes.bool,
+    autofocus: PropTypes.bool,
+    onChange: PropTypes.func,
+};
+exports.default = SelectWidget;

package/lib/components/widgets/SeparatedDateTimeWidget.d.ts

@@ -0,0 +1,19 @@
+export default class SeparatedDateTimeWidget extends React.Component<any, any, any> {
+    static contextType: React.Context<import("../../ReactContext").ContextProps>;
+    static propTypes: {
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        value: PropTypes.Requireable<string>;
+    };
+    constructor(props: any);
+    constructor(props: any, context: any);
+    getStateFromProps(props: any): {
+        date: any;
+        time: string | undefined;
+    };
+    onDateChange: (value: any) => void;
+    onTimeChange: (value: any) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/widgets/SeparatedDateTimeWidget.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 DateWidget_1 = require("./DateWidget");
+const TimeWidget_1 = require("./TimeWidget");
+const BaseComponent_1 = require("../BaseComponent");
+const ReactContext_1 = require("../../ReactContext");
+let SeparatedDateTimeWidget = class SeparatedDateTimeWidget extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onDateChange = (value) => {
+            this.props.onChange(value ? (this.state.time ? value + this.state.time : value) : null);
+        };
+        this.onTimeChange = (value) => {
+            this.props.onChange(value ? this.state.date + value : this.state.date);
+        };
+    }
+    getStateFromProps(props) {
+        let { value } = props;
+        let date, time;
+        if (value) {
+            let splitted = value.split("T");
+            if (splitted.length == 2) {
+                time = "T" + splitted[1];
+            }
+            date = splitted[0];
+        }
+        return { date, time };
+    }
+    render() {
+        const hasDate = !!this.state.date;
+        const { Row, Col, FormGroup } = this.context.theme;
+        return (React.createElement(Row, null,
+            React.createElement(Col, { lg: hasDate ? 6 : 12 },
+                React.createElement(FormGroup, null,
+                    React.createElement(DateWidget_1.default, Object.assign({}, this.props, { onChange: this.onDateChange, value: this.state.date })))),
+            hasDate ? (React.createElement(Col, { lg: 6 },
+                React.createElement(FormGroup, null,
+                    React.createElement(TimeWidget_1.default, Object.assign({}, this.props, { onChange: this.onTimeChange, value: this.state.time }))))) : null));
+    }
+};
+SeparatedDateTimeWidget.contextType = ReactContext_1.default;
+SeparatedDateTimeWidget.propTypes = {
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["string"])
+    }).isRequired,
+    value: PropTypes.string
+};
+SeparatedDateTimeWidget = __decorate([
+    BaseComponent_1.default
+], SeparatedDateTimeWidget);
+exports.default = SeparatedDateTimeWidget;

package/lib/components/widgets/TaxonImageWidget.d.ts

@@ -0,0 +1,13 @@
+export default class TaxonImageWidget extends React.Component<any, any, any> {
+    static propTypes: {
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        value: PropTypes.Requireable<string>;
+    };
+    constructor(props: any);
+    constructor(props: any, context: any);
+    onTaxonImageClick: (taxonID: any) => () => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/widgets/TaxonImageWidget.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const PropTypes = require("prop-types");
+const utils_1 = require("../../utils");
+class TaxonImageWidget extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onTaxonImageClick = (taxonID) => () => {
+            this.props.onChange(taxonID);
+        };
+    }
+    render() {
+        const { SchemaField } = this.props.registry.fields;
+        const { uiSchema } = utils_1.getUiOptions(this.props);
+        const schemaField = uiSchema
+            ? React.createElement(SchemaField, Object.assign({}, this.props, { schema: Object.assign(Object.assign({}, this.props.schema), { title: "" }), uiSchema: Object.assign(Object.assign({}, uiSchema), { "ui:title": "" }) }))
+            : null;
+        return (React.createElement(React.Fragment, null,
+            ["MX.45", "MX.255"].map(taxonID => React.createElement("div", { key: taxonID, style: { height: 100, width: 100 }, onClick: this.onTaxonImageClick(taxonID) })),
+            schemaField));
+    }
+}
+exports.default = TaxonImageWidget;
+TaxonImageWidget.propTypes = {
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["string"])
+    }).isRequired,
+    value: PropTypes.string
+};

package/lib/components/widgets/TextSelectWidget.d.ts

@@ -0,0 +1,25 @@
+export default TextSelectWidget;
+declare class TextSelectWidget extends React.Component<any, any, any> {
+    static contextType: React.Context<import("../../ReactContext").ContextProps>;
+    static propTypes: {
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        value: PropTypes.Requireable<string>;
+    };
+    constructor(props: any);
+    getInitialState(props: any): {
+        selectedCheckboxes: Set<any>;
+        enums: any;
+        otherValue: string;
+        freeTextField: any;
+    };
+    getStateFromProps(props: any): {
+        otherValue: string;
+    };
+    onCheckBoxChange: (label: any) => () => void;
+    onInputChange: (value: any) => void;
+    onChange: (textValue: any) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/widgets/TextSelectWidget.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const PropTypes = require("prop-types");
+const utils_1 = require("../../utils");
+const immutability_helper_1 = require("immutability-helper");
+const BaseInputTemplate_1 = require("../templates/BaseInputTemplate");
+const ReactContext_1 = require("../../ReactContext");
+class TextSelectWidget extends React.Component {
+    constructor(props) {
+        super(props);
+        this.onCheckBoxChange = (label) => () => {
+            const selectedCheckboxes = this.state.selectedCheckboxes;
+            if (selectedCheckboxes.has(label)) {
+                selectedCheckboxes.delete(label);
+            }
+            else {
+                selectedCheckboxes.add(label);
+            }
+            this.setState({ selectedCheckboxes: selectedCheckboxes });
+            this.onChange(this.state.otherValue);
+        };
+        this.onInputChange = (value) => {
+            this.onChange(value);
+        };
+        this.onChange = (textValue) => {
+            let newValue = [...Array.from(this.state.selectedCheckboxes)];
+            if (this.state.selectedCheckboxes.has(this.state.freeTextField)) {
+                if (textValue && textValue.length > 0) {
+                    newValue = immutability_helper_1.default(newValue, { $push: [textValue] });
+                }
+                newValue.splice(newValue.indexOf(this.state.freeTextField), 1);
+            }
+            this.props.onChange(newValue.join(", "));
+        };
+        this.state = this.getInitialState(props);
+    }
+    UNSAFE_componentWillReceiveProps(props) {
+        this.setState(this.getStateFromProps(props));
+    }
+    getInitialState(props) {
+        let { enums = [], delimiter = ", ", freeTextField } = utils_1.getUiOptions(props);
+        const { value } = props;
+        const selectedCheckboxes = new Set();
+        const values = !value ? [] : value.split(delimiter);
+        const otherValues = [];
+        values.map(val => {
+            if (enums.indexOf(val) !== -1) {
+                selectedCheckboxes.add(val);
+            }
+            else {
+                otherValues.push(val);
+            }
+        });
+        if (otherValues.length > 0) {
+            selectedCheckboxes.add(freeTextField);
+        }
+        return { selectedCheckboxes, enums, otherValue: otherValues.join(delimiter), freeTextField };
+    }
+    getStateFromProps(props) {
+        let { enums = [], delimiter = ", " } = utils_1.getUiOptions(props);
+        const { value } = props;
+        const values = !value ? [] : value.split(delimiter);
+        const otherValues = [];
+        values.map(val => {
+            if (enums.indexOf(val) === -1) {
+                otherValues.push(val);
+            }
+        });
+        return { otherValue: otherValues.join(delimiter) };
+    }
+    render() {
+        let { enums, otherValue, freeTextField, selectedCheckboxes } = this.state;
+        if (freeTextField) {
+            enums = immutability_helper_1.default(enums, { $push: [freeTextField] });
+        }
+        const { Checkbox } = this.context.theme;
+        return (React.createElement("div", { className: "laji-text-select" },
+            enums.map((label, i) => {
+                return (React.createElement(Checkbox, { key: i, title: label, checked: selectedCheckboxes.has(label), onChange: this.onCheckBoxChange(label) }, label));
+            }),
+            freeTextField ?
+                React.createElement(BaseInputTemplate_1.default, Object.assign({}, this.props, { id: this.props.id + "_input", value: otherValue, onChange: this.onInputChange, disabled: !selectedCheckboxes.has(freeTextField) }))
+                : null));
+    }
+}
+TextSelectWidget.contextType = ReactContext_1.default;
+TextSelectWidget.propTypes = {
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["string"])
+    }).isRequired,
+    value: PropTypes.string
+};
+exports.default = TextSelectWidget;

package/lib/components/widgets/TextareaWidget.d.ts

@@ -0,0 +1,32 @@
+export default class TextareaWidget extends React.Component<any, any, any> {
+    static propTypes: {
+        "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+            emptyValue: PropTypes.Requireable<string>;
+            rows: PropTypes.Requireable<number>;
+        }>>;
+        schema: PropTypes.Requireable<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        value: PropTypes.Requireable<string>;
+    };
+    static contextType: React.Context<import("../../ReactContext").ContextProps>;
+    constructor(props: any);
+    textareaRef: React.RefObject<any>;
+    _context: Record<string, unknown>;
+    getStateFromProps: (props: any) => {
+        value: any;
+    };
+    onFocus: (e: any) => void;
+    focused: boolean | undefined;
+    onBlur: (e: any) => void;
+    onChange: (value: any) => void;
+    timeout: any;
+    _onChange: ({ target: { value } }: {
+        target: {
+            value: any;
+        };
+    }) => void;
+    onKeyDown: (e: any) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/widgets/TextareaWidget.js

@@ -0,0 +1,87 @@
+"use strict";
+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 Context_1 = require("../../Context");
+const ReactContext_1 = require("../../ReactContext");
+const utils_2 = require("../../utils");
+class TextareaWidget extends React.Component {
+    constructor(props) {
+        super(props);
+        this.getStateFromProps = (props) => {
+            return { value: props.value };
+        };
+        this.onFocus = (e) => {
+            this.focused = true;
+            this.props.onFocus && this.props.onFocus(e);
+        };
+        this.onBlur = (e) => {
+            this.focused = false;
+            if (this.state.value !== this.props.value) {
+                this.props.onChange(this.state.value);
+            }
+            if (this.timeout)
+                clearTimeout(this.timeout);
+            this.props.onBlur && this.props.onBlur(e);
+        };
+        this.onChange = (value) => {
+            this.setState({ value }, () => {
+                if (!this.focused) {
+                    this.props.onChange(value);
+                }
+                else {
+                    if (this.timeout)
+                        clearTimeout(this.timeout);
+                    this.timeout = this.props.formContext.setTimeout(() => {
+                        this.props.onChange(value === "" ? utils_2.getUiOptions(this.props).emptyValue : value);
+                    }, 1000);
+                }
+            });
+        };
+        this._onChange = ({ target: { value } }) => {
+            this.onChange(value);
+        };
+        this.onKeyDown = (e) => {
+            const inputAllowed = !this.props.disabled && !this.props.readonly;
+            const isCtrlEnter = e.ctrlKey && e.key === "Enter";
+            if (this.state.enterReserved && inputAllowed && isCtrlEnter) {
+                this.onChange(this.state.value + "\n");
+                e.preventDefault();
+                e.stopPropagation();
+            }
+        };
+        this.state = this.getStateFromProps(props);
+        this.textareaRef = React.createRef();
+        this._context = Context_1.default(props.formContext.contextId);
+        Object.keys(props.formContext.services.keyHandler.shortcuts).some(keyCombo => {
+            if (keyCombo === "Enter") {
+                //	// Direct mutation should be ok in constructor.
+                this.state.enterReserved = true; // eslint-disable-line react/no-direct-mutation-state
+            }
+        });
+    }
+    UNSAFE_componentWillReceiveProps(props) {
+        this.setState(this.getStateFromProps(props));
+    }
+    render() {
+        const { id, options, placeholder, disabled, readonly, autofocus } = this.props;
+        const { value } = this.state;
+        const { required = this.props.required } = options;
+        const textarea = React.createElement("textarea", { id: id, className: "form-control", value: typeof value === "undefined" ? "" : value, placeholder: placeholder, required: required, disabled: disabled, readOnly: readonly, autoFocus: autofocus, rows: options.rows, onFocus: this.onFocus, onBlur: this.onBlur, onChange: this._onChange, onKeyDown: this.onKeyDown });
+        return this.state.enterReserved ? (React.createElement(components_1.TooltipComponent, { tooltip: `${utils_1.stringifyKeyCombo("ctrl+Enter")} ${this.props.formContext.translations.textareaHint}`, placement: "bottom" }, textarea)) : textarea;
+    }
+}
+exports.default = TextareaWidget;
+TextareaWidget.propTypes = {
+    "ui:options": PropTypes.shape({
+        emptyValue: PropTypes.string,
+        rows: PropTypes.number,
+    }),
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["string"])
+    }),
+    value: PropTypes.string
+};
+TextareaWidget.contextType = ReactContext_1.default;

package/lib/components/widgets/TimeWidget.d.ts

@@ -0,0 +1,11 @@
+export default TimeWidget;
+declare function TimeWidget(props: any): JSX.Element;
+declare namespace TimeWidget {
+    namespace propTypes {
+        const schema: PropTypes.Requireable<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        const value: PropTypes.Requireable<string>;
+    }
+}
+import * as PropTypes from "prop-types";

package/lib/components/widgets/TimeWidget.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const PropTypes = require("prop-types");
+const moment = require("moment");
+const DateTimeWidget_1 = require("./DateTimeWidget");
+const utils_1 = require("../../utils");
+const TimeWidget = (props) => {
+    const { onChange } = props;
+    const _onChange = React.useCallback((value) => onChange(utils_1.isEmptyString(value) ? undefined : (moment(value).format("HH:mm"))), [onChange]);
+    return (React.createElement(DateTimeWidget_1.default, Object.assign({}, props, { onChange: _onChange, calendar: false, value: props.value ? (moment().format("YYYY-MM-DD") + `T${props.value}`) : null })));
+};
+TimeWidget.propTypes = {
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["string"])
+    }),
+    value: PropTypes.string
+};
+exports.default = TimeWidget;

package/lib/components/widgets/URLWidget.d.ts

@@ -0,0 +1,14 @@
+export default URLWidget;
+declare function URLWidget({ value, options }: {
+    value: any;
+    options?: {} | undefined;
+}): JSX.Element;
+declare namespace URLWidget {
+    namespace propTypes {
+        const schema: PropTypes.Requireable<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        const value: PropTypes.Requireable<string>;
+    }
+}
+import * as PropTypes from "prop-types";

package/lib/components/widgets/URLWidget.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const PropTypes = require("prop-types");
+const URLWidget = ({ value, options = {} }) => React.createElement("a", { href: `${options.template || ""}${value}`, target: "_blank", rel: "noopener noreferrer" }, `${options.template || ""}${value}`);
+URLWidget.propTypes = {
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["string"])
+    }),
+    value: PropTypes.string
+};
+exports.default = URLWidget;

package/lib/components/widgets/UpperCaseWidget.d.ts

@@ -0,0 +1,13 @@
+export default class UpperCaseWidget extends React.Component<any, any, any> {
+    static propTypes: {
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        value: PropTypes.Requireable<string>;
+    };
+    constructor(props: any);
+    constructor(props: any, context: any);
+    formatValue: (value: any) => any;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/widgets/UpperCaseWidget.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const PropTypes = require("prop-types");
+const BaseInputTemplate_1 = require("../templates/BaseInputTemplate");
+class UpperCaseWidget extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.formatValue = (value) => typeof value === "string" ? value.toUpperCase() : value;
+    }
+    render() {
+        return React.createElement(BaseInputTemplate_1.default, Object.assign({}, this.props, { formatValue: this.formatValue }));
+    }
+}
+exports.default = UpperCaseWidget;
+UpperCaseWidget.propTypes = {
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["string"])
+    }).isRequired,
+    value: PropTypes.string
+};

package/lib/index.d.ts

@@ -0,0 +1,20 @@
+import LajiForm, { LajiFormProps } from "./components/LajiForm";
+declare type LajiFormWrapperProps = LajiFormProps & {
+    rootElem: HTMLDivElement;
+};
+export default class LajiFormWrapper {
+    props: LajiFormProps;
+    state: LajiFormProps;
+    rootElem: HTMLDivElement;
+    lajiForm: LajiForm;
+    constructor(props: LajiFormWrapperProps);
+    submit: () => void;
+    submitOnlySchemaValidations: () => void;
+    setState: (state: Partial<LajiFormProps>) => void;
+    pushBlockingLoader: () => void;
+    popBlockingLoader: () => void;
+    getSettings: () => {};
+    destroy: () => void;
+    unmount: () => void;
+}
+export {};