@wise/dynamic-flow-client 5.8.1 → 5.9.0

package/build/utils/recursiveMerge.test.js

@@ -0,0 +1,93 @@
+import { recursiveMerge } from './recursiveMerge';
+describe('Recursive Merge', () => {
+    it('when merging with null, returns current value', () => {
+        const a = true;
+        const b = null;
+        const result = recursiveMerge(a, b);
+        expect(result).toEqual(a);
+    });
+    it('when merging with different type, returns new value', () => {
+        const a = true;
+        const b = 'Overridden';
+        const result = recursiveMerge(a, b);
+        expect(result).toEqual(b);
+    });
+    it('when merging object with object, returns combined object', () => {
+        const a = { prop1: 'value1' };
+        const b = { prop2: 'value2' };
+        const result = recursiveMerge(a, b);
+        expect(result).toEqual({
+            prop1: 'value1',
+            prop2: 'value2',
+        });
+    });
+    it('when merging object with object, performs a deep merge', () => {
+        const a = { prop1: { prop2: 'value2' } };
+        const b = { prop1: { prop3: 'value3' } };
+        const result = recursiveMerge(a, b);
+        expect(result).toEqual({
+            prop1: {
+                prop2: 'value2',
+                prop3: 'value3',
+            },
+        });
+    });
+    it('when merging empty arrays, returns empty array', () => {
+        const a = [];
+        const b = [];
+        const result = recursiveMerge(a, b);
+        expect(result).toEqual([]);
+    });
+    it('when merging arrays, returns merged array', () => {
+        const a = [null, { prop1: 'value1' }, { prop3: 'value3' }, { prop5: 'value5' }];
+        const b = [{ prop7: 'value7' }, null, { prop3: 'value8' }];
+        const result = recursiveMerge(a, b);
+        expect(result).toEqual([
+            { prop7: 'value7' },
+            { prop1: 'value1' },
+            { prop3: 'value8' },
+            { prop5: 'value5' },
+        ]);
+    });
+    it('when merging arrays in reverse order, maintains correct merging behavior', () => {
+        const a = [null, { prop1: 'value1' }, { prop3: 'value3' }, { prop5: 'value5' }];
+        const b = [{ prop7: 'value7' }, null, { prop3: 'value8' }];
+        const result = recursiveMerge(b, a);
+        expect(result).toEqual([
+            { prop7: 'value7' },
+            { prop1: 'value1' },
+            { prop3: 'value3' },
+            { prop5: 'value5' },
+        ]);
+    });
+    it('when a is null and b is not null, returns b', () => {
+        const a = null;
+        const b = { key: 'value' };
+        const result = recursiveMerge(a, b);
+        expect(result).toEqual(b);
+    });
+    it('when both a and b are null, returns null', () => {
+        const a = null;
+        const b = null;
+        const result = recursiveMerge(a, b);
+        expect(result).toBeNull();
+    });
+    it('when merging arrays with different lengths, handles undefined values correctly', () => {
+        const a = [1, 2, 3];
+        const b = [4, 5];
+        const result = recursiveMerge(a, b);
+        expect(result).toEqual([4, 5, 3]);
+    });
+    it('when merging nested objects within arrays, properly merges the nested objects', () => {
+        const a = [{ nested: { prop1: 'value1' } }];
+        const b = [{ nested: { prop2: 'value2' } }];
+        const result = recursiveMerge(a, b);
+        expect(result).toEqual([{ nested: { prop1: 'value1', prop2: 'value2' } }]);
+    });
+    it('when merging File instances, returns the second instance', () => {
+        const a = new File(['content'], 'fileA.txt', { type: 'text/plain' });
+        const b = new File(['content'], 'fileB.txt', { type: 'text/plain' });
+        const result = recursiveMerge(a, b);
+        expect(result).toBe(b);
+    });
+});

package/build/utils/type-utils.js

@@ -0,0 +1,21 @@
+import { isArray, isNullish, isObject } from './type-validators';
+export const hasChildren = (component) => 'getChildren' in component && typeof component.getChildren === 'function';
+export const isHiddenComponent = (component) => 'hidden' in component && component.hidden;
+export const isObjectLocalValue = (value) => value != null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof File);
+export const isArrayLocalValue = (value) => Array.isArray(value);
+export const isObjectModel = (model) => model != null && typeof model === 'object' && !Array.isArray(model);
+export const isArrayModel = (model) => Array.isArray(model);
+export const isAllOfSchema = (schema) => 'allOf' in schema && !isNullish(schema.allOf);
+export const isBooleanSchema = (schema) => 'type' in schema && schema.type === 'boolean';
+export const isBlobSchema = (schema) => 'type' in schema && schema.type === 'blob';
+export const isConstSchema = (schema) => 'const' in schema && schema.const !== undefined;
+export const isIntegerSchema = (schema) => 'type' in schema && schema.type === 'integer';
+export const isNumberSchema = (schema) => 'type' in schema && schema.type === 'number';
+export const isObjectSchema = (schema) => 'type' in schema && schema.type === 'object';
+export const isOneOfSchema = (schema) => 'oneOf' in schema && !isNullish(schema.oneOf);
+export const isArraySchema = (schema) => 'items' in schema && !isNullish(schema.items);
+export const isArrayListSchema = (schema) => 'items' in schema && isObject(schema.items) && !isArray(schema.items);
+export const isArrayTupleSchema = (schema) => 'items' in schema && !isObject(schema.items) && isArray(schema.items);
+export const isStringSchema = (schema) => 'type' in schema && schema.type === 'string';
+export const isStringSchemaWithUpload = (schema) => isStringSchema(schema) && schema.format === 'base64url';
+export const isSchemaWithPersistAsync = (schema) => 'persistAsync' in schema && !isNullish(schema.persistAsync);

package/build/utils/type-validators.js

@@ -0,0 +1,11 @@
+export const isString = (value) => typeof value === 'string';
+export const isNumber = (value) => typeof value === 'number' && !Number.isNaN(value);
+export const isInteger = (value) => isNumber(value) && Math.floor(value) === value;
+export const isBoolean = (value) => typeof value === 'boolean';
+export const isObject = (value) => !isNullish(value) && (value === null || value === void 0 ? void 0 : value.constructor) === Object;
+export const isArray = (value) => Array.isArray(value);
+export const isNull = (value) => value === null;
+export const isUndefined = (value) => typeof value === 'undefined';
+export const isNullish = (v) => isNull(v) || isUndefined(v);
+export const isFile = (value) => value instanceof File;
+export const isValidDate = (value) => isString(value) && /^\d{4}-\d{2}-\d{2}$/.test(value);

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

@@ -0,0 +1,180 @@
+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

@@ -0,0 +1,15 @@
+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), []);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wise/dynamic-flow-client",
-  "version": "5.8.1",
+  "version": "5.9.0",
   "description": "Dynamic Flow web client",
   "license": "Apache-2.0",
   "main": "./build/main.js",
@@ -72,8 +72,8 @@
     "typescript": "5.9.3",
     "vitest": "4.0.18",
     "vitest-fetch-mock": "0.4.5",
-    "@wise/dynamic-flow-renderers": "0.0.0",
-    "@wise/dynamic-flow-fixtures": "0.0.1"
+    "@wise/dynamic-flow-fixtures": "0.0.1",
+    "@wise/dynamic-flow-renderers": "0.0.0"
   },
   "peerDependencies": {
     "@transferwise/components": "^46.104.0",
@@ -86,7 +86,7 @@
     "react-intl": "^6 || ^7"
   },
   "dependencies": {
-    "@wise/dynamic-flow-types": "4.8.1"
+    "@wise/dynamic-flow-types": "4.9.0"
   },
   "scripts": {
     "dev": "EXCLUDE_VISUAL_TESTS=true pnpm storybook dev -p 3003",