@opengeoweb/form-fields 2.0.1

package/form-fields.esm.js

@@ -0,0 +1,802 @@
+import * as React from 'react';
+import React__default from 'react';
+import { FormControl, FormHelperText, InputLabel, Select, RadioGroup, TextField, InputAdornment } from '@material-ui/core';
+import { useFormContext, Controller, useForm, FormProvider } from 'react-hook-form';
+import moment from 'moment';
+import { isEqual } from 'lodash';
+import { KeyboardDateTimePicker } from '@material-ui/pickers';
+import moment$1 from 'moment-timezone';
+
+/*! *****************************************************************************
+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.
+***************************************************************************** */
+
+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;
+}
+
+/* *
+ * 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(value).isValid() : true;
+};
+var isBefore = function isBefore(ownDate, referenceDate) {
+  return ownDate ? moment.utc(ownDate) < moment.utc(referenceDate) : true;
+};
+var isAfter = function isAfter(ownDate, otherDate) {
+  return ownDate ? moment.utc(ownDate).isAfter(moment.utc(otherDate)) : true;
+};
+var isBetween = function isBetween(ownDate, otherDateStart, otherDateEnd) {
+  return moment.utc(ownDate) >= moment.utc(otherDateStart) && moment.utc(ownDate) <= moment.utc(otherDateEnd);
+};
+var isXHoursBefore = function isXHoursBefore(ownDate, otherDate) {
+  var hours = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4;
+
+  if (isEmpty(ownDate) || isEmpty(otherDate)) {
+    return true;
+  }
+
+  var duration = moment.duration(moment.utc(ownDate).diff(otherDate));
+  var inHours = duration.asHours();
+  return inHours >= -hours;
+};
+var isXHoursAfter = function isXHoursAfter(ownDate, otherDate) {
+  var hours = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 4;
+
+  if (isEmpty(ownDate) || isEmpty(otherDate)) {
+    return true;
+  }
+
+  var duration = moment.duration(moment.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 _geojson$features$0$g = geojson.features[0].geometry,
+      coordinates = _geojson$features$0$g.coordinates,
+      type = _geojson$features$0$g.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 _geojson$features$0$g2 = geojson.features[0].geometry,
+      coordinates = _geojson$features$0$g2.coordinates,
+      type = _geojson$features$0$g2.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) {
+  var maxPoints = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 7;
+  var hasGeometry = hasValidGeometry(geojson);
+
+  if (!hasGeometry) {
+    return false;
+  } // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+
+
+  var _geojson$features$0$g3 = geojson.features[0].geometry,
+      coordinates = _geojson$features$0$g3.coordinates,
+      type = _geojson$features$0$g3.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 _geojson$features$0$g4 = geojson.features[0].geometry,
+      coordinates = _geojson$features$0$g4.coordinates,
+      type = _geojson$features$0$g4.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 !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.createElement(FormControl, Object.assign({
+    fullWidth: true
+  }, props, {
+    error: !!errors
+  }), children, errors && /*#__PURE__*/React.createElement(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,
+      _a$defaultValue = _a.defaultValue,
+      defaultValue = _a$defaultValue === void 0 ? '' : _a$defaultValue,
+      children = _a.children,
+      rules = _a.rules,
+      _a$onChange = _a.onChange,
+      _onChange = _a$onChange === void 0 ? function () {} : _a$onChange,
+      disabled = _a.disabled,
+      className = _a.className,
+      otherProps = __rest(_a, ["name", "label", "defaultValue", "children", "rules", "onChange", "disabled", "className"]);
+
+  var labelId = "".concat(name, "-label");
+  var inputRef = React.useRef(null);
+
+  var _useFormContext = useFormContext(),
+      control = _useFormContext.control,
+      formErrors = _useFormContext.errors;
+
+  var errors = getErrors(name, formErrors);
+  return /*#__PURE__*/React.createElement(ReactHookFormFormControl, {
+    className: className,
+    disabled: disabled,
+    errors: errors
+  }, /*#__PURE__*/React.createElement(InputLabel, {
+    variant: "filled",
+    id: labelId
+  }, label), /*#__PURE__*/React.createElement(Controller, {
+    render: function render(_props) {
+      return /*#__PURE__*/React.createElement(Select, Object.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,
+      _a$defaultValue = _a.defaultValue,
+      defaultValue = _a$defaultValue === void 0 ? '' : _a$defaultValue,
+      children = _a.children,
+      rules = _a.rules,
+      _a$disabled = _a.disabled,
+      disabled = _a$disabled === void 0 ? false : _a$disabled,
+      _a$onChange = _a.onChange,
+      _onChange = _a$onChange === void 0 ? function () {
+    return null;
+  } : _a$onChange,
+      otherProps = __rest(_a, ["name", "label", "defaultValue", "children", "rules", "disabled", "onChange"]);
+
+  var labelId = "".concat(name, "-label");
+  var inputRef = React.useRef(null);
+
+  var _useFormContext = useFormContext(),
+      control = _useFormContext.control,
+      formErrors = _useFormContext.errors;
+
+  var errors = getErrors(name, formErrors);
+  return /*#__PURE__*/React.createElement(ReactHookFormFormControl, {
+    disabled: disabled,
+    errors: errors
+  }, /*#__PURE__*/React.createElement(InputLabel, {
+    id: labelId
+  }, label), /*#__PURE__*/React.createElement(Controller, {
+    render: function render(_props) {
+      return /*#__PURE__*/React.createElement(RadioGroup, Object.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,
+      _a$defaultValue = _a.defaultValue,
+      defaultValue = _a$defaultValue === void 0 ? '' : _a$defaultValue,
+      rules = _a.rules,
+      _a$disabled = _a.disabled,
+      disabled = _a$disabled === void 0 ? false : _a$disabled,
+      _a$upperCase = _a.upperCase,
+      upperCase = _a$upperCase === void 0 ? false : _a$upperCase,
+      _a$helperText = _a.helperText,
+      helperText = _a$helperText === void 0 ? '' : _a$helperText,
+      className = _a.className,
+      _a$onChange = _a.onChange,
+      _onChange = _a$onChange === void 0 ? function () {
+    return null;
+  } : _a$onChange,
+      otherProps = __rest(_a, ["name", "label", "defaultValue", "rules", "disabled", "upperCase", "helperText", "className", "onChange"]);
+
+  var inputRef = React.useRef(null);
+
+  var _useFormContext = useFormContext(),
+      control = _useFormContext.control,
+      formErrors = _useFormContext.errors;
+
+  var errors = getErrors(name, formErrors);
+  return /*#__PURE__*/React.createElement(ReactHookFormFormControl, {
+    className: className,
+    disabled: disabled,
+    errors: errors
+  }, /*#__PURE__*/React.createElement(Controller, {
+    render: function render(_props) {
+      return /*#__PURE__*/React.createElement(TextField, Object.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();
+    }
+  }));
+};
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+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() {
+  var inputMode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'numeric';
+  var allowedKeys = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', 'Backspace', 'ArrowRight', 'ArrowLeft', 'Tab', 'Home', 'End', 'PageDown', 'PageUp', 'Delete'].concat(_toConsumableArray(inputMode === 'decimal' ? ['.'] : []));
+  return allowedKeys;
+};
+
+var ReactHookFormNumberField = function ReactHookFormNumberField(_a) {
+  var name = _a.name,
+      label = _a.label,
+      _a$defaultValue = _a.defaultValue,
+      defaultValue = _a$defaultValue === void 0 ? '' : _a$defaultValue,
+      rules = _a.rules,
+      _a$disabled = _a.disabled,
+      disabled = _a$disabled === void 0 ? false : _a$disabled,
+      _a$inputMode = _a.inputMode,
+      inputMode = _a$inputMode === void 0 ? 'numeric' : _a$inputMode,
+      _a$helperText = _a.helperText,
+      helperText = _a$helperText === void 0 ? '' : _a$helperText,
+      className = _a.className,
+      _a$onChange = _a.onChange,
+      _onChange = _a$onChange === void 0 ? function () {
+    return null;
+  } : _a$onChange,
+      otherProps = __rest(_a, ["name", "label", "defaultValue", "rules", "disabled", "inputMode", "helperText", "className", "onChange"]);
+
+  var inputRef = React.useRef(null);
+
+  var _useFormContext = useFormContext(),
+      control = _useFormContext.control,
+      formErrors = _useFormContext.errors;
+
+  var errors = getErrors(name, formErrors);
+  var validationRules = Object.assign(Object.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.createElement(ReactHookFormFormControl, {
+    className: className,
+    disabled: disabled,
+    errors: errors
+  }, /*#__PURE__*/React.createElement(Controller, {
+    render: function render(_props) {
+      return /*#__PURE__*/React.createElement(TextField, Object.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$1.tz.setDefault('Etc/GMT-0');
+var getFormattedValue = function getFormattedValue(value) {
+  var isMoment = moment$1(value).isValid();
+  return isMoment ? moment$1.utc(value).format() : value;
+};
+
+var ReactHookKeyboardDateTimePicker = function ReactHookKeyboardDateTimePicker(_a) {
+  var name = _a.name,
+      rules = _a.rules,
+      disabled = _a.disabled,
+      _a$label = _a.label,
+      label = _a$label === void 0 ? 'Select date and time' : _a$label,
+      _a$format = _a.format,
+      format = _a$format === void 0 ? 'YYYY/MM/DD HH:mm' : _a$format,
+      _a$openTo = _a.openTo,
+      openTo = _a$openTo === void 0 ? 'hours' : _a$openTo,
+      _a$defaultNullValue = _a.defaultNullValue,
+      defaultNullValue = _a$defaultNullValue === void 0 ? null : _a$defaultNullValue,
+      _a$helperText = _a.helperText,
+      helperText = _a$helperText === void 0 ? '' : _a$helperText,
+      _a$onChange = _a.onChange,
+      _onChange = _a$onChange === void 0 ? function () {
+    return null;
+  } : _a$onChange,
+      className = _a.className,
+      otherProps = __rest(_a, ["name", "rules", "disabled", "label", "format", "openTo", "defaultNullValue", "helperText", "onChange", "className"]);
+
+  var inputRef = React.useRef(null);
+
+  var _useFormContext = useFormContext(),
+      control = _useFormContext.control,
+      formErrors = _useFormContext.errors,
+      getValues = _useFormContext.getValues;
+
+  var errors = getErrors(name, formErrors);
+  return /*#__PURE__*/React.createElement(ReactHookFormFormControl, {
+    disabled: disabled,
+    errors: errors,
+    className: className
+  }, /*#__PURE__*/React.createElement(Controller, {
+    render: function render(_props) {
+      return /*#__PURE__*/React.createElement(KeyboardDateTimePicker, Object.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.createElement(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();
+      }
+    }
+  }));
+};
+
+/* *
+ * 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 defaultFormOptions = {
+  mode: 'onChange',
+  reValidateMode: 'onChange'
+};
+
+var ReactHookFormProvider = function ReactHookFormProvider(_ref) {
+  var children = _ref.children,
+      _ref$options = _ref.options,
+      options = _ref$options === void 0 ? defaultFormOptions : _ref$options;
+  var formMethods = useForm(options);
+  return /*#__PURE__*/React__default.createElement(FormProvider, Object.assign({}, formMethods), children);
+};
+
+/* *
+ * 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 ReactHookFormHiddenInput = function ReactHookFormHiddenInput(_ref) {
+  var name = _ref.name,
+      _ref$defaultValue = _ref.defaultValue,
+      defaultValue = _ref$defaultValue === void 0 ? null : _ref$defaultValue,
+      rules = _ref.rules;
+
+  var _useFormContext = useFormContext(),
+      control = _useFormContext.control;
+
+  return /*#__PURE__*/React.createElement(Controller, {
+    render: function render(field) {
+      return field.value !== null ? /*#__PURE__*/React.createElement("input", Object.assign({}, field, {
+        type: "hidden"
+      })) : null;
+    },
+    name: name,
+    control: control,
+    defaultValue: defaultValue,
+    rules: rules
+  });
+};
+
+export { ReactHookKeyboardDateTimePicker as ReactHookFormDateTime, ReactHookFormFormControl, ReactHookFormHiddenInput, ReactHookFormNumberField, ReactHookFormProvider, ReactHookFormRadioGroup, ReactHookFormSelect, ReactHookFormTextField, containsNoCommas, defaultFormOptions, errorMessages, getDeepProperty, hasIntersectionWithFIR, hasMaxFeaturePoints, hasMulitpleIntersections, isAfter, isBefore, isBetween, isEmpty, isGeometryDirty, isInteger, isLatitude, isLongitude, isMaximumOneDrawing, isNonOrBothCoordinates, isValidDate, isValidGeoJsonCoordinates, isValidMax, isValidMin, isXHoursAfter, isXHoursBefore };