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

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

@@ -0,0 +1,113 @@
+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 { waitFor, act } from '@testing-library/react';
+import { renderHook } from '@testing-library/react-hooks';
+import { usePendingPromiseCounter } from './usePendingPromiseCounter';
+var makePromiseController = function () {
+    var resolvePromise;
+    var rejectPromise;
+    var promise = new Promise(function (resolve, reject) {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+    });
+    return {
+        promise: promise,
+        resolve: resolvePromise,
+        reject: rejectPromise,
+    };
+};
+describe('usePendingPromiseCounter', function () {
+    it('should increment the count when promises are added', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            result = renderHook(function () { return usePendingPromiseCounter(); }).result;
+            act(function () { return result.current.addPendingPromise(makePromiseController().promise); });
+            expect(result.current.pendingPromises).toBe(1);
+            act(function () { return result.current.addPendingPromise(makePromiseController().promise); });
+            expect(result.current.pendingPromises).toBe(2);
+            act(function () { return result.current.addPendingPromise(makePromiseController().promise); });
+            expect(result.current.pendingPromises).toBe(3);
+            return [2 /*return*/];
+        });
+    }); });
+    it('should decrement the count when promises are resolved', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, pc1, pc2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    result = renderHook(function () { return usePendingPromiseCounter(); }).result;
+                    pc1 = makePromiseController();
+                    pc2 = makePromiseController();
+                    act(function () { return result.current.addPendingPromise(pc1.promise); });
+                    act(function () { return result.current.addPendingPromise(pc2.promise); });
+                    expect(result.current.pendingPromises).toBe(2);
+                    pc1.resolve();
+                    return [4 /*yield*/, waitFor(function () { return expect(result.current.pendingPromises).toBe(1); })];
+                case 1:
+                    _a.sent();
+                    pc2.resolve();
+                    return [4 /*yield*/, waitFor(function () { return expect(result.current.pendingPromises).toBe(0); })];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should decrement the count when promises are rejected', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, pc1, pc2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    result = renderHook(function () { return usePendingPromiseCounter(); }).result;
+                    pc1 = makePromiseController();
+                    pc2 = makePromiseController();
+                    act(function () { return result.current.addPendingPromise(pc1.promise); });
+                    act(function () { return result.current.addPendingPromise(pc2.promise); });
+                    expect(result.current.pendingPromises).toBe(2);
+                    pc1.reject();
+                    return [4 /*yield*/, waitFor(function () { return expect(result.current.pendingPromises).toBe(1); })];
+                case 1:
+                    _a.sent();
+                    pc2.reject();
+                    return [4 /*yield*/, waitFor(function () { return expect(result.current.pendingPromises).toBe(0); })];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

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, { 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/eventsContext/EventsContext.spec.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { useEffect } from 'react';
+import { EventsContextProvider, useEventDispatcher } from './EventsContext';
+describe('Tracking Provider', function () {
+    function TestChild(_a) {
+        var eventName = _a.eventName, properties = _a.properties;
+        var onEvent = useEventDispatcher();
+        useEffect(function () {
+            onEvent(eventName, properties);
+        }, []);
+        return _jsx("span", { children: eventName });
+    }
+    describe('when provider is initialised with metadata', function () {
+        function renderComponent(onEvent) {
+            render(_jsx(EventsContextProvider, { metadata: { flowId: 'myFlowId', stepId: 'myStepId', custom: 'property' }, onEvent: onEvent, children: _jsx(TestChild, { eventName: "Dynamic Flow - Flow Started", properties: { custom: 'property' } }) }));
+        }
+        describe('and is called upon mounting', function () {
+            describe('it calls the onEvent callback', function () {
+                it('with the specified eventName', function () {
+                    var onEvent = jest.fn();
+                    renderComponent(onEvent);
+                    expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Flow Started', expect.anything());
+                });
+                it('with the specified custom properties', function () {
+                    var onEvent = jest.fn();
+                    renderComponent(onEvent);
+                    expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Flow Started', expect.objectContaining({ custom: 'property' }));
+                });
+                it('with the specified flow and step ids any custom properties', function () {
+                    var onEvent = jest.fn();
+                    renderComponent(onEvent);
+                    expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Flow Started', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId', custom: 'property' }));
+                });
+            });
+        });
+        describe('and the event handler throws an error', function () {
+            it('handles the error gracefully', function () {
+                var onEvent = function () {
+                    throw new Error('Mixpanel error');
+                };
+                renderComponent(onEvent);
+                expect(renderComponent).not.toThrow();
+            });
+        });
+    });
+});

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

@@ -0,0 +1,11 @@
+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, { 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/featureContext/FeatureContext.spec.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { renderHook } from '@testing-library/react-hooks';
+import { FeatureName } from '../../constants/FeatureName';
+import { FeatureContextProvider, useFeatureFlag } from './FeatureContext';
+var features = [
+    {
+        featureName: FeatureName.SAMPLE_FEATURE,
+        variant: 1,
+        enabled: true,
+        initiation: 'INITIATED',
+    },
+];
+var wrapper = function (_a) {
+    var children = _a.children;
+    return (_jsx(FeatureContextProvider, { features: features, children: children }));
+};
+describe('useFeatureFlag', function () {
+    it('returns a feature by name when it exists', function () {
+        var result = renderHook(function () { return useFeatureFlag(FeatureName.SAMPLE_FEATURE); }, {
+            wrapper: wrapper,
+        }).result;
+        expect(result.current).toStrictEqual(features[0]);
+    });
+    it('returns undefined for a non-existing feature', function () {
+        var result = renderHook(function () { return useFeatureFlag('NonExistingFeature'); }, {
+            wrapper: wrapper,
+        }).result;
+        expect(result.current).toBeUndefined();
+    });
+});

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, { 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/contexts/logContext/LogContext.spec.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { useEffect } from 'react';
+import { useLogger, LogProvider } from './LogContext';
+describe('Logging Provider', function () {
+    function TestChild() {
+        var log = useLogger();
+        useEffect(function () {
+            // eslint-disable-next-line testing-library/no-debugging-utils
+            log.debug('Deprecation warning', 'Some description.');
+            log.info('Invalid schema or model', 'Some description.');
+            log.warning('Action supressed', 'Some description.');
+            log.error('Deprecated schema', 'This schema is no longer supported.');
+            log.critical('Deprecated schema', 'This schema is no longer supported.');
+        }, []);
+        return _jsx("span", { children: "info,error" });
+    }
+    describe('when provider is initialised with flowId and stepId', function () {
+        function renderComponent(onLog) {
+            render(_jsx(LogProvider, { flowId: "myFlowId", stepId: "myStepId", onLog: onLog, children: _jsx(TestChild, {}) }));
+        }
+        describe('and is called within a component', function () {
+            it('calls the onLog callback', function () {
+                var onLog = jest.fn();
+                renderComponent(onLog);
+                expect(onLog).toHaveBeenCalledWith('debug', 'Dynamic Flow debug - Deprecation warning - Some description.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+                expect(onLog).toHaveBeenCalledWith('info', 'Dynamic Flow info - Invalid schema or model - Some description.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+                expect(onLog).toHaveBeenCalledWith('warning', 'Dynamic Flow warning - Action supressed - Some description.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+                expect(onLog).toHaveBeenCalledWith('error', 'Dynamic Flow error - Deprecated schema - This schema is no longer supported.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+                expect(onLog).toHaveBeenCalledWith('critical', 'Dynamic Flow critical - Deprecated schema - This schema is no longer supported.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
+            });
+        });
+        describe('and the logging function throws an error', function () {
+            it('handles the error gracefully', function () {
+                var onLog = function () {
+                    throw new Error('Rollbar error');
+                };
+                renderComponent(onLog);
+                expect(renderComponent).not.toThrow();
+            });
+        });
+    });
+});

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/useDebouncedFunction/useDebouncedFunction.spec.js

@@ -0,0 +1,59 @@
+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 { waitFor } from '@testing-library/react';
+import { renderHook } from '@testing-library/react-hooks';
+import { useDebouncedFunction } from './useDebouncedFunction';
+describe('useDebouncedFunction hook', function () {
+    it('debounces a callback', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var callback, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    callback = jest.fn();
+                    result = renderHook(function () { return useDebouncedFunction(callback, 200); }).result;
+                    result.current();
+                    expect(callback).not.toHaveBeenCalled();
+                    return [4 /*yield*/, waitFor(function () {
+                            expect(callback).toHaveBeenCalledTimes(1);
+                        }, { interval: 200 })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

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 };
+}