@wise/dynamic-flow-client 3.3.2 → 3.4.0-experimental-9862ccf

package/build/common/httpClientContext/HttpClientContext.js

@@ -0,0 +1,35 @@
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { makeHttpClient } from '../makeHttpClient';
+var HttpClientContext = createContext(undefined);
+export function HttpClientProvider(_a) {
+    var httpClient = _a.httpClient, children = _a.children;
+    return _jsx(HttpClientContext.Provider, __assign({ value: httpClient }, { children: children }));
+}
+export function HttpClientProviderFromBaseUrl(_a) {
+    var baseUrl = _a.baseUrl, children = _a.children;
+    var httpClient = useMemo(function () { return makeHttpClient(baseUrl); }, [baseUrl]);
+    return _jsx(HttpClientContext.Provider, __assign({ value: httpClient }, { children: children }));
+}
+/**
+ * Provides the fetch(er) function for dynamic flows asynchronous operations.
+ */
+export var useHttpClient = function () {
+    var contextFetch = useContext(HttpClientContext);
+    return contextFetch !== null && contextFetch !== void 0 ? contextFetch : fetch;
+};
+export var useHasHttpClientProvider = function () {
+    var context = useContext(HttpClientContext);
+    return Boolean(context);
+};

package/build/common/httpClientContext/index.js

@@ -0,0 +1 @@
+export * from './HttpClientContext';

package/build/common/makeHttpClient/index.js

@@ -0,0 +1 @@
+export * from './makeHttpClient';

package/build/common/makeHttpClient/makeHttpClient.js

@@ -0,0 +1,34 @@
+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 { isRelativePath } from '../utils/api-utils';
+export var makeHttpClient = function (baseUrl, additionalHeaders) {
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    return function (input, init) {
+        var resource = applyBaseUrl(input, baseUrl || '');
+        return fetch(resource, mergeRequestInit(init !== null && init !== void 0 ? init : {}, { headers: additionalHeaders }));
+    };
+};
+var applyBaseUrl = function (input, baseUrl) {
+    return typeof input === 'string' && isRelativePath(input) ? baseUrl + input : input;
+};
+export var mergeRequestInit = function (init, additionalInit) { return (__assign(__assign(__assign({}, init), additionalInit), { headers: mergeHeaders(init === null || init === void 0 ? void 0 : init.headers, additionalInit === null || additionalInit === void 0 ? void 0 : additionalInit.headers) })); };
+var mergeHeaders = function (initHeaders, additionalHeaders) {
+    if (!initHeaders && !additionalHeaders) {
+        return {};
+    }
+    var headers = new Headers(initHeaders);
+    for (var _i = 0, _a = Object.entries(additionalHeaders !== null && additionalHeaders !== void 0 ? additionalHeaders : {}); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], value = _b[1];
+        headers.set(key, value);
+    }
+    return headers;
+};

package/build/common/messages/generic-error.messages.js

@@ -0,0 +1,18 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    genericErrorRetryHint: {
+        id: 'dynamicFlows.PersistAsyncSchema.genericError',
+        defaultMessage: 'Something went wrong, please try again.',
+        description: 'Generic error message for persist async schema'
+    },
+    genericError: {
+        id: 'dynamicFlows.ErrorBoundary.errorAlert',
+        defaultMessage: 'Something went wrong.',
+        description: 'Generic error message for when something has gone wrong.'
+    },
+    retry: {
+        id: 'dynamicFlows.ErrorBoundary.retry',
+        defaultMessage: 'Retry',
+        description: 'Usually this follows the generic error and contains a link.'
+    }
+});

package/build/common/messages/help.messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    helpAria: {
+        id: 'dynamicFlows.Help.ariaLabel',
+        defaultMessage: 'Click here for more info.',
+        description: 'Aria label for help.'
+    }
+});

package/build/common/messages/multi-file-upload.messages.js

@@ -0,0 +1,18 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    minItemsError: {
+        id: 'dynamicFlows.MultipleFileUploadSchema.minItemsError',
+        defaultMessage: 'Please upload at least {minItems} file(s).',
+        description: 'Customer has uploaded not enough files. To fix: upload more files.'
+    },
+    maxItemsError: {
+        id: 'dynamicFlows.MultipleFileUploadSchema.maxItemsError',
+        defaultMessage: 'Please upload {maxItems} or fewer files.',
+        description: 'Customer has uploaded too many files. To fix: upload fewer files.'
+    },
+    maxFileSizeError: {
+        id: 'dynamicFlows.MultipleFileUploadSchema.maxFileSizeError',
+        defaultMessage: 'Sorry, that file is too big. Please upload a smaller file.',
+        description: "Customer has uploaded a file that's too big. To fix: upload a smaller file."
+    }
+});

package/build/common/messages/paragraph.messages.js

@@ -0,0 +1,13 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    copy: {
+        id: 'dynamicFlows.DynamicParagraph.copy',
+        defaultMessage: 'Copy',
+        description: 'Copy to clipboard button label.'
+    },
+    copied: {
+        id: 'dynamicFlows.DynamicParagraph.copied',
+        defaultMessage: 'Copied to clipboard',
+        description: 'Appears in a snackbar when the copy operation succeeds.'
+    }
+});

package/build/common/messages/repeatable.messages.js

@@ -0,0 +1,23 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    addItemTitle: {
+        id: 'dynamicFlows.ArraySchema.addItemTitle',
+        defaultMessage: 'Add Item',
+        description: 'Label on the button used to open a form to add an item'
+    },
+    addItem: {
+        id: 'dynamicFlows.ArraySchema.addItem',
+        defaultMessage: 'Save',
+        description: 'Label on the add button used to submit a form that adds an item'
+    },
+    editItem: {
+        id: 'dynamicFlows.ArraySchema.editItem',
+        defaultMessage: 'Save',
+        description: 'Label on the edit button used to submit a form that edits an item'
+    },
+    removeItem: {
+        id: 'dynamicFlows.ArraySchema.removeItem',
+        defaultMessage: 'Remove',
+        description: 'Label on the remove button used to confirm deletion of an item'
+    }
+});

package/build/common/messages/validation.array.messages.js

@@ -0,0 +1,13 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    minItemsError: {
+        id: 'dynamicFlows.ArraySchema.minItemsError',
+        defaultMessage: 'Please add at least {minItems}.',
+        description: 'Customer inputs less than the expected number of values'
+    },
+    maxItemsError: {
+        id: 'dynamicFlows.ArraySchema.maxItemsError',
+        defaultMessage: 'Please add {maxItems} or fewer.',
+        description: 'Customer inputs more than the allowed number of values'
+    }
+});

package/build/common/messages/validation.messages.js

@@ -0,0 +1,53 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    type: {
+        id: 'dynamicFlows.ControlFeedback.type',
+        defaultMessage: 'Incorrect type',
+        description: ''
+    },
+    minimum: {
+        id: 'dynamicFlows.ControlFeedback.minimum',
+        defaultMessage: "Please enter a number that's {minimum} or more.",
+        description: ''
+    },
+    maximum: {
+        id: 'dynamicFlows.ControlFeedback.maximum',
+        defaultMessage: "Please enter a number that's {maximum} or less.",
+        description: ''
+    },
+    minLength: {
+        id: 'dynamicFlows.ControlFeedback.minLength',
+        defaultMessage: 'Please enter at least {minLength} characters.',
+        description: ''
+    },
+    maxLength: {
+        id: 'dynamicFlows.ControlFeedback.maxLength',
+        defaultMessage: 'Please enter {maxLength} or fewer characters.',
+        description: ''
+    },
+    minimumDate: {
+        id: 'dynamicFlows.ControlFeedback.minimumDate',
+        defaultMessage: "Please enter a date that's on or after {minimum}.",
+        description: ''
+    },
+    maximumDate: {
+        id: 'dynamicFlows.ControlFeedback.maximumDate',
+        defaultMessage: "Please enter a date that's on or before {maximum}.",
+        description: ''
+    },
+    pattern: {
+        id: 'dynamicFlows.ControlFeedback.pattern',
+        defaultMessage: 'Please enter this in the correct format.',
+        description: ''
+    },
+    patternDate: {
+        id: 'dynamicFlows.ControlFeedback.patternDate',
+        defaultMessage: 'Please enter a date in the corrrect format.',
+        description: ''
+    },
+    required: {
+        id: 'dynamicFlows.ControlFeedback.required',
+        defaultMessage: 'Please fill out this field.',
+        description: ''
+    }
+});

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

@@ -0,0 +1,4 @@
+export function isRelativePath(url) {
+    if (url === void 0) { url = ''; }
+    return !['https://', 'http://', 'data:'].some(function (prefix) { return url.startsWith(prefix) && url.length > prefix.length; });
+}

package/build/legacy/common/constants/DateMode.js

@@ -0,0 +1,4 @@
+export var DateMode = {
+    DAY_MONTH_YEAR: 'day-month-year',
+    MONTH_YEAR: 'month-year'
+};

package/build/legacy/common/constants/FeatureName.js

@@ -0,0 +1,4 @@
+export var FeatureName;
+(function (FeatureName) {
+    FeatureName["SAMPLE_FEATURE"] = "sample-feature";
+})(FeatureName || (FeatureName = {}));

package/build/legacy/common/constants/FormControlType.js

@@ -0,0 +1,21 @@
+export var FormControlType = {
+    RADIO: 'radio',
+    CHECKBOX: 'checkbox',
+    SELECT: 'select',
+    EMAIL: 'email',
+    FILE: 'file',
+    DATE: 'date',
+    DATETIME: 'date-time',
+    DATELOOKUP: 'date-lookup',
+    TEL: 'tel',
+    // For string schemas with number format
+    NUMERIC: 'numeric',
+    // For number schemas
+    NUMBER: 'number',
+    HIDDEN: 'hidden',
+    PASSWORD: 'password',
+    TEXT: 'text',
+    TEXTAREA: 'textarea',
+    UPLOAD: 'upload',
+    TAB: 'tab'
+};

package/build/legacy/common/constants/MonthFormat.js

@@ -0,0 +1,4 @@
+export var MonthFormat = {
+    SHORT: 'short',
+    LONG: 'long'
+};

package/build/legacy/common/constants/Size.js

@@ -0,0 +1,7 @@
+export var Size = {
+    EXTRA_SMALL: 'xs',
+    SMALL: 'sm',
+    MEDIUM: 'md',
+    LARGE: 'lg',
+    EXTRA_LARGE: 'xl'
+};

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

@@ -0,0 +1,4 @@
+export * from './DateMode';
+export * from './FormControlType';
+export * from './MonthFormat';
+export * from './Size';

package/build/legacy/common/contexts/dynamicFlowContexts/DynamicFlowContexts.js

@@ -0,0 +1,36 @@
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { usePendingPromiseCounter } from './usePendingPromiseCounter';
+var defaultContextValue = {
+    loading: false,
+    registerPersistAsyncPromise: function (promise) {
+        //
+    }
+};
+var DFContext = createContext(defaultContextValue);
+export var DynamicFlowProvider = function (_a) {
+    var loading = _a.loading, children = _a.children;
+    var _b = usePendingPromiseCounter(), pendingPromises = _b.pendingPromises, addPendingPromise = _b.addPendingPromise;
+    var providerValue = useMemo(function () {
+        return {
+            loading: loading || pendingPromises > 0,
+            registerPersistAsyncPromise: addPendingPromise
+        };
+    }, [loading, pendingPromises, addPendingPromise]);
+    return _jsx(DFContext.Provider, __assign({ value: providerValue }, { children: children }));
+};
+export var useDynamicFlow = function () {
+    var context = useContext(DFContext);
+    return context || defaultContextValue;
+};

package/build/legacy/common/contexts/dynamicFlowContexts/usePendingPromiseCounter.js

@@ -0,0 +1,13 @@
+import { useCallback, useState } from 'react';
+export function usePendingPromiseCounter() {
+    var _a = useState(0), count = _a[0], setCount = _a[1];
+    var addPendingPromise = useCallback(function (promise) {
+        setCount(function (c) { return c + 1; });
+        promise["catch"](noop)["finally"](function () { return delayUntilNextCycle(function () { return setCount(function (c) { return Math.max(0, c - 1); }); }); });
+    }, [setCount]);
+    return { addPendingPromise: addPendingPromise, pendingPromises: count };
+}
+var delayUntilNextCycle = function (fn) { return setTimeout(function () { return fn(); }, 0); };
+var noop = function () {
+    // no-op
+};

package/build/legacy/common/contexts/eventsContext/EventsContext.js

@@ -0,0 +1,38 @@
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+var EventsContext = createContext({
+    triggerEvent: function () {
+        // noop
+    }
+});
+export function EventsContextProvider(_a) {
+    var metadata = _a.metadata, children = _a.children, onEvent = _a.onEvent;
+    var value = useMemo(function () { return ({ triggerEvent: getEventDispatcher(onEvent, metadata) }); }, [onEvent, metadata]);
+    return _jsx(EventsContext.Provider, __assign({ value: value }, { children: children }));
+}
+export function useEventDispatcher() {
+    var triggerEvent = useContext(EventsContext).triggerEvent;
+    return triggerEvent;
+}
+export var getEventDispatcher = function (onEvent, metadata) {
+    return function (eventName, properties) {
+        if (properties === void 0) { properties = {}; }
+        try {
+            onEvent(eventName, __assign(__assign({}, metadata), properties));
+        }
+        catch (_a) {
+            // noop
+        }
+    };
+};

package/build/legacy/common/contexts/featureContext/FeatureContext.js

@@ -0,0 +1,22 @@
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+var FeatureContext = createContext([]);
+export function FeatureContextProvider(_a) {
+    var features = _a.features, children = _a.children;
+    return _jsx(FeatureContext.Provider, __assign({ value: features }, { children: children }));
+}
+export var useFeatureFlag = function (featureName) {
+    var features = useContext(FeatureContext);
+    return features === null || features === void 0 ? void 0 : features.find(function (feature) { return feature.featureName === featureName; });
+};

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

@@ -0,0 +1,3 @@
+export * from './dynamicFlowContexts/DynamicFlowContexts';
+export * from './eventsContext/EventsContext';
+export * from './logContext/LogContext';

package/build/legacy/common/contexts/logContext/LogContext.js

@@ -0,0 +1,44 @@
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+export var getLogger = function (level, onLog, flowId, stepId) {
+    if (flowId === void 0) { flowId = 'UNKNOWN-FLOW-ID'; }
+    if (stepId === void 0) { stepId = 'UNKNOWN-FLOW-ID'; }
+    return function (title, description, extra) {
+        try {
+            onLog(level, "Dynamic Flow ".concat(level, " - ").concat(title, " - ").concat(description), __assign({ flowId: flowId, stepId: stepId }, extra));
+        }
+        catch (_a) {
+            // noop
+        }
+    };
+};
+var LogContext = createContext(null);
+export function LogProvider(_a) {
+    var flowId = _a.flowId, stepId = _a.stepId, children = _a.children, onLog = _a.onLog;
+    var value = useMemo(function () { return ({
+        debug: getLogger('debug', onLog, flowId, stepId),
+        info: getLogger('info', onLog, flowId, stepId),
+        warning: getLogger('warning', onLog, flowId, stepId),
+        error: getLogger('error', onLog, flowId, stepId),
+        critical: getLogger('critical', onLog, flowId, stepId)
+    }); }, [onLog, flowId, stepId]);
+    return _jsx(LogContext.Provider, __assign({ value: value }, { children: children }));
+}
+export var useLogger = function () {
+    var logging = useContext(LogContext);
+    if (logging == null) {
+        throw new Error('Logging context not found. Did you forget to wrap your component in a <LogProvider />?');
+    }
+    return logging;
+};

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

@@ -0,0 +1,7 @@
+export * from './useDebouncedFunction/useDebouncedFunction';
+export * from './useExternal/useExternal';
+export * from './useExternalStepPolling/useExternalStepPolling';
+export * from './usePersistAsync/usePersistAsync';
+export * from './usePolling/usePolling';
+export * from './usePrevious/usePrevious';
+export * from './useStepPolling/useStepPolling';

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

@@ -0,0 +1,9 @@
+/* References:
+- https://github.com/gnbaron/use-lodash-debounce
+- https://dmitripavlutin.com/react-throttle-debounce/
+*/
+import { useCallback } from 'react';
+import { debounce } from '../../utils';
+export function useDebouncedFunction(callback, waitMs) {
+    return useCallback(debounce(callback, waitMs), [callback, waitMs]);
+}

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

@@ -0,0 +1,15 @@
+import { useEffect, useState } from 'react';
+export function useExternal(url) {
+    // If we fail to open the window, the user will need to open this on their own
+    var _a = useState(null), externalWindow = _a[0], setExternalWindow = _a[1];
+    var _b = useState(false), hasManuallyTriggered = _b[0], setHasManuallyTriggered = _b[1];
+    var dismissConfirmation = function () { return setHasManuallyTriggered(true); };
+    useEffect(function () {
+        if (url) {
+            setHasManuallyTriggered(false);
+            setExternalWindow(window.open(url, '_blank'));
+        }
+    }, [url]);
+    var requiresManualTrigger = Boolean(url && !externalWindow && !hasManuallyTriggered);
+    return { requiresManualTrigger: requiresManualTrigger, dismissConfirmation: dismissConfirmation };
+}

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

@@ -0,0 +1,70 @@
+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 { useCallback, useMemo } from 'react';
+import { usePolling } from '..';
+import { useHttpClient } from '../../../../common/httpClientContext';
+/** @deprecated External step is no longer supported */
+export function useExternalStepPolling(polling, onAction) {
+    var httpClient = useHttpClient();
+    var asyncFn = useMemo(function () {
+        if (polling) {
+            return function () {
+                return httpClient(polling.url)
+                    .then(function (response) {
+                    if (response.ok) {
+                        try {
+                            return response.json();
+                        }
+                        catch (_a) {
+                            throw new Error('failed');
+                        }
+                    }
+                    else {
+                        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) {
+        var responseHandlers = (polling === null || polling === void 0 ? void 0 : polling.responseHandlers) || [];
+        var responseHandler = responseHandlers.find(function (handler) { return handler.result === pollingResponse.result; });
+        if (responseHandler === null || responseHandler === void 0 ? void 0 : responseHandler.action) {
+            var action = responseHandler.action;
+            if (action.exit) {
+                var mergedResult = __assign(__assign({}, (action.result || {})), (pollingResponse.data || {}));
+                onAction(__assign(__assign({}, action), { result: mergedResult }));
+            }
+            else {
+                var mergedData = __assign(__assign({}, (action.data || {})), (pollingResponse.data || {}));
+                onAction(__assign(__assign({}, action), { data: mergedData }));
+            }
+            return false; // stop polling
+        }
+        return true; // continue polling
+    }, [polling === null || polling === void 0 ? void 0 : polling.responseHandlers, onAction]);
+    usePolling({
+        asyncFn: asyncFn,
+        interval: (polling === null || polling === void 0 ? void 0 : polling.interval) || 0,
+        maxAttempts: (polling === null || polling === void 0 ? void 0 : polling.maxAttempts) || 0,
+        maxConsecutiveFails: (polling === null || polling === void 0 ? void 0 : polling.maxConsecutiveFails) || 0,
+        onPollingResponse: onPollingResponse,
+        onFailure: useCallback(function () {
+            if (polling) {
+                onAction(polling.onError.action);
+            }
+        }, [onAction, polling])
+    });
+}