intelicoreact 1.6.6 → 1.6.8

package/dist/Atomic/FormElements/InputCalendar/InputCalendar.stories.js

@@ -20,6 +20,19 @@ const _jsxruntime = require("react/jsx-runtime");
 const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
 const _InputCalendar = /*#__PURE__*/ _interop_require_default(require("./InputCalendar"));
 require("../../../../../scss/main.scss");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -66,6 +79,45 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 global.lng = 'en';
 const _default = {
     title: 'Form Elements/Input Calendar',
@@ -82,12 +134,11 @@ const Template = (args)=>{
     return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
         children: [
             /*#__PURE__*/ (0, _jsxruntime.jsx)("input", {}),
-            /*#__PURE__*/ (0, _jsxruntime.jsx)(_InputCalendar.default, {
-                ...args,
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(_InputCalendar.default, _object_spread_props(_object_spread({}, args), {
                 value: date,
                 onChange: (val)=>setDate(val),
                 disabled: disabled
-            }),
+            })),
             /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
                 style: {
                     display: 'flex',
@@ -113,3 +164,5 @@ CalendarTemplate.args = {
     minDate: '01/10/1990',
     maxDate: '04/20/2022'
 };
+
+//# sourceMappingURL=InputCalendar.stories.js.map

package/dist/Atomic/FormElements/InputCalendar/InputCalendar.stories.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/Atomic/FormElements/InputCalendar/InputCalendar.stories.js"],"sourcesContent":["import React, {useState} from 'react';\n\nimport InputCalendar from './InputCalendar';\n\nimport '../../../../../scss/main.scss';\n\nglobal.lng = 'en';\n\nexport default {\n  title: 'Form Elements/Input Calendar',\n  component: InputCalendar,\n  argTypes: {\n    value: {\n      description: 'string (mm.dd.yyyy)',\n    },\n  },\n};\n\nconst Template = args => {\n  const [date, setDate] = useState('');\n  const [disabled, setDisabled] = useState(false);\n\n  return (\n    <>\n      <input />\n      <InputCalendar {...args} value={date} onChange={val => setDate(val)} disabled={disabled} />\n      <div style={{display: 'flex', flexFlow: 'row nowrap', justifyContent: 'flex-end', marginTop: '10px'}}>\n        <button\n          style={{border: 'solid 1px black', padding: '10px', width: '80px'}}\n          onClick={() => setDisabled(!disabled)}\n        >\n          {disabled ? 'Enable' : 'Disable'}\n        </button>\n      </div>\n    </>\n  );\n};\n\nexport const CalendarTemplate = Template.bind({});\n\nCalendarTemplate.args = {\n  minDate: '01/10/1990',\n  maxDate: '04/20/2022',\n  // isDontLimitFuture: true,\n  // isListTop: true,\n};\n"],"names":["CalendarTemplate","global","lng","title","component","InputCalendar","argTypes","value","description","Template","args","date","setDate","useState","disabled","setDisabled","input","onChange","val","div","style","display","flexFlow","justifyContent","marginTop","button","border","padding","width","onClick","bind","minDate","maxDate"],"mappings":";;;;;;;;;;;IAsCaA,gBAAgB;eAAhBA;;IA9Bb,OAQE;eARF;;;;+DAR8B;sEAEJ;QAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEPC,OAAOC,GAAG,GAAG;MAEb,WAAe;IACbC,OAAO;IACPC,WAAWC,sBAAa;IACxBC,UAAU;QACRC,OAAO;YACLC,aAAa;QACf;IACF;AACF;AAEA,MAAMC,WAAWC,CAAAA;IACf,MAAM,CAACC,MAAMC,QAAQ,GAAGC,IAAAA,eAAQ,EAAC;IACjC,MAAM,CAACC,UAAUC,YAAY,GAAGF,IAAAA,eAAQ,EAAC;IAEzC,qBACE;;0BACE,qBAACG;0BACD,qBAACX,sBAAa,0CAAKK;gBAAMH,OAAOI;gBAAMM,UAAUC,CAAAA,MAAON,QAAQM;gBAAMJ,UAAUA;;0BAC/E,qBAACK;gBAAIC,OAAO;oBAACC,SAAS;oBAAQC,UAAU;oBAAcC,gBAAgB;oBAAYC,WAAW;gBAAM;0BACjG,cAAA,qBAACC;oBACCL,OAAO;wBAACM,QAAQ;wBAAmBC,SAAS;wBAAQC,OAAO;oBAAM;oBACjEC,SAAS,IAAMd,YAAY,CAACD;8BAE3BA,WAAW,WAAW;;;;;AAKjC;AAEO,MAAMd,mBAAmBS,SAASqB,IAAI,CAAC,CAAC;AAE/C9B,iBAAiBU,IAAI,GAAG;IACtBqB,SAAS;IACTC,SAAS;AAGX"}

package/dist/Atomic/FormElements/InputColor/InputColor.js

@@ -14,15 +14,104 @@ const _classnames = /*#__PURE__*/ _interop_require_default(require("classnames")
 const _fieldValueFormatters = require("../../../Functions/fieldValueFormatters");
 const _Input = /*#__PURE__*/ _interop_require_default(require("../Input/Input"));
 require("./InputColor.scss");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-const InputColor = ({ value, className, symbolsLimit = 7, onChange, withHexFormat = {
-    withSharp: false,
-    isTurnOn: true
-}, initialHexOfColorBlock = "#9AA0B9", testId = "", withDelete = true, ...args })=>{
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+const InputColor = (_param)=>{
+    var { value, className, symbolsLimit = 7, onChange, withHexFormat = {
+        withSharp: false,
+        isTurnOn: true
+    }, initialHexOfColorBlock = "#9AA0B9", testId = "", withDelete = true } = _param, args = _object_without_properties(_param, [
+        "value",
+        "className",
+        "symbolsLimit",
+        "onChange",
+        "withHexFormat",
+        "initialHexOfColorBlock",
+        "testId",
+        "withDelete"
+    ]);
     const { withSharp, isTurnOn: isHex } = withHexFormat;
     // HANDLES
     const handle = {
@@ -46,8 +135,7 @@ const InputColor = ({ value, className, symbolsLimit = 7, onChange, withHexForma
                     backgroundColor: value && value.length === 7 ? value : initialHexOfColorBlock
                 }
             }),
-            /*#__PURE__*/ (0, _jsxruntime.jsx)(_Input.default, {
-                ...args,
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(_Input.default, _object_spread_props(_object_spread({}, args), {
                 value: value,
                 withDelete: withDelete,
                 onChange: handle.change,
@@ -55,8 +143,10 @@ const InputColor = ({ value, className, symbolsLimit = 7, onChange, withHexForma
                 testId: `inputColor--key-${testId}`,
                 className: (0, _classnames.default)("input inputColor__input"),
                 type: "text"
-            })
+            }))
         ]
     });
 };
 const _default = InputColor;
+
+//# sourceMappingURL=InputColor.js.map

package/dist/Atomic/FormElements/InputColor/InputColor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/Atomic/FormElements/InputColor/InputColor.js"],"sourcesContent":["import React from \"react\";\n\nimport cn from \"classnames\";\n\nimport {\n  formatToHex,\n  formatToOnlyASCIICodeText,\n} from \"../../../Functions/fieldValueFormatters\";\nimport Input from \"../Input/Input\";\n\nimport \"./InputColor.scss\";\n\nconst InputColor = ({\n  value,\n  className,\n  symbolsLimit = 7,\n  onChange,\n  withHexFormat = {\n    withSharp: false,\n    isTurnOn: true,\n  },\n  initialHexOfColorBlock = \"#9AA0B9\",\n  testId = \"\",\n  withDelete = true,\n  ...args\n}) => {\n  const { withSharp, isTurnOn: isHex } = withHexFormat;\n  // HANDLES\n  const handle = {\n    change: (e) => {\n      let inputValue = e?.target ? e.target.value : e;\n      inputValue = formatToOnlyASCIICodeText(inputValue);\n      if (isHex) inputValue = formatToHex({ inputValue, withSharp: withSharp });\n      if (symbolsLimit && inputValue.length > Number(symbolsLimit))\n        inputValue = inputValue.substring(0, Number(symbolsLimit));\n\n      onChange?.(inputValue);\n    },\n  };\n\n  return (\n    <div className={cn(\"inputColor\", className)}>\n      <div\n        className={cn(\"inputColor__color-block\")}\n        style={{\n          backgroundColor:\n            value && value.length === 7 ? value : initialHexOfColorBlock,\n        }}\n      />\n      <Input\n        {...args}\n        value={value}\n        withDelete={withDelete}\n        onChange={handle.change}\n        symbolsLimit={symbolsLimit || 7}\n        testId={`inputColor--key-${testId}`}\n        className={cn(\"input inputColor__input\")}\n        type=\"text\"\n      />\n    </div>\n  );\n};\n\nexport default InputColor;\n"],"names":["InputColor","value","className","symbolsLimit","onChange","withHexFormat","withSharp","isTurnOn","initialHexOfColorBlock","testId","withDelete","args","isHex","handle","change","e","inputValue","target","formatToOnlyASCIICodeText","formatToHex","length","Number","substring","div","cn","style","backgroundColor","Input","type"],"mappings":";;;;+BA+DA;;;eAAA;;;;8DA/DkB;mEAEH;sCAKR;8DACW;QAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEP,MAAMA,aAAa;QAAC,EAClBC,KAAK,EACLC,SAAS,EACTC,eAAe,CAAC,EAChBC,QAAQ,EACRC,gBAAgB;QACdC,WAAW;QACXC,UAAU;IACZ,CAAC,EACDC,yBAAyB,SAAS,EAClCC,SAAS,EAAE,EACXC,aAAa,IAAI,EAElB,WADIC;QAXHV;QACAC;QACAC;QACAC;QACAC;QAIAG;QACAC;QACAC;;IAGA,MAAM,EAAEJ,SAAS,EAAEC,UAAUK,KAAK,EAAE,GAAGP;IACvC,UAAU;IACV,MAAMQ,SAAS;QACbC,QAAQ,CAACC;YACP,IAAIC,aAAaD,CAAAA,cAAAA,wBAAAA,EAAGE,MAAM,IAAGF,EAAEE,MAAM,CAAChB,KAAK,GAAGc;YAC9CC,aAAaE,IAAAA,+CAAyB,EAACF;YACvC,IAAIJ,OAAOI,aAAaG,IAAAA,iCAAW,EAAC;gBAAEH;gBAAYV,WAAWA;YAAU;YACvE,IAAIH,gBAAgBa,WAAWI,MAAM,GAAGC,OAAOlB,eAC7Ca,aAAaA,WAAWM,SAAS,CAAC,GAAGD,OAAOlB;YAE9CC,qBAAAA,+BAAAA,SAAWY;QACb;IACF;IAEA,qBACE,sBAACO;QAAIrB,WAAWsB,IAAAA,mBAAE,EAAC,cAActB;;0BAC/B,qBAACqB;gBACCrB,WAAWsB,IAAAA,mBAAE,EAAC;gBACdC,OAAO;oBACLC,iBACEzB,SAASA,MAAMmB,MAAM,KAAK,IAAInB,QAAQO;gBAC1C;;0BAEF,qBAACmB,cAAK,0CACAhB;gBACJV,OAAOA;gBACPS,YAAYA;gBACZN,UAAUS,OAAOC,MAAM;gBACvBX,cAAcA,gBAAgB;gBAC9BM,QAAQ,CAAC,gBAAgB,EAAEA,QAAQ;gBACnCP,WAAWsB,IAAAA,mBAAE,EAAC;gBACdI,MAAK;;;;AAIb;MAEA,WAAe5B"}

package/dist/Atomic/FormElements/InputColor/InputColor.stories.js

@@ -20,6 +20,19 @@ const _jsxruntime = require("react/jsx-runtime");
 const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
 const _InputColor = /*#__PURE__*/ _interop_require_default(require("./InputColor"));
 require("../../../../../scss/main.scss");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -66,6 +79,45 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 global.lng = 'en';
 const _default = {
     title: 'Form Elements/InputColor',
@@ -99,11 +151,10 @@ const _default = {
 };
 const Template = (args)=>{
     const [value, setValue] = (0, _react.useState)('');
-    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_InputColor.default, {
-        ...args,
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_InputColor.default, _object_spread_props(_object_spread({}, args), {
         value: value,
         onChange: (e)=>setValue(e)
-    });
+    }));
 };
 const InputTemplate = Template.bind({});
 InputTemplate.args = {
@@ -117,3 +168,5 @@ InputTemplate.args = {
     error: '',
     disabled: false
 };
+
+//# sourceMappingURL=InputColor.stories.js.map

package/dist/Atomic/FormElements/InputColor/InputColor.stories.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/Atomic/FormElements/InputColor/InputColor.stories.js"],"sourcesContent":["import React, {useState} from 'react';\nimport InputColor from './InputColor';\n\nimport '../../../../../scss/main.scss';\n\nglobal.lng = 'en';\n\nexport default {\n  title: 'Form Elements/InputColor',\n  component: InputColor,\n  argTypes: {\n    disabled: {\n      description: 'boolean',\n    },\n    initialHexColorBlock: {\n      description: 'string - initial color (placeholder) of color block',\n    },\n    error: {\n      description: 'text - coloring input if is errored',\n    },\n    withDelete: {\n      description: 'boolean - add clear-cross by hover',\n    },\n    placeholder: {\n      description: 'text',\n    },\n    value: {description: '(* - required prop)'},\n    className: {description: 'string'},\n    symbolsLimit: {\n      description: 'Set limit of symbols in input, overhead will be ignored',\n    },\n  },\n};\n\nconst Template = args => {\n  const [value, setValue] = useState('');\n  return <InputColor {...args} value={value} onChange={e => setValue(e)} />;\n};\n\nexport const InputTemplate = Template.bind({});\n\nInputTemplate.args = {\n  withHexFormat: {\n    isTurnOn: true,\n    withSharp: true,\n  },\n  symbolsLimit: 7,\n  placeholder: '#',\n  initialHexOfColorBlock: '#9AA0B9',\n  error: '',\n  disabled: false,\n};\n"],"names":["InputTemplate","global","lng","title","component","InputColor","argTypes","disabled","description","initialHexColorBlock","error","withDelete","placeholder","value","className","symbolsLimit","Template","args","setValue","useState","onChange","e","bind","withHexFormat","isTurnOn","withSharp","initialHexOfColorBlock"],"mappings":";;;;;;;;;;;IAuCaA,aAAa;eAAbA;;IAhCb,OAyBE;eAzBF;;;;+DAP8B;mEACP;QAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEPC,OAAOC,GAAG,GAAG;MAEb,WAAe;IACbC,OAAO;IACPC,WAAWC,mBAAU;IACrBC,UAAU;QACRC,UAAU;YACRC,aAAa;QACf;QACAC,sBAAsB;YACpBD,aAAa;QACf;QACAE,OAAO;YACLF,aAAa;QACf;QACAG,YAAY;YACVH,aAAa;QACf;QACAI,aAAa;YACXJ,aAAa;QACf;QACAK,OAAO;YAACL,aAAa;QAAqB;QAC1CM,WAAW;YAACN,aAAa;QAAQ;QACjCO,cAAc;YACZP,aAAa;QACf;IACF;AACF;AAEA,MAAMQ,WAAWC,CAAAA;IACf,MAAM,CAACJ,OAAOK,SAAS,GAAGC,IAAAA,eAAQ,EAAC;IACnC,qBAAO,qBAACd,mBAAU,0CAAKY;QAAMJ,OAAOA;QAAOO,UAAUC,CAAAA,IAAKH,SAASG;;AACrE;AAEO,MAAMrB,gBAAgBgB,SAASM,IAAI,CAAC,CAAC;AAE5CtB,cAAciB,IAAI,GAAG;IACnBM,eAAe;QACbC,UAAU;QACVC,WAAW;IACb;IACAV,cAAc;IACdH,aAAa;IACbc,wBAAwB;IACxBhB,OAAO;IACPH,UAAU;AACZ"}

package/dist/Atomic/FormElements/InputCurrency/InputCurrency.interface.js

@@ -2,3 +2,5 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+
+//# sourceMappingURL=InputCurrency.interface.js.map

package/dist/Atomic/FormElements/InputCurrency/InputCurrency.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/Atomic/FormElements/InputCurrency/InputCurrency.interface.ts"],"names":[],"mappings":""}

package/dist/Atomic/FormElements/InputCurrency/InputCurrency.js

@@ -13,6 +13,19 @@ const _classnames = /*#__PURE__*/ _interop_require_default(require("classnames")
 const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
 const _fieldValueFormatters = require("../../../Functions/fieldValueFormatters");
 require("./InputCurrency.scss");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -59,6 +72,45 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 const attrsOfNativeInputDefault = {};
 const CN = 'input-currency';
 const ONLY_NUMBERS_DEFAULT = {
@@ -82,10 +134,9 @@ const InputCurrency = ({ currencySymbol = '$', testId = CN, onChange, className,
         const integerPart = parts[0];
         const decimalPart = parts[1];
         // Filter and format the integer part
-        const preparedIntegerValue = (0, _fieldValueFormatters.filterNumeric)(integerPart, {
-            ...onlyNumbers,
+        const preparedIntegerValue = (0, _fieldValueFormatters.filterNumeric)(integerPart, _object_spread_props(_object_spread({}, onlyNumbers), {
             type: 'int'
-        });
+        }));
         const parsedIntegerValue = Number.parseInt(preparedIntegerValue);
         if (!Number.isNaN(parsedIntegerValue)) {
             if (parsedIntegerValue === 0 && !decimalPart) {
@@ -170,15 +221,15 @@ const InputCurrency = ({ currencySymbol = '$', testId = CN, onChange, className,
             'input-currency__error': error,
             'input-currency__focused': isFocused
         }),
-        children: /*#__PURE__*/ (0, _jsxruntime.jsx)("input", {
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)("input", _object_spread_props(_object_spread({
             className: CN,
             type: "text",
             ref: inputRef,
             value: inputValue,
             onChange: formatCurrencyInput,
             onClick: onInputClick,
-            onKeyDown: onKeyDown,
-            ...attributesOfNativeInput,
+            onKeyDown: onKeyDown
+        }, attributesOfNativeInput), {
             onFocus: (e)=>{
                 var _attributesOfNativeInput_onFocus;
                 attributesOfNativeInput === null || attributesOfNativeInput === void 0 ? void 0 : (_attributesOfNativeInput_onFocus = attributesOfNativeInput.onFocus) === null || _attributesOfNativeInput_onFocus === void 0 ? void 0 : _attributesOfNativeInput_onFocus.call(attributesOfNativeInput, e);
@@ -193,8 +244,10 @@ const InputCurrency = ({ currencySymbol = '$', testId = CN, onChange, className,
                 }
                 setIsFocused(false);
             }
-        })
+        }))
     });
 };
 InputCurrency.displayName = 'InputCurrency';
 const _default = InputCurrency;
+
+//# sourceMappingURL=InputCurrency.js.map

package/dist/Atomic/FormElements/InputCurrency/InputCurrency.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/Atomic/FormElements/InputCurrency/InputCurrency.tsx"],"sourcesContent":["import type { FC } from 'react';\n\nimport type { IInputCurrencyProps } from './InputCurrency.interface';\n\nimport cn from 'classnames';\nimport React, { useEffect, useRef, useState } from 'react';\n\nimport { filterNumeric } from '../../../Functions/fieldValueFormatters';\n\nimport './InputCurrency.scss';\n\nconst attrsOfNativeInputDefault = {} as IInputCurrencyProps['attributesOfNativeInput'];\nconst CN = 'input-currency';\nconst ONLY_NUMBERS_DEFAULT = {\n  type: 'float',\n  decimalPlaces: 2,\n};\n\nconst InputCurrency: FC<IInputCurrencyProps> = ({\n  currencySymbol = '$',\n  testId = CN,\n  onChange,\n  className,\n  value,\n  disabled,\n  attributesOfNativeInput = attrsOfNativeInputDefault,\n  min = 0,\n  max,\n  error,\n  isNoCheckMinMax,\n  allowZero = false,\n  onlyNumbers = ONLY_NUMBERS_DEFAULT,\n}) => {\n  const [inputValue, setInputValue] = useState<string>(currencySymbol);\n  const [isFocused, setIsFocused] = useState<boolean>(false);\n  const inputRef = useRef<HTMLInputElement>(null);\n\n  const formatNumberWithCommas = (number: number | string): string => {\n    const parts = number.toString().split('.');\n    parts[0] = parts[0].replace(/\\B(?=(\\d{3})+(?!\\d))/g, ',');\n    return parts.join('.');\n  };\n\n  const formatCurrencyInput = (event: React.ChangeEvent<HTMLInputElement>): void => {\n    let newValue = event.target.value;\n    newValue = newValue.replace(currencySymbol, '');\n\n    // Handle decimal input separately\n    const parts = newValue.split('.');\n    const integerPart = parts[0];\n    const decimalPart = parts[1];\n\n    // Filter and format the integer part\n    const preparedIntegerValue = filterNumeric(integerPart, { ...onlyNumbers, type: 'int' });\n    const parsedIntegerValue = Number.parseInt(preparedIntegerValue);\n\n    if (!Number.isNaN(parsedIntegerValue)) {\n      if (parsedIntegerValue === 0 && !decimalPart) {\n        if (allowZero) {\n          setInputValue(`${currencySymbol}0`);\n          onChange(0);\n        }\n        else {\n          setInputValue(currencySymbol);\n          onChange('');\n        }\n      }\n      else {\n        let formattedValue = formatNumberWithCommas(parsedIntegerValue);\n\n        // Add decimal part if exists\n        if (decimalPart !== undefined) {\n          const filteredDecimal = filterNumeric(decimalPart, { type: 'int' });\n          if (filteredDecimal) {\n            formattedValue += `.${filteredDecimal.slice(0, onlyNumbers.decimalPlaces)}`;\n          }\n          else if (decimalPart === '') {\n            formattedValue += '.';\n          }\n        }\n\n        setInputValue(`${currencySymbol}${formattedValue}`);\n        onChange(Number.parseFloat(formattedValue.replace(/,/g, '')));\n      }\n    }\n    else {\n      setInputValue(currencySymbol);\n      onChange('');\n    }\n  };\n\n  const onInputClick = (): void => {\n    if (!inputValue && inputRef.current) {\n      inputRef.current.selectionStart = inputRef.current.selectionEnd\n        = currencySymbol ? currencySymbol.length : 1;\n    }\n  };\n\n  const onKeyDown = (event: React.KeyboardEvent<HTMLInputElement>): void => {\n    if (event.key.match(/^[a-z0-9]$/i) && inputRef.current) {\n      setInputValue(inputValue.slice(0, inputRef.current.selectionStart || 0));\n    }\n  };\n\n  const checkMinMax = (event: React.FocusEvent<HTMLInputElement> | null, checkValue?: string | number): boolean => {\n    const clearValue = checkValue ?? filterNumeric(event?.target?.value || '', onlyNumbers);\n\n    if (!clearValue) return false;\n\n    const numericValue = typeof clearValue === 'string' ? Number.parseFloat(clearValue) : clearValue;\n\n    if (numericValue < min) {\n      setInputValue(`${currencySymbol}${formatNumberWithCommas(min)}`);\n      onChange(min);\n      return false;\n    }\n\n    if (max && numericValue > max) {\n      setInputValue(`${currencySymbol}${formatNumberWithCommas(max)}`);\n      onChange(max);\n      return false;\n    }\n\n    return true;\n  };\n\n  useEffect(() => {\n    if (value === 0 || value === '0') {\n      if (allowZero) {\n        setInputValue(`${currencySymbol}0`);\n        onChange(0);\n      }\n      else {\n        setInputValue(currencySymbol);\n        onChange('');\n      }\n    }\n    else if (value) {\n      setInputValue(`${currencySymbol}${formatNumberWithCommas(value)}`);\n    }\n    else {\n      setInputValue(currencySymbol);\n    }\n  }, [value, currencySymbol, allowZero]);\n\n  return (\n    <div\n      data-testid={testId}\n      className={cn('input-currency-box', className, {\n        disabled,\n        'input-currency__error': error,\n        'input-currency__focused': isFocused,\n      })}\n    >\n      <input\n        className={CN}\n        type=\"text\"\n        ref={inputRef}\n        value={inputValue}\n        onChange={formatCurrencyInput}\n        onClick={onInputClick}\n        onKeyDown={onKeyDown}\n        {...attributesOfNativeInput}\n        onFocus={(e) => {\n          attributesOfNativeInput?.onFocus?.(e);\n          setIsFocused(true);\n        }}\n        onBlur={(e) => {\n          attributesOfNativeInput?.onBlur?.(e);\n          if (!isNoCheckMinMax) {\n            const currentValue = Number.parseFloat(\n              filterNumeric(inputValue.replace(currencySymbol, ''), onlyNumbers),\n            );\n            checkMinMax(null, currentValue);\n          }\n          setIsFocused(false);\n        }}\n      />\n    </div>\n  );\n};\n\nInputCurrency.displayName = 'InputCurrency';\n\nexport default InputCurrency;\n"],"names":["attrsOfNativeInputDefault","CN","ONLY_NUMBERS_DEFAULT","type","decimalPlaces","InputCurrency","currencySymbol","testId","onChange","className","value","disabled","attributesOfNativeInput","min","max","error","isNoCheckMinMax","allowZero","onlyNumbers","inputValue","setInputValue","useState","isFocused","setIsFocused","inputRef","useRef","formatNumberWithCommas","number","parts","toString","split","replace","join","formatCurrencyInput","event","newValue","target","integerPart","decimalPart","preparedIntegerValue","filterNumeric","parsedIntegerValue","Number","parseInt","isNaN","formattedValue","undefined","filteredDecimal","slice","parseFloat","onInputClick","current","selectionStart","selectionEnd","length","onKeyDown","key","match","checkMinMax","checkValue","clearValue","numericValue","useEffect","div","data-testid","cn","input","ref","onClick","onFocus","e","onBlur","currentValue","displayName"],"mappings":"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"}

package/dist/Atomic/FormElements/InputCurrency/index.js

@@ -14,3 +14,5 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+
+//# sourceMappingURL=index.js.map

package/dist/Atomic/FormElements/InputCurrency/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/Atomic/FormElements/InputCurrency/index.ts"],"sourcesContent":["export { default } from './InputCurrency';\nexport type { IInputCurrencyProps, IOnlyNumbersConfig } from './InputCurrency.interface';\n"],"names":["default"],"mappings":";;;;+BAASA;;;eAAAA,sBAAO;;;sEAAQ"}

package/dist/Atomic/FormElements/InputDateRange/InputDateRange.js

@@ -17,6 +17,19 @@ const _Arrow = /*#__PURE__*/ _interop_require_default(require("../../UI/Arrow/Ar
 const _OpenedPart = /*#__PURE__*/ _interop_require_default(require("./components/OpenedPart"));
 const _dependencies = require("./dependencies");
 require("./InputDateRange.scss");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -63,6 +76,45 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 const checkFormat = (date, format)=>{
     const momentObj = (0, _momenttimezone.default)(date, format);
     return momentObj.isValid() ? momentObj.format(format) : null;
@@ -85,20 +137,17 @@ const InputDateRange = (props)=>{
     const [dateRangeContainerId, setDateRangeContainerId] = (0, _react.useState)(Math.random().toString(16).slice(2));
     const handleChange = (input)=>{
         const newValue = (0, _dependencies.getActualDateRange)(input);
-        const formatedValue = {
+        const formatedValue = _object_spread({
             intervalKey: newValue.intervalKey,
             start: newValue.start ? (0, _momenttimezone.default)(newValue.start).format(_dependencies.MAIN_FORMAT) : newValue.start,
-            end: newValue.end ? (0, _momenttimezone.default)(newValue.end).format(_dependencies.MAIN_FORMAT) : newValue.end,
-            ...newValue.compare ? {
-                compare: newValue.compare
-            } : {},
-            ...newValue.startPrevDate ? {
-                startPrevDate: (0, _momenttimezone.default)(newValue.startPrevDate).format(_dependencies.MAIN_FORMAT)
-            } : {},
-            ...newValue.endPrevDate ? {
-                endPrevDate: (0, _momenttimezone.default)(newValue.endPrevDate).format(_dependencies.MAIN_FORMAT)
-            } : {}
-        };
+            end: newValue.end ? (0, _momenttimezone.default)(newValue.end).format(_dependencies.MAIN_FORMAT) : newValue.end
+        }, newValue.compare ? {
+            compare: newValue.compare
+        } : {}, newValue.startPrevDate ? {
+            startPrevDate: (0, _momenttimezone.default)(newValue.startPrevDate).format(_dependencies.MAIN_FORMAT)
+        } : {}, newValue.endPrevDate ? {
+            endPrevDate: (0, _momenttimezone.default)(newValue.endPrevDate).format(_dependencies.MAIN_FORMAT)
+        } : {});
         onChange(formatedValue);
         return formatedValue;
     };
@@ -150,8 +199,7 @@ const InputDateRange = (props)=>{
         }
         const startPrevDate = (0, _momenttimezone.default)(newStart).subtract(intervalHoursCount, "hours").subtract(1, "seconds");
         const endPrevDate = (0, _momenttimezone.default)(newEnd).subtract(1, "seconds");
-        handleChange({
-            ...value,
+        handleChange(_object_spread_props(_object_spread({}, value), {
             intervalKey: (_getActualDateRange = (0, _dependencies.getActualDateRange)({
                 start: newStart,
                 end: newEnd
@@ -160,7 +208,7 @@ const InputDateRange = (props)=>{
             end: newEnd,
             startPrevDate,
             endPrevDate
-        });
+        }));
     };
     const handleArrowClick = (type)=>{
         slideInterval(type === "right" ? "forward" : "back");
@@ -270,8 +318,7 @@ const InputDateRange = (props)=>{
                                 })
                             ]
                         }),
-                        isToggled && !isUseAbs && /*#__PURE__*/ (0, _jsxruntime.jsx)(_OpenedPart.default, {
-                            ...props,
+                        isToggled && !isUseAbs && /*#__PURE__*/ (0, _jsxruntime.jsx)(_OpenedPart.default, _object_spread_props(_object_spread({}, props), {
                             dateRangeContainerId: dateRangeContainerId,
                             mainId: id,
                             testId: testId,
@@ -289,7 +336,7 @@ const InputDateRange = (props)=>{
                             momentMaxDate: momentMaxDate,
                             isDontLimitFuture: isDontLimitFuture,
                             isListTop: isListTop
-                        })
+                        }))
                     ]
                 })
             }),
@@ -301,3 +348,5 @@ const InputDateRange = (props)=>{
     });
 };
 const _default = /*#__PURE__*/ _react.default.memo(InputDateRange);
+
+//# sourceMappingURL=InputDateRange.js.map