@wise/dynamic-flow-client 3.11.3 → 3.11.4-experiment-node20-aa45bc2

package/build/legacy/formControl/utils/value-utils.js

@@ -0,0 +1,108 @@
+/* eslint-disable no-console */
+import { dateStringToDate } from '../../common/utils';
+import { isBoolean, isNull, isNumber, isObject, isString } from '../../common/validators';
+export var getSafeStringValue = function (value, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.coerceValue, coerceValue = _a === void 0 ? false : _a;
+    if (isNull(value)) {
+        return undefined;
+    }
+    if (isObject(value)) {
+        logInvalidTypeFallbackWarning({ received: 'object', expected: 'string' });
+        return undefined;
+    }
+    if (!isString(value)) {
+        if (coerceValue) {
+            // TODO: Remove this coercion once we're sure everyone has had a chance to address warnings
+            logInvalidTypeCoercedWarning({ received: typeof value, expected: 'string' });
+            return String(value);
+        }
+        else {
+            logInvalidTypeFallbackWarning({ received: typeof value, expected: 'string' });
+            return undefined;
+        }
+    }
+    return value;
+};
+export var getSafeStringOrNumberValue = function (value, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.coerceValue, coerceValue = _a === void 0 ? false : _a;
+    if (isNull(value)) {
+        return undefined;
+    }
+    if (isNumber(value)) {
+        return value;
+    }
+    var logProps = { received: typeof value, expected: 'string or number' };
+    if (isObject(value)) {
+        logInvalidTypeFallbackWarning(logProps);
+        return undefined;
+    }
+    if (!isString(value)) {
+        if (coerceValue) {
+            // TODO: Remove this coercion once we're sure everyone has had a chance to address warnings
+            logInvalidTypeCoercedWarning(logProps);
+            return String(value);
+        }
+        else {
+            logInvalidTypeFallbackWarning(logProps);
+            return undefined;
+        }
+    }
+    return value;
+};
+export var getSafeBooleanValue = function (value, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.coerceValue, coerceValue = _a === void 0 ? false : _a;
+    if (isNull(value)) {
+        return false;
+    }
+    if (!isBoolean(value)) {
+        if (coerceValue) {
+            // TODO: Remove this coercion once we're sure everyone has had a chance to address warnings
+            logInvalidTypeCoercedWarning({ received: typeof value, expected: 'boolean' });
+            return Boolean(value);
+        }
+        else {
+            logInvalidTypeFallbackWarning({ received: typeof value, expected: 'boolean' });
+            return undefined;
+        }
+    }
+    return value;
+};
+export var getSafeDateOrStringValue = function (value) {
+    if (isNull(value)) {
+        return undefined;
+    }
+    if (!(value instanceof Date) && !isString(value)) {
+        logInvalidTypeFallbackWarning({ received: typeof value, expected: 'string or Date' });
+        return undefined;
+    }
+    return value;
+};
+export var getSafeDateStringValue = function (value) {
+    if (isNull(value)) {
+        return null;
+    }
+    if (!isString(value)) {
+        logInvalidTypeFallbackWarning({
+            received: typeof value,
+            expected: 'string',
+            fallback: 'null',
+        });
+        return null;
+    }
+    var date = dateStringToDate(value);
+    if (date === null) {
+        console.warn('Incorrectly formatted date string. Falling back to null.');
+    }
+    return date;
+};
+var logInvalidTypeCoercedWarning = function (_a) {
+    var received = _a.received, expected = _a.expected;
+    console.warn("Value with type ".concat(received, " passed to control that only accepts type ").concat(expected, ". Type will be coerced, but this behaviour will change in the future, so please fix your code."));
+};
+var logInvalidTypeFallbackWarning = function (_a) {
+    var received = _a.received, expected = _a.expected, _b = _a.fallback, fallback = _b === void 0 ? 'undefined' : _b;
+    console.warn("Value with type ".concat(received, " passed to control that only accepts type ").concat(expected, ". Falling back to ").concat(fallback));
+};

package/build/legacy/formControl/utils/value-utils.spec.js

@@ -0,0 +1,158 @@
+import { getSafeBooleanValue, getSafeDateOrStringValue, getSafeDateStringValue, getSafeStringOrNumberValue, getSafeStringValue, } from './value-utils';
+describe('getSafeStringValue', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('returns undefined when value is null', function () {
+        expect(getSafeStringValue(null)).toBeUndefined();
+    });
+    it('returns undefined and logs a warning if value is an object', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeStringValue({ value: 1, label: 'One' })).toBeUndefined();
+        expect(mockWarn).toHaveBeenCalledTimes(1);
+    });
+    it('returns undefined and logs a warning if value is not a string', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeStringValue(1)).toBeUndefined();
+        expect(getSafeStringValue(false)).toBeUndefined();
+        expect(getSafeStringValue(new Date())).toBeUndefined();
+        expect(mockWarn).toHaveBeenCalledTimes(3);
+    });
+    it('returns value when value is a string', function () {
+        expect(getSafeStringValue('')).toBe('');
+        expect(getSafeStringValue('cat')).toBe('cat');
+    });
+    describe('when coerceValue is true', function () {
+        it('returns coerced value and logs a warning if value is not a string', function () {
+            var mockWarn = jest.fn();
+            jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+            expect(getSafeStringValue(1, { coerceValue: true })).toBe('1');
+            expect(getSafeStringValue(false, { coerceValue: true })).toBe('false');
+            expect(mockWarn).toHaveBeenCalledTimes(2);
+        });
+    });
+});
+describe('getSafeStringOrNumberValue', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('returns undefined when value is null', function () {
+        expect(getSafeStringOrNumberValue(null)).toBeUndefined();
+    });
+    it('returns undefined when value is NaN', function () {
+        expect(getSafeStringOrNumberValue(NaN)).toBeUndefined();
+    });
+    it('returns value if value is a valid number', function () {
+        expect(getSafeStringOrNumberValue(10)).toBe(10);
+        expect(getSafeStringOrNumberValue(10.5)).toBe(10.5);
+    });
+    it('returns undefined and logs a warning if value is an object', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeStringOrNumberValue({ value: 1, label: 'One' })).toBeUndefined();
+        expect(mockWarn).toHaveBeenCalledTimes(1);
+    });
+    it('returns undefined and logs a warning if value is not a string', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeStringOrNumberValue(false)).toBeUndefined();
+        expect(mockWarn).toHaveBeenCalledTimes(1);
+    });
+    it('returns value when value is a string', function () {
+        expect(getSafeStringOrNumberValue('')).toBe('');
+        expect(getSafeStringOrNumberValue('cat')).toBe('cat');
+    });
+    describe('when coerceValue is true', function () {
+        it('returns coerced value and logs a warning if value is not a string', function () {
+            var mockWarn = jest.fn();
+            jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+            expect(getSafeStringOrNumberValue(false, { coerceValue: true })).toBe('false');
+            expect(mockWarn).toHaveBeenCalledTimes(1);
+        });
+    });
+});
+describe('getSafeBooleanValue', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('returns false when value is null', function () {
+        expect(getSafeBooleanValue(null)).toBe(false);
+    });
+    it('returns undefined and logs a warning if value is not a boolean', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeBooleanValue(1)).toBeUndefined();
+        expect(getSafeBooleanValue(NaN)).toBeUndefined();
+        expect(getSafeBooleanValue(new Date())).toBeUndefined();
+        expect(getSafeBooleanValue('cat')).toBeUndefined();
+        expect(getSafeBooleanValue({ value: 1, label: 'One' })).toBeUndefined();
+        expect(mockWarn).toHaveBeenCalledTimes(5);
+    });
+    it('returns value when value is a boolean', function () {
+        expect(getSafeBooleanValue(true)).toBe(true);
+        expect(getSafeBooleanValue(false)).toBe(false);
+    });
+    describe('when coerceValue is true', function () {
+        it('returns coerced value and logs a warning if value is not a boolean', function () {
+            var mockWarn = jest.fn();
+            jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+            expect(getSafeBooleanValue(1, { coerceValue: true })).toBe(true);
+            expect(getSafeBooleanValue(NaN, { coerceValue: true })).toBe(false);
+            expect(getSafeBooleanValue('cat', { coerceValue: true })).toBe(true);
+            expect(getSafeBooleanValue(new Date(), { coerceValue: true })).toBe(true);
+            expect(getSafeBooleanValue({ value: 1, label: 'One' }, { coerceValue: true })).toBe(true);
+            expect(mockWarn).toHaveBeenCalledTimes(5);
+        });
+    });
+});
+describe('getSafeDateOrStringValue', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('returns undefined when value is null', function () {
+        expect(getSafeDateOrStringValue(null)).toBeUndefined();
+    });
+    it('returns value if value is a string', function () {
+        expect(getSafeDateOrStringValue('2019-04-06')).toBe('2019-04-06');
+    });
+    it('returns value if value is a Date', function () {
+        var date = new Date();
+        expect(getSafeDateOrStringValue(date)).toBe(date);
+    });
+    it('returns undefined and logs a warning if value is not a date or a string', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeDateOrStringValue(1)).toBeUndefined();
+        expect(getSafeDateOrStringValue(false)).toBeUndefined();
+        expect(getSafeDateOrStringValue({ value: 1, label: 'One' })).toBeUndefined();
+        expect(mockWarn).toHaveBeenCalledTimes(3);
+    });
+});
+describe('getSafeDateStringValue', function () {
+    afterEach(function () {
+        jest.clearAllMocks();
+    });
+    it('returns null when value is null', function () {
+        expect(getSafeDateStringValue(null)).toBeNull();
+    });
+    it('returns null and logs a warning if value is not a string', function () {
+        var mockWarn = jest.fn();
+        jest.spyOn(console, 'warn').mockImplementation(mockWarn);
+        expect(getSafeDateStringValue(1)).toBeNull();
+        expect(getSafeDateStringValue(false)).toBeNull();
+        expect(getSafeDateStringValue(new Date())).toBeNull();
+        expect(getSafeDateStringValue({ value: 1, label: 'One' })).toBeNull();
+        expect(mockWarn).toHaveBeenCalledTimes(4);
+    });
+    it('returns value as a date if value is a correctly formatted date string', function () {
+        var _a;
+        expect((_a = getSafeDateStringValue('2019-04-06')) === null || _a === void 0 ? void 0 : _a.toDateString()).toStrictEqual(new Date(2019, 3, 6).toDateString());
+    });
+    it('returns null if value is an incorrectly formatted date string', function () {
+        expect(getSafeDateStringValue('')).toBeNull();
+        expect(getSafeDateStringValue('cat')).toBeNull();
+        expect(getSafeDateStringValue('2022')).toBeNull();
+    });
+});