intelicoreact 1.6.7 → 1.6.8

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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+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
+    };
+}
+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 = {
+        change: (e)=>{
+            let inputValue = (e === null || e === void 0 ? void 0 : e.target) ? e.target.value : e;
+            inputValue = (0, _fieldValueFormatters.formatToOnlyASCIICodeText)(inputValue);
+            if (isHex) inputValue = (0, _fieldValueFormatters.formatToHex)({
+                inputValue,
+                withSharp: withSharp
+            });
+            if (symbolsLimit && inputValue.length > Number(symbolsLimit)) inputValue = inputValue.substring(0, Number(symbolsLimit));
+            onChange === null || onChange === void 0 ? void 0 : onChange(inputValue);
+        }
+    };
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)("div", {
+        className: (0, _classnames.default)("inputColor", className),
+        children: [
+            /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+                className: (0, _classnames.default)("inputColor__color-block"),
+                style: {
+                    backgroundColor: value && value.length === 7 ? value : initialHexOfColorBlock
+                }
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(_Input.default, _object_spread_props(_object_spread({}, args), {
+                value: value,
+                withDelete: withDelete,
+                onChange: handle.change,
+                symbolsLimit: symbolsLimit || 7,
+                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

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    InputTemplate: function() {
+        return InputTemplate;
+    },
+    default: function() {
+        return _default;
+    }
+});
+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
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    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',
+    component: _InputColor.default,
+    argTypes: {
+        disabled: {
+            description: 'boolean'
+        },
+        initialHexColorBlock: {
+            description: 'string - initial color (placeholder) of color block'
+        },
+        error: {
+            description: 'text - coloring input if is errored'
+        },
+        withDelete: {
+            description: 'boolean - add clear-cross by hover'
+        },
+        placeholder: {
+            description: 'text'
+        },
+        value: {
+            description: '(* - required prop)'
+        },
+        className: {
+            description: 'string'
+        },
+        symbolsLimit: {
+            description: 'Set limit of symbols in input, overhead will be ignored'
+        }
+    }
+};
+const Template = (args)=>{
+    const [value, setValue] = (0, _react.useState)('');
+    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 = {
+    withHexFormat: {
+        isTurnOn: true,
+        withSharp: true
+    },
+    symbolsLimit: 7,
+    placeholder: '#',
+    initialHexOfColorBlock: '#9AA0B9',
+    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

@@ -0,0 +1,6 @@
+"use strict";
+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

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+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
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    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 = {
+    type: 'float',
+    decimalPlaces: 2
+};
+const InputCurrency = ({ currencySymbol = '$', testId = CN, onChange, className, value, disabled, attributesOfNativeInput = attrsOfNativeInputDefault, min = 0, max, error, isNoCheckMinMax, allowZero = false, onlyNumbers = ONLY_NUMBERS_DEFAULT })=>{
+    const [inputValue, setInputValue] = (0, _react.useState)(currencySymbol);
+    const [isFocused, setIsFocused] = (0, _react.useState)(false);
+    const inputRef = (0, _react.useRef)(null);
+    const formatNumberWithCommas = (number)=>{
+        const parts = number.toString().split('.');
+        parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+        return parts.join('.');
+    };
+    const formatCurrencyInput = (event)=>{
+        let newValue = event.target.value;
+        newValue = newValue.replace(currencySymbol, '');
+        // Handle decimal input separately
+        const parts = newValue.split('.');
+        const integerPart = parts[0];
+        const decimalPart = parts[1];
+        // Filter and format the integer part
+        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) {
+                if (allowZero) {
+                    setInputValue(`${currencySymbol}0`);
+                    onChange(0);
+                } else {
+                    setInputValue(currencySymbol);
+                    onChange('');
+                }
+            } else {
+                let formattedValue = formatNumberWithCommas(parsedIntegerValue);
+                // Add decimal part if exists
+                if (decimalPart !== undefined) {
+                    const filteredDecimal = (0, _fieldValueFormatters.filterNumeric)(decimalPart, {
+                        type: 'int'
+                    });
+                    if (filteredDecimal) {
+                        formattedValue += `.${filteredDecimal.slice(0, onlyNumbers.decimalPlaces)}`;
+                    } else if (decimalPart === '') {
+                        formattedValue += '.';
+                    }
+                }
+                setInputValue(`${currencySymbol}${formattedValue}`);
+                onChange(Number.parseFloat(formattedValue.replace(/,/g, '')));
+            }
+        } else {
+            setInputValue(currencySymbol);
+            onChange('');
+        }
+    };
+    const onInputClick = ()=>{
+        if (!inputValue && inputRef.current) {
+            inputRef.current.selectionStart = inputRef.current.selectionEnd = currencySymbol ? currencySymbol.length : 1;
+        }
+    };
+    const onKeyDown = (event)=>{
+        if (event.key.match(/^[a-z0-9]$/i) && inputRef.current) {
+            setInputValue(inputValue.slice(0, inputRef.current.selectionStart || 0));
+        }
+    };
+    const checkMinMax = (event, checkValue)=>{
+        var _event_target;
+        const clearValue = checkValue !== null && checkValue !== void 0 ? checkValue : (0, _fieldValueFormatters.filterNumeric)((event === null || event === void 0 ? void 0 : (_event_target = event.target) === null || _event_target === void 0 ? void 0 : _event_target.value) || '', onlyNumbers);
+        if (!clearValue) return false;
+        const numericValue = typeof clearValue === 'string' ? Number.parseFloat(clearValue) : clearValue;
+        if (numericValue < min) {
+            setInputValue(`${currencySymbol}${formatNumberWithCommas(min)}`);
+            onChange(min);
+            return false;
+        }
+        if (max && numericValue > max) {
+            setInputValue(`${currencySymbol}${formatNumberWithCommas(max)}`);
+            onChange(max);
+            return false;
+        }
+        return true;
+    };
+    (0, _react.useEffect)(()=>{
+        if (value === 0 || value === '0') {
+            if (allowZero) {
+                setInputValue(`${currencySymbol}0`);
+                onChange(0);
+            } else {
+                setInputValue(currencySymbol);
+                onChange('');
+            }
+        } else if (value) {
+            setInputValue(`${currencySymbol}${formatNumberWithCommas(value)}`);
+        } else {
+            setInputValue(currencySymbol);
+        }
+    }, [
+        value,
+        currencySymbol,
+        allowZero
+    ]);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+        "data-testid": testId,
+        className: (0, _classnames.default)('input-currency-box', className, {
+            disabled,
+            'input-currency__error': error,
+            'input-currency__focused': isFocused
+        }),
+        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), {
+            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);
+                setIsFocused(true);
+            },
+            onBlur: (e)=>{
+                var _attributesOfNativeInput_onBlur;
+                attributesOfNativeInput === null || attributesOfNativeInput === void 0 ? void 0 : (_attributesOfNativeInput_onBlur = attributesOfNativeInput.onBlur) === null || _attributesOfNativeInput_onBlur === void 0 ? void 0 : _attributesOfNativeInput_onBlur.call(attributesOfNativeInput, e);
+                if (!isNoCheckMinMax) {
+                    const currentValue = Number.parseFloat((0, _fieldValueFormatters.filterNumeric)(inputValue.replace(currencySymbol, ''), onlyNumbers));
+                    checkMinMax(null, currentValue);
+                }
+                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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _InputCurrency.default;
+    }
+});
+const _InputCurrency = /*#__PURE__*/ _interop_require_default(require("./InputCurrency"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? 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"}