intelicoreact 1.6.7 → 1.6.8

package/dist/Functions/guards/typeGuards.js

@@ -0,0 +1,376 @@
+/**
+ * @name isArray
+ * @description Функция isArray принимает значение и возвращает true, если переданное значение является массивом.
+ * @param value - значение для проверки
+ * @example
+ * const result = isArray([]);
+ * console.log(result); // true
+ * @example
+ * const result = isArray({});
+ * console.log(result); // false
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const isArray = (value)=>Array.isArray(value);
+/**
+ * @name isObject
+ * @description Функция isObject принимает значение и возвращает true, если переданное значение является объектом.
+ * @param value - значение для проверки
+ * @example
+ * const result = isObject({});
+ * console.log(result); // true
+ * @example
+ * const result = isObject([]);
+ * console.log(result); // false
+ */ function isObject(value) {
+    return typeof value === 'object' && value !== null && !isArray(value);
+}
+/**
+ * @name isNumber
+ * @description Функция isNumber принимает значение и возвращает true, если переданное значение является числом.
+ * @param value - значение для проверки
+ * @example
+ * const result = isNumber(1);
+ * console.log(result); // true
+ */ const isNumber = (value)=>typeof value === 'number';
+/**
+ * @name isString
+ * @description Функция isString принимает значение и возвращает true, если переданное значение является строкой.
+ * @param value - значение для проверки
+ * @example
+ * const result = isString('string');
+ * console.log(result); // true
+ */ const isString = (value)=>typeof value === 'string';
+/**
+ * @name isBoolean
+ * @description Функция isBoolean принимает значение и возвращает true, если переданное значение является булевым.
+ * @param value - значение для проверки
+ * @example
+ * const result = isBoolean(true);
+ * console.log(result); // true
+ */ const isBoolean = (value)=>typeof value === 'boolean';
+/**
+ * @name isFunction
+ * @description Функция isFunction принимает значение и возвращает true, если переданное значение является функцией.
+ * @param value - значение для проверки
+ * @example
+ * const result = isFunction(() => {});
+ * console.log(result); // true
+ * @example
+ * const result = isFunction('string');
+ * console.log(result); // false
+ * @example
+ * const result = isFunction(1);
+ * console.log(result); // false
+ */ const isFunction = (value)=>typeof value === 'function';
+/**
+ * @name isInstanceOf
+ * @description Функция isInstanceOf принимает значение и возвращает true, если переданное значение является экземпляром класса.
+ * @param value - значение для проверки
+ * @param classType - класс для проверки
+ * @example
+ * class TestClass {}
+ * const result = isInstanceOf(new TestClass(), TestClass);
+ * console.log(result); // true
+ */ const isInstanceOf = (value, classType)=>value instanceof classType;
+/**
+ * @name isEnumValue
+ * @description Функция isEnumValue принимает значение и возвращает true, если переданное значение является значением enum.
+ * @param enumObject - enum для проверки
+ * @param value - значение для проверки
+ * @example
+ * enum Colors {
+ * Red = 'red',
+ * Green = 'green',
+ * Blue = 'blue',
+ * }
+ * const result = isEnumValue(Colors, 'red');
+ * console.log(result); // true
+ * @returns true - если значение является значением enum, false - если значение не является значением enum
+ */ function isEnumValue(enumObject, value) {
+    return Object.values(enumObject).includes(value);
+}
+/**
+ * @name isNullOrUndefined
+ * @description Функция isNullOrUndefined принимает значение и возвращает true, если переданное значение является null или undefined.
+ * @param value - значение для проверки
+ * @example
+ * isNullOrUndefined(null) // true
+ * isNullOrUndefined(undefined) // true
+ * isNullOrUndefined(1) // false
+ */ function isNullOrUndefined(value) {
+    return value === null || value === undefined;
+}
+/**
+ * @name isTruthy
+ * @description Функция isTruthy принимает значение и возвращает true, если переданное значение является true.
+ * @param value - значение для проверки
+ * @example
+ * isTruthy(true) // true
+ * isTruthy(1) // true
+ * isTruthy(Infinity) // true
+ * isTruthy(-Infinity) // true
+ * isTruthy(Symbol()) // true
+ * isTruthy('some string') // true
+ * isTruthy({}) // true
+ * isTruthy([]) // true
+ * isTruthy(Symbol('some description')) // true
+ * isTruthy(() => {}) // true
+ * isTruthy(function() {}) // true
+ * isTruthy(class {}) // true
+ * isTruthy(0) // false
+ * isTruthy('') // false
+ * isTruthy(null) // false
+ * isTruthy(undefined) // false
+ * isTruthy(NaN) // false
+ * isTruthy(false) // false
+ */ const isTruthy = (value)=>!!value;
+/**
+ * @name isEmptyObject
+ * @description Функция isEmptyObject принимает значение и возвращает true, если переданное значение является пустым объектом.
+ * @param value - значение для проверки
+ * @example
+ * isEmptyObject({}) // true
+ * isEmptyObject({ a: 1 }) // false
+ */ const isEmptyObject = (value)=>isObject(value) && Object.keys(value).length === 0;
+/**
+ * @name isTypedArray
+ * @description Функция isTypedArray принимает значение и возвращает true, если переданное значение является массивом определенного типа.
+ * @param value - значение для проверки
+ * @param type - тип для проверки
+ * @example
+ * isTypedArray([1, 2, 3], Number) // true
+ * isTypedArray([1, 2, 3], String) // false
+ */ function isTypedArray(value, type) {
+    return isArray(value) && value.every((item)=>item instanceof type);
+}
+/**
+ * @name isArrayWithLength
+ * @description Функция isArrayWithLength принимает значение и возвращает true, если переданное значение является массивом определенной длины.
+ * @param value - значение для проверки
+ * @param length - длина массива
+ * @example
+ * isArrayWithLength([1, 2, 3], 3) // true
+ * isArrayWithLength([1, 2, 3], 2) // false
+ */ function isArrayWithLength(value, length) {
+    return isArray(value) && value.length === length;
+}
+/**
+ * @name isEmptyArray
+ * @description Функция isEmptyArray принимает значение и возвращает true, если переданное значение является пустым массивом.
+ * @param value - значение для проверки
+ * @example
+ * isEmptyArray([]) // true
+ * isEmptyArray([1]) // false
+ */ const isEmptyArray = (value)=>Array.isArray(value) && value.length === 0;
+/**
+ * @name isTypeOrNull
+ * @description Функция isTypeOrNull принимает значение и возвращает true, если переданное значение является экземпляром класса или null.
+ * @param value - значение для проверки
+ * @param type - класс для проверки
+ * @example
+ * isTypeOrNull(null, SomeClass) // true
+ * isTypeOrNull(new SomeClass(), SomeClass) // true
+ */ function isTypeOrNull(value, type) {
+    return value === null || value instanceof type;
+}
+const nonNullable = (value)=>value !== null && value !== undefined;
+/**
+ * @name isDate
+ * @description Функция isDate принимает значение и возвращает true, если переданное значение является объектом Date.
+ * @param value - значение для проверки
+ * @example
+ * isDate(new Date()) // true
+ * isDate('2023-01-01') // false
+ */ const isDate = (value)=>value instanceof Date;
+/**
+ * @name isPromise
+ * @description Функция isPromise принимает значение и возвращает true, если переданное значение является Promise.
+ * @param value - значение для проверки
+ * @example
+ * isPromise(Promise.resolve()) // true
+ * isPromise({ then: () => {} }) // false
+ */ const isPromise = (value)=>value instanceof Promise;
+/**
+ * @name isRegExp
+ * @description Функция isRegExp принимает значение и возвращает true, если переданное значение является регулярным выражением.
+ * @param value - значение для проверки
+ * @example
+ * isRegExp(/test/) // true
+ * isRegExp('test') // false
+ */ const isRegExp = (value)=>value instanceof RegExp;
+/**
+ * @name isPrimitive
+ * @description Функция isPrimitive принимает значение и возвращает true, если переданное значение является примитивом.
+ * @param value - значение для проверки
+ * @example
+ * isPrimitive(42) // true
+ * isPrimitive('test') // true
+ * isPrimitive(true) // true
+ * isPrimitive(null) // true
+ * isPrimitive(undefined) // true
+ * isPrimitive({}) // false
+ */ function isPrimitive(value) {
+    return value === null || value === undefined || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+/**
+ * @name isError
+ * @description Функция isError принимает значение и возвращает true, если переданное значение является объектом ошибки.
+ * @param value - значение для проверки
+ * @example
+ * isError(new Error()) // true
+ * isError({ message: 'error' }) // false
+ */ const isError = (value)=>value instanceof Error;
+/**
+ * @name isSymbol
+ * @description Функция isSymbol принимает значение и возвращает true, если переданное значение является символом.
+ * @param value - значение для проверки
+ * @example
+ * isSymbol(Symbol()) // true
+ * isSymbol('symbol') // false
+ */ const isSymbol = (value)=>typeof value === 'symbol';
+/**
+ * @name isMap
+ * @description Функция isMap принимает значение и возвращает true, если переданное значение является объектом Map.
+ * @param value - значение для проверки
+ * @example
+ * isMap(new Map()) // true
+ * isMap({}) // false
+ */ const isMap = (value)=>value instanceof Map;
+/**
+ * @name isSet
+ * @description Функция isSet принимает значение и возвращает true, если переданное значение является объектом Set.
+ * @param value - значение для проверки
+ * @example
+ * isSet(new Set()) // true
+ * isSet([]) // false
+ */ const isSet = (value)=>value instanceof Set;
+/**
+ * @name isReactElement
+ * @description Функция isReactElement принимает значение и возвращает true, если переданное значение является React элементом.
+ * @param value - значение для проверки
+ * @example
+ * isReactElement(<div>Test</div>) // true
+ * isReactElement('div') // false
+ */ function isReactElement(value) {
+    return isObject(value) && 'type' in value && 'props' in value && '$$typeof' in value;
+}
+/**
+ * @name isReactComponent
+ * @description Функция isReactComponent принимает значение и возвращает true, если переданное значение является React компонентом.
+ * @param value - значение для проверки
+ * @example
+ * const MyComponent = () => <div>Test</div>;
+ * isReactComponent(MyComponent) // true
+ * isReactComponent('div') // false
+ */ function isReactComponent(value) {
+    return isFunction(value) || isObject(value) && 'render' in value;
+}
+/**
+ * @name isComponentType
+ * @description Функция isComponentType принимает значение и тип компонента, возвращает true, если переданное значение является компонентом указанного типа.
+ * @param value - значение для проверки
+ * @param componentType - тип компонента для проверки
+ * @example
+ * const MyComponent = () => <div>Test</div>;
+ * isComponentType(<MyComponent />, MyComponent) // true
+ */ function isComponentType(value, componentType) {
+    return isReactElement(value) && value.type === componentType;
+}
+/**
+ * @name isReactEvent
+ * @description Функция isReactEvent принимает значение и возвращает true, если переданное значение является React событием.
+ * @param value - значение для проверки
+ * @example
+ * const handleClick = (e) => {
+ *   if (isReactEvent(e)) {
+ *     e.preventDefault();
+ *   }
+ * };
+ */ function isReactEvent(value) {
+    return isObject(value) && 'nativeEvent' in value && 'currentTarget' in value && 'target' in value;
+}
+/**
+ * @name isRef
+ * @description Функция isRef принимает значение и возвращает true, если переданное значение является React рефом.
+ * @param value - значение для проверки
+ * @example
+ * const ref = useRef(null);
+ * isRef(ref) // true
+ */ function isRef(value) {
+    return isObject(value) && 'current' in value;
+}
+/**
+ * @name isContext
+ * @description Функция isContext принимает значение и возвращает true, если переданное значение является React контекстом.
+ * @param value - значение для проверки
+ * @example
+ * const MyContext = React.createContext(null);
+ * isContext(MyContext) // true
+ */ function isContext(value) {
+    return isObject(value) && 'Provider' in value && 'Consumer' in value;
+}
+/**
+ * @name isType
+ * @description Функция isType принимает значение и тип, возвращает true, если переданное значение соответствует указанному типу.
+ * @param value - значение для проверки
+ * @param type - тип для проверки
+ * @example
+ * interface User {
+ *   name: string;
+ *   age: number;
+ * }
+ *
+ * const user = { name: "John", age: 30 };
+ * const isUser = isType<User>(user,);
+ * console.log(isUser); // true
+ *
+ * const notUser = "John";
+ * console.log(isType<User>(notUser)); // false
+ */ function isType(value) {
+    const type = typeof value;
+    return type === 'string' || type === 'number' || type === 'boolean' || type === 'object' || type === 'function' || type === 'undefined' || type === 'symbol' || type === 'bigint';
+}
+const typesGuards = {
+    isArray,
+    isObject,
+    isNumber,
+    isString,
+    isBoolean,
+    isFunction,
+    isInstanceOf,
+    isEnumValue,
+    isNullOrUndefined,
+    isTruthy,
+    isEmptyObject,
+    isEmptyArray,
+    isTypedArray,
+    isArrayWithLength,
+    isTypeOrNull,
+    nonNullable,
+    isDate,
+    isPromise,
+    isRegExp,
+    isPrimitive,
+    isError,
+    isSymbol,
+    isMap,
+    isSet,
+    isReactElement,
+    isReactComponent,
+    isComponentType,
+    isReactEvent,
+    isRef,
+    isContext,
+    isType
+};
+const _default = typesGuards;
+
+//# sourceMappingURL=typeGuards.js.map

package/dist/Functions/guards/typeGuards.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/Functions/guards/typeGuards.ts"],"sourcesContent":["/**\n * @name isArray\n * @description Функция isArray принимает значение и возвращает true, если переданное значение является массивом.\n * @param value - значение для проверки\n * @example\n * const result = isArray([]);\n * console.log(result); // true\n * @example\n * const result = isArray({});\n * console.log(result); // false\n */\nconst isArray = (value: unknown): value is unknown[] => Array.isArray(value);\n\n/**\n * @name isObject\n * @description Функция isObject принимает значение и возвращает true, если переданное значение является объектом.\n * @param value - значение для проверки\n * @example\n * const result = isObject({});\n * console.log(result); // true\n * @example\n * const result = isObject([]);\n * console.log(result); // false\n */\nfunction isObject(value: unknown): value is object {\n  return typeof value === 'object' && value !== null && !isArray(value)\n}\n\n/**\n * @name isNumber\n * @description Функция isNumber принимает значение и возвращает true, если переданное значение является числом.\n * @param value - значение для проверки\n * @example\n * const result = isNumber(1);\n * console.log(result); // true\n */\nconst isNumber = (value: unknown): value is number => typeof value === 'number';\n\n/**\n * @name isString\n * @description Функция isString принимает значение и возвращает true, если переданное значение является строкой.\n * @param value - значение для проверки\n * @example\n * const result = isString('string');\n * console.log(result); // true\n */\nconst isString = (value: unknown): value is string => typeof value === 'string';\n\n/**\n * @name isBoolean\n * @description Функция isBoolean принимает значение и возвращает true, если переданное значение является булевым.\n * @param value - значение для проверки\n * @example\n * const result = isBoolean(true);\n * console.log(result); // true\n */\nconst isBoolean = (value: unknown): value is boolean => typeof value === 'boolean';\n\n/**\n * @name isFunction\n * @description Функция isFunction принимает значение и возвращает true, если переданное значение является функцией.\n * @param value - значение для проверки\n * @example\n * const result = isFunction(() => {});\n * console.log(result); // true\n * @example\n * const result = isFunction('string');\n * console.log(result); // false\n * @example\n * const result = isFunction(1);\n * console.log(result); // false\n */\nconst isFunction = (value: unknown): value is (...args: any[]) => any => typeof value === 'function';\n\n/**\n * @name isInstanceOf\n * @description Функция isInstanceOf принимает значение и возвращает true, если переданное значение является экземпляром класса.\n * @param value - значение для проверки\n * @param classType - класс для проверки\n * @example\n * class TestClass {}\n * const result = isInstanceOf(new TestClass(), TestClass);\n * console.log(result); // true\n */\nconst isInstanceOf = <T>(value: unknown, classType: new () => T): value is T => value instanceof classType;\n\n/**\n * @name isEnumValue\n * @description Функция isEnumValue принимает значение и возвращает true, если переданное значение является значением enum.\n * @param enumObject - enum для проверки\n * @param value - значение для проверки\n * @example\n * enum Colors {\n * Red = 'red',\n * Green = 'green',\n * Blue = 'blue',\n * }\n * const result = isEnumValue(Colors, 'red');\n * console.log(result); // true\n * @returns true - если значение является значением enum, false - если значение не является значением enum\n */\nfunction isEnumValue<T extends string | number>(enumObject: Record<string, T>, value: unknown): value is T {\n  return Object.values(enumObject).includes(value as T)\n}\n\n/**\n * @name isNullOrUndefined\n * @description Функция isNullOrUndefined принимает значение и возвращает true, если переданное значение является null или undefined.\n * @param value - значение для проверки\n * @example\n * isNullOrUndefined(null) // true\n * isNullOrUndefined(undefined) // true\n * isNullOrUndefined(1) // false\n */\nfunction isNullOrUndefined(value: unknown): value is null | undefined {\n  return value === null || value === undefined\n}\n\n/**\n * @name isTruthy\n * @description Функция isTruthy принимает значение и возвращает true, если переданное значение является true.\n * @param value - значение для проверки\n * @example\n * isTruthy(true) // true\n * isTruthy(1) // true\n * isTruthy(Infinity) // true\n * isTruthy(-Infinity) // true\n * isTruthy(Symbol()) // true\n * isTruthy('some string') // true\n * isTruthy({}) // true\n * isTruthy([]) // true\n * isTruthy(Symbol('some description')) // true\n * isTruthy(() => {}) // true\n * isTruthy(function() {}) // true\n * isTruthy(class {}) // true\n * isTruthy(0) // false\n * isTruthy('') // false\n * isTruthy(null) // false\n * isTruthy(undefined) // false\n * isTruthy(NaN) // false\n * isTruthy(false) // false\n */\nconst isTruthy = (value: unknown): value is boolean | number | string | object => !!value;\n\n/**\n * @name isEmptyObject\n * @description Функция isEmptyObject принимает значение и возвращает true, если переданное значение является пустым объектом.\n * @param value - значение для проверки\n * @example\n * isEmptyObject({}) // true\n * isEmptyObject({ a: 1 }) // false\n */\nconst isEmptyObject = (value: unknown): value is object => isObject(value) && Object.keys(value).length === 0;\n\n/**\n * @name isTypedArray\n * @description Функция isTypedArray принимает значение и возвращает true, если переданное значение является массивом определенного типа.\n * @param value - значение для проверки\n * @param type - тип для проверки\n * @example\n * isTypedArray([1, 2, 3], Number) // true\n * isTypedArray([1, 2, 3], String) // false\n */\nfunction isTypedArray<T>(value: unknown, type: new (...args: any[]) => T): value is T[] {\n  return isArray(value) && value.every(item => item instanceof type)\n}\n\n/**\n * @name isArrayWithLength\n * @description Функция isArrayWithLength принимает значение и возвращает true, если переданное значение является массивом определенной длины.\n * @param value - значение для проверки\n * @param length - длина массива\n * @example\n * isArrayWithLength([1, 2, 3], 3) // true\n * isArrayWithLength([1, 2, 3], 2) // false\n */\nfunction isArrayWithLength(value: unknown, length: number): value is unknown[] {\n  return isArray(value) && value.length === length\n}\n\n/**\n * @name isEmptyArray\n * @description Функция isEmptyArray принимает значение и возвращает true, если переданное значение является пустым массивом.\n * @param value - значение для проверки\n * @example\n * isEmptyArray([]) // true\n * isEmptyArray([1]) // false\n */\nconst isEmptyArray = (value: unknown): value is [] => Array.isArray(value) && value.length === 0;\n\n/**\n * @name isTypeOrNull\n * @description Функция isTypeOrNull принимает значение и возвращает true, если переданное значение является экземпляром класса или null.\n * @param value - значение для проверки\n * @param type - класс для проверки\n * @example\n * isTypeOrNull(null, SomeClass) // true\n * isTypeOrNull(new SomeClass(), SomeClass) // true\n */\nfunction isTypeOrNull<T>(value: unknown, type: new (...args: any[]) => T): value is T | null {\n  return value === null || value instanceof type\n}\n\nconst nonNullable = <T>(value: T): value is NonNullable<T> => value !== null && value !== undefined;\n\n/**\n * @name isDate\n * @description Функция isDate принимает значение и возвращает true, если переданное значение является объектом Date.\n * @param value - значение для проверки\n * @example\n * isDate(new Date()) // true\n * isDate('2023-01-01') // false\n */\nconst isDate = (value: unknown): value is Date => value instanceof Date;\n\n/**\n * @name isPromise\n * @description Функция isPromise принимает значение и возвращает true, если переданное значение является Promise.\n * @param value - значение для проверки\n * @example\n * isPromise(Promise.resolve()) // true\n * isPromise({ then: () => {} }) // false\n */\nconst isPromise = (value: unknown): value is Promise<unknown> => value instanceof Promise;\n\n/**\n * @name isRegExp\n * @description Функция isRegExp принимает значение и возвращает true, если переданное значение является регулярным выражением.\n * @param value - значение для проверки\n * @example\n * isRegExp(/test/) // true\n * isRegExp('test') // false\n */\nconst isRegExp = (value: unknown): value is RegExp => value instanceof RegExp;\n\n/**\n * @name isPrimitive\n * @description Функция isPrimitive принимает значение и возвращает true, если переданное значение является примитивом.\n * @param value - значение для проверки\n * @example\n * isPrimitive(42) // true\n * isPrimitive('test') // true\n * isPrimitive(true) // true\n * isPrimitive(null) // true\n * isPrimitive(undefined) // true\n * isPrimitive({}) // false\n */\nfunction isPrimitive(value: unknown): value is string | number | boolean | null | undefined {\n  return value === null || value === undefined || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'\n}\n\n/**\n * @name isError\n * @description Функция isError принимает значение и возвращает true, если переданное значение является объектом ошибки.\n * @param value - значение для проверки\n * @example\n * isError(new Error()) // true\n * isError({ message: 'error' }) // false\n */\nconst isError = (value: unknown): value is Error => value instanceof Error;\n\n/**\n * @name isSymbol\n * @description Функция isSymbol принимает значение и возвращает true, если переданное значение является символом.\n * @param value - значение для проверки\n * @example\n * isSymbol(Symbol()) // true\n * isSymbol('symbol') // false\n */\nconst isSymbol = (value: unknown): value is symbol => typeof value === 'symbol';\n\n/**\n * @name isMap\n * @description Функция isMap принимает значение и возвращает true, если переданное значение является объектом Map.\n * @param value - значение для проверки\n * @example\n * isMap(new Map()) // true\n * isMap({}) // false\n */\nconst isMap = (value: unknown): value is Map<unknown, unknown> => value instanceof Map;\n\n/**\n * @name isSet\n * @description Функция isSet принимает значение и возвращает true, если переданное значение является объектом Set.\n * @param value - значение для проверки\n * @example\n * isSet(new Set()) // true\n * isSet([]) // false\n */\nconst isSet = (value: unknown): value is Set<unknown> => value instanceof Set;\n\n/**\n * @name isReactElement\n * @description Функция isReactElement принимает значение и возвращает true, если переданное значение является React элементом.\n * @param value - значение для проверки\n * @example\n * isReactElement(<div>Test</div>) // true\n * isReactElement('div') // false\n */\nfunction isReactElement(value: unknown): value is React.ReactElement {\n  return isObject(value) && 'type' in value && 'props' in value && '$$typeof' in value;\n}\n\n/**\n * @name isReactComponent\n * @description Функция isReactComponent принимает значение и возвращает true, если переданное значение является React компонентом.\n * @param value - значение для проверки\n * @example\n * const MyComponent = () => <div>Test</div>;\n * isReactComponent(MyComponent) // true\n * isReactComponent('div') // false\n */\nfunction isReactComponent(value: unknown): value is React.ComponentType {\n  return isFunction(value) || (isObject(value) && 'render' in value);\n}\n\n/**\n * @name isComponentType\n * @description Функция isComponentType принимает значение и тип компонента, возвращает true, если переданное значение является компонентом указанного типа.\n * @param value - значение для проверки\n * @param componentType - тип компонента для проверки\n * @example\n * const MyComponent = () => <div>Test</div>;\n * isComponentType(<MyComponent />, MyComponent) // true\n */\nfunction isComponentType<T extends React.ComponentType>(value: unknown, componentType: T): value is React.ReactElement<React.ComponentProps<T>> {\n  return isReactElement(value) && value.type === componentType;\n}\n\n/**\n * @name isReactEvent\n * @description Функция isReactEvent принимает значение и возвращает true, если переданное значение является React событием.\n * @param value - значение для проверки\n * @example\n * const handleClick = (e) => {\n *   if (isReactEvent(e)) {\n *     e.preventDefault();\n *   }\n * };\n */\nfunction isReactEvent(value: unknown): value is React.SyntheticEvent {\n  return isObject(value) && 'nativeEvent' in value && 'currentTarget' in value && 'target' in value;\n}\n\n/**\n * @name isRef\n * @description Функция isRef принимает значение и возвращает true, если переданное значение является React рефом.\n * @param value - значение для проверки\n * @example\n * const ref = useRef(null);\n * isRef(ref) // true\n */\nfunction isRef(value: unknown): value is React.RefObject<unknown> {\n  return isObject(value) && 'current' in value;\n}\n\n/**\n * @name isContext\n * @description Функция isContext принимает значение и возвращает true, если переданное значение является React контекстом.\n * @param value - значение для проверки\n * @example\n * const MyContext = React.createContext(null);\n * isContext(MyContext) // true\n */\nfunction isContext(value: unknown): value is React.Context<unknown> {\n  return isObject(value) && 'Provider' in value && 'Consumer' in value;\n}\n\n/**\n * @name isType\n * @description Функция isType принимает значение и тип, возвращает true, если переданное значение соответствует указанному типу.\n * @param value - значение для проверки\n * @param type - тип для проверки\n * @example\n * interface User {\n *   name: string;\n *   age: number;\n * }\n *\n * const user = { name: \"John\", age: 30 };\n * const isUser = isType<User>(user,);\n * console.log(isUser); // true\n *\n * const notUser = \"John\";\n * console.log(isType<User>(notUser)); // false\n */\nfunction isType<T>(value: unknown): value is T {\n  const type = typeof value;\n  return (\n    type === 'string'\n    || type === 'number'\n    || type === 'boolean'\n    || type === 'object'\n    || type === 'function'\n    || type === 'undefined'\n    || type === 'symbol'\n    || type === 'bigint'\n  );\n}\n\nconst typesGuards = {\n  isArray,\n  isObject,\n  isNumber,\n  isString,\n  isBoolean,\n  isFunction,\n  isInstanceOf,\n  isEnumValue,\n  isNullOrUndefined,\n  isTruthy,\n  isEmptyObject,\n  isEmptyArray,\n  isTypedArray,\n  isArrayWithLength,\n  isTypeOrNull,\n  nonNullable,\n  isDate,\n  isPromise,\n  isRegExp,\n  isPrimitive,\n  isError,\n  isSymbol,\n  isMap,\n  isSet,\n  isReactElement,\n  isReactComponent,\n  isComponentType,\n  isReactEvent,\n  isRef,\n  isContext,\n  isType,\n};\n\nexport default typesGuards;\n"],"names":["isArray","value","Array","isObject","isNumber","isString","isBoolean","isFunction","isInstanceOf","classType","isEnumValue","enumObject","Object","values","includes","isNullOrUndefined","undefined","isTruthy","isEmptyObject","keys","length","isTypedArray","type","every","item","isArrayWithLength","isEmptyArray","isTypeOrNull","nonNullable","isDate","Date","isPromise","Promise","isRegExp","RegExp","isPrimitive","isError","Error","isSymbol","isMap","Map","isSet","Set","isReactElement","isReactComponent","isComponentType","componentType","isReactEvent","isRef","isContext","isType","typesGuards"],"mappings":"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"}

package/dist/Functions/hooks/useFormFieldsChangesManager.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+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 _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 timeouts = {
+    timeoutId: null
+};
+const formChanges = [];
+// ? validateField - должен возвращать структуру { field, isValid }
+const useFormFieldsChangesManager = ({ form, setForm, callback, validateField, settings })=>{
+    const { isNotSetForm, isUseValidation = false } = settings || {};
+    //? Пробовал ставить просто useEffect по formChangesRef.current,
+    //? но по какой-то причине после изменении рефки не заходило в useEffect.
+    //? Однако если срабатывал useEffect по какой-нибудь другой переменной,
+    //? то и в useEffect по formChangesRef.current тоже заходило.
+    //? Поэтому тут нужен этот стейт,
+    //? хотя по итогу в конечной реализации с ним даже неплохо получилось (но вообще очень странная ерунда...)
+    const [isFormMustBeChanget, setIsFormMustBeChanget] = (0, _react.useState)(false);
+    //? Ф-я является ф-ей - постановщиком изменений формы в очередь.
+    //? Ф-я получается самовызывающимся геттером.
+    //? Cуть ф-ии:
+    //?   Для того чтоб не спамить изменениями, если их назначается много в рамках одной итерации,
+    //?   ипользую прием с переназначением setTimeout
+    //?   Чтобы преждевременно не спровацировать сработку useEffect
+    //?   по стейту фиксирующему "отмашку" к началу изменений (isFormMustBeChanget)
+    //?   откладываю переназначение этого стейта до приостановки непрерывных вызовов assignChangesToField,
+    //?   но при этом при каждом ее вызове продолжаю добавлять изменения в массив
+    const assignChangesToField = (()=>{
+        return (data, key)=>{
+            clearTimeout(timeouts.timeoutId);
+            formChanges.push({
+                key,
+                data
+            });
+            setIsFormMustBeChanget(false);
+            timeouts.timeoutId = setTimeout(()=>setIsFormMustBeChanget(true), 1);
+            return formChanges;
+        };
+    })();
+    //? Ф-я применяет "накопленные" изменения
+    const changeForm = /*#__PURE__*/ function() {
+        var _ref = _async_to_generator(function*() {
+            let modifiedFormFromOutside;
+            const errorsFromChanges = {};
+            const newForm = formChanges.reduce((acc, change)=>{
+                const { data, key } = change;
+                const { error } = data || {};
+                const field = acc.find((field)=>field.key === key);
+                if (field) {
+                    acc = acc.map((field)=>field.key === key ? _object_spread({}, field, data) : field);
+                    if (error || error !== undefined) errorsFromChanges[key] = error;
+                }
+                return acc;
+            }, form);
+            // ToDo - порефакторить, не прогонять валидацию всех полей, а только измененных
+            const validatedForm = isUseValidation && typeof validateField === "function" ? newForm.map((field)=>{
+                var _validateField_field, _validateField;
+                return _object_spread_props(_object_spread({}, field), {
+                    error: ((_validateField = validateField(_object_spread({}, field), newForm)) === null || _validateField === void 0 ? void 0 : (_validateField_field = _validateField.field) === null || _validateField_field === void 0 ? void 0 : _validateField_field.error) || errorsFromChanges[field.key] || ""
+                });
+            }) : newForm;
+            if (callback && typeof callback === "function") modifiedFormFromOutside = yield callback(validatedForm);
+            if (!isNotSetForm) yield setForm(modifiedFormFromOutside !== null && modifiedFormFromOutside !== void 0 ? modifiedFormFromOutside : validatedForm);
+            formChanges.length = 0;
+            setIsFormMustBeChanget(false);
+        });
+        return function changeForm() {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    (0, _react.useEffect)(()=>{
+        if (isFormMustBeChanget) changeForm();
+    }, [
+        isFormMustBeChanget
+    ]);
+    return {
+        assignChangesToField,
+        isFormMustBeChanget,
+        setIsFormMustBeChanget,
+        changesArray: [
+            ...formChanges
+        ]
+    };
+};
+const _default = useFormFieldsChangesManager;
+
+//# sourceMappingURL=useFormFieldsChangesManager.js.map

package/dist/Functions/hooks/useFormFieldsChangesManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/Functions/hooks/useFormFieldsChangesManager.js"],"sourcesContent":["import React, { useEffect, useState } from \"react\";\n\nconst timeouts = { timeoutId: null };\nconst formChanges = [];\n\n// ? validateField - должен возвращать структуру { field, isValid }\nconst useFormFieldsChangesManager = ({\n  form,\n  setForm,\n  callback,\n  validateField,\n  settings,\n}) => {\n  const { isNotSetForm, isUseValidation = false } = settings || {};\n\n  //? Пробовал ставить просто useEffect по formChangesRef.current,\n  //? но по какой-то причине после изменении рефки не заходило в useEffect.\n  //? Однако если срабатывал useEffect по какой-нибудь другой переменной,\n  //? то и в useEffect по formChangesRef.current тоже заходило.\n  //? Поэтому тут нужен этот стейт,\n  //? хотя по итогу в конечной реализации с ним даже неплохо получилось (но вообще очень странная ерунда...)\n  const [isFormMustBeChanget, setIsFormMustBeChanget] = useState(false);\n\n  //? Ф-я является ф-ей - постановщиком изменений формы в очередь.\n  //? Ф-я получается самовызывающимся геттером.\n  //? Cуть ф-ии:\n  //?   Для того чтоб не спамить изменениями, если их назначается много в рамках одной итерации,\n  //?   ипользую прием с переназначением setTimeout\n\n  //?   Чтобы преждевременно не спровацировать сработку useEffect\n  //?   по стейту фиксирующему \"отмашку\" к началу изменений (isFormMustBeChanget)\n  //?   откладываю переназначение этого стейта до приостановки непрерывных вызовов assignChangesToField,\n  //?   но при этом при каждом ее вызове продолжаю добавлять изменения в массив\n  const assignChangesToField = (() => {\n    return (data, key) => {\n      clearTimeout(timeouts.timeoutId);\n      formChanges.push({ key, data });\n      setIsFormMustBeChanget(false);\n      timeouts.timeoutId = setTimeout(() => setIsFormMustBeChanget(true), 1);\n      return formChanges;\n    };\n  })();\n\n  //? Ф-я применяет \"накопленные\" изменения\n  const changeForm = async () => {\n    let modifiedFormFromOutside;\n    const errorsFromChanges = {};\n\n    const newForm = formChanges.reduce((acc, change) => {\n      const { data, key } = change;\n      const { error } = data || {};\n      const field = acc.find((field) => field.key === key);\n\n      if (field) {\n        acc = acc.map((field) =>\n          field.key === key ? { ...field, ...data } : field,\n        );\n        if (error || error !== undefined) errorsFromChanges[key] = error;\n      }\n      return acc;\n    }, form);\n\n    // ToDo - порефакторить, не прогонять валидацию всех полей, а только измененных\n    const validatedForm =\n      isUseValidation && typeof validateField === \"function\"\n        ? newForm.map((field) => ({\n            ...field,\n            error:\n              validateField({ ...field }, newForm)?.field?.error ||\n              errorsFromChanges[field.key] ||\n              \"\",\n          }))\n        : newForm;\n\n    if (callback && typeof callback === \"function\")\n      modifiedFormFromOutside = await callback(validatedForm);\n    if (!isNotSetForm) await setForm(modifiedFormFromOutside ?? validatedForm);\n\n    formChanges.length = 0;\n    setIsFormMustBeChanget(false);\n  };\n\n  useEffect(() => {\n    if (isFormMustBeChanget) changeForm();\n  }, [isFormMustBeChanget]);\n\n  return {\n    assignChangesToField,\n    isFormMustBeChanget,\n    setIsFormMustBeChanget,\n    changesArray: [...formChanges],\n  };\n};\n\nexport default useFormFieldsChangesManager;\n"],"names":["timeouts","timeoutId","formChanges","useFormFieldsChangesManager","form","setForm","callback","validateField","settings","isNotSetForm","isUseValidation","isFormMustBeChanget","setIsFormMustBeChanget","useState","assignChangesToField","data","key","clearTimeout","push","setTimeout","changeForm","modifiedFormFromOutside","errorsFromChanges","newForm","reduce","acc","change","error","field","find","map","undefined","validatedForm","length","useEffect","changesArray"],"mappings":";;;;+BA8FA;;;eAAA;;;+DA9F2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3C,MAAMA,WAAW;IAAEC,WAAW;AAAK;AACnC,MAAMC,cAAc,EAAE;AAEtB,mEAAmE;AACnE,MAAMC,8BAA8B,CAAC,EACnCC,IAAI,EACJC,OAAO,EACPC,QAAQ,EACRC,aAAa,EACbC,QAAQ,EACT;IACC,MAAM,EAAEC,YAAY,EAAEC,kBAAkB,KAAK,EAAE,GAAGF,YAAY,CAAC;IAE/D,gEAAgE;IAChE,yEAAyE;IACzE,uEAAuE;IACvE,6DAA6D;IAC7D,iCAAiC;IACjC,0GAA0G;IAC1G,MAAM,CAACG,qBAAqBC,uBAAuB,GAAGC,IAAAA,eAAQ,EAAC;IAE/D,gEAAgE;IAChE,6CAA6C;IAC7C,cAAc;IACd,8FAA8F;IAC9F,iDAAiD;IAEjD,+DAA+D;IAC/D,+EAA+E;IAC/E,sGAAsG;IACtG,6EAA6E;IAC7E,MAAMC,uBAAuB,AAAC,CAAA;QAC5B,OAAO,CAACC,MAAMC;YACZC,aAAajB,SAASC,SAAS;YAC/BC,YAAYgB,IAAI,CAAC;gBAAEF;gBAAKD;YAAK;YAC7BH,uBAAuB;YACvBZ,SAASC,SAAS,GAAGkB,WAAW,IAAMP,uBAAuB,OAAO;YACpE,OAAOV;QACT;IACF,CAAA;IAEA,yCAAyC;IACzC,MAAMkB;mBAAa,oBAAA;YACjB,IAAIC;YACJ,MAAMC,oBAAoB,CAAC;YAE3B,MAAMC,UAAUrB,YAAYsB,MAAM,CAAC,CAACC,KAAKC;gBACvC,MAAM,EAAEX,IAAI,EAAEC,GAAG,EAAE,GAAGU;gBACtB,MAAM,EAAEC,KAAK,EAAE,GAAGZ,QAAQ,CAAC;gBAC3B,MAAMa,QAAQH,IAAII,IAAI,CAAC,CAACD,QAAUA,MAAMZ,GAAG,KAAKA;gBAEhD,IAAIY,OAAO;oBACTH,MAAMA,IAAIK,GAAG,CAAC,CAACF,QACbA,MAAMZ,GAAG,KAAKA,MAAM,mBAAKY,OAAUb,QAASa;oBAE9C,IAAID,SAASA,UAAUI,WAAWT,iBAAiB,CAACN,IAAI,GAAGW;gBAC7D;gBACA,OAAOF;YACT,GAAGrB;YAEH,+EAA+E;YAC/E,MAAM4B,gBACJtB,mBAAmB,OAAOH,kBAAkB,aACxCgB,QAAQO,GAAG,CAAC,CAACF;oBAGTrB,sBAAAA;uBAHoB,wCACnBqB;oBACHD,OACEpB,EAAAA,iBAAAA,cAAc,mBAAKqB,QAASL,sBAA5BhB,sCAAAA,uBAAAA,eAAsCqB,KAAK,cAA3CrB,2CAAAA,qBAA6CoB,KAAK,KAClDL,iBAAiB,CAACM,MAAMZ,GAAG,CAAC,IAC5B;;iBAEJO;YAEN,IAAIjB,YAAY,OAAOA,aAAa,YAClCe,0BAA0B,MAAMf,SAAS0B;YAC3C,IAAI,CAACvB,cAAc,MAAMJ,QAAQgB,oCAAAA,qCAAAA,0BAA2BW;YAE5D9B,YAAY+B,MAAM,GAAG;YACrBrB,uBAAuB;QACzB;wBApCMQ;;;;IAsCNc,IAAAA,gBAAS,EAAC;QACR,IAAIvB,qBAAqBS;IAC3B,GAAG;QAACT;KAAoB;IAExB,OAAO;QACLG;QACAH;QACAC;QACAuB,cAAc;eAAIjC;SAAY;IAChC;AACF;MAEA,WAAeC"}