intelicoreact 1.5.32 → 1.5.34

package/dist/src/Functions/useClickOutside.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useClickOutside", {
+    enumerable: true,
+    get: function() {
+        return useClickOutside;
+    }
+});
+const _react = require("react");
+const useClickOutside = (ref, setOut, open)=>{
+    function handleClickOutside(event) {
+        if (ref.current && !ref.current.contains(event.target)) {
+            setOut(open);
+        }
+    }
+    (0, _react.useEffect)(()=>{
+        document.addEventListener("mousedown", handleClickOutside);
+        return ()=>{
+            document.removeEventListener("mousedown", handleClickOutside);
+        };
+    }, [
+        ref
+    ]);
+};

package/dist/src/Functions/useDebounce.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useDebounce", {
+    enumerable: true,
+    get: function() {
+        return useDebounce;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+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;
+}
+const useDebounce = ({ searchValue, delay })=>{
+    const [debouncedValue, setDebouncedValue] = (0, _react.useState)(searchValue);
+    (0, _react.useEffect)(()=>{
+        const handler = setTimeout(()=>{
+            setDebouncedValue(searchValue);
+        }, delay);
+        return ()=>{
+            clearTimeout(handler);
+        };
+    }, [
+        searchValue,
+        delay
+    ]);
+    return debouncedValue;
+};

package/dist/src/Functions/useFieldFocus.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return useFieldsFocus;
+    }
+});
+const _react = require("react");
+function useFieldsFocus({ form, setForm }) {
+    const isFormAsObject = Boolean(typeof form === "object" && !Array.isArray(form));
+    const getField = (key)=>{
+        if (isFormAsObject) {
+            var _Object_values;
+            var _form_key;
+            return (_form_key = form === null || form === void 0 ? void 0 : form[key]) !== null && _form_key !== void 0 ? _form_key : (_Object_values = Object.values(form)) === null || _Object_values === void 0 ? void 0 : _Object_values.find((field)=>field.key === key);
+        } else {
+            return form === null || form === void 0 ? void 0 : form.find((field)=>field.key === key);
+        }
+    };
+    const getErroredFields = ()=>{
+        if (isFormAsObject) {
+            var _Object_values;
+            return (_Object_values = Object.values(form)) === null || _Object_values === void 0 ? void 0 : _Object_values.filter((field)=>field.error);
+        } else {
+            return form === null || form === void 0 ? void 0 : form.filter((f)=>f === null || f === void 0 ? void 0 : f.error);
+        }
+    };
+    const addRefsToFields = ()=>{
+        if (isFormAsObject) {
+            setForm((form)=>{
+                var _Object_keys;
+                return (_Object_keys = Object.keys(form)) === null || _Object_keys === void 0 ? void 0 : _Object_keys.reduce((result, key)=>{
+                    const field = form[key];
+                    return {
+                        ...result,
+                        [key]: {
+                            ...field,
+                            ref: /*#__PURE__*/ (0, _react.createRef)(),
+                            wrapperRef: /*#__PURE__*/ (0, _react.createRef)()
+                        }
+                    };
+                }, {});
+            });
+        } else {
+            setForm((form)=>{
+                return form === null || form === void 0 ? void 0 : form.map((field)=>{
+                    field.ref = /*#__PURE__*/ (0, _react.createRef)();
+                    field.wrapperRef = /*#__PURE__*/ (0, _react.createRef)();
+                    return field;
+                });
+            });
+        }
+    };
+    const toggleFieldFocus = ({ field, action = "focus" })=>{
+        if (!field || !(field === null || field === void 0 ? void 0 : field.ref)) return null;
+        setTimeout(()=>{
+            var _field_ref_current_querySelector, _field_ref_current;
+            (_field_ref_current = field.ref.current) === null || _field_ref_current === void 0 ? void 0 : (_field_ref_current_querySelector = _field_ref_current.querySelector((field === null || field === void 0 ? void 0 : field.focusSelector) || "input")) === null || _field_ref_current_querySelector === void 0 ? void 0 : _field_ref_current_querySelector[action]();
+        }, 50);
+    };
+    const setFocusTo = (key)=>{
+        const field = getField(key);
+        if (!field) return false;
+        toggleFieldFocus({
+            field
+        });
+    };
+    const setFocusToErroredField = ()=>{
+        var _getErroredFields;
+        const field = (_getErroredFields = getErroredFields()) === null || _getErroredFields === void 0 ? void 0 : _getErroredFields[0];
+        if (!field) return false;
+        toggleFieldFocus({
+            field
+        });
+    };
+    (0, _react.useEffect)(()=>{
+        addRefsToFields();
+    }, [
+        form === null || form === void 0 ? void 0 : form.length
+    ]);
+    return {
+        setFocusTo,
+        setFocusToErroredField
+    };
+}

package/dist/src/Functions/useFormTools/form-drivers/ArrayWithObjects.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ArrayWithObjects;
+    }
+});
+const _General = /*#__PURE__*/ _interop_require_default(require("../functions/General"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function ArrayWithObjects({ form, setForm, FormFields }) {
+    const { joinData, getFieldData, updateFormField, getFormFields, getFormFieldsAsArray, getFormFieldsKeys } = (0, _General.default)({
+        FormFields
+    });
+    const getFormField = (key, argForm = form)=>{
+        var _getFormFields;
+        return (_getFormFields = getFormFields(argForm)) === null || _getFormFields === void 0 ? void 0 : _getFormFields.find((f)=>f.key === key);
+    };
+    const setFormFields = (data)=>{
+        const isFunction = typeof data === "function";
+        setForm((state)=>isFunction ? data(state) : data);
+    };
+    const setFormField = (data, key = null)=>setFormFields((fields)=>updateFormField(fields, data, key));
+    const removeAllFormFields = ()=>setFormFields([]);
+    return {
+        joinData,
+        getFieldData,
+        getFormFields,
+        getFormField,
+        setFormFields,
+        setFormField,
+        getFormFieldsAsArray: (fields)=>getFormFieldsAsArray(fields || getFormFields()),
+        getFormFieldsKeys: (fields)=>getFormFieldsKeys(fields || getFormFields()),
+        removeAllFormFields
+    };
+}

package/dist/src/Functions/useFormTools/form-drivers/ObjectWithIterableObjects.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ObjectWithIterableObjects;
+    }
+});
+function ObjectWithIterableObjects({ form, setForm, FormFields }) {
+    const joinData = (...args)=>{
+        const [mainArg] = args;
+        const MainArgProto = Array.isArray(mainArg) ? "Array" : typeof mainArg === "object" ? "Object" : undefined;
+        const template = Array.isArray(mainArg) ? [] : typeof mainArg === "object" ? {} : null;
+        if (!template) return undefined;
+        return args.reduce((result, item)=>{
+            if (MainArgProto === "Array") {
+                if (Array.isArray(item)) {
+                    return [
+                        ...result,
+                        ...item
+                    ];
+                } else {
+                    return [
+                        ...result,
+                        item
+                    ];
+                }
+            } else if (MainArgProto === "Object") {
+                return {
+                    ...result,
+                    ...item
+                };
+            } else {
+                return template;
+            }
+        }, template);
+    };
+    const getFieldData = (key)=>{
+        if (Array.isArray(FormFields)) {
+            return FormFields[key] || FormFields.find((f)=>f.key === key);
+        } else if (typeof FormFields === "object") {
+            return FormFields[key] || Object.values(FormFields).find((f)=>f.key === key);
+        } else {
+            return undefined;
+        }
+    };
+    const getFormFields = ()=>{
+        return form.fields || form;
+    };
+    const getFormField = (key)=>{
+        // eslint-disable-next-line no-undef
+        if (FormProto === "Array") {
+            return getFormFields().find((field)=>field.key === key);
+        // eslint-disable-next-line no-undef
+        } else if (FormProto === "Object") {
+            return Object.values(getFormFields()).find((field)=>field.key === key) || Object.keys(getFormFields()).reduce((result, field)=>{
+                if (field === key) result = getFormFields()[field];
+                return result;
+            }, {});
+        } else {
+            return undefined;
+        }
+    };
+    const setFormFields = (data)=>{
+        const isFunction = typeof data === "function";
+        setForm((state)=>{
+            if (state.fields) {
+                return {
+                    ...state,
+                    fields: isFunction ? data(state.fields) : data
+                };
+            } else {
+                return isFunction ? data(state) : data;
+            }
+        });
+    };
+    const setFormField = (data, key = null)=>{
+        const isFunction = typeof data === "function";
+        setFormFields((fields)=>{
+            const pop = (fields, key)=>{
+                const result = {
+                    fields,
+                    item: undefined
+                };
+                result.item = fields[key] || fields.find((f)=>f.key === key);
+                if (!result.item) return result;
+                if (Array.isArray(fields)) {
+                    const index = parseInt(key, 10);
+                    if (!isNaN(index)) {
+                        result.fields.splice(key, 1);
+                    } else {
+                        result.fields = result.fields.filter((f)=>f.key !== key);
+                    }
+                } else if (typeof fields === "object") {
+                    result.fields = Object.values(fields).reduce((object, { key: fKey })=>{
+                        if (key !== fKey) {
+                            object[key] = fields[key];
+                        }
+                        return object;
+                    }, {});
+                }
+                return result;
+            };
+            const update = (fields)=>{
+                //KEY is NULLable
+                if (!key) {
+                    return data.key ? Object.values(fields).reduce((result, field, i)=>{
+                        const index = fields[field.key] ? field.key : i;
+                        return {
+                            ...result,
+                            [index]: data.key === field.key ? isFunction ? data(field) : data : field
+                        };
+                    }, {}) : {
+                        ...fields,
+                        [fields.length || 0]: isFunction ? data({}) : data
+                    };
+                }
+                const { fields: filtered, item: field } = pop(fields, key);
+                const updatedField = isFunction ? data(field || {}) : {
+                    ...field,
+                    ...data
+                };
+                return joinData(filtered, fields[key] ? {
+                    [key]: updatedField
+                } : updatedField);
+            };
+            return update(fields);
+        });
+    };
+    return {
+        joinData,
+        getFieldData,
+        getFormFields,
+        getFormField,
+        setFormFields,
+        setFormField
+    };
+}

package/dist/src/Functions/useFormTools/form-drivers/ObjectWithNamedKeyObjects.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ObjectWithNamedKeyObjects;
+    }
+});
+const _General = /*#__PURE__*/ _interop_require_default(require("../functions/General"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const noop = ()=>{};
+function ObjectWithNamedKeyObjects({ form, setForm = noop, FormFields } = {}) {
+    const { joinData, getFieldData, updateFormField, getFormFields, getFormFieldsAsArray, getFormFieldsKeys } = (0, _General.default)({
+        FormFields
+    });
+    const getFormField = (key, argForm = form)=>{
+        var _Object_values, _Object_keys;
+        return ((_Object_values = Object.values(getFormFields(argForm))) === null || _Object_values === void 0 ? void 0 : _Object_values.find((field)=>(field === null || field === void 0 ? void 0 : field.key) === key)) || ((_Object_keys = Object.keys(getFormFields(argForm))) === null || _Object_keys === void 0 ? void 0 : _Object_keys.reduce((result, field)=>{
+            if (field === key) result = getFormFields(argForm)[field];
+            return result;
+        }, null));
+    };
+    const setFormFields = (data)=>{
+        const isFunction = typeof data === "function";
+        setForm((state)=>{
+            if (state.fields) {
+                return {
+                    ...state,
+                    fields: isFunction ? data(state.fields) : data
+                };
+            } else {
+                return isFunction ? data(state) : data;
+            }
+        });
+    };
+    const setFormField = (data, key = null)=>setFormFields((fields)=>updateFormField(fields, data, key));
+    const removeAllFormFields = ()=>setFormFields({});
+    const removeFormField = (key)=>setFormFields((state)=>Object.keys(state).filter((fKey)=>fKey !== key).reduce((obj, key)=>({
+                    ...obj,
+                    [key]: state[key]
+                }), {}));
+    const removeFormFields = ([...keys])=>setFormFields((state)=>Object.keys(state).filter((fKey)=>!keys.includes(fKey)).reduce((obj, key)=>({
+                    ...obj,
+                    [key]: state[key]
+                }), {}));
+    return {
+        joinData,
+        getFieldData,
+        getFormFields,
+        getFormField,
+        setFormFields,
+        setFormField,
+        // eslint-disable-next-line no-dupe-keys
+        getFormFields: ()=>getFormFields(form),
+        getFormFieldsAsArray: ()=>getFormFieldsAsArray(getFormFields(form)),
+        getFormFieldsKeys: ()=>getFormFieldsKeys(getFormFields(form)),
+        removeAllFormFields,
+        removeFormField,
+        removeFormFields
+    };
+}

package/dist/src/Functions/useFormTools/functions/General.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return General;
+    }
+});
+function General({ form, FormFields = [] } = {}) {
+    const joinData = (...args)=>{
+        const [mainArg] = args;
+        const MainArgProto = Array.isArray(mainArg) ? "Array" : typeof mainArg === "object" ? "Object" : undefined;
+        const template = Array.isArray(mainArg) ? [] : typeof mainArg === "object" ? {} : null;
+        if (!template) return undefined;
+        return args.reduce((result, item)=>{
+            if (MainArgProto === "Array") {
+                if (Array.isArray(item)) {
+                    return [
+                        ...result,
+                        ...item
+                    ];
+                } else {
+                    return [
+                        ...result,
+                        item
+                    ];
+                }
+            } else if (MainArgProto === "Object") {
+                return {
+                    ...result,
+                    ...item
+                };
+            } else {
+                return template;
+            }
+        }, template);
+    };
+    const getFieldData = (key)=>{
+        if (Array.isArray(FormFields)) {
+            if (FormFields[key]) {
+                return {
+                    ...FormFields[key]
+                };
+            } else {
+                return {
+                    ...FormFields.find((f)=>f.key === key)
+                };
+            }
+        } else if (typeof FormFields === "object") {
+            return {
+                ...FormFields[key]
+            } || {
+                ...Object.values(FormFields).find((f)=>f.key === key)
+            };
+        } else {
+            return undefined;
+        }
+    };
+    const getFormFields = (argForm = form)=>{
+        return (argForm === null || argForm === void 0 ? void 0 : argForm.fields) || argForm;
+    };
+    const getFormFieldsAsArray = (fields)=>{
+        if (Array.isArray(fields)) return fields;
+        if (typeof fields === "object") {
+            return Object.values(fields);
+        }
+        return fields;
+    };
+    const getFormFieldsKeys = (fields = getFormFields())=>{
+        if (Array.isArray(fields)) return fields.map(({ key })=>key);
+        if (typeof fields === "object") {
+            return Object.values(fields).map(({ key })=>key);
+        }
+        return fields;
+    };
+    const popFormField = (fields, key)=>{
+        const result = {
+            item: undefined,
+            itemIndex: undefined
+        };
+        if (Array.isArray(fields)) {
+            result.item = fields === null || fields === void 0 ? void 0 : fields.find((f)=>f.key === key);
+            result.itemIndex = result.item ? fields.findIndex((f)=>f.key === key) : fields.length;
+        } else if (typeof fields === "object") {
+            result.item = fields[key] || Object.values(fields).find((f)=>f.key === key);
+            result.itemIndex = result.item ? fields[key] ? key : Object.values(fields).findIndex((f)=>f.key === key) : key;
+        }
+        return result;
+    };
+    const updateFormField = (fields, data, key)=>{
+        const isFunction = typeof data === "function";
+        //KEY is NULLable
+        if (!key) {
+            return data.key ? Object.values(fields).reduce((result, field, i)=>{
+                const index = fields[field.key] ? field.key : i;
+                return {
+                    ...result,
+                    [index]: data.key === field.key ? isFunction ? data(field) : data : field
+                };
+            }, {}) : {
+                ...fields,
+                [fields.length || 0]: isFunction ? data({}) : data
+            };
+        }
+        const { item: field = data, itemIndex } = popFormField(fields, key);
+        fields[itemIndex] = isFunction ? data(field || {}) : {
+            ...field,
+            ...data
+        };
+        return fields;
+    };
+    const getFieldClassName = (key, type)=>{
+        return `form-${type}_field-${key}`;
+    };
+    return {
+        joinData,
+        getFieldData,
+        popFormField,
+        updateFormField,
+        getFormFields,
+        getFormFieldsAsArray,
+        getFieldClassName,
+        getFormFieldsKeys
+    };
+}

package/dist/src/Functions/useFormTools/functions/RenderFields.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return RenderFields;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const defaultRenderFieldComponent = ()=>{
+    // eslint-disable-next-line no-console
+    console.error("RenderFields: RenderFieldComponent Property is not recieved!");
+    return null;
+};
+const defaultFormDataDriver = ()=>{
+    // eslint-disable-next-line no-console
+    console.error("RenderFields: FormDataDriver Property is not recieved!");
+    return null;
+};
+const defaultOnFieldChange = ()=>{
+    // eslint-disable-next-line no-console
+    console.warn("RenderFields: Be careful, onFieldChange handler is not recieved!");
+    return null;
+};
+const defaultOnFieldBlur = ()=>{
+    // eslint-disable-next-line no-console
+    console.warn("RenderFields: Be careful, defaultOnFieldBlur handler is not recieved!");
+    return null;
+};
+function RenderFields({ form, fields, cols = 1, FormDataDriver = defaultFormDataDriver, RenderFieldComponent = defaultRenderFieldComponent, onFieldChange = defaultOnFieldChange, onFieldBlur = defaultOnFieldBlur } = {}) {
+    const maxColumns = 6;
+    const maxWidth = 12;
+    const { getFormField } = FormDataDriver({
+        form
+    });
+    const getColumnsQty = ()=>{
+        return cols > maxColumns ? maxColumns : cols;
+    };
+    const renderFormField = (key)=>{
+        try {
+            const field = {
+                ...getFormField(key),
+                key
+            };
+            const { wrapperRef } = field;
+            return /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+                id: `render-field-wrapper-${key}`,
+                ref: wrapperRef ? typeof wrapperRef === "function" ? (node)=>wrapperRef(node, key) : wrapperRef : null,
+                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(RenderFieldComponent, {
+                    field: field,
+                    onChange: (value)=>onFieldChange(key, value),
+                    onBlur: (...args)=>onFieldBlur(...args)
+                }, key)
+            }, `render-field-wrapper-${key}`);
+        } catch (e) {
+            return null;
+        }
+    };
+    const renderSingleColumn = ()=>{
+        return fields.map(renderFormField);
+    };
+    const renderSplitColumns = ()=>{
+        const fieldsLen = (fields === null || fields === void 0 ? void 0 : fields.length) || 0;
+        const columnsQty = getColumnsQty() > fieldsLen ? fieldsLen : getColumnsQty();
+        if (!columnsQty) return null;
+        const parts = new Array(columnsQty).fill([]).map((v, i)=>{
+            const startIndex = fieldsLen / columnsQty * i;
+            const endIndex = startIndex + fieldsLen / columnsQty;
+            return fields.slice(startIndex, endIndex);
+        });
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+            className: "row",
+            children: parts.map((part, i)=>/*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
+                    className: `col-12 col-lg-${parseInt(maxWidth / columnsQty, 10)}`,
+                    children: part.map(renderFormField)
+                }, `render-fields-row-${i}`))
+        });
+    };
+    const render = cols === 1 ? renderSingleColumn : renderSplitColumns;
+    return render();
+}

package/dist/src/Functions/useFormTools/functions/usePrevious.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = require("react");
+function usePrevious(value) {
+    const ref = (0, _react.useRef)();
+    (0, _react.useEffect)(()=>{
+        ref.current = value;
+    }, [
+        value
+    ]);
+    return ref.current;
+}
+const _default = usePrevious;