@wise/dynamic-flow-client 3.9.1 → 3.9.2-experimental-535221d

package/build/legacy/common/utils/date-utils.js

@@ -0,0 +1,22 @@
+import { isNumber } from '../validators';
+// function taken from: https://stackoverflow.com/questions/23593052/format-javascript-date-as-yyyy-mm-dd
+function formatDate(date) {
+    var d = new Date(date);
+    var month = String(d.getMonth() + 1);
+    var day = String(d.getDate());
+    var year = d.getFullYear();
+    var formattedMonth = month.length < 2 ? "0".concat(month) : month;
+    var formattedDay = day.length < 2 ? "0".concat(day) : day;
+    return [year, formattedMonth, formattedDay].join('-');
+}
+export var dateStringToDate = function (dateString) {
+    if (!dateString) {
+        return null;
+    }
+    var _a = dateString.split('-').map(function (number) { return parseInt(number, 10); }), year = _a[0], month = _a[1], date = _a[2];
+    if (!isNumber(year) || !isNumber(month) || !isNumber(date)) {
+        return null;
+    }
+    return new Date(year, month - 1, date);
+};
+export var dateToDateString = function (date) { return formatDate(date); };

package/build/legacy/common/utils/debounce.js

@@ -0,0 +1,39 @@
+export var debounce = function (callback, waitMs) {
+    var timeoutId;
+    var lastArgs;
+    var clearTimer = function () {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+        lastArgs = null;
+    };
+    var debouncedFn = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        lastArgs = args;
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(function () {
+            callback.apply(void 0, lastArgs);
+            timeoutId = null;
+            lastArgs = null;
+        }, waitMs);
+    };
+    debouncedFn.cancel = function () {
+        if (timeoutId !== null) {
+            clearTimer();
+        }
+    };
+    debouncedFn.flush = function () {
+        if (timeoutId !== null) {
+            callback.apply(void 0, lastArgs);
+            clearTimer();
+        }
+    };
+    debouncedFn.isPending = function () { return timeoutId !== null; };
+    return debouncedFn;
+};

package/build/legacy/common/utils/debounce.spec.js

@@ -0,0 +1,72 @@
+import { debounce } from './debounce';
+describe('debounce', function () {
+    beforeAll(function () {
+        jest.useFakeTimers();
+    });
+    afterAll(function () {
+        jest.useRealTimers();
+    });
+    it('will delay function execution until the wait period has passed', function () {
+        var fn = jest.fn();
+        var debouncedFn = debounce(fn, 5);
+        debouncedFn();
+        expect(fn).toHaveBeenCalledTimes(0);
+        jest.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(1);
+    });
+    it('will call function with provided arguments', function () {
+        var fn = jest.fn();
+        var debouncedFn = debounce(fn, 5);
+        debouncedFn('a', 'b', 'c');
+        jest.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(1);
+        expect(fn).toHaveBeenCalledWith('a', 'b', 'c');
+    });
+    it('will reset the wait period and ignore previous executions if called within the wait period', function () {
+        var fn = jest.fn();
+        var debouncedFn = debounce(fn, 5);
+        debouncedFn(1, 2, 3);
+        jest.advanceTimersByTime(4);
+        debouncedFn('a', 'b', 'c');
+        jest.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(1);
+        expect(fn).toHaveBeenCalledWith('a', 'b', 'c');
+    });
+    it('will call the same function twice if invoked after the wait period', function () {
+        var fn = jest.fn();
+        var debouncedFn = debounce(fn, 5);
+        debouncedFn();
+        jest.advanceTimersByTime(5);
+        debouncedFn();
+        jest.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(2);
+    });
+    describe('flush', function () {
+        it('will call the callback immediately', function () {
+            var fn = jest.fn();
+            var debouncedFn = debounce(fn, 5);
+            debouncedFn();
+            debouncedFn.flush();
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('uses the last passed args', function () {
+            var fn = jest.fn();
+            var debouncedFn = debounce(fn, 5);
+            debouncedFn(1, 2, 3);
+            debouncedFn('a', 'b', 'c');
+            debouncedFn.flush();
+            expect(fn).toHaveBeenCalledTimes(1);
+            expect(fn).toHaveBeenCalledWith('a', 'b', 'c');
+        });
+    });
+    describe('cancel', function () {
+        it('cancels any waiting callback', function () {
+            var fn = jest.fn();
+            var debouncedFn = debounce(fn, 5);
+            debouncedFn();
+            debouncedFn.cancel();
+            jest.advanceTimersByTime(5);
+            expect(fn).toHaveBeenCalledTimes(0);
+        });
+    });
+});

package/build/legacy/common/utils/file-utils.js

@@ -0,0 +1,45 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+export function toKilobytes(sizeInBytes) {
+    var ONE_KB_IN_BYTES = 1024;
+    return Math.floor(sizeInBytes / ONE_KB_IN_BYTES);
+}
+// TODO: Refactor: This is duplicate logic as in CameraStep.tsx
+export var toBase64 = function (file) {
+    return new Promise(function (resolve, reject) {
+        // we can safely assume the type of reader.result is string
+        // because we're calling reader.readAsDataURL
+        // https://developer.mozilla.org/en-US/docs/Web/API/FileReader/result
+        var reader = new FileReader();
+        reader.readAsDataURL(file);
+        reader.addEventListener('load', function () { return resolve(reader.result); });
+        reader.addEventListener('error', function (error) { return reject(error); });
+    });
+};
+export function areFilesSame(newFiles, files) {
+    var fileIdToExistingFileMap = files.reduce(function (map, fileObject) {
+        var _a;
+        return (__assign(__assign({}, map), (_a = {}, _a[fileObject.id] = fileObject, _a)));
+    }, {});
+    for (var _i = 0, newFiles_1 = newFiles; _i < newFiles_1.length; _i++) {
+        var newFile = newFiles_1[_i];
+        var existingFileObject = fileIdToExistingFileMap[newFile.id];
+        var fileDoesNotExistAlready = !existingFileObject;
+        if (fileDoesNotExistAlready) {
+            return false;
+        }
+        if (existingFileObject.status !== newFile.status) {
+            return false;
+        }
+    }
+    return true;
+}

package/build/legacy/common/utils/file-utils.spec.js

@@ -0,0 +1,69 @@
+import { Status } from '@transferwise/components';
+import { areFilesSame } from './file-utils';
+var constructFile = function (_a) {
+    var _b = _a.id, id = _b === void 0 ? 123 : _b, _c = _a.status, status = _c === void 0 ? Status.SUCCEEDED : _c;
+    return ({ id: id, status: status });
+};
+describe('Given a set of utility functions for file', function () {
+    describe('when checking if two lists of files are same', function () {
+        it('should return true if empty file list is compared', function () {
+            expect(areFilesSame([], [])).toBeTruthy();
+        });
+        it('should return false comparing file with different ids', function () {
+            var file = constructFile({ id: 123 });
+            var anotherFile = constructFile({ id: 234 });
+            expect(areFilesSame([anotherFile], [file])).toBeFalsy();
+        });
+        it('should return true comparing file with same ids', function () {
+            var file = constructFile({ id: 123 });
+            var anotherFile = constructFile({ id: 123 });
+            expect(areFilesSame([anotherFile], [file])).toBeTruthy();
+        });
+        it('should return false comparing file with same ids but different status', function () {
+            var anotherFile = constructFile({ id: 123, status: Status.FAILED });
+            var file = constructFile({ id: 123, status: Status.SUCCEEDED });
+            expect(areFilesSame([anotherFile], [file])).toBeFalsy();
+        });
+        it('should return false comparing respective file ids with their status status', function () {
+            var fileUpdate1 = constructFile({ id: 111, status: Status.FAILED });
+            var fileUpdate2 = constructFile({ id: 222, status: Status.SUCCEEDED });
+            var fileUpdate3 = constructFile({ id: 333, status: Status.SUCCEEDED });
+            var file1 = constructFile({ id: 111, status: Status.PENDING });
+            var file2 = constructFile({ id: 222, status: Status.SUCCEEDED });
+            var file3 = constructFile({ id: 333, status: Status.SUCCEEDED });
+            expect(areFilesSame([fileUpdate1, fileUpdate2, fileUpdate3], [file1, file2, file3])).toBeFalsy();
+        });
+        describe('should only consider id and status in similarity comparison', function () {
+            it('when files are same', function () {
+                var anotherFile = {
+                    id: 111,
+                    status: Status.SUCCEEDED,
+                    url: 'www.something.com/file.png',
+                    filename: 'filename1.png',
+                };
+                var file = {
+                    id: 111,
+                    status: Status.SUCCEEDED,
+                    url: 'www.somethingElse.com/file.png',
+                    filename: 'filename2.png',
+                };
+                expect(areFilesSame([anotherFile], [file])).toBeTruthy();
+            });
+            it('when files are different', function () {
+                var anotherFile = {
+                    id: 111,
+                    status: Status.SUCCEEDED,
+                    url: 'www.something.com/file.png',
+                    filename: 'filename.png',
+                };
+                var file = {
+                    id: 112,
+                    status: Status.SUCCEEDED,
+                    url: 'www.something.com/file.png',
+                    filename: 'filename.png',
+                };
+                expect(areFilesSame([anotherFile], [file])).toBeFalsy();
+            });
+        });
+    });
+});

package/build/legacy/common/utils/id-utils.js

@@ -0,0 +1,5 @@
+export var generateRandomId = function (prefix) {
+    if (prefix === void 0) { prefix = ''; }
+    var prefixString = prefix ? "".concat(prefix, "-") : '';
+    return "".concat(prefixString).concat(Math.floor(100000000 * Math.random()));
+};

package/build/legacy/common/utils/id-utils.spec.js

@@ -0,0 +1,12 @@
+import { generateRandomId } from './id-utils';
+jest.spyOn(Math, 'random').mockReturnValue(0.123456789);
+describe('generateRandomId', function () {
+    it('should generate a random id', function () {
+        var id = generateRandomId();
+        expect(id).toBe('12345678');
+    });
+    it('should generate a random id with a prefix', function () {
+        var id = generateRandomId('prefix');
+        expect(id).toBe('prefix-12345678');
+    });
+});

package/build/legacy/common/utils/index.js

@@ -0,0 +1,11 @@
+export * from './api-utils';
+export * from './date-utils';
+export * from './debounce';
+export * from './is-equal';
+export * from './file-utils';
+export * from './id-utils';
+export * from './step-utils';
+export * from './model-utils';
+export * from './misc-utils';
+export * from './schema-utils';
+export * from './mobile-utils';

package/build/legacy/common/utils/is-equal.js

@@ -0,0 +1,21 @@
+export var isEqual = function (a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every(function (item, index) { return isEqual(item, b[index]); });
+    }
+    if (isNonNullObject(a) && isNonNullObject(b) && isObjectEquals(a, b)) {
+        return true;
+    }
+    return false;
+};
+var isObjectEquals = function (a, b) {
+    var keysA = Object.keys(a);
+    var keysB = Object.keys(b);
+    return (keysA.length === keysB.length &&
+        keysA.every(function (key) { return Object.hasOwnProperty.call(b, key) && isEqual(a[key], b[key]); }));
+};
+var isNonNullObject = function (a) {
+    return typeof a === 'object' && a !== null;
+};

package/build/legacy/common/utils/is-equal.spec.js

@@ -0,0 +1,88 @@
+import { isEqual } from './is-equal';
+describe('isEqual', function () {
+    describe('primitives', function () {
+        it('will be true for null equality', function () {
+            expect(isEqual(null, null)).toBe(true);
+        });
+        it('will be true for undefined equality', function () {
+            expect(isEqual(undefined, undefined)).toBe(true);
+        });
+        it('will be true for string equality', function () {
+            expect(isEqual('a string', 'a string')).toBe(true);
+            expect(isEqual('', '')).toBe(true);
+        });
+        it('will be true for number equality', function () {
+            expect(isEqual(0, 0)).toBe(true);
+            expect(isEqual(123, 123)).toBe(true);
+            expect(isEqual(123.456, 123.456)).toBe(true);
+            expect(isEqual(123, 123.0)).toBe(true);
+        });
+        it('will be true for boolean equality', function () {
+            expect(isEqual(false, false)).toBe(true);
+            expect(isEqual(true, true)).toBe(true);
+        });
+        it('will be false for null inequality', function () {
+            expect(isEqual(null, undefined)).toBe(false);
+            expect(isEqual(null, '')).toBe(false);
+            expect(isEqual(null, 0)).toBe(false);
+            expect(isEqual(null, {})).toBe(false);
+        });
+        it('will be false for undefined inequality', function () {
+            expect(isEqual(undefined, null)).toBe(false);
+            expect(isEqual(undefined, '')).toBe(false);
+            expect(isEqual(undefined, 0)).toBe(false);
+            expect(isEqual(undefined, {})).toBe(false);
+        });
+        it('will be false for string inequality', function () {
+            expect(isEqual('a string', null)).toBe(false);
+            expect(isEqual('a string', '')).toBe(false);
+            expect(isEqual('a string', 0)).toBe(false);
+            expect(isEqual('a string', {})).toBe(false);
+        });
+        it('will be false for number inequality', function () {
+            expect(isEqual(123, null)).toBe(false);
+            expect(isEqual(123, '')).toBe(false);
+            expect(isEqual(123, 0)).toBe(false);
+            expect(isEqual(123, {})).toBe(false);
+        });
+    });
+    describe('arrays', function () {
+        it('will be true for primitive array equality', function () {
+            expect(isEqual([1, 2, 3], [1, 2, 3])).toBe(true);
+            expect(isEqual(['a', 'b', 'c'], ['a', 'b', 'c'])).toBe(true);
+            expect(isEqual([true, false], [true, false])).toBe(true);
+            expect(isEqual([null, undefined], [null, undefined])).toBe(true);
+        });
+        it('will be true for complex array equality', function () {
+            expect(isEqual([{ a: 1, b: 2 }, { c: { d: 4 } }], [{ a: 1, b: 2 }, { c: { d: 4 } }])).toBe(true);
+            expect(isEqual([{}], [{}])).toBe(true);
+        });
+        it('will be true for nested array equality', function () {
+            expect(isEqual([[1], [2], [3, 4]], [[1], [2], [3, 4]])).toBe(true);
+        });
+        it('will be false for inequivalent arrays', function () {
+            expect(isEqual([1, 2, 3], [4, 5, 6])).toBe(false);
+            expect(isEqual([null], [{}])).toBe(false);
+            expect(isEqual({ a: 'b' }, { b: 'c' })).toBe(false);
+        });
+        it('will be false for differently ordered arrays', function () {
+            expect(isEqual([1, 2, 3], [3, 2, 1])).toBe(false);
+        });
+    });
+    describe('objects', function () {
+        it('will return true for equivalent objects', function () {
+            expect(isEqual({ a: 'b', b: 1 }, { a: 'b', b: 1 })).toBe(true);
+            expect(isEqual({}, {})).toBe(true);
+        });
+        it('will return true for nested equivalent objects', function () {
+            expect(isEqual({ a: 'b', b: { c: { d: 1 } } }, { b: { c: { d: 1 } }, a: 'b' })).toBe(true);
+            expect(isEqual({ a: 'b', b: [1, 2, 3] }, { b: [1, 2, 3], a: 'b' })).toBe(true);
+        });
+        it('will return false for inequivalent objects', function () {
+            expect(isEqual({ a: 'b' }, { b: 1, c: 2 })).toBe(false);
+            expect(isEqual({ a: 'c', b: { c: { d: 1 } } }, { b: { c: { d: 1 } }, a: 'b' })).toBe(false);
+            expect(isEqual({ a: 'b', b: [1, 2, 3] }, { a: 'b', b: [4, 5, 6] })).toBe(false);
+            expect(isEqual({ a: 1 }, { a: 2 })).toBe(false);
+        });
+    });
+});

package/build/legacy/common/utils/misc-utils.js

@@ -0,0 +1,4 @@
+import { isNull, isString } from '../validators';
+export var isBasicError = function (error) {
+    return isString(error) || isNull(error);
+};

package/build/legacy/common/utils/mobile-utils.js

@@ -0,0 +1,23 @@
+export var isMobile = function () { return isMobileScreenSize() && (isTouchScreen() || isMobileUA()); };
+export var isMobileUA = function (userAgent) {
+    if (userAgent === void 0) { userAgent = window.navigator.userAgent; }
+    // eslint-disable-next-line regexp/no-unused-capturing-group
+    return /mobi|\b(iphone|android|blackberry|webos|windows phone)\b/i.test(userAgent);
+};
+export var isMobileScreenSize = function (width, height) {
+    if (width === void 0) { width = window.screen.width; }
+    if (height === void 0) { height = window.screen.height; }
+    return width < 768 || height < 768;
+};
+export var isTouchScreen = function (navigator, matchMedia) {
+    if (navigator === void 0) { navigator = window.navigator; }
+    if (matchMedia === void 0) { matchMedia = window.matchMedia; }
+    if ('maxTouchPoints' in navigator) {
+        return navigator.maxTouchPoints > 0;
+    }
+    var mQ = matchMedia === null || matchMedia === void 0 ? void 0 : matchMedia('(pointer:coarse)');
+    if ((mQ === null || mQ === void 0 ? void 0 : mQ.media) === '(pointer:coarse)') {
+        return Boolean(mQ.matches);
+    }
+    return false;
+};

package/build/legacy/common/utils/mobile-utils.spec.js

@@ -0,0 +1,71 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { isMobileUA, isMobileScreenSize, isTouchScreen } from './mobile-utils';
+describe('hasMobileUA', function () {
+    it('should return true for iPhone user agent', function () {
+        expect(isMobileUA('Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Mobile/15E148 Safari/604.1')).toBe(true);
+    });
+    it('should return true for Android user agent', function () {
+        expect(isMobileUA('Mozilla/5.0 (Linux; Android 11; Pixel 4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.66 Mobile Safari/537.36')).toBe(true);
+    });
+    it('should return true for BlackBerry user agent', function () {
+        expect(isMobileUA('Mozilla/5.0 (BB10; Touch) AppleWebKit/537.36 (KHTML, like Gecko) Version/10.3.2.2639 Mobile Safari/537.36')).toBe(true);
+    });
+    it('should return true for webOS user agent', function () {
+        expect(isMobileUA('Mozilla/5.0 (webOS/2.2.4; U; en-US) AppleWebKit/534.6 (KHTML, like Gecko) wOSBrowser/234.83 Safari/534.6 Pre/3.0')).toBe(true);
+    });
+    it('should return true for Windows Phone user agent', function () {
+        expect(isMobileUA('Mozilla/5.0 (Windows Phone 10.0; Android 4.2.1; Trident/7.0; Touch; rv:11.0; IEMobile/11.0; NOKIA; Lumia 520) like Gecko')).toBe(true);
+    });
+    it('should return false if user agent indicates desktop', function () {
+        expect(isMobileUA('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36')).toBe(false);
+    });
+});
+describe('hasMobileScreenSize', function () {
+    it('should return true if screen width < 768px', function () {
+        expect(isMobileScreenSize(390, 844)).toBe(true);
+        expect(isMobileScreenSize(844, 390)).toBe(true);
+    });
+    it('should return true if screen height < 768px (landscape mode)', function () {
+        expect(isMobileScreenSize(844, 390)).toBe(true);
+    });
+    it('should return false if screen width > 768px', function () {
+        expect(isMobileScreenSize(1024, 768)).toBe(false);
+    });
+});
+describe('hasTouchScreen', function () {
+    var mockNavigator = {
+        userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36',
+    };
+    it('should return true if the device has a touch screen', function () {
+        expect(isTouchScreen(__assign(__assign({}, mockNavigator), { maxTouchPoints: 1 }))).toBe(true);
+    });
+    it('should return false if the device does not have a touch screen', function () {
+        expect(isTouchScreen(__assign(__assign({}, mockNavigator), { maxTouchPoints: 0 }))).toBe(false);
+    });
+    it('should return true if matchMedia indicates a touch screen', function () {
+        var mockMatchMedia = jest.fn().mockReturnValue({ media: '(pointer:coarse)', matches: true });
+        var result = isTouchScreen(mockNavigator, mockMatchMedia);
+        expect(mockMatchMedia).toHaveBeenCalledWith('(pointer:coarse)');
+        expect(result).toBe(true);
+    });
+    it('should return false if matchMedia does not indicate a touch screen', function () {
+        var mockMatchMedia = jest.fn().mockReturnValue({ media: '(pointer:coarse)', matches: false });
+        var result = isTouchScreen(mockNavigator, mockMatchMedia);
+        expect(mockMatchMedia).toHaveBeenCalledWith('(pointer:coarse)');
+        expect(result).toBe(false);
+    });
+    it('should return false when none of the conditions are met', function () {
+        var result = isTouchScreen(mockNavigator, undefined);
+        expect(result).toBe(false);
+    });
+});

package/build/legacy/common/utils/model-utils.js

@@ -0,0 +1,33 @@
+import { isArray, isBoolean, isNull, isNumber, isString } from '../validators';
+export var isObjectModel = function (model) {
+    return typeof model === 'object' && model !== null && model.constructor === Object;
+};
+export var isNullableObjectModel = function (model) {
+    return isNull(model) || isObjectModel(model);
+};
+export var isNullableBasicModel = function (model) {
+    return isBoolean(model) || isNumber(model) || isString(model) || isNull(model);
+};
+export var isNullableStringModel = function (model) {
+    return isString(model) || isNull(model);
+};
+export var isArrayModel = function (model) {
+    if (isArray(model)) {
+        if (model.length === 0) {
+            return true;
+        }
+        return model.every(function (item) {
+            return typeof item === 'string' ||
+                typeof item === 'number' ||
+                typeof item === 'boolean' ||
+                typeof item === 'object';
+        });
+    }
+    return false;
+};
+export var isNullableArrayModel = function (model) {
+    if (isNull(model)) {
+        return true;
+    }
+    return isArrayModel(model);
+};

package/build/legacy/common/utils/schema-utils.js

@@ -0,0 +1,113 @@
+import { isObject, isUndefined } from '../validators';
+export function isConstSchema(schema) {
+    return !isUndefined(schema === null || schema === void 0 ? void 0 : schema.const);
+}
+export function isNoNConstSchema(schema) {
+    return Boolean(schema) && !isConstSchema(schema);
+}
+export var isReadOnlySchema = function (schema) {
+    return Boolean(schema.readOnly) && isBasicSchema(schema);
+};
+export var isPromotedOneOfSchema = function (schema) {
+    return Boolean(schema.oneOf) && Boolean(schema.promotion);
+};
+export var basicTypes = new Set(['string', 'number', 'integer', 'boolean']);
+export function isBasicSchema(schema) {
+    return (basicTypes.has(schema.type || '') ||
+        ('const' in schema && schema.const !== undefined && !isObject(schema.const)));
+}
+export function isObjectSchema(schema) {
+    return schema.type === 'object';
+}
+export function isOneOfObjectSchema(schema) {
+    return isOneOfSchema(schema) && schema.oneOf.every(function (subSchema) { return subSchema.type === 'object'; });
+}
+export function isOneOfSchema(schema) {
+    return Boolean(schema.oneOf);
+}
+export function isAllOfSchema(schema) {
+    return Boolean(schema.allOf);
+}
+export function isBlobSchema(schema) {
+    return schema.type === 'blob';
+}
+export function isArraySchema(schema) {
+    return schema.type === 'array';
+}
+export function isTupleArraySchema(schema) {
+    if (isArraySchema(schema)) {
+        var schemaItems = schema.items;
+        return Array.isArray(schemaItems);
+    }
+    return false;
+}
+export function isListArraySchema(schema) {
+    if (isArraySchema(schema)) {
+        var schemaItems = schema.items;
+        return !Array.isArray(schemaItems);
+    }
+    return false;
+}
+export function isStringSchema(schema) {
+    return schema.type === 'string';
+}
+export function isPersistAsyncSchema(schema) {
+    return Boolean(schema.persistAsync);
+}
+export function isPersistAsyncFileSchema(schema) {
+    return (isPersistAsyncSchema(schema) &&
+        (isBlobSchema(schema.persistAsync.schema) || isBase64FileSchema(schema.persistAsync.schema)));
+}
+export var isValidationAsyncSchema = function (schema) {
+    return isBasicSchema(schema) && Boolean(schema.validationAsync);
+};
+function isBase64FileSchema(schema) {
+    return schema.type === 'string' && schema.format === 'base64url';
+}
+export function isFileUploadSchema(schema) {
+    return schema.type === 'string' && schema.format === 'base64url';
+}
+export var isMultipleFileUploadSchema = function (schema) {
+    return isListArraySchema(schema) && isPersistAsyncFileSchema(schema.items);
+};
+export var isMultiSelectConstSchema = function (schema) {
+    var _a;
+    if (isListArraySchema(schema)) {
+        var items = schema.items;
+        if (isOneOfSchema(items) && ((_a = items.oneOf) === null || _a === void 0 ? void 0 : _a.every(isConstSchema))) {
+            return true;
+        }
+    }
+    return false;
+};
+export var getSchemaType = function (schema) {
+    // Order of application is important here
+    if (isReadOnlySchema(schema)) {
+        return 'readOnly';
+    }
+    if (isPersistAsyncSchema(schema)) {
+        return 'persistAsync';
+    }
+    if (isValidationAsyncSchema(schema)) {
+        return 'validationAsync';
+    }
+    if (isObjectSchema(schema)) {
+        return 'object';
+    }
+    if (isArraySchema(schema)) {
+        return 'array';
+    }
+    if (isPromotedOneOfSchema(schema)) {
+        return 'promotedOneOf';
+    }
+    if (isOneOfSchema(schema)) {
+        return 'oneOf';
+    }
+    if (isAllOfSchema(schema)) {
+        return 'allOf';
+    }
+    if (isBasicSchema(schema)) {
+        return 'basic';
+    }
+    return null;
+};