@wise/dynamic-flow-client 5.11.0 → 5.12.0

package/build/utils/type-validators.test.js

@@ -1,180 +0,0 @@
-import { isString, isNumber, isInteger, isBoolean, isArray, isObject, isNull, isUndefined, isNullish, isValidDate, } from './type-validators';
-describe('type-validators', () => {
-    describe('isString', () => {
-        it('should return true when the value is a string', () => {
-            expect(isString('a')).toBe(true);
-            expect(isString('')).toBe(true);
-        });
-        it('should return false when the value is a different primitive type', () => {
-            expect(isString(1)).toBe(false);
-            expect(isString(true)).toBe(false);
-            expect(isString(undefined)).toBe(false);
-            expect(isString(null)).toBe(false);
-            expect(isString(Number.NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', () => {
-            expect(isString([])).toBe(false);
-            expect(isString({})).toBe(false);
-        });
-    });
-    describe('isNumber', () => {
-        it('should return true when the value is a number', () => {
-            expect(isNumber(1)).toBe(true);
-            expect(isNumber(0)).toBe(true);
-            expect(isNumber(1.23)).toBe(true);
-            expect(isNumber(-1)).toBe(true);
-        });
-        it('should return false when the value is a different primitive type', () => {
-            expect(isNumber('a')).toBe(false);
-            expect(isNumber(true)).toBe(false);
-            expect(isNumber(undefined)).toBe(false);
-            expect(isNumber(null)).toBe(false);
-            expect(isNumber(Number.NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', () => {
-            expect(isNumber([])).toBe(false);
-            expect(isNumber({})).toBe(false);
-        });
-    });
-    describe('isInteger', () => {
-        it('should return true when the value is a integer', () => {
-            expect(isInteger(1)).toBe(true);
-            expect(isInteger(0)).toBe(true);
-            expect(isInteger(-1)).toBe(true);
-        });
-        it('should return false when the value is a float', () => {
-            expect(isInteger(1.23)).toBe(false);
-            expect(isInteger(-1.23)).toBe(false);
-        });
-        it('should return false when the value is a different primitive type', () => {
-            expect(isInteger('a')).toBe(false);
-            expect(isInteger(true)).toBe(false);
-            expect(isInteger(undefined)).toBe(false);
-            expect(isInteger(null)).toBe(false);
-            expect(isInteger(Number.NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', () => {
-            expect(isInteger([])).toBe(false);
-            expect(isInteger({})).toBe(false);
-        });
-    });
-    describe('isBoolean', () => {
-        it('should return true when the value is a boolean', () => {
-            expect(isBoolean(true)).toBe(true);
-            expect(isBoolean(false)).toBe(true);
-        });
-        it('should return false when the value is a different primitive type', () => {
-            expect(isBoolean(1)).toBe(false);
-            expect(isBoolean('a')).toBe(false);
-            expect(isBoolean(undefined)).toBe(false);
-            expect(isBoolean(null)).toBe(false);
-            expect(isBoolean(Number.NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', () => {
-            expect(isBoolean([])).toBe(false);
-            expect(isBoolean({})).toBe(false);
-        });
-    });
-    describe('isArray', () => {
-        it('should return true when the value is an array', () => {
-            expect(isArray([1])).toBe(true);
-            expect(isArray([])).toBe(true);
-        });
-        it('should return false when the value is null or undefined', () => {
-            expect(isArray(undefined)).toBe(false);
-            expect(isArray(null)).toBe(false);
-        });
-        it('should return false when the value is a different primitive type', () => {
-            expect(isArray(1)).toBe(false);
-            expect(isArray('a')).toBe(false);
-            expect(isArray(true)).toBe(false);
-            expect(isArray(Number.NaN)).toBe(false);
-        });
-        it('should return false when the value is an object', () => {
-            expect(isArray({})).toBe(false);
-        });
-    });
-    describe('isObject', () => {
-        it('should return true when the value is an object', () => {
-            expect(isObject({ a: 1 })).toBe(true);
-            expect(isObject({})).toBe(true);
-        });
-        it('should return false when the value is an array', () => {
-            expect(isObject([])).toBe(false);
-        });
-        it('should return false when the value is a primitive', () => {
-            expect(isObject(1)).toBe(false);
-            expect(isObject('a')).toBe(false);
-            expect(isObject(true)).toBe(false);
-            expect(isObject(Number.NaN)).toBe(false);
-        });
-        it('should return false when the value is null or undefined', () => {
-            expect(isObject(undefined)).toBe(false);
-            expect(isObject(null)).toBe(false);
-        });
-    });
-    describe('isNull', () => {
-        it('should return true when the value is null', () => {
-            expect(isNull(null)).toBe(true);
-        });
-        it('should return false when the value is undefined', () => {
-            expect(isNull(undefined)).toBe(false);
-        });
-        it('should return false when the value is a primitive', () => {
-            expect(isNull(0)).toBe(false);
-            expect(isNull(false)).toBe(false);
-            expect(isNull(Number.NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', () => {
-            expect(isNull([])).toBe(false);
-            expect(isNull({})).toBe(false);
-        });
-    });
-    describe('isUndefined', () => {
-        it('should return true when the value is undefined', () => {
-            expect(isUndefined(undefined)).toBe(true);
-        });
-        it('should return false when the value is a primitive', () => {
-            expect(isUndefined(0)).toBe(false);
-            expect(isUndefined(false)).toBe(false);
-            expect(isUndefined(null)).toBe(false);
-            expect(isUndefined(Number.NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', () => {
-            expect(isNull([])).toBe(false);
-            expect(isNull({})).toBe(false);
-        });
-    });
-    describe('isNullish', () => {
-        it('should return true when the value is null or undefined', () => {
-            expect(isNullish(null)).toBe(true);
-            expect(isNullish(undefined)).toBe(true);
-        });
-        it('should return false when the value is a primitive', () => {
-            expect(isNullish(0)).toBe(false);
-            expect(isNullish(false)).toBe(false);
-            expect(isNullish(Number.NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', () => {
-            expect(isNullish([])).toBe(false);
-            expect(isNullish({})).toBe(false);
-        });
-    });
-    describe('isValidDate', () => {
-        it('should return false for a non-date string', () => {
-            expect(isValidDate('not-a-date')).toBe(false);
-            expect(isValidDate('')).toBe(false);
-        });
-        it('should return false for a non-formatted date', () => {
-            expect(isValidDate('2021/01/01')).toBe(false);
-            expect(isValidDate('01-01-2021')).toBe(false);
-        });
-        it('should return false for a partial date', () => {
-            expect(isValidDate('2021-01')).toBe(false);
-        });
-        it("should return true for a well-formatted full-date (even if the date doesn't exist)", () => {
-            expect(isValidDate('2021-01-01')).toBe(true);
-            expect(isValidDate('2021-02-30')).toBe(true);
-        });
-    });
-});

package/build/utils/useStableCallback.js

@@ -1,15 +0,0 @@
-import { useCallback, useEffect, useRef } from 'react';
-/**
- * Returns a referentially stable function that always calls the latest function.
- * @param handler
- * @returns
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function useStableCallback(handler) {
-    const ref = useRef(handler);
-    useEffect(() => {
-        ref.current = handler;
-    });
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return useCallback((...args) => (ref.current ? ref.current(...args) : null), []);
-}