@elliemae/ds-controlled-form 3.0.0-alpha.3 → 3.0.0-next.11

package/dist/cjs/mask-hook/hooks/useZipCode.js

@@ -0,0 +1,77 @@
+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 useZipCode_exports = {};
+__export(useZipCode_exports, {
+  UseZipCodeMaskWithSchema: () => UseZipCodeMaskWithSchema,
+  useZipCode: () => useZipCode
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+var import_ds_utilities = require("@elliemae/ds-utilities");
+var import_utils = require("../utils");
+var import_react_desc_prop_types = require("../react-desc-prop-types");
+const zipCodeSpecialChars = [["-", 5]];
+const conformValue = (rawValue, cursorPos, lastKeyCode) => {
+  let maskedValue = rawValue.split("").filter((char) => char >= "0" && char <= "9");
+  maskedValue = maskedValue.slice(0, 6);
+  const maskedPos = (0, import_utils.getPartialMaskedPos)(rawValue, maskedValue, cursorPos);
+  return (0, import_utils.addSpecialCharacters)(maskedValue, zipCodeSpecialChars, maskedPos, lastKeyCode);
+};
+const useZipCode = (props) => {
+  const propsWithDefault = (0, import_ds_props_helpers.useMemoMergePropsWithDefault)(props, import_react_desc_prop_types.DSMaskHookDefaultProps);
+  (0, import_ds_props_helpers.useValidateTypescriptPropTypes)(propsWithDefault, import_react_desc_prop_types.DSMaskHookPropsTypes);
+  const { valueSetter, onChange: userOnChange, onKeyDown: userOnKeyDown } = propsWithDefault;
+  const lastKeyCode = (0, import_react.useRef)("Unidentified");
+  const scheduleAfterRender = (0, import_ds_utilities.useCallbackAfterRender)();
+  const [, setKey] = (0, import_react.useState)(0);
+  const onKeyDown = (0, import_react.useCallback)((e) => {
+    lastKeyCode.current = e.code;
+    if (userOnKeyDown)
+      userOnKeyDown(e);
+  }, [userOnKeyDown]);
+  const onChange = (0, import_react.useCallback)((e) => {
+    const [mask, cursorPos] = conformValue(e.target.value, e.target.selectionEnd ?? 0, lastKeyCode.current);
+    valueSetter((prevMask) => {
+      if (mask === prevMask)
+        setKey((key) => key + 1);
+      return mask;
+    });
+    if (userOnChange)
+      userOnChange(e, mask);
+    scheduleAfterRender(() => (0, import_utils.setCursorPosition)(e.target, cursorPos));
+  }, [valueSetter, scheduleAfterRender, userOnChange]);
+  return {
+    onKeyDown,
+    onChange
+  };
+};
+const UseZipCodeMaskWithSchema = (0, import_ds_props_helpers.describe)(useZipCode);
+UseZipCodeMaskWithSchema.propTypes = import_react_desc_prop_types.DSMaskHookPropsTypes;
+module.exports = __toCommonJS(useZipCode_exports);
+//# sourceMappingURL=useZipCode.js.map

package/dist/cjs/mask-hook/hooks/useZipCode.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/mask-hook/hooks/useZipCode.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React, { useCallback, useRef, useState } from 'react';\nimport { describe, useMemoMergePropsWithDefault, useValidateTypescriptPropTypes } from '@elliemae/ds-props-helpers';\nimport { useCallbackAfterRender } from '@elliemae/ds-utilities';\nimport { addSpecialCharacters, getPartialMaskedPos, setCursorPosition } from '../utils';\nimport { DSMaskHookDefaultProps, DSMaskHookPropsTypes, DSMaskT } from '../react-desc-prop-types';\n\nconst zipCodeSpecialChars: [string, number][] = [['-', 5]];\n\nconst conformValue = (rawValue: string, cursorPos: number, lastKeyCode: string) => {\n  // Work with digits only\n  let maskedValue = rawValue.split('').filter((char) => char >= '0' && char <= '9');\n\n  // We only consider first 5 digits\n  maskedValue = maskedValue.slice(0, 6);\n\n  const maskedPos = getPartialMaskedPos(rawValue, maskedValue, cursorPos);\n\n  return addSpecialCharacters(maskedValue, zipCodeSpecialChars, maskedPos, lastKeyCode);\n};\n\nexport const useZipCode: DSMaskT.Hook = (props) => {\n  const propsWithDefault = useMemoMergePropsWithDefault(props, DSMaskHookDefaultProps);\n  useValidateTypescriptPropTypes(propsWithDefault, DSMaskHookPropsTypes);\n\n  const { valueSetter, onChange: userOnChange, onKeyDown: userOnKeyDown } = propsWithDefault;\n\n  const lastKeyCode = useRef('Unidentified');\n\n  const scheduleAfterRender = useCallbackAfterRender();\n\n  // Some times, the value of the mask is not gonna change (user types invalid char for example)\n  // This makes the input to go from \"correct\" -> \"incorrect\" -> \"correct\"\n  // But since the input is controlled, the input does not re-render\n  // This makes the input go mumbo-jumbo and places the cursor in the end, because we kinda changed the value async\n  // Solution for this is to trigger a re-render, we do this with a set state call in the on change event\n  const [, setKey] = useState(0);\n\n  const onKeyDown: React.KeyboardEventHandler<HTMLInputElement> = useCallback(\n    (e) => {\n      lastKeyCode.current = e.code;\n      if (userOnKeyDown) userOnKeyDown(e);\n    },\n    [userOnKeyDown],\n  );\n\n  const onChange: React.ChangeEventHandler<HTMLInputElement> = useCallback(\n    (e) => {\n      const [mask, cursorPos] = conformValue(e.target.value, e.target.selectionEnd ?? 0, lastKeyCode.current);\n      valueSetter((prevMask) => {\n        // Here we need to update the key\n        if (mask === prevMask) setKey((key) => key + 1);\n\n        return mask;\n      });\n      if (userOnChange) userOnChange(e, mask);\n      scheduleAfterRender(() => setCursorPosition(e.target, cursorPos));\n    },\n    [valueSetter, scheduleAfterRender, userOnChange],\n  );\n\n  return {\n    onKeyDown,\n    onChange,\n  };\n};\n\nexport const UseZipCodeMaskWithSchema = describe(useZipCode);\nUseZipCodeMaskWithSchema.propTypes = DSMaskHookPropsTypes;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAqD;AACrD,8BAAuF;AACvF,0BAAuC;AACvC,mBAA6E;AAC7E,mCAAsE;AAEtE,MAAM,sBAA0C,CAAC,CAAC,KAAK;AAEvD,MAAM,eAAe,CAAC,UAAkB,WAAmB,gBAAwB;AAEjF,MAAI,cAAc,SAAS,MAAM,IAAI,OAAO,CAAC,SAAS,QAAQ,OAAO,QAAQ;AAG7E,gBAAc,YAAY,MAAM,GAAG;AAEnC,QAAM,YAAY,sCAAoB,UAAU,aAAa;AAE7D,SAAO,uCAAqB,aAAa,qBAAqB,WAAW;AAAA;AAGpE,MAAM,aAA2B,CAAC,UAAU;AACjD,QAAM,mBAAmB,0DAA6B,OAAO;AAC7D,8DAA+B,kBAAkB;AAEjD,QAAM,EAAE,aAAa,UAAU,cAAc,WAAW,kBAAkB;AAE1E,QAAM,cAAc,yBAAO;AAE3B,QAAM,sBAAsB;AAO5B,QAAM,CAAC,EAAE,UAAU,2BAAS;AAE5B,QAAM,YAA0D,8BAC9D,CAAC,MAAM;AACL,gBAAY,UAAU,EAAE;AACxB,QAAI;AAAe,oBAAc;AAAA,KAEnC,CAAC;AAGH,QAAM,WAAuD,8BAC3D,CAAC,MAAM;AACL,UAAM,CAAC,MAAM,aAAa,aAAa,EAAE,OAAO,OAAO,EAAE,OAAO,gBAAgB,GAAG,YAAY;AAC/F,gBAAY,CAAC,aAAa;AAExB,UAAI,SAAS;AAAU,eAAO,CAAC,QAAQ,MAAM;AAE7C,aAAO;AAAA;AAET,QAAI;AAAc,mBAAa,GAAG;AAClC,wBAAoB,MAAM,oCAAkB,EAAE,QAAQ;AAAA,KAExD,CAAC,aAAa,qBAAqB;AAGrC,SAAO;AAAA,IACL;AAAA,IACA;AAAA;AAAA;AAIG,MAAM,2BAA2B,sCAAS;AACjD,yBAAyB,YAAY;",
+  "names": []
+}

package/dist/cjs/mask-hook/index.js

@@ -0,0 +1,28 @@
+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 __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 mask_hook_exports = {};
+var React = __toESM(require("react"));
+__reExport(mask_hook_exports, require("./hooks"));
+module.exports = __toCommonJS(mask_hook_exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/mask-hook/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mask-hook/index.ts", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export * from './hooks';\nexport type { DSMaskT } from './react-desc-prop-types';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;ACAA,YAAuB;ADAvB,8BAAc;",
+  "names": []
+}

package/dist/cjs/mask-hook/react-desc-prop-types.js

@@ -0,0 +1,89 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 react_desc_prop_types_exports = {};
+__export(react_desc_prop_types_exports, {
+  DSMaskHookDefaultProps: () => DSMaskHookDefaultProps,
+  DSMaskHookPropsTypes: () => DSMaskHookPropsTypes,
+  DSMaskNumberHookDefaultProps: () => DSMaskNumberHookDefaultProps,
+  DSMaskNumberHookPropsTypes: () => DSMaskNumberHookPropsTypes,
+  DSMaskPhoneHookDefaultProps: () => DSMaskPhoneHookDefaultProps,
+  DSMaskPhoneHookPropsTypes: () => DSMaskPhoneHookPropsTypes
+});
+var React = __toESM(require("react"));
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+const DSMaskHookDefaultProps = {
+  onChange: () => null,
+  onKeyDown: () => null,
+  onBlur: () => null
+};
+const DSMaskPhoneHookDefaultProps = __spreadProps(__spreadValues({}, DSMaskHookDefaultProps), {
+  isInternational: false
+});
+const DSMaskNumberHookDefaultProps = __spreadProps(__spreadValues({}, DSMaskHookDefaultProps), {
+  suffix: "",
+  prefix: "",
+  decimalPlaces: 2,
+  allowNegative: false,
+  includeThousandsSeparator: true,
+  decimalRequired: false
+});
+const DSMaskHookPropsTypes = {
+  valueSetter: import_ds_props_helpers.PropTypes.func.description("React set state function for the value").isRequired,
+  onChange: import_ds_props_helpers.PropTypes.func.description("Callback for onChange"),
+  onKeyDown: import_ds_props_helpers.PropTypes.func.description("Callback for onKeyDown")
+};
+const DSMaskPhoneHookPropsTypes = __spreadProps(__spreadValues({}, DSMaskHookPropsTypes), {
+  isInternational: import_ds_props_helpers.PropTypes.bool.description("Use or not internaltional phone mask number").defaultValue(false)
+});
+const DSMaskNumberHookPropsTypes = __spreadProps(__spreadValues({}, DSMaskHookPropsTypes), {
+  suffix: import_ds_props_helpers.PropTypes.string.description("String will be added at the end of the input value").defaultValue(""),
+  prefix: import_ds_props_helpers.PropTypes.string.description("String will be added at the start of the input value").defaultValue(""),
+  decimalPlaces: import_ds_props_helpers.PropTypes.number.description("Number of decimals allowed").defaultValue(2),
+  allowNegative: import_ds_props_helpers.PropTypes.bool.description("Wether the input allows negative number").defaultValue(false),
+  includeThousandsSeparator: import_ds_props_helpers.PropTypes.bool.description("Wether the integer part will be separated by thousands").defaultValue(true),
+  decimalRequired: import_ds_props_helpers.PropTypes.bool.description("Wether decimal part is mandatory").defaultValue(false)
+});
+module.exports = __toCommonJS(react_desc_prop_types_exports);
+//# sourceMappingURL=react-desc-prop-types.js.map

package/dist/cjs/mask-hook/react-desc-prop-types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mask-hook/react-desc-prop-types.ts", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { PropTypes } from '@elliemae/ds-props-helpers';\nimport React, { WeakValidationMap } from 'react';\n\nexport declare namespace DSMaskT {\n  interface HookArgs {\n    valueSetter: React.Dispatch<React.SetStateAction<string>>;\n    onChange?: (e: React.ChangeEvent<HTMLInputElement>, mask?: string) => void;\n    onKeyDown?: React.KeyboardEventHandler<HTMLInputElement>;\n    onBlur?: React.FocusEventHandler<HTMLInputElement>;\n  }\n\n  interface HookReturn {\n    onChange: React.ChangeEventHandler<HTMLInputElement>;\n    onKeyDown: React.KeyboardEventHandler<HTMLInputElement>;\n    onBlur?: React.FocusEventHandler<HTMLInputElement>;\n  }\n\n  export interface NumberHookArgs extends HookArgs {\n    suffix: string;\n    prefix: string;\n    decimalPlaces: number;\n    allowNegative: boolean;\n    includeThousandsSeparator: boolean;\n    decimalRequired: boolean;\n  }\n\n  export interface PhoneHookArgs extends HookArgs {\n    isInternational: boolean;\n  }\n\n  export type Hook = (args: HookArgs) => HookReturn;\n  export type PhoneHook = (args: PhoneHookArgs) => HookReturn;\n  export type NumberHook = (args: NumberHookArgs) => HookReturn;\n}\n\nexport const DSMaskHookDefaultProps: Partial<DSMaskT.PhoneHookArgs> = {\n  onChange: () => null,\n  onKeyDown: () => null,\n  onBlur: () => null,\n};\n\nexport const DSMaskPhoneHookDefaultProps: Partial<DSMaskT.PhoneHookArgs> = {\n  ...DSMaskHookDefaultProps,\n  isInternational: false,\n};\n\nexport const DSMaskNumberHookDefaultProps: Partial<DSMaskT.NumberHookArgs> = {\n  ...DSMaskHookDefaultProps,\n  suffix: '',\n  prefix: '',\n  decimalPlaces: 2,\n  allowNegative: false,\n  includeThousandsSeparator: true,\n  decimalRequired: false,\n};\n\nexport const DSMaskHookPropsTypes = {\n  valueSetter: PropTypes.func.description('React set state function for the value').isRequired,\n  onChange: PropTypes.func.description('Callback for onChange'),\n  onKeyDown: PropTypes.func.description('Callback for onKeyDown'),\n} as WeakValidationMap<unknown>;\n\nexport const DSMaskPhoneHookPropsTypes = {\n  ...DSMaskHookPropsTypes,\n  isInternational: PropTypes.bool.description('Use or not internaltional phone mask number').defaultValue(false),\n} as WeakValidationMap<unknown>;\n\nexport const DSMaskNumberHookPropsTypes = {\n  ...DSMaskHookPropsTypes,\n  suffix: PropTypes.string.description('String will be added at the end of the input value').defaultValue(''),\n  prefix: PropTypes.string.description('String will be added at the start of the input value').defaultValue(''),\n  decimalPlaces: PropTypes.number.description('Number of decimals allowed').defaultValue(2),\n  allowNegative: PropTypes.bool.description('Wether the input allows negative number').defaultValue(false),\n  includeThousandsSeparator: PropTypes.bool\n    .description('Wether the integer part will be separated by thousands')\n    .defaultValue(true),\n  decimalRequired: PropTypes.bool.description('Wether decimal part is mandatory').defaultValue(false),\n} as WeakValidationMap<unknown>;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,8BAA0B;AAmCnB,MAAM,yBAAyD;AAAA,EACpE,UAAU,MAAM;AAAA,EAChB,WAAW,MAAM;AAAA,EACjB,QAAQ,MAAM;AAAA;AAGT,MAAM,8BAA8D,iCACtE,yBADsE;AAAA,EAEzE,iBAAiB;AAAA;AAGZ,MAAM,+BAAgE,iCACxE,yBADwE;AAAA,EAE3E,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,eAAe;AAAA,EACf,eAAe;AAAA,EACf,2BAA2B;AAAA,EAC3B,iBAAiB;AAAA;AAGZ,MAAM,uBAAuB;AAAA,EAClC,aAAa,kCAAU,KAAK,YAAY,0CAA0C;AAAA,EAClF,UAAU,kCAAU,KAAK,YAAY;AAAA,EACrC,WAAW,kCAAU,KAAK,YAAY;AAAA;AAGjC,MAAM,4BAA4B,iCACpC,uBADoC;AAAA,EAEvC,iBAAiB,kCAAU,KAAK,YAAY,+CAA+C,aAAa;AAAA;AAGnG,MAAM,6BAA6B,iCACrC,uBADqC;AAAA,EAExC,QAAQ,kCAAU,OAAO,YAAY,sDAAsD,aAAa;AAAA,EACxG,QAAQ,kCAAU,OAAO,YAAY,wDAAwD,aAAa;AAAA,EAC1G,eAAe,kCAAU,OAAO,YAAY,8BAA8B,aAAa;AAAA,EACvF,eAAe,kCAAU,KAAK,YAAY,2CAA2C,aAAa;AAAA,EAClG,2BAA2B,kCAAU,KAClC,YAAY,0DACZ,aAAa;AAAA,EAChB,iBAAiB,kCAAU,KAAK,YAAY,oCAAoC,aAAa;AAAA;",
+  "names": []
+}

package/dist/cjs/mask-hook/utils/addSpecialCharacters.js

@@ -0,0 +1,57 @@
+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 addSpecialCharacters_exports = {};
+__export(addSpecialCharacters_exports, {
+  addSpecialCharacters: () => addSpecialCharacters
+});
+var React = __toESM(require("react"));
+const addSpecialCharacters = (maskWithoutSpecialChars, specialCharsDescr, maskedPos, lastKeyCode) => {
+  const finalMask = maskWithoutSpecialChars;
+  let finalMaskedPos = maskedPos;
+  specialCharsDescr.forEach(([chars, pos]) => {
+    if (finalMask.length > pos) {
+      finalMask.splice(pos, 0, ...chars);
+      if (finalMaskedPos >= pos)
+        finalMaskedPos += chars.length;
+    }
+  });
+  if (lastKeyCode !== "Backspace" && finalMaskedPos < finalMask.length) {
+    specialCharsDescr.forEach(([chars, pos]) => {
+      if (finalMaskedPos === pos)
+        finalMaskedPos += chars.length;
+    });
+  } else if (lastKeyCode === "Backspace" && finalMaskedPos) {
+    specialCharsDescr.forEach(([chars, pos]) => {
+      if (pos + 1 <= finalMaskedPos && finalMaskedPos <= pos + chars.length)
+        finalMaskedPos = pos;
+    });
+  }
+  return [finalMask.join(""), finalMaskedPos];
+};
+module.exports = __toCommonJS(addSpecialCharacters_exports);
+//# sourceMappingURL=addSpecialCharacters.js.map

package/dist/cjs/mask-hook/utils/addSpecialCharacters.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/mask-hook/utils/addSpecialCharacters.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable max-params */\n/**\n *\n * @param {string[]} maskWithoutSpecialChars An array of characters with the unfinished mask\n * @param {[string, number][]} specialCharsDescr An array of tuples. Each tuple contains a string and a position (What string to add in a particular position)\n * @param {number} maskedPos Current masked position\n * @param {string} lastKeyCode Last key code of the user\n * @returns {[string, number]} A tuple containing the final mask and the final masked position\n */\nexport const addSpecialCharacters = (\n  maskWithoutSpecialChars: string[],\n  specialCharsDescr: [string, number][],\n  maskedPos: number,\n  lastKeyCode: string,\n): [string, number] => {\n  const finalMask = maskWithoutSpecialChars;\n  let finalMaskedPos = maskedPos;\n\n  // We insert the special chars in the respective positions, tweaking the masked pos\n  specialCharsDescr.forEach(([chars, pos]) => {\n    if (finalMask.length > pos) {\n      finalMask.splice(pos, 0, ...chars);\n      if (finalMaskedPos >= pos) finalMaskedPos += chars.length;\n    }\n  });\n\n  if (lastKeyCode !== 'Backspace' && finalMaskedPos < finalMask.length) {\n    // If not erasing, move the cursor forward if we are in a special chars area\n    specialCharsDescr.forEach(([chars, pos]) => {\n      if (finalMaskedPos === pos) finalMaskedPos += chars.length;\n    });\n  } else if (lastKeyCode === 'Backspace' && finalMaskedPos) {\n    // If erasing, move the cursor back if we are in a special chars area\n    specialCharsDescr.forEach(([chars, pos]) => {\n      if (pos + 1 <= finalMaskedPos && finalMaskedPos <= pos + chars.length) finalMaskedPos = pos;\n    });\n  }\n\n  return [finalMask.join(''), finalMaskedPos];\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADShB,MAAM,uBAAuB,CAClC,yBACA,mBACA,WACA,gBACqB;AACrB,QAAM,YAAY;AAClB,MAAI,iBAAiB;AAGrB,oBAAkB,QAAQ,CAAC,CAAC,OAAO,SAAS;AAC1C,QAAI,UAAU,SAAS,KAAK;AAC1B,gBAAU,OAAO,KAAK,GAAG,GAAG;AAC5B,UAAI,kBAAkB;AAAK,0BAAkB,MAAM;AAAA;AAAA;AAIvD,MAAI,gBAAgB,eAAe,iBAAiB,UAAU,QAAQ;AAEpE,sBAAkB,QAAQ,CAAC,CAAC,OAAO,SAAS;AAC1C,UAAI,mBAAmB;AAAK,0BAAkB,MAAM;AAAA;AAAA,aAE7C,gBAAgB,eAAe,gBAAgB;AAExD,sBAAkB,QAAQ,CAAC,CAAC,OAAO,SAAS;AAC1C,UAAI,MAAM,KAAK,kBAAkB,kBAAkB,MAAM,MAAM;AAAQ,yBAAiB;AAAA;AAAA;AAI5F,SAAO,CAAC,UAAU,KAAK,KAAK;AAAA;",
+  "names": []
+}

package/dist/cjs/mask-hook/utils/getPartialMaskedPos.js

@@ -0,0 +1,42 @@
+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 getPartialMaskedPos_exports = {};
+__export(getPartialMaskedPos_exports, {
+  getPartialMaskedPos: () => getPartialMaskedPos
+});
+var React = __toESM(require("react"));
+const getPartialMaskedPos = (rawValue, maskWithoutSpecialChars, cursorPos) => {
+  let maskedPos = 0;
+  for (let i = 0; i < cursorPos; i += 1) {
+    if (maskWithoutSpecialChars[maskedPos] === rawValue[i])
+      maskedPos += 1;
+  }
+  return maskedPos;
+};
+module.exports = __toCommonJS(getPartialMaskedPos_exports);
+//# sourceMappingURL=getPartialMaskedPos.js.map

package/dist/cjs/mask-hook/utils/getPartialMaskedPos.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/mask-hook/utils/getPartialMaskedPos.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export const getPartialMaskedPos = (rawValue: string, maskWithoutSpecialChars: string[], cursorPos: number): number => {\n  let maskedPos = 0;\n  for (let i = 0; i < cursorPos; i += 1) {\n    if (maskWithoutSpecialChars[maskedPos] === rawValue[i]) maskedPos += 1;\n  }\n  return maskedPos;\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAhB,MAAM,sBAAsB,CAAC,UAAkB,yBAAmC,cAA8B;AACrH,MAAI,YAAY;AAChB,WAAS,IAAI,GAAG,IAAI,WAAW,KAAK,GAAG;AACrC,QAAI,wBAAwB,eAAe,SAAS;AAAI,mBAAa;AAAA;AAEvE,SAAO;AAAA;",
+  "names": []
+}

package/dist/cjs/mask-hook/utils/index.js

@@ -0,0 +1,31 @@
+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 __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 utils_exports = {};
+var React = __toESM(require("react"));
+__reExport(utils_exports, require("./addSpecialCharacters"));
+__reExport(utils_exports, require("./getPartialMaskedPos"));
+__reExport(utils_exports, require("./setCursorPosition"));
+__reExport(utils_exports, require("./sharedFilters"));
+module.exports = __toCommonJS(utils_exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/mask-hook/utils/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/mask-hook/utils/index.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export * from './addSpecialCharacters';\nexport * from './getPartialMaskedPos';\nexport * from './setCursorPosition';\nexport * from './sharedFilters';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;ACAA,YAAuB;ADAvB,0BAAc;AACd,0BAAc;AACd,0BAAc;AACd,0BAAc;",
+  "names": []
+}

package/dist/cjs/mask-hook/utils/setCursorPosition.js

@@ -0,0 +1,37 @@
+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 setCursorPosition_exports = {};
+__export(setCursorPosition_exports, {
+  setCursorPosition: () => setCursorPosition
+});
+var React = __toESM(require("react"));
+const setCursorPosition = (input, position) => {
+  input.setSelectionRange(position, position, "forward");
+};
+module.exports = __toCommonJS(setCursorPosition_exports);
+//# sourceMappingURL=setCursorPosition.js.map

package/dist/cjs/mask-hook/utils/setCursorPosition.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/mask-hook/utils/setCursorPosition.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export const setCursorPosition = (input: HTMLInputElement, position: number) => {\n  input.setSelectionRange(position, position, 'forward');\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAhB,MAAM,oBAAoB,CAAC,OAAyB,aAAqB;AAC9E,QAAM,kBAAkB,UAAU,UAAU;AAAA;",
+  "names": []
+}

package/dist/cjs/mask-hook/utils/sharedFilters.js

@@ -0,0 +1,35 @@
+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 sharedFilters_exports = {};
+__export(sharedFilters_exports, {
+  filterNumbersOnly: () => filterNumbersOnly
+});
+var React = __toESM(require("react"));
+const filterNumbersOnly = (charactersToFilter) => charactersToFilter.filter((char) => char >= "0" && char <= "9");
+module.exports = __toCommonJS(sharedFilters_exports);
+//# sourceMappingURL=sharedFilters.js.map

package/dist/cjs/mask-hook/utils/sharedFilters.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/mask-hook/utils/sharedFilters.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable max-params */\n/**\n *\n * @param {string[]} charactersToFilter An array of characters to filter from\n * @returns [string] the filtered array including only 0~9 characters\n */\nexport const filterNumbersOnly = (charactersToFilter: string[]): string[] =>\n  charactersToFilter.filter((char) => char >= '0' && char <= '9');\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADMhB,MAAM,oBAAoB,CAAC,uBAChC,mBAAmB,OAAO,CAAC,SAAS,QAAQ,OAAO,QAAQ;",
+  "names": []
+}

package/dist/cjs/text-input/DSInputText.js

@@ -0,0 +1,107 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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 DSInputText_exports = {};
+__export(DSInputText_exports, {
+  DSInputText: () => DSInputText,
+  DSInputTextWithSchema: () => DSInputTextWithSchema
+});
+var React = __toESM(require("react"));
+var import_react = __toESM(require("react"));
+var import_ds_icons = require("@elliemae/ds-icons");
+var import_ds_icon = require("@elliemae/ds-icon");
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+var import_useInputText = require("./config/useInputText");
+var import_data_test_ids = require("./exported-related/data-test-ids");
+var import_react_desc_prop_types = require("./react-desc-prop-types");
+var import_components = require("./styled/components");
+const DSInputText = (props) => {
+  const _a = (0, import_useInputText.useInputText)(props), {
+    globalAttributes: _b
+  } = _a, _c = _b, { className } = _c, otherGlobalAttributes = __objRest(_c, ["className"]), {
+    hasFocus,
+    handlers,
+    propsWithDefault,
+    xstyledProps
+  } = _a;
+  const { clearable, disabled, hasError, innerRef, placeholder, readOnly, inputSize, onClear, value } = propsWithDefault;
+  const shouldDisplayClearButton = clearable && value !== "";
+  return /* @__PURE__ */ import_react.default.createElement(import_components.StyledInputWrapper, __spreadValues({
+    className,
+    cols: shouldDisplayClearButton ? ["auto", "min-content"] : ["auto"],
+    isDisabled: disabled,
+    isReadOnly: readOnly,
+    hasError,
+    hasFocus,
+    inputSize
+  }, xstyledProps), /* @__PURE__ */ import_react.default.createElement(import_components.StyledInput, __spreadValues(__spreadValues({
+    "data-testid": import_data_test_ids.DSInputTextDataTestIds.INPUT,
+    disabled,
+    placeholder,
+    readOnly,
+    ref: innerRef,
+    value
+  }, handlers), otherGlobalAttributes)), shouldDisplayClearButton && /* @__PURE__ */ import_react.default.createElement(import_components.StyledClearButton, {
+    "aria-label": "Clear input value",
+    buttonType: "icon",
+    "data-testid": import_data_test_ids.DSInputTextDataTestIds.CLEAR_BUTTON,
+    onClick: onClear
+  }, /* @__PURE__ */ import_react.default.createElement(import_ds_icons.CloseMedium, {
+    color: import_ds_icon.DSIconColors.PRIMARY
+  })));
+};
+DSInputText.propTypes = import_react_desc_prop_types.DSInputTextPropTypes;
+const DSInputTextWithSchema = (0, import_ds_props_helpers.describe)(DSInputText);
+DSInputTextWithSchema.propTypes = import_react_desc_prop_types.DSInputTextPropTypes;
+module.exports = __toCommonJS(DSInputText_exports);
+//# sourceMappingURL=DSInputText.js.map

package/dist/cjs/text-input/DSInputText.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/text-input/DSInputText.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React from 'react';\nimport { CloseMedium } from '@elliemae/ds-icons';\nimport { DSIconColors } from '@elliemae/ds-icon';\nimport { describe } from '@elliemae/ds-props-helpers';\nimport { useInputText } from './config/useInputText';\nimport { DSInputTextDataTestIds } from './exported-related/data-test-ids';\nimport { DSInputTextPropTypes, DSInputTextT } from './react-desc-prop-types';\nimport { StyledClearButton, StyledInput, StyledInputWrapper } from './styled/components';\n\nexport const DSInputText: React.ComponentType<DSInputTextT.Props> = (props) => {\n  const {\n    globalAttributes: { className, ...otherGlobalAttributes },\n    hasFocus,\n    handlers,\n    propsWithDefault,\n    xstyledProps,\n  } = useInputText(props);\n\n  const { clearable, disabled, hasError, innerRef, placeholder, readOnly, inputSize, onClear, value } =\n    propsWithDefault;\n\n  const shouldDisplayClearButton = clearable && value !== '';\n\n  return (\n    <StyledInputWrapper\n      className={className}\n      cols={shouldDisplayClearButton ? ['auto', 'min-content'] : ['auto']}\n      isDisabled={disabled}\n      isReadOnly={readOnly}\n      hasError={hasError}\n      hasFocus={hasFocus}\n      inputSize={inputSize}\n      {...xstyledProps}\n    >\n      <StyledInput\n        data-testid={DSInputTextDataTestIds.INPUT}\n        disabled={disabled}\n        placeholder={placeholder}\n        readOnly={readOnly}\n        ref={innerRef}\n        value={value}\n        {...handlers}\n        {...otherGlobalAttributes}\n      />\n      {shouldDisplayClearButton && (\n        <StyledClearButton\n          aria-label=\"Clear input value\"\n          buttonType=\"icon\"\n          data-testid={DSInputTextDataTestIds.CLEAR_BUTTON}\n          onClick={onClear}\n        >\n          <CloseMedium color={DSIconColors.PRIMARY} />\n        </StyledClearButton>\n      )}\n    </StyledInputWrapper>\n  );\n};\n\nDSInputText.propTypes = DSInputTextPropTypes;\n\nexport const DSInputTextWithSchema = describe(DSInputText);\nDSInputTextWithSchema.propTypes = DSInputTextPropTypes;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAkB;AAClB,sBAA4B;AAC5B,qBAA6B;AAC7B,8BAAyB;AACzB,0BAA6B;AAC7B,2BAAuC;AACvC,mCAAmD;AACnD,wBAAmE;AAE5D,MAAM,cAAuD,CAAC,UAAU;AAC7E,QAMI,2CAAa,QALG;AAAA,IAAlB,kBAAkB;AAAA,MAKhB,IALgB,SAAE,gBAAF,IAAgB,kCAAhB,IAAgB,CAAd,eAAF;AAAA,IAClB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,MACE;AAEJ,QAAM,EAAE,WAAW,UAAU,UAAU,UAAU,aAAa,UAAU,WAAW,SAAS,UAC1F;AAEF,QAAM,2BAA2B,aAAa,UAAU;AAExD,SACE,mDAAC,sCAAD;AAAA,IACE;AAAA,IACA,MAAM,2BAA2B,CAAC,QAAQ,iBAAiB,CAAC;AAAA,IAC5D,YAAY;AAAA,IACZ,YAAY;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,KACI,eAEJ,mDAAC,+BAAD;AAAA,IACE,eAAa,4CAAuB;AAAA,IACpC;AAAA,IACA;AAAA,IACA;AAAA,IACA,KAAK;AAAA,IACL;AAAA,KACI,WACA,yBAEL,4BACC,mDAAC,qCAAD;AAAA,IACE,cAAW;AAAA,IACX,YAAW;AAAA,IACX,eAAa,4CAAuB;AAAA,IACpC,SAAS;AAAA,KAET,mDAAC,6BAAD;AAAA,IAAa,OAAO,4BAAa;AAAA;AAAA;AAO3C,YAAY,YAAY;AAEjB,MAAM,wBAAwB,sCAAS;AAC9C,sBAAsB,YAAY;",
+  "names": []
+}