@elliemae/ds-form 2.2.0-alpha.3 → 3.0.0-next.0

package/cjs/InputMask/DSInputMaskDeprecated.js

@@ -1,94 +1,122 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
-  }
-  return target;
-};
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
-var DSInputMaskDeprecated_exports = {};
-__export(DSInputMaskDeprecated_exports, {
-  DSInputMaskDeprecated: () => DSInputMaskDeprecated,
-  default: () => DSInputMaskDeprecated_default
-});
-var React = __toESM(require("react"));
-var import_react = __toESM(require("react"));
-var import_lodash = __toESM(require("lodash"));
-var import_prop_types = __toESM(require("prop-types"));
-var import_text_mask_core = __toESM(require("text-mask-core"));
-var import_setCaretPosition = __toESM(require("./utils/setCaretPosition"));
-var import_TextBox = __toESM(require("../TextBox"));
-const getValueFromEventOrString = (e) => {
+'use strict';
+
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var React = require('react');
+var lodash = require('lodash');
+var textMaskCore = require('text-mask-core');
+var setCaretPosition = require('./utils/setCaretPosition.js');
+var DSTextBox = require('../TextBox/DSTextBox.js');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+const _excluded = ["autoFocus", "style", "disabled", "className", "name", "maxLength", "minLength", "fluidWidth", "placeholder", "onKeyDown", "onClick", "onChange", "onFocus", "onBlur", "onPaste", "onKeyUp", "hasError", "readOnly", "type", "innerRef", "clearable", "leftComponent", "rightComponent", "value"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+const getValueFromEventOrString = e => {
   let value = e;
+
   if (e && e.target) {
     const {
-      target: { value: eValue }
+      target: {
+        value: eValue
+      }
     } = e;
     value = eValue;
   }
+
   return value;
 };
-const getRawMask = (mask, rawValue = "") => typeof mask === "function" ? mask(rawValue) : mask;
+
+const getRawMask = function (mask) {
+  let rawValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  return typeof mask === 'function' ? mask(rawValue) : mask;
+}; // this is not safe because we don't take in consideration a lot of cases
+// just a monkeypatch untill we get the v2 going,
+// this work with "internal" masks...
+
+
 const UNSAFEGetRawValue = (value, mask) => {
+  var _safeValue$split, _safeValue$split$filt;
+
   const safeValue = getValueFromEventOrString(value);
-  if (!safeValue)
-    return "";
+  if (!safeValue) return '';
   const rawMask = getRawMask(mask, value);
-  const characterToStrip = rawMask.filter((char) => typeof char === "string");
-  return safeValue?.split("")?.filter((char) => {
-    const indexCharToStrip = characterToStrip.findIndex((strip) => strip === char);
+  const characterToStrip = rawMask.filter(char => typeof char === 'string');
+  return safeValue === null || safeValue === void 0 ? void 0 : (_safeValue$split = safeValue.split('')) === null || _safeValue$split === void 0 ? void 0 : (_safeValue$split$filt = _safeValue$split.filter(char => {
+    const indexCharToStrip = characterToStrip.findIndex(strip => strip === char);
+
     if (indexCharToStrip >= 0) {
       characterToStrip.splice(indexCharToStrip, 1);
       return false;
     }
+
     return true;
-  })?.join("");
-};
+  })) === null || _safeValue$split$filt === void 0 ? void 0 : _safeValue$split$filt.join('');
+}; // this is not safe because we don't take in consideration a lot of cases
+// just a monkeypatch untill we get the v2 going,
+// this work with "internal" masks...
+
+
 const UNSAFEIsRawValue = (value, mask) => {
+  var _safeValue$split2;
+
   const safeValue = getValueFromEventOrString(value);
-  if (!safeValue)
-    return false;
+  if (!safeValue) return false;
   const rawMask = getRawMask(mask, safeValue);
-  const characterToStrip = rawMask.filter((char) => typeof char === "string");
-  if (safeValue)
-    safeValue?.split("")?.forEach((char) => {
-      const indexCharToStrip = characterToStrip.findIndex((strip) => strip === char);
-      if (indexCharToStrip >= 0) {
-        characterToStrip.splice(indexCharToStrip, 1);
-      }
-    });
+  const characterToStrip = rawMask.filter(char => typeof char === 'string');
+  if (safeValue) safeValue === null || safeValue === void 0 ? void 0 : (_safeValue$split2 = safeValue.split('')) === null || _safeValue$split2 === void 0 ? void 0 : _safeValue$split2.forEach(char => {
+    const indexCharToStrip = characterToStrip.findIndex(strip => strip === char);
+
+    if (indexCharToStrip >= 0) {
+      characterToStrip.splice(indexCharToStrip, 1);
+    }
+  }); // if we matched all the character to strip, this is not a raw value
+  // unsafe, but "good enough" for most masks...
+
   return characterToStrip.length !== 0;
 };
-class DSInputMaskDeprecated extends import_react.Component {
+
+class DSInputMaskDeprecated extends React.Component {
   constructor(props) {
+    var _this;
+
     super(props);
+    _this = this;
     this.lastkey = null;
     this.lastkeycode = null;
-    this.conformValue = (rawValueOrEvent, currentCaretPosition, { skipCaretPositioning = false, skipOnChangeCallback = false } = {}) => {
-      const { previousConformedValue } = this.state;
-      const { onChange, mask, placeholderChar = "_", pipe } = this.props;
-      const rawValue = getValueFromEventOrString(rawValueOrEvent);
+
+    this.conformValue = function (rawValueOrEvent, currentCaretPosition) {
+      let {
+        skipCaretPositioning = false,
+        skipOnChangeCallback = false
+      } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      const {
+        previousConformedValue
+      } = _this.state;
+      const {
+        onChange,
+        mask,
+        placeholderChar = '_',
+        pipe
+      } = _this.props;
+      const rawValue = getValueFromEventOrString(rawValueOrEvent); // short-circuit logic if user cleared the input
+
       if (rawValue.length === 0) {
-        this.setState({
+        _this.setState({
           maskedValue: rawValue,
           previousConformedValue: rawValue,
           focus: true
@@ -98,39 +126,64 @@ class DSInputMaskDeprecated extends import_react.Component {
               value: rawValue,
               originalValue: rawValue
             },
-            lastkey: this.lastkey
+            lastkey: _this.lastkey
           };
           onChange(event);
         });
+
         return;
       }
+
       const rawMaskWithTraps = getRawMask(mask, rawValue);
-      const rawMask = rawMaskWithTraps.filter((val) => val !== "[]");
-      const conformToMaskResults = (0, import_text_mask_core.conformToMask)(rawValue, rawMask, {
+      const rawMask = rawMaskWithTraps.filter(val => val !== '[]'); // generate the final result we want to put in the state and in the input box
+
+      const conformToMaskResults = textMaskCore.conformToMask(rawValue, rawMask, _objectSpread({
         guide: false,
-        placeholderChar,
-        ...previousConformedValue && { previousConformedValue }
-      });
-      const { conformedValue: pipelessConformed } = conformToMaskResults;
+        placeholderChar
+      }, previousConformedValue && {
+        previousConformedValue
+      }));
+      const {
+        conformedValue: pipelessConformed
+      } = conformToMaskResults; // when the last character must be always preserved we need to manually ensure it
+      //  because
+      //    conformToMask -> guide: false will interpeter the last character
+      //     will remove the last character if it's part of the mask
+      //   we may want to add a prop for this in the future?
+      //   this is used for example with "decimal" and "percentage" masks
+
       let conformedValueEnsureLastMaskChar = pipelessConformed;
       const lastMaskChar = rawMask[rawMask.length - 1];
       const lastValueChar = pipelessConformed.charAt(pipelessConformed.length - 1);
-      if (typeof lastMaskChar === "string" && lastMaskChar !== lastValueChar) {
+
+      if (typeof lastMaskChar === 'string' && lastMaskChar !== lastValueChar) {
         conformedValueEnsureLastMaskChar = pipelessConformed + lastMaskChar;
       }
+
       let pipeResult = {
         indexesOfPipedChars: [],
         value: conformedValueEnsureLastMaskChar,
         valid: true
       };
-      if (typeof pipe === "function")
-        pipeResult = pipe()(conformedValueEnsureLastMaskChar);
-      const conformedValue = pipeResult.valid ? pipeResult.value : previousConformedValue;
-      const generatedPlaceHolder = (0, import_text_mask_core.conformToMask)("", rawMask, {
+      if (typeof pipe === 'function') pipeResult = pipe()(conformedValueEnsureLastMaskChar); // if the pipe results in an invalid value, we don't allow the change
+      //   meaning the final result will be like the user never tried to change the input
+      //   this is because the user will have to inject the validation in his pipe
+      //   probably pipe is never used, because this never worked before...
+      //   we will deprecate the "pipe" props in the future
+
+      const conformedValue = pipeResult.valid ? pipeResult.value : previousConformedValue; // generate the "placeholder" used in calculating new caret position
+      // this means we need
+      //   empty string as a value
+      //   guide:true
+      //   we can ignore "previousConformedValue" parameter
+
+      const generatedPlaceHolder = textMaskCore.conformToMask('', rawMask, {
         guide: true,
         placeholderChar
       });
-      const { indexesOfPipedChars } = pipeResult;
+      const {
+        indexesOfPipedChars
+      } = pipeResult;
       const adjustCaretPositionOpts = {
         previousConformedValue,
         conformedValue,
@@ -141,8 +194,9 @@ class DSInputMaskDeprecated extends import_react.Component {
         indexesOfPipedChars,
         caretTrapIndexes: []
       };
-      const caretPos = (0, import_text_mask_core.adjustCaretPosition)(adjustCaretPositionOpts);
-      this.setState({
+      const caretPos = textMaskCore.adjustCaretPosition(adjustCaretPositionOpts);
+
+      _this.setState({
         maskedValue: conformedValue,
         previousConformedValue: conformedValue,
         focus: true
@@ -152,65 +206,95 @@ class DSInputMaskDeprecated extends import_react.Component {
             value: conformedValue,
             originalValue: rawValue
           },
-          lastkey: this.lastkey
+          lastkey: _this.lastkey
         };
-        if (!skipOnChangeCallback)
-          onChange(event);
-        if (!skipCaretPositioning)
-          setTimeout(() => (0, import_setCaretPosition.setCaretPosition)(this.inputref, caretPos));
+        if (!skipOnChangeCallback) onChange(event);
+        if (!skipCaretPositioning) setTimeout(() => setCaretPosition(_this.inputref, caretPos));
       });
     };
-    this.handleOnChange = (e) => {
-      const rawValue = e?.target?.value || "";
-      const { selectionEnd } = e.target;
+
+    this.handleOnChange = e => {
+      var _e$target;
+
+      const rawValue = (e === null || e === void 0 ? void 0 : (_e$target = e.target) === null || _e$target === void 0 ? void 0 : _e$target.value) || '';
+      const {
+        selectionEnd
+      } = e.target;
       const currentCaretPosition = selectionEnd;
       this.conformValue(rawValue, currentCaretPosition);
     };
-    this.handleKeyDown = (e) => {
+
+    this.handleKeyDown = e => {
       e.stopPropagation();
-      const { onKeyDown } = this.props;
+      const {
+        onKeyDown
+      } = this.props;
       this.lastkey = e.key;
       this.lastkeycode = e.keyCode;
       onKeyDown(e);
     };
-    this.handleBlur = (e) => {
-      const { onBlur } = this.props;
-      this.setState({ focus: false });
+
+    this.handleBlur = e => {
+      const {
+        onBlur
+      } = this.props;
+      this.setState({
+        focus: false
+      });
       onBlur(e);
     };
-    this.inputref = import_react.default.createRef();
+
+    this.inputref = /*#__PURE__*/React__default["default"].createRef();
     this.state = {
-      maskedValue: "",
-      previousConformedValue: ""
+      maskedValue: '',
+      previousConformedValue: ''
     };
     this.conformValue = this.conformValue.bind(this);
   }
+
   componentDidMount() {
-    const { value, mask } = this.props;
+    const {
+      value,
+      mask
+    } = this.props;
     const isAlreadyRaw = UNSAFEIsRawValue(value, mask);
     const rawVal = isAlreadyRaw ? value : UNSAFEGetRawValue(value, mask);
-    if (rawVal === "")
-      return;
+    if (rawVal === '') return; // if value from props is raw, we invoke onChange
+    //  not invoking onChange on a raw value breaks the internal components depending on this...
+
     const shouldSkipOnChange = !isAlreadyRaw;
     this.conformValue(rawVal, rawVal.length, {
       skipCaretPositioning: true,
       skipOnChangeCallback: shouldSkipOnChange
     });
   }
+
   componentDidUpdate(prevProps) {
-    const { value: prevValOrEvent, mask: prevMask } = prevProps;
-    const { value: valOrEvent, mask } = this.props;
+    // ensure the mask is re-applied when value/mask props changes.
+    // this is required by internal implementations like DSDateRangePicker
+    const {
+      value: prevValOrEvent,
+      mask: prevMask
+    } = prevProps;
+    const {
+      value: valOrEvent,
+      mask
+    } = this.props;
     const value = getValueFromEventOrString(valOrEvent);
     const isAlreadyRaw = UNSAFEIsRawValue(value, mask);
     const rawVal = isAlreadyRaw ? value : UNSAFEGetRawValue(value, mask);
-    if (rawVal === "")
-      return;
+    if (rawVal === '') return;
     const rawMask = getRawMask(mask, rawVal);
     const prevVal = getValueFromEventOrString(prevValOrEvent);
     const prevIsAlreadyRaw = UNSAFEIsRawValue(prevVal, prevMask);
     const prevRawVal = prevIsAlreadyRaw ? prevVal : UNSAFEGetRawValue(prevVal, prevMask);
-    const prevRawMask = getRawMask(prevMask, prevRawVal);
-    if (prevVal !== value || !(0, import_lodash.isEqual)(prevRawMask, rawMask)) {
+    const prevRawMask = getRawMask(prevMask, prevRawVal); // we need to compare "raw" masks, because mask sometimes are functions
+    //  and if we don't compare raw mask, isEqual will produce unexpected result
+    //  which would lead to infinite loops
+
+    if (prevVal !== value || !lodash.isEqual(prevRawMask, rawMask)) {
+      // if value from props is raw, we invoke onChange
+      //  not invoking onChange on a raw value breaks the internal components depending on this...
       const shouldSkipOnChange = !isAlreadyRaw;
       this.conformValue(rawVal, rawVal.length, {
         skipCaretPositioning: true,
@@ -218,8 +302,10 @@ class DSInputMaskDeprecated extends import_react.Component {
       });
     }
   }
+
   render() {
-    const {
+    const _this$props = this.props,
+          {
       autoFocus,
       style,
       disabled,
@@ -243,69 +329,50 @@ class DSInputMaskDeprecated extends import_react.Component {
       clearable = false,
       leftComponent,
       rightComponent,
-      value,
-      ...rest
-    } = this.props;
-    const { maskedValue, focus } = this.state;
+      value
+    } = _this$props,
+          rest = _objectWithoutProperties__default["default"](_this$props, _excluded);
+
+    const {
+      maskedValue,
+      focus
+    } = this.state; // if component is "controlled" we print the value from the props
+    // if it's not controlled we use the internal state
+    // handleOnChange has the logic to invoke the onChange with the mask applied
+    // if the dev controls the component but pass down a value not conformed to the mask
+    // it's a problem to be fixed on the dev side.
+    // this means no "get derived state from props" mumbo-jumbos
+
     const propsValue = getValueFromEventOrString(value);
-    const finalValue = typeof propsValue === "string" || typeof propsValue === "number" ? propsValue : maskedValue;
-    return /* @__PURE__ */ import_react.default.createElement(import_TextBox.DSTextBox, {
-      ...rest,
-      "aria-label": rest["aria-label"],
-      className,
-      clearable,
-      disabled,
-      fluidWidth,
-      hasError,
+    const finalValue = typeof propsValue === 'string' || typeof propsValue === 'number' ? propsValue : maskedValue;
+    return /*#__PURE__*/jsxRuntime.jsx(DSTextBox["default"], _objectSpread(_objectSpread({}, rest), {}, {
+      "aria-label": rest['aria-label'],
+      className: className,
+      clearable: clearable,
+      disabled: disabled,
+      fluidWidth: fluidWidth,
+      hasError: hasError,
       isActive: focus,
-      leftComponent,
-      maxLength,
-      minLength,
-      name,
+      leftComponent: leftComponent,
+      maxLength: maxLength,
+      minLength: minLength,
+      name: name,
       onBlur: this.handleBlur,
       onChange: this.handleOnChange,
-      onClick,
-      onFocus,
+      onClick: onClick,
+      onFocus: onFocus,
       onKeyDown: this.handleKeyDown,
-      onKeyUp,
-      onPaste,
-      placeholder,
-      readOnly,
-      rightComponent,
-      style,
-      type,
+      onKeyUp: onKeyUp,
+      onPaste: onPaste,
+      placeholder: placeholder,
+      readOnly: readOnly,
+      rightComponent: rightComponent,
+      style: style,
+      type: type,
       value: finalValue
-    });
+    }));
   }
+
 }
-DSInputMaskDeprecated.propTypes = {
-  autoFocus: import_prop_types.default.bool,
-  style: import_prop_types.default.object,
-  disabled: import_prop_types.default.bool,
-  className: import_prop_types.default.string,
-  name: import_prop_types.default.string,
-  maxLength: import_prop_types.default.number,
-  minLength: import_prop_types.default.number,
-  fluidWidth: import_prop_types.default.bool,
-  placeholder: import_prop_types.default.string,
-  value: import_prop_types.default.string,
-  onChange: import_prop_types.default.func,
-  onKeyDown: import_prop_types.default.func,
-  leftComponent: import_prop_types.default.element,
-  rightComponent: import_prop_types.default.element,
-  onFocus: import_prop_types.default.func,
-  onBlur: import_prop_types.default.func,
-  onPaste: import_prop_types.default.func,
-  onKeyUp: import_prop_types.default.func,
-  hasError: import_prop_types.default.bool,
-  readOnly: import_prop_types.default.bool,
-  onClick: import_prop_types.default.func,
-  clearable: import_prop_types.default.bool,
-  type: import_prop_types.default.string,
-  innerRef: import_prop_types.default.any,
-  mask: import_prop_types.default.any,
-  placeholderChar: import_prop_types.default.string
-};
-var DSInputMaskDeprecated_default = DSInputMaskDeprecated;
-module.exports = __toCommonJS(DSInputMaskDeprecated_exports);
-//# sourceMappingURL=DSInputMaskDeprecated.js.map
+
+module.exports = DSInputMaskDeprecated;

package/cjs/InputMask/InputMaskContext.js

@@ -1,47 +1,29 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
-  }
-  return target;
-};
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
-var InputMaskContext_exports = {};
-__export(InputMaskContext_exports, {
-  InputMaskContext: () => InputMaskContext
-});
-var React = __toESM(require("react"));
-var import_react = __toESM(require("react"));
-const InputMaskContext = import_react.default.createContext({
-  rawValue: "",
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+const InputMaskContext = /*#__PURE__*/React__default["default"].createContext({
+  rawValue: '',
   setRawValue: () => null,
   rawMask: null,
   setRawMask: () => null,
   focus: false,
   setFocus: () => null,
-  lastkey: { code: null, key: null },
+  lastkey: {
+    code: null,
+    key: null
+  },
   setLastkey: () => null,
-  cursorPosition: { current: 0 },
+  cursorPosition: {
+    current: 0
+  },
   setCursorPosition: () => null
 });
-module.exports = __toCommonJS(InputMaskContext_exports);
-//# sourceMappingURL=InputMaskContext.js.map
+
+exports.InputMaskContext = InputMaskContext;

package/cjs/InputMask/MaskPipes.js

@@ -1,40 +1,13 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
-  }
-  return target;
-};
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
-var MaskPipes_exports = {};
-__export(MaskPipes_exports, {
-  MASK_PIPES: () => MASK_PIPES,
-  maskPipes: () => maskPipes
-});
-var React = __toESM(require("react"));
-var import_AutoCorrectedDatePipe = __toESM(require("./addons/AutoCorrectedDatePipe"));
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var AutoCorrectedDatePipe = require('./addons/AutoCorrectedDatePipe.js');
+
 const MASK_PIPES = {
-  AUTO_CORRECT_DATE: import_AutoCorrectedDatePipe.autoCorrectedDatePipe
+  AUTO_CORRECT_DATE: AutoCorrectedDatePipe.autoCorrectedDatePipe
 };
 const maskPipes = [MASK_PIPES.AUTO_CORRECT_DATE];
-module.exports = __toCommonJS(MaskPipes_exports);
-//# sourceMappingURL=MaskPipes.js.map
+
+exports.MASK_PIPES = MASK_PIPES;
+exports.maskPipes = maskPipes;