@evervault/react-native 2.5.1 → 2.6.1

package/build/cjs/ThreeDSecure/session.js

@@ -0,0 +1,141 @@
+'use strict';
+
+var config = require('./config.js');
+var event = require('./event.js');
+
+function stopPolling(intervalRef, setIsVisible) {
+    setIsVisible(false);
+    if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+    }
+}
+async function startSession(session, options, intervalRef, setIsVisible) {
+    try {
+        const sessionState = await session.get();
+        function fail() {
+            stopPolling(intervalRef, setIsVisible);
+            options?.onFailure?.(new Error("3DS session failed"));
+        }
+        switch (sessionState.status) {
+            case "success": {
+                stopPolling(intervalRef, setIsVisible);
+                options?.onSuccess?.();
+                break;
+            }
+            case "failure": {
+                fail();
+                break;
+            }
+            case "action-required": {
+                const failOnChallenge = typeof options?.failOnChallenge === "function"
+                    ? await options.failOnChallenge()
+                    : options?.failOnChallenge ?? false;
+                if (failOnChallenge) {
+                    fail();
+                    break;
+                }
+                const event$1 = new event.ThreeDSecureEvent("requestChallenge", session);
+                options?.onRequestChallenge?.(event$1);
+                if (event$1.defaultPrevented) {
+                    fail();
+                    break;
+                }
+                setIsVisible(true);
+                pollSession(session, options, intervalRef, setIsVisible);
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error checking session state", error);
+        options?.onError?.(new Error("Failed to check 3DS session state"));
+    }
+}
+function pollSession(session, options, intervalRef, setIsVisible, interval = 3000) {
+    function fail() {
+        stopPolling(intervalRef, setIsVisible);
+        options?.onFailure?.(new Error("3DS session failed"));
+    }
+    intervalRef.current = setInterval(async () => {
+        try {
+            const pollResponse = await session.get();
+            switch (pollResponse.status) {
+                case "success": {
+                    stopPolling(intervalRef, setIsVisible);
+                    options?.onSuccess?.();
+                    break;
+                }
+                case "failure": {
+                    fail();
+                    break;
+                }
+                case "action-required": {
+                    const failOnChallenge = typeof options?.failOnChallenge === "function"
+                        ? await options.failOnChallenge()
+                        : options?.failOnChallenge ?? false;
+                    if (failOnChallenge) {
+                        fail();
+                        break;
+                    }
+                    const event$1 = new event.ThreeDSecureEvent("requestChallenge", session);
+                    options?.onRequestChallenge?.(event$1);
+                    if (event$1.defaultPrevented) {
+                        fail();
+                        break;
+                    }
+                    setIsVisible(true);
+                }
+            }
+        }
+        catch (error) {
+            stopPolling(intervalRef, setIsVisible);
+            console.error("Error polling session", error);
+            options?.onError?.(new Error("Error polling 3DS session"));
+        }
+    }, interval);
+}
+function threeDSecureSession({ sessionId, appId, options, intervalRef, setIsVisible, }) {
+    async function get() {
+        try {
+            const response = await fetch(`https://${config.EV_API_DOMAIN}/frontend/3ds/browser-sessions/${sessionId}`, {
+                headers: {
+                    "x-evervault-app-id": appId,
+                },
+            });
+            const result = (await response.json());
+            return result;
+        }
+        catch (error) {
+            console.error("Error fetching 3DS session status", error);
+            throw error;
+        }
+    }
+    async function cancel() {
+        try {
+            await fetch(`https://${config.EV_API_DOMAIN}/frontend/3ds/browser-sessions/${sessionId}`, {
+                method: "PATCH",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-evervault-app-id": appId,
+                },
+                body: JSON.stringify({ outcome: "cancelled" }),
+            });
+            options?.onFailure?.(new Error("3DS session cancelled by user"));
+            stopPolling(intervalRef, setIsVisible);
+        }
+        catch (error) {
+            console.error("Error cancelling 3DS session", error);
+            throw error;
+        }
+    }
+    return {
+        sessionId,
+        get,
+        cancel,
+    };
+}
+
+exports.pollSession = pollSession;
+exports.startSession = startSession;
+exports.stopPolling = stopPolling;
+exports.threeDSecureSession = threeDSecureSession;

package/build/cjs/ThreeDSecure/types.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/build/cjs/ThreeDSecure/useThreeDSecure.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var React = require('react');
+var session = require('./session.js');
+var useEvervault = require('../useEvervault.js');
+
+function useThreeDSecure(options) {
+    const { appId } = useEvervault.useEvervault();
+    const intervalRef = React.useRef(null);
+    const [session$1, setSession] = React.useState(null);
+    const [isVisible, setIsVisible] = React.useState(false);
+    const failOnChallenge = options?.failOnChallenge ?? false;
+    const start = React.useCallback((sessionId, options) => {
+        const startOptions = {
+            ...options,
+            failOnChallenge: options?.failOnChallenge ?? failOnChallenge,
+        };
+        const session$1 = session.threeDSecureSession({
+            sessionId,
+            appId,
+            options: startOptions,
+            intervalRef,
+            setIsVisible,
+        });
+        setSession(session$1);
+        session.startSession(session$1, startOptions, intervalRef, setIsVisible);
+    }, [appId, failOnChallenge]);
+    const cancel = React.useCallback(async () => {
+        if (session$1) {
+            await session$1.cancel();
+        }
+        else {
+            console.warn("No 3DS session to cancel");
+        }
+    }, [session$1]);
+    return React.useMemo(() => ({
+        start,
+        cancel,
+        session: session$1,
+        isVisible,
+    }), [start, cancel, session$1, isVisible]);
+}
+
+exports.useThreeDSecure = useThreeDSecure;

package/build/cjs/__mocks__/NativeEvervault.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const encryptedValue = "ev:W98t:uu98aas09udya863ty9372y7y23h97rg6gfs678987";
+const NativeEvervault = {
+    initialize: vi.fn(),
+    encryptString: vi.fn(() => Promise.resolve(encryptedValue)),
+    encryptNumber: vi.fn(() => Promise.resolve(encryptedValue)),
+    encryptBoolean: vi.fn(() => Promise.resolve(encryptedValue)),
+    encryptObject: vi.fn(),
+    encryptArray: vi.fn(),
+};
+
+exports.NativeEvervault = NativeEvervault;
+exports.encryptedValue = encryptedValue;

package/build/cjs/__mocks__/react-native-webview.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var reactNative = require('react-native');
+
+function WebView(props) {
+    return jsxRuntime.jsx(reactNative.View, { testID: "webview", ...props });
+}
+
+exports.WebView = WebView;

package/build/cjs/context.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var React = require('react');
+
+const EvervaultContext = React.createContext(null);
+
+exports.EvervaultContext = EvervaultContext;

package/build/cjs/index.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var sdk = require('./sdk.js');
+var EvervaultProvider = require('./EvervaultProvider.js');
+var useEvervault = require('./useEvervault.js');
+var index = require('./Card');
+var index$1 = require('./ThreeDSecure');
+var Holder = require('./Card/Holder.js');
+var Expiry = require('./Card/Expiry.js');
+var Cvc = require('./Card/Cvc.js');
+var Number = require('./Card/Number.js');
+var useThreeDSecure = require('./ThreeDSecure/useThreeDSecure.js');
+
+const verifyInstallation = sdk.sdk.verify;
+
+exports.EvervaultProvider = EvervaultProvider.EvervaultProvider;
+exports.useEvervault = useEvervault.useEvervault;
+exports.Card = index.Card;
+exports.ThreeDSecure = index$1.ThreeDSecure;
+exports.CardHolder = Holder.CardHolder;
+exports.CardExpiry = Expiry.CardExpiry;
+exports.CardCvc = Cvc.CardCvc;
+exports.CardNumber = Number.CardNumber;
+exports.useThreeDSecure = useThreeDSecure.useThreeDSecure;
+exports.verifyInstallation = verifyInstallation;

package/build/cjs/node_modules/@hookform/resolvers/dist/resolvers.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var index_esm = require('../../../react-hook-form/dist/index.esm.js');
+
+const r=(t,r,o)=>{if(t&&"reportValidity"in t){const s=index_esm.get(o,r);t.setCustomValidity(s&&s.message||""),t.reportValidity();}},o=(e,t)=>{for(const o in t.fields){const s=t.fields[o];s&&s.ref&&"reportValidity"in s.ref?r(s.ref,o,e):s&&s.refs&&s.refs.forEach(t=>r(t,o,e));}},s=(r,s)=>{s.shouldUseNativeValidation&&o(r,s);const n={};for(const o in r){const f=index_esm.get(s.fields,o),c=Object.assign(r[o]||{},{ref:f&&f.ref});if(i(s.names||Object.keys(r),o)){const r=Object.assign({},index_esm.get(n,o));index_esm.set(r,"root",c),index_esm.set(n,o,r);}else index_esm.set(n,o,c);}return n},i=(e,t)=>{const r=n(t);return e.some(e=>n(e).match(`^${r}\\.\\d+`))};function n(e){return e.replace(/\]|\[/g,"")}
+
+exports.toNestErrors = s;
+exports.validateFieldsNatively = o;

package/build/cjs/node_modules/@hookform/resolvers/zod/dist/zod.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var resolvers = require('../../dist/resolvers.js');
+var index_esm = require('../../../../react-hook-form/dist/index.esm.js');
+
+function n(r,e){for(var n={};r.length;){var s=r[0],t=s.code,i=s.message,a=s.path.join(".");if(!n[a])if("unionErrors"in s){var u=s.unionErrors[0].errors[0];n[a]={message:u.message,type:u.code};}else n[a]={message:i,type:t};if("unionErrors"in s&&s.unionErrors.forEach(function(e){return e.errors.forEach(function(e){return r.push(e)})}),e){var c=n[a].types,f=c&&c[s.code];n[a]=index_esm.appendErrors(a,e,n,t,f?[].concat(f,s.message):s.message);}r.shift();}return n}function s(o,s,t){return void 0===t&&(t={}),function(i,a,u){try{return Promise.resolve(function(e,n){try{var a=Promise.resolve(o["sync"===t.mode?"parse":"parseAsync"](i,s)).then(function(e){return u.shouldUseNativeValidation&&resolvers.validateFieldsNatively({},u),{errors:{},values:t.raw?Object.assign({},i):e}});}catch(r){return n(r)}return a&&a.then?a.then(void 0,n):a}(0,function(r){if(function(r){return Array.isArray(null==r?void 0:r.errors)}(r))return {values:{},errors:resolvers.toNestErrors(n(r.errors,!u.shouldUseNativeValidation&&"all"===u.criteriaMode),u)};throw r}))}catch(r){return Promise.reject(r)}}}
+
+exports.zodResolver = s;