@opengeoweb/form-fields 2.0.1

package/form-fields.umd.js

@@ -0,0 +1,836 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('@material-ui/core'), require('react-hook-form'), require('moment'), require('lodash'), require('@material-ui/pickers'), require('moment-timezone')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'react', '@material-ui/core', 'react-hook-form', 'moment', 'lodash', '@material-ui/pickers', 'moment-timezone'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FormFields = {}, global.React, global.core, global.reactHookForm, global.moment, global.lodash, global.pickers, global.moment$1));
+})(this, (function (exports, React, core, reactHookForm, moment, lodash, pickers, moment$1) { 'use strict';
+
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n["default"] = e;
+        return Object.freeze(n);
+    }
+
+    var React__namespace = /*#__PURE__*/_interopNamespace(React);
+    var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+    var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
+    var moment__default$1 = /*#__PURE__*/_interopDefaultLegacy(moment$1);
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __rest(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;
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spreadArray(to, from) {
+        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+            to[j] = from[i];
+        return to;
+    }
+
+    /* *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *     http://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     *
+     * Copyright 2021 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+     * Copyright 2021 - Finnish Meteorological Institute (FMI)
+     * */
+    var errorMessages = {
+      required: 'This field is required',
+      isValidDate: 'Not a valid date',
+      isAfter: 'Date should not be before',
+      isXHoursBefore: 'Date is too far in the past',
+      isXHoursAfter: 'Date is too far in the future',
+      isBefore: 'Timestamp too late',
+      minLevel: 'The minimum level is 1',
+      isLatitude: 'Invalid latitude, expected number with maximum two decimal degrees between -90.00 and 90.00',
+      isLongitude: 'Invalid longitude, expected number with maximum two decimal degrees between -180.00 and 180.00',
+      isValidMax: 'The maximum value is exceeded',
+      isLevelLower: 'The lower level has to be below the upper level',
+      isNonOrBothCoordinates: 'Please enter both coordinates',
+      isInteger: 'Invalid entry, enter a non-decimal number',
+      isNumeric: 'Invalid entry, enter a numeric value',
+      containsNoCommas: 'Please use a dot (.) as decimal separator',
+      minVisibility: 'The minimum visibility is 0',
+      maxVisibility: 'The maximum visibility is 4900'
+    };
+    var regexMaxTwoDecimals = /^\s*-?\d+(\.\d{1,2})?\s*$/; // validations
+
+    var isEmpty = function isEmpty(value) {
+      if (typeof value === 'string' && !value.trim().length || value === null || value === undefined) {
+        return true;
+      }
+
+      return false;
+    };
+    var isValidDate = function isValidDate(value) {
+      return value ? moment__default["default"](value).isValid() : true;
+    };
+    var isBefore = function isBefore(ownDate, referenceDate) {
+      return ownDate ? moment__default["default"].utc(ownDate) < moment__default["default"].utc(referenceDate) : true;
+    };
+    var isAfter = function isAfter(ownDate, otherDate) {
+      return ownDate ? moment__default["default"].utc(ownDate).isAfter(moment__default["default"].utc(otherDate)) : true;
+    };
+    var isBetween = function isBetween(ownDate, otherDateStart, otherDateEnd) {
+      return moment__default["default"].utc(ownDate) >= moment__default["default"].utc(otherDateStart) && moment__default["default"].utc(ownDate) <= moment__default["default"].utc(otherDateEnd);
+    };
+    var isXHoursBefore = function isXHoursBefore(ownDate, otherDate, hours) {
+      if (hours === void 0) {
+        hours = 4;
+      }
+
+      if (isEmpty(ownDate) || isEmpty(otherDate)) {
+        return true;
+      }
+
+      var duration = moment__default["default"].duration(moment__default["default"].utc(ownDate).diff(otherDate));
+      var inHours = duration.asHours();
+      return inHours >= -hours;
+    };
+    var isXHoursAfter = function isXHoursAfter(ownDate, otherDate, hours) {
+      if (hours === void 0) {
+        hours = 4;
+      }
+
+      if (isEmpty(ownDate) || isEmpty(otherDate)) {
+        return true;
+      }
+
+      var duration = moment__default["default"].duration(moment__default["default"].utc(ownDate).diff(otherDate));
+      var inHours = duration.asHours();
+      return inHours <= hours;
+    };
+    var isLatitude = function isLatitude(lat) {
+      if (!lat) return true;
+      return isFinite(lat) && Math.abs(lat) <= 90 && regexMaxTwoDecimals.test(lat.toString());
+    };
+    var isLongitude = function isLongitude(lng) {
+      if (!lng) return true;
+      return isFinite(lng) && Math.abs(lng) <= 180 && lng >= -180 && regexMaxTwoDecimals.test(lng.toString());
+    };
+    var isValidMax = function isValidMax(value, maxValue) {
+      if (isEmpty(value)) {
+        return true;
+      }
+
+      return !(value > maxValue);
+    };
+    var isValidMin = function isValidMin(value, minValue) {
+      if (isEmpty(value)) {
+        return true;
+      }
+
+      return !(value < minValue);
+    };
+    var hasValidGeometry = function hasValidGeometry(geojson) {
+      if (!geojson || !geojson.features || !geojson.features.length || !geojson.features[0].geometry || // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      !geojson.features[0].geometry.coordinates || !geojson.features[0].geometry.type) {
+        return false;
+      }
+
+      return true;
+    };
+    var isValidGeoJsonCoordinates = function isValidGeoJsonCoordinates(geojson) {
+      var hasGeometry = hasValidGeometry(geojson);
+
+      if (!hasGeometry) {
+        return false;
+      } // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+
+
+      var _a = geojson.features[0].geometry,
+          coordinates = _a.coordinates,
+          type = _a.type; // For type POINT coordinates is an array of 2
+
+      if (coordinates.length === 2 && type === 'Point') {
+        return true;
+      } // For type POLYGON coordinates is an array of arrays
+
+
+      if (coordinates.length === 1 && coordinates[0].length > 0 && type === 'Polygon') {
+        return true;
+      }
+
+      return false;
+    };
+    var isMaximumOneDrawing = function isMaximumOneDrawing(geojson) {
+      var hasGeometry = hasValidGeometry(geojson);
+
+      if (!hasGeometry) {
+        return true; // no need to check further when there is no drawing yet
+      } // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+
+
+      var _a = geojson.features[0].geometry,
+          coordinates = _a.coordinates,
+          type = _a.type; // For type POLYGON only one array of coordinates is allowed
+
+      if (type === 'Polygon' && coordinates.length > 1) {
+        return false;
+      }
+
+      return true;
+    };
+    var hasIntersectionWithFIR = function hasIntersectionWithFIR(geojson, intersection) {
+      if (!hasValidGeometry(geojson) || // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      !geojson.features[0].geometry.coordinates.length || geojson.features[0].geometry.type === 'Polygon' && !geojson.features[0].geometry.coordinates[0].length) {
+        return true; // no need to check further when there is no drawing yet
+      } // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+
+
+      var coordinates = intersection.features[0].geometry.coordinates;
+
+      if (coordinates.length > 0 && coordinates[0].length === 0) {
+        return false;
+      }
+
+      return true;
+    };
+    var hasMaxFeaturePoints = function hasMaxFeaturePoints(geojson, maxPoints) {
+      if (maxPoints === void 0) {
+        maxPoints = 7;
+      }
+
+      var hasGeometry = hasValidGeometry(geojson);
+
+      if (!hasGeometry) {
+        return false;
+      } // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+
+
+      var _a = geojson.features[0].geometry,
+          coordinates = _a.coordinates,
+          type = _a.type;
+
+      if (type === 'Polygon' && coordinates[0].length > maxPoints) {
+        return true;
+      }
+
+      return false;
+    };
+    var hasMulitpleIntersections = function hasMulitpleIntersections(geojson) {
+      var hasGeometry = hasValidGeometry(geojson);
+
+      if (!hasGeometry) {
+        return false;
+      } // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+
+
+      var _a = geojson.features[0].geometry,
+          coordinates = _a.coordinates,
+          type = _a.type;
+
+      if (type === 'MultiPolygon' || coordinates.length > 1 && type !== 'Point') {
+        return true;
+      }
+
+      return false;
+    };
+    var isGeometryDirty = function isGeometryDirty(geoJSON, formGeoJSON) {
+      if (geoJSON === (undefined) || formGeoJSON === (undefined) || !hasValidGeometry(geoJSON) || !hasValidGeometry(formGeoJSON)) {
+        return false;
+      }
+
+      return !lodash.isEqual( // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      geoJSON.features[0].geometry.coordinates, // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      formGeoJSON.features[0].geometry.coordinates);
+    };
+    var isInteger = function isInteger(value) {
+      if (isEmpty(value)) {
+        return true;
+      }
+
+      return Number.isInteger(value);
+    }; // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    var isNonOrBothCoordinates = function isNonOrBothCoordinates(coordinate, otherCoordinate) {
+      if (coordinate && otherCoordinate || !coordinate && !otherCoordinate) {
+        return true;
+      }
+
+      if (coordinate) {
+        return true;
+      }
+
+      return false;
+    };
+    var containsNoCommas = function containsNoCommas(val) {
+      if (typeof val === 'string' && val.includes(',')) {
+        return false;
+      }
+
+      return true;
+    };
+
+    var ReactHookFormFormControl = function ReactHookFormFormControl(_a) {
+      var children = _a.children,
+          errors = _a.errors,
+          props = __rest(_a, ["children", "errors"]);
+
+      return /*#__PURE__*/React__namespace.createElement(core.FormControl, __assign({
+        fullWidth: true
+      }, props, {
+        error: !!errors
+      }), children, errors && /*#__PURE__*/React__namespace.createElement(core.FormHelperText, {
+        variant: "filled"
+      }, errors.message || errorMessages[errors.type]));
+    };
+
+    function getDeepProperty(p, o) {
+      return p.reduce(function (xs, x) {
+        return xs && xs[x] ? xs[x] : null;
+      }, o);
+    }
+    var getErrors = function getErrors(name, errors) {
+      var nameAsArray = name.split('.');
+      return getDeepProperty(nameAsArray, errors);
+    };
+
+    var ReactHookFormSelect = function ReactHookFormSelect(_a) {
+      var name = _a.name,
+          label = _a.label,
+          _b = _a.defaultValue,
+          defaultValue = _b === void 0 ? '' : _b,
+          children = _a.children,
+          rules = _a.rules,
+          _c = _a.onChange,
+          _onChange = _c === void 0 ? function () {} : _c,
+          disabled = _a.disabled,
+          className = _a.className,
+          otherProps = __rest(_a, ["name", "label", "defaultValue", "children", "rules", "onChange", "disabled", "className"]);
+
+      var labelId = name + "-label";
+      var inputRef = React__namespace.useRef(null);
+
+      var _d = reactHookForm.useFormContext(),
+          control = _d.control,
+          formErrors = _d.errors;
+
+      var errors = getErrors(name, formErrors);
+      return /*#__PURE__*/React__namespace.createElement(ReactHookFormFormControl, {
+        className: className,
+        disabled: disabled,
+        errors: errors
+      }, /*#__PURE__*/React__namespace.createElement(core.InputLabel, {
+        variant: "filled",
+        id: labelId
+      }, label), /*#__PURE__*/React__namespace.createElement(reactHookForm.Controller, {
+        render: function render(_props) {
+          return /*#__PURE__*/React__namespace.createElement(core.Select, __assign({
+            labelId: labelId,
+            label: label,
+            inputRef: inputRef,
+            name: name,
+            onChange: function onChange(changeEvent) {
+              _props.onChange(changeEvent.target.value); // default props
+
+
+              _onChange(changeEvent);
+            },
+            value: _props.value,
+            variant: "filled"
+          }, otherProps), children);
+        },
+        name: name,
+        control: control,
+        defaultValue: defaultValue,
+        rules: rules,
+        onFocus: function onFocus() {
+          var _a;
+
+          inputRef.current.disabled = false;
+          (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+        }
+      }));
+    };
+
+    var ReactHookFormRadioGroup = function ReactHookFormRadioGroup(_a) {
+      var name = _a.name,
+          label = _a.label,
+          _b = _a.defaultValue,
+          defaultValue = _b === void 0 ? '' : _b,
+          children = _a.children,
+          rules = _a.rules,
+          _c = _a.disabled,
+          disabled = _c === void 0 ? false : _c,
+          _d = _a.onChange,
+          _onChange = _d === void 0 ? function () {
+        return null;
+      } : _d,
+          otherProps = __rest(_a, ["name", "label", "defaultValue", "children", "rules", "disabled", "onChange"]);
+
+      var labelId = name + "-label";
+      var inputRef = React__namespace.useRef(null);
+
+      var _e = reactHookForm.useFormContext(),
+          control = _e.control,
+          formErrors = _e.errors;
+
+      var errors = getErrors(name, formErrors);
+      return /*#__PURE__*/React__namespace.createElement(ReactHookFormFormControl, {
+        disabled: disabled,
+        errors: errors
+      }, /*#__PURE__*/React__namespace.createElement(core.InputLabel, {
+        id: labelId
+      }, label), /*#__PURE__*/React__namespace.createElement(reactHookForm.Controller, {
+        render: function render(_props) {
+          return /*#__PURE__*/React__namespace.createElement(core.RadioGroup, __assign({
+            value: _props.value,
+            onChange: function onChange(changeEvent) {
+              _props.onChange(changeEvent.target.value);
+
+              _onChange(changeEvent, changeEvent.target.value);
+            },
+            innerRef: inputRef,
+            name: name
+          }, otherProps), children);
+        },
+        name: name,
+        control: control,
+        defaultValue: defaultValue,
+        rules: rules,
+        onFocus: function onFocus() {
+          // move focus to first radio on error
+          var firstElement = inputRef.current.querySelector('input');
+
+          if (firstElement) {
+            firstElement.disabled = false;
+            firstElement === null || firstElement === void 0 ? void 0 : firstElement.focus();
+          }
+        }
+      }));
+    };
+
+    var styles = {
+      textEditor: {
+        backgroundColor: 'rgba(0, 117, 169, 0.05)'
+      }
+    };
+    var convertTextInputValue = function convertTextInputValue(value, inCapitals) {
+      return inCapitals ? value.toUpperCase() : value;
+    };
+
+    var ReactHookFormTextField = function ReactHookFormTextField(_a) {
+      var name = _a.name,
+          label = _a.label,
+          _b = _a.defaultValue,
+          defaultValue = _b === void 0 ? '' : _b,
+          rules = _a.rules,
+          _c = _a.disabled,
+          disabled = _c === void 0 ? false : _c,
+          _d = _a.upperCase,
+          upperCase = _d === void 0 ? false : _d,
+          _e = _a.helperText,
+          helperText = _e === void 0 ? '' : _e,
+          className = _a.className,
+          _f = _a.onChange,
+          _onChange = _f === void 0 ? function () {
+        return null;
+      } : _f,
+          otherProps = __rest(_a, ["name", "label", "defaultValue", "rules", "disabled", "upperCase", "helperText", "className", "onChange"]);
+
+      var inputRef = React__namespace.useRef(null);
+
+      var _g = reactHookForm.useFormContext(),
+          control = _g.control,
+          formErrors = _g.errors;
+
+      var errors = getErrors(name, formErrors);
+      return /*#__PURE__*/React__namespace.createElement(ReactHookFormFormControl, {
+        className: className,
+        disabled: disabled,
+        errors: errors
+      }, /*#__PURE__*/React__namespace.createElement(reactHookForm.Controller, {
+        render: function render(_props) {
+          return /*#__PURE__*/React__namespace.createElement(core.TextField, __assign({
+            label: label,
+            style: otherProps.multiline ? styles.textEditor : {},
+            error: !!errors,
+            helperText: helperText,
+            value: _props.value,
+            variant: "filled",
+            type: "text",
+            name: name,
+            onChange: function onChange(evt) {
+              var value = evt.target.value;
+              var convertedValue = convertTextInputValue(value, upperCase);
+
+              _props.onChange(convertedValue);
+
+              _onChange(null);
+            },
+            disabled: disabled,
+            inputRef: inputRef
+          }, otherProps));
+        },
+        name: name,
+        control: control,
+        defaultValue: defaultValue,
+        rules: rules,
+        disabled: disabled,
+        onFocus: function onFocus() {
+          var _a;
+
+          inputRef.current.disabled = false;
+          (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+        }
+      }));
+    };
+
+    var convertNumericInputValue = function convertNumericInputValue(value, inputMode) {
+      if (value !== '' && !isNaN(parseFloat(value))) {
+        // float is returned as string, option 'valueAsNumber: true' will take care of the parsing
+        return inputMode === 'numeric' ? parseInt(value, 10) : value;
+      }
+
+      return value;
+    };
+    var parseInput = function parseInput(value) {
+      // allow '-' at the start of the value
+      if (typeof value === 'string' && value.includes('-')) {
+        return value.split('-').reduce(function (list, el) {
+          if (!el.length && !list.length) {
+            return '-';
+          }
+
+          return list.concat(el);
+        }, '');
+      } // return value when '.' is given
+
+
+      if (typeof value === 'string' && value.includes('.')) {
+        return value;
+      }
+
+      return value == null || isNaN(value) ? '' : value.toString();
+    };
+    var getAllowedKeys = function getAllowedKeys(inputMode) {
+      if (inputMode === void 0) {
+        inputMode = 'numeric';
+      }
+
+      var allowedKeys = __spreadArray(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', 'Backspace', 'ArrowRight', 'ArrowLeft', 'Tab', 'Home', 'End', 'PageDown', 'PageUp', 'Delete'], __read(inputMode === 'decimal' ? ['.'] : []));
+
+      return allowedKeys;
+    };
+
+    var ReactHookFormNumberField = function ReactHookFormNumberField(_a) {
+      var name = _a.name,
+          label = _a.label,
+          _b = _a.defaultValue,
+          defaultValue = _b === void 0 ? '' : _b,
+          rules = _a.rules,
+          _c = _a.disabled,
+          disabled = _c === void 0 ? false : _c,
+          _d = _a.inputMode,
+          inputMode = _d === void 0 ? 'numeric' : _d,
+          _e = _a.helperText,
+          helperText = _e === void 0 ? '' : _e,
+          className = _a.className,
+          _f = _a.onChange,
+          _onChange = _f === void 0 ? function () {
+        return null;
+      } : _f,
+          otherProps = __rest(_a, ["name", "label", "defaultValue", "rules", "disabled", "inputMode", "helperText", "className", "onChange"]);
+
+      var inputRef = React__namespace.useRef(null);
+
+      var _g = reactHookForm.useFormContext(),
+          control = _g.control,
+          formErrors = _g.errors;
+
+      var errors = getErrors(name, formErrors);
+
+      var validationRules = __assign(__assign({}, rules), {
+        setValueAs: function setValueAs(value) {
+          return parseFloat(value);
+        }
+      });
+
+      var allowedKeyes = getAllowedKeys(inputMode);
+
+      var onKeyDown = function onKeyDown(event) {
+        if (!allowedKeyes.includes(event.key) || // only allow one seperator
+        event.key === '.' && event.target.value.includes('.') || // only allow one -
+        event.key === '-' && event.target.value.includes('-')) {
+          event.preventDefault();
+        }
+      };
+
+      return /*#__PURE__*/React__namespace.createElement(ReactHookFormFormControl, {
+        className: className,
+        disabled: disabled,
+        errors: errors
+      }, /*#__PURE__*/React__namespace.createElement(reactHookForm.Controller, {
+        render: function render(_props) {
+          return /*#__PURE__*/React__namespace.createElement(core.TextField, __assign({
+            label: label,
+            error: !!errors,
+            helperText: helperText,
+            inputMode: inputMode,
+            value: parseInput(_props.value),
+            variant: "filled",
+            type: "text",
+            inputProps: {
+              inputMode: inputMode
+            },
+            name: name,
+            onChange: function onChange(evt) {
+              _props.onChange(convertNumericInputValue(evt.target.value, inputMode));
+
+              _onChange(null);
+            },
+            onKeyDown: onKeyDown,
+            disabled: disabled,
+            inputRef: inputRef
+          }, otherProps));
+        },
+        name: name,
+        control: control,
+        defaultValue: defaultValue,
+        rules: validationRules,
+        disabled: disabled,
+        onFocus: function onFocus() {
+          var _a;
+
+          inputRef.current.disabled = false;
+          (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+        }
+      }));
+    };
+
+    moment__default$1["default"].tz.setDefault('Etc/GMT-0');
+    var getFormattedValue = function getFormattedValue(value) {
+      var isMoment = moment__default$1["default"](value).isValid();
+      return isMoment ? moment__default$1["default"].utc(value).format() : value;
+    };
+
+    var ReactHookKeyboardDateTimePicker = function ReactHookKeyboardDateTimePicker(_a) {
+      var name = _a.name,
+          rules = _a.rules,
+          disabled = _a.disabled,
+          _b = _a.label,
+          label = _b === void 0 ? 'Select date and time' : _b,
+          _c = _a.format,
+          format = _c === void 0 ? 'YYYY/MM/DD HH:mm' : _c,
+          _d = _a.openTo,
+          openTo = _d === void 0 ? 'hours' : _d,
+          _e = _a.defaultNullValue,
+          defaultNullValue = _e === void 0 ? null : _e,
+          _f = _a.helperText,
+          helperText = _f === void 0 ? '' : _f,
+          _g = _a.onChange,
+          _onChange = _g === void 0 ? function () {
+        return null;
+      } : _g,
+          className = _a.className,
+          otherProps = __rest(_a, ["name", "rules", "disabled", "label", "format", "openTo", "defaultNullValue", "helperText", "onChange", "className"]);
+
+      var inputRef = React__namespace.useRef(null);
+
+      var _h = reactHookForm.useFormContext(),
+          control = _h.control,
+          formErrors = _h.errors,
+          getValues = _h.getValues;
+
+      var errors = getErrors(name, formErrors);
+      return /*#__PURE__*/React__namespace.createElement(ReactHookFormFormControl, {
+        disabled: disabled,
+        errors: errors,
+        className: className
+      }, /*#__PURE__*/React__namespace.createElement(reactHookForm.Controller, {
+        render: function render(_props) {
+          return /*#__PURE__*/React__namespace.createElement(pickers.KeyboardDateTimePicker, __assign({
+            autoOk: true,
+            name: name,
+            ampm: false,
+            format: format,
+            label: label,
+            value: _props.value,
+            openTo: openTo,
+            error: !!errors,
+            disabled: disabled,
+            onChange: function onChange(value) {
+              _props.onChange(getFormattedValue(value));
+
+              _onChange(getFormattedValue(value));
+            },
+            invalidDateMessage: null,
+            inputVariant: "filled",
+            inputRef: inputRef,
+            InputAdornmentProps: {
+              position: 'start'
+            },
+            helperText: helperText,
+            InputProps: {
+              endAdornment: /*#__PURE__*/React__namespace.createElement(core.InputAdornment, {
+                style: {
+                  paddingTop: '16px'
+                },
+                position: "end"
+              }, "UTC")
+            }
+          }, otherProps));
+        },
+        name: name,
+        control: control,
+        rules: rules,
+        defaultValue: getValues(name) || defaultNullValue,
+        onFocus: function onFocus() {
+          var _a;
+
+          if (inputRef.current) {
+            inputRef.current.disabled = false;
+            (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+          }
+        }
+      }));
+    };
+
+    var defaultFormOptions = {
+      mode: 'onChange',
+      reValidateMode: 'onChange'
+    };
+
+    var ReactHookFormProvider = function ReactHookFormProvider(_a) {
+      var children = _a.children,
+          _b = _a.options,
+          options = _b === void 0 ? defaultFormOptions : _b;
+      var formMethods = reactHookForm.useForm(options);
+      return /*#__PURE__*/React__default["default"].createElement(reactHookForm.FormProvider, __assign({}, formMethods), children);
+    };
+
+    var ReactHookFormHiddenInput = function ReactHookFormHiddenInput(_a) {
+      var name = _a.name,
+          _b = _a.defaultValue,
+          defaultValue = _b === void 0 ? null : _b,
+          rules = _a.rules;
+      var control = reactHookForm.useFormContext().control;
+      return /*#__PURE__*/React__namespace.createElement(reactHookForm.Controller, {
+        render: function render(field) {
+          return field.value !== null ? /*#__PURE__*/React__namespace.createElement("input", __assign({}, field, {
+            type: "hidden"
+          })) : null;
+        },
+        name: name,
+        control: control,
+        defaultValue: defaultValue,
+        rules: rules
+      });
+    };
+
+    exports.ReactHookFormDateTime = ReactHookKeyboardDateTimePicker;
+    exports.ReactHookFormFormControl = ReactHookFormFormControl;
+    exports.ReactHookFormHiddenInput = ReactHookFormHiddenInput;
+    exports.ReactHookFormNumberField = ReactHookFormNumberField;
+    exports.ReactHookFormProvider = ReactHookFormProvider;
+    exports.ReactHookFormRadioGroup = ReactHookFormRadioGroup;
+    exports.ReactHookFormSelect = ReactHookFormSelect;
+    exports.ReactHookFormTextField = ReactHookFormTextField;
+    exports.containsNoCommas = containsNoCommas;
+    exports.defaultFormOptions = defaultFormOptions;
+    exports.errorMessages = errorMessages;
+    exports.getDeepProperty = getDeepProperty;
+    exports.hasIntersectionWithFIR = hasIntersectionWithFIR;
+    exports.hasMaxFeaturePoints = hasMaxFeaturePoints;
+    exports.hasMulitpleIntersections = hasMulitpleIntersections;
+    exports.isAfter = isAfter;
+    exports.isBefore = isBefore;
+    exports.isBetween = isBetween;
+    exports.isEmpty = isEmpty;
+    exports.isGeometryDirty = isGeometryDirty;
+    exports.isInteger = isInteger;
+    exports.isLatitude = isLatitude;
+    exports.isLongitude = isLongitude;
+    exports.isMaximumOneDrawing = isMaximumOneDrawing;
+    exports.isNonOrBothCoordinates = isNonOrBothCoordinates;
+    exports.isValidDate = isValidDate;
+    exports.isValidGeoJsonCoordinates = isValidGeoJsonCoordinates;
+    exports.isValidMax = isValidMax;
+    exports.isValidMin = isValidMin;
+    exports.isXHoursAfter = isXHoursAfter;
+    exports.isXHoursBefore = isXHoursBefore;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));