@wise/dynamic-flow-client 3.3.2 → 3.4.0-experimental-ed080a1

package/build/legacy/common/hooks/usePersistAsync/usePersistAsync.js

@@ -0,0 +1,172 @@
+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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { useState } from 'react';
+import { useIntl } from 'react-intl';
+import { isBlobSchema } from '../../utils';
+import { isNull, isObject, isNumber, isString, isValidSchema } from '../../validators';
+import messages from '../../../../common/messages/generic-error.messages';
+import { getErrorFromResponse } from '../../../jsonSchemaForm/persistAsyncSchema/persistAsyncBasicSchema/PersistAsyncBasicSchema'; // FIXME: extract these functions form that schema component to either here or their own module
+import { useHttpClient } from '../../../../common/httpClientContext';
+export var usePersistAsync = function (persistAsync) {
+    var _a = useState(null), abortController = _a[0], setAbortController = _a[1];
+    var httpClient = useHttpClient();
+    var intl = useIntl();
+    var schema = persistAsync.schema;
+    function handlePersistAsync(model) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isInvalidSchema;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        isInvalidSchema = model instanceof Blob ? !isBlobSchema(schema) : !isValidSchema(model, schema);
+                        if (isNull(model) || isInvalidSchema) {
+                            handleError();
+                        }
+                        return [4 /*yield*/, performPersistAsync(model)];
+                    case 1: 
+                    // eslint-disable-next-line @typescript-eslint/return-await
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    }
+    var abortCurrentRequestAndGetNewAbortSignal = function () {
+        if (abortController) {
+            abortController.abort();
+        }
+        var newAbortController = new AbortController();
+        setAbortController(newAbortController);
+        return newAbortController.signal;
+    };
+    function constructFetchInit(model) {
+        var _a;
+        var isBlob = isBlobSchema(schema);
+        var signal = abortCurrentRequestAndGetNewAbortSignal();
+        var requestKey = persistAsync.param;
+        var requestBody = isBlob
+            ? wrapInFormData(requestKey, model)
+            : JSON.stringify((_a = {}, _a[requestKey] = model, _a));
+        return {
+            method: persistAsync.method,
+            headers: __assign({}, (!isBlob && { 'Content-Type': 'application/json' })),
+            body: requestBody,
+            signal: signal
+        };
+    }
+    function performPersistAsync(payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, jsonResponse, id, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, httpClient(persistAsync.url, constructFetchInit(payload))];
+                    case 1:
+                        response = _a.sent();
+                        if (!response.ok) {
+                            // eslint-disable-next-line @typescript-eslint/return-await
+                            return [2 /*return*/, handleHTTPError(response)];
+                        }
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        jsonResponse = _a.sent();
+                        if (isObject(jsonResponse)) {
+                            id = jsonResponse[persistAsync.idProperty];
+                            if (isString(id) || isNumber(id)) {
+                                return [2 /*return*/, { data: id }];
+                            }
+                        }
+                        return [2 /*return*/, handleError()];
+                    case 3:
+                        error_1 = _a.sent();
+                        return [2 /*return*/, handleError(error_1)];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    }
+    function handleHTTPError(response) {
+        return __awaiter(this, void 0, void 0, function () {
+            var jsonResponse, error;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(response.status === 422)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, response.json()];
+                    case 1:
+                        jsonResponse = _a.sent();
+                        if (isObject(jsonResponse)) {
+                            error = getErrorFromResponse(persistAsync.param, jsonResponse);
+                            if (isString(error)) {
+                                throw new Error(error);
+                            }
+                        }
+                        _a.label = 2;
+                    case 2: throw new Error(intl.formatMessage(messages.genericErrorRetryHint));
+                }
+            });
+        });
+    }
+    var handleError = function (error) {
+        var message = hasStringMessage(error)
+            ? error.message
+            : intl.formatMessage(messages.genericErrorRetryHint);
+        throw new Error(message);
+    };
+    return handlePersistAsync;
+};
+function wrapInFormData(key, value) {
+    var formData = new FormData();
+    if (value !== null) {
+        formData.append(key, value);
+    }
+    return formData;
+}
+function hasStringMessage(value) {
+    return isObject(value) && 'message' in value && typeof value.message === 'string';
+}

package/build/legacy/common/hooks/usePolling/usePolling.js

@@ -0,0 +1,51 @@
+import { useEffect, useMemo, useRef } from 'react';
+export function usePolling(_a) {
+    var asyncFn = _a.asyncFn, interval = _a.interval, maxAttempts = _a.maxAttempts, maxConsecutiveFails = _a.maxConsecutiveFails, onPollingResponse = _a.onPollingResponse, onFailure = _a.onFailure;
+    var onPollingResponseReference = useRef(onPollingResponse);
+    var onFailureReference = useRef(onFailure);
+    var poll = useMemo(function () {
+        return createPollingClosure(asyncFn, maxAttempts, maxConsecutiveFails, function (pollingResponse) { return onPollingResponseReference.current(pollingResponse); }, function () { return onFailureReference.current(); });
+    }, [asyncFn, maxAttempts, maxConsecutiveFails]);
+    // eslint-disable-next-line consistent-return
+    useEffect(function () {
+        if (interval > 0) {
+            var intervalReference_1 = setInterval(function () {
+                poll();
+            }, interval);
+            return function () { return clearInterval(intervalReference_1); };
+        }
+    }, [poll, interval]);
+    useEffect(function () {
+        onPollingResponseReference.current = onPollingResponse;
+        onFailureReference.current = onFailure;
+    }, [onPollingResponse, onFailure]);
+}
+export function createPollingClosure(asyncFn, maxAttempts, maxConsecutiveFails, onPollingResponse, onFailure) {
+    var isPolling = true;
+    var consecutiveFailures = 0;
+    var attemptCount = 0;
+    return asyncFn
+        ? function () {
+            if (isPolling) {
+                attemptCount++;
+                asyncFn()
+                    .then(function (pollingResponse) {
+                    consecutiveFailures = 0;
+                    isPolling = onPollingResponse(pollingResponse);
+                })["catch"](function (error) {
+                    // do not fail on network errors
+                    if (error.message !== 'network failed') {
+                        consecutiveFailures += 1;
+                    }
+                })["finally"](function () {
+                    if (consecutiveFailures >= maxConsecutiveFails || attemptCount >= maxAttempts) {
+                        onFailure();
+                        isPolling = false;
+                    }
+                });
+            }
+        }
+        : function () {
+            //
+        };
+}

package/build/legacy/common/hooks/usePrevious/usePrevious.js

@@ -0,0 +1,8 @@
+import { useEffect, useRef } from 'react';
+export var usePrevious = function (value) {
+    var reference = useRef();
+    useEffect(function () {
+        reference.current = value;
+    }, [value]);
+    return reference.current;
+};

package/build/legacy/common/hooks/useStepPolling/useStepPolling.js

@@ -0,0 +1,43 @@
+import { useCallback, useMemo } from 'react';
+import { usePolling } from '..';
+import { useHttpClient } from '../../../../common/httpClientContext';
+export function useStepPolling(polling, onAction) {
+    var httpClient = useHttpClient();
+    var asyncFn = useMemo(function () {
+        if (polling) {
+            return function () {
+                return httpClient(polling.url)
+                    .then(function (response) {
+                    if (response.ok) {
+                        return response
+                            .json()
+                            .then(function (pollingResponse) { return pollingResponse; })["catch"](function (error) { return null; });
+                    }
+                    throw new Error('failed');
+                })["catch"](function (error) {
+                    throw new Error(error.message === 'failed' ? 'failed' : 'network failed');
+                });
+            };
+        }
+        return undefined;
+    }, [polling, httpClient]);
+    var onPollingResponse = useCallback(function (pollingResponse) {
+        if (pollingResponse === null || pollingResponse === void 0 ? void 0 : pollingResponse.action) {
+            onAction(pollingResponse.action);
+            return false; // stop polling
+        }
+        return true; // continue polling
+    }, [onAction]);
+    usePolling({
+        asyncFn: asyncFn,
+        interval: 1000 * ((polling === null || polling === void 0 ? void 0 : polling.interval) || 0),
+        maxAttempts: (polling === null || polling === void 0 ? void 0 : polling.maxAttempts) || 0,
+        maxConsecutiveFails: 1,
+        onPollingResponse: onPollingResponse,
+        onFailure: useCallback(function () {
+            if (polling) {
+                onAction(polling.onError.action);
+            }
+        }, [onAction, polling])
+    });
+}

package/build/legacy/common/messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    required: {
+        id: 'dynamicFlows.DefaultErrorMessages.required',
+        defaultMessage: 'Please fill out this field.',
+        description: 'Customer has left the required field empty'
+    }
+});

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

@@ -0,0 +1,6 @@
+export function isStatus2xx(status) {
+    return status >= 200 && status < 300;
+}
+export function isStatus422(status) {
+    return status === 422;
+}

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,38 @@
+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();
+        }
+    };
+    return debouncedFn;
+};

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/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/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/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/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,97 @@
+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) {
+    var schemaItems = schema.items;
+    return Array.isArray(schemaItems);
+}
+export function isListArraySchema(schema) {
+    var schemaItems = schema.items;
+    return !Array.isArray(schemaItems);
+}
+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 isArraySchema(schema) && isListArraySchema(schema) && isPersistAsyncFileSchema(schema.items);
+};
+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;
+};

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

@@ -0,0 +1,32 @@
+import { isObjectSchema, isFileUploadSchema } from './schema-utils';
+export var isCameraStep = function (step) {
+    return isFormStep(step) && hasSingleAction(step) && hasSingleFileUploadSchemaWithCameraOnly(step);
+};
+var isFormStep = function (step) { return !step.type || step.type === 'form'; };
+var hasSingleAction = function (step) { var _a; return ((_a = step === null || step === void 0 ? void 0 : step.actions) === null || _a === void 0 ? void 0 : _a.length) === 1; };
+var hasSingleFileUploadSchemaWithCameraOnly = function (step) {
+    if (!step.schemas) {
+        return false;
+    }
+    var schemas = filterHiddenSchemas(step.schemas);
+    if ((schemas === null || schemas === void 0 ? void 0 : schemas.length) !== 1) {
+        return false;
+    }
+    var firstSchema = schemas[0];
+    if (!isObjectSchema(firstSchema) || Object.values(firstSchema.properties).length !== 1) {
+        return false;
+    }
+    var childSchema = Object.values(firstSchema.properties)[0];
+    if (!isFileUploadSchema(childSchema)) {
+        return false;
+    }
+    return childSchema.source === 'camera';
+};
+export var filterHiddenSchemas = function (schemas) {
+    return schemas.filter(function (schema) {
+        if (isObjectSchema(schema)) {
+            return Object.values((schema === null || schema === void 0 ? void 0 : schema.properties) || {}).find(function (schema) { return (schema === null || schema === void 0 ? void 0 : schema.hidden) !== true; });
+        }
+        return (schema === null || schema === void 0 ? void 0 : schema.hidden) !== true;
+    });
+};

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

@@ -0,0 +1,5 @@
+export { getValidModelParts, getValidObjectModelParts, getValidBasicModelOrNull, } from './models/model-validators';
+export { isValidSchema } from './schemas/schema-validators';
+export { getValidationFailures, getArrayValidationFailures, } from './validationFailures/validation-failures';
+export * from './types/type-validators';
+export * from './values/value-validators';