@evervault/react-native 2.5.1 → 2.6.0

package/build/esm/Card/schema.js

@@ -0,0 +1,30 @@
+import z from '../node_modules/zod/lib';
+import { validateCVC as R, validateExpiry as b, validateNumber as C } from '../packages/card-validator/dist/evervault-card-validator.main.js';
+import { isAcceptedBrand } from './utils.js';
+
+function getCardFormSchema(acceptedBrands) {
+    return z.object({
+        name: z.string().min(1, "Missing name"),
+        number: z
+            .string()
+            .min(1, "Required")
+            .refine((value) => C(value).isValid, {
+            message: "Invalid card number",
+        })
+            .refine((value) => isAcceptedBrand(acceptedBrands, C(value)), { message: "Brand not accepted" }),
+        expiry: z
+            .string()
+            .min(1, "Required")
+            .refine((value) => b(value).isValid, {
+            message: "Invalid expiry",
+        }),
+        cvc: z
+            .string()
+            .min(1, "Required")
+            .refine((value) => R(value).isValid, {
+            message: "Invalid CVC",
+        }),
+    });
+}
+
+export { getCardFormSchema };

package/build/{Card → esm/Card}/types.d.ts

@@ -34,4 +34,3 @@ export interface CardPayload {
         cvc?: string;
     };
 }
-//# sourceMappingURL=types.d.ts.map

package/build/esm/Card/types.js

@@ -0,0 +1,19 @@
+const CARD_BRAND_NAMES = [
+    "american-express",
+    "visa",
+    "mastercard",
+    "discover",
+    "jcb",
+    "diners-club",
+    "unionpay",
+    "maestro",
+    "mir",
+    "elo",
+    "hipercard",
+    "hiper",
+    "szep",
+    "uatp",
+    "rupay",
+];
+
+export { CARD_BRAND_NAMES };

package/build/{Card → esm/Card}/utils.d.ts

@@ -14,4 +14,3 @@ export declare function formatExpiry(expiry: string): {
     month: string;
     year: string;
 } | null;
-//# sourceMappingURL=utils.d.ts.map

package/build/esm/Card/utils.js

@@ -0,0 +1,82 @@
+import { validateNumber as C, validateCVC as R, validateExpiry as b } from '../packages/card-validator/dist/evervault-card-validator.main.js';
+
+async function formatPayload(values, context) {
+    const number = values.number?.replace(/\s/g, "") || "";
+    const { brand, localBrands, bin, lastFour, isValid: isNumberValid, } = C(number);
+    if (number.length > 0 &&
+        brand !== "american-express" &&
+        values.cvc?.length === 4) {
+        context.form.setValue("cvc", values.cvc?.slice(0, 3));
+    }
+    const { cvc, isValid: isCvcValid } = R(values.cvc ?? "", number);
+    const formErrors = context.form.formState.errors;
+    const isValid = !Object.keys(formErrors).length;
+    const isComplete = areValuesComplete(values);
+    const errors = {};
+    if (formErrors.name?.message) {
+        errors.name = formErrors.name.message;
+    }
+    if (formErrors.number?.message) {
+        errors.number = formErrors.number.message;
+    }
+    if (formErrors.expiry?.message) {
+        errors.expiry = formErrors.expiry.message;
+    }
+    if (formErrors.cvc?.message) {
+        errors.cvc = formErrors.cvc.message;
+    }
+    return {
+        card: {
+            name: values.name ?? null,
+            brand,
+            localBrands,
+            bin,
+            lastFour,
+            expiry: formatExpiry(values.expiry ?? ""),
+            number: isNumberValid ? await context.encrypt(number) : null,
+            cvc: isCvcValid ? await context.encrypt(cvc ?? "") : null,
+        },
+        isComplete,
+        isValid: isValid && isComplete,
+        errors,
+    };
+}
+function areValuesComplete(values) {
+    if ("name" in values && !values.name?.length) {
+        return false;
+    }
+    if ("number" in values && !C(values.number ?? "").isValid) {
+        return false;
+    }
+    if ("expiry" in values && !b(values.expiry ?? "").isValid) {
+        return false;
+    }
+    if ("cvc" in values &&
+        !R(values.cvc ?? "", values.number).isValid) {
+        return false;
+    }
+    return true;
+}
+function isAcceptedBrand(acceptedBrands, cardNumberValidationResult) {
+    if (!acceptedBrands?.length)
+        return true;
+    if (!cardNumberValidationResult.isValid)
+        return false;
+    const { brand, localBrands } = cardNumberValidationResult;
+    const acceptedBrandsSet = new Set(acceptedBrands);
+    const isBrandAccepted = brand !== null && acceptedBrandsSet.has(brand);
+    const isLocalBrandAccepted = localBrands.some((localBrand) => acceptedBrandsSet.has(localBrand));
+    return isBrandAccepted || isLocalBrandAccepted;
+}
+function formatExpiry(expiry) {
+    const parsedExpiry = b(expiry);
+    if (!parsedExpiry.isValid) {
+        return null;
+    }
+    return {
+        month: parsedExpiry.month,
+        year: parsedExpiry.year,
+    };
+}
+
+export { areValuesComplete, formatExpiry, formatPayload, isAcceptedBrand };

package/build/{EvervaultProvider.d.ts → esm/EvervaultProvider.d.ts}

@@ -4,4 +4,3 @@ export interface EvervaultProviderProps extends PropsWithChildren {
     appId: string;
 }
 export declare function EvervaultProvider({ teamId, appId, children, }: EvervaultProviderProps): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=EvervaultProvider.d.ts.map

package/build/esm/EvervaultProvider.js

@@ -0,0 +1,15 @@
+import { jsx } from 'react/jsx-runtime';
+import { useMemo, useCallback } from 'react';
+import { EvervaultContext } from './context.js';
+import { sdk } from './sdk.js';
+
+function EvervaultProvider({ teamId, appId, children, }) {
+    const instanceId = useMemo(() => sdk.initialize(teamId, appId), [teamId, appId]);
+    const encrypt = useCallback(function (data) {
+        return sdk.encrypt(instanceId, data);
+    }, [instanceId]);
+    const context = useMemo(() => ({ teamId, appId, encrypt }), [teamId, appId, encrypt]);
+    return (jsx(EvervaultContext.Provider, { value: context, children: children }));
+}
+
+export { EvervaultProvider };

package/build/{Input.d.ts → esm/Input.d.ts}

@@ -16,4 +16,3 @@ export interface EvervaultInputProps<Values extends Record<string, unknown>> ext
 export declare const EvervaultInput: <Values extends Record<string, unknown>>(props: EvervaultInputProps<Values> & {
     ref?: Ref<EvervaultInput>;
 }) => ReactNode;
-//# sourceMappingURL=Input.d.ts.map

package/build/esm/Input.js

@@ -0,0 +1,103 @@
+import { jsx } from 'react/jsx-runtime';
+import { createContext, forwardRef, useContext, useMemo, useRef, useImperativeHandle, useCallback } from 'react';
+import { mergeRefs } from './utils.js';
+import { useFormContext, useController } from './node_modules/react-hook-form/dist/index.esm.js';
+import MaskInput from './node_modules/react-native-mask-input/lib/module/MaskInput.js';
+
+const EvervaultInputContext = createContext({
+    validationMode: "all",
+});
+function useForwardedInputRef(ref) {
+    const inputRef = useRef(null);
+    useImperativeHandle(ref, useCallback(() => ({
+        isFocused() {
+            return inputRef.current?.isFocused() ?? false;
+        },
+        focus() {
+            inputRef.current?.focus();
+        },
+        blur() {
+            inputRef.current?.blur();
+        },
+        clear() {
+            inputRef.current?.clear();
+        },
+        measure(callback) {
+            inputRef.current?.measure(callback);
+        },
+        measureInWindow(callback) {
+            inputRef.current?.measureInWindow(callback);
+        },
+        measureLayout(relativeToNativeComponentRef, onSuccess, onFail) {
+            inputRef.current?.measureLayout(relativeToNativeComponentRef, onSuccess, onFail);
+        },
+    }), [inputRef]));
+    return inputRef;
+}
+function mask(format) {
+    const maskArray = [];
+    let isObfuscated = false;
+    format.split("").forEach((char) => {
+        if (char === "[") {
+            isObfuscated = true;
+            return;
+        }
+        else if (char === "]") {
+            isObfuscated = false;
+            return;
+        }
+        let value = char;
+        if (char === "9") {
+            value = isObfuscated ? [/\d/] : /\d/;
+        }
+        maskArray.push(value);
+    });
+    return maskArray;
+}
+const EvervaultInput = forwardRef(function EvervaultInput({ name, mask, obfuscateValue, ...props }, ref) {
+    const { validationMode } = useContext(EvervaultInputContext);
+    const inputRef = useForwardedInputRef(ref);
+    const methods = useFormContext();
+    const { field, fieldState } = useController({
+        control: methods.control,
+        name,
+        shouldUnregister: true,
+    });
+    const obfuscationCharacter = useMemo(() => {
+        if (typeof obfuscateValue === "string") {
+            return obfuscateValue;
+        }
+        else {
+            return "•";
+        }
+    }, [obfuscateValue]);
+    return (jsx(MaskInput
+    // Overridable props
+    , { 
+        // Overridable props
+        id: field.name, ...props, 
+        // Strict props
+        ref: mergeRefs(inputRef, field.ref), editable: !field.disabled && (props.editable ?? true), onBlur: (evt) => {
+            const shouldValidate = validationMode === "onBlur" ||
+                validationMode === "onTouched" ||
+                validationMode === "all";
+            methods.setValue(field.name, field.value, {
+                shouldDirty: true,
+                shouldTouch: true,
+                shouldValidate,
+            });
+            props.onBlur?.(evt);
+        }, mask: mask, maskAutoComplete: !!mask, obfuscationCharacter: obfuscationCharacter, showObfuscatedValue: !!obfuscateValue, value: field.value, onChangeText: (masked, unmasked) => {
+            const shouldValidate = (validationMode === "onTouched" && fieldState.isTouched) ||
+                ((validationMode === "onChange" || validationMode === "all") &&
+                    (!!fieldState.error || fieldState.isTouched));
+            methods.setValue(field.name, unmasked, {
+                shouldDirty: true,
+                shouldValidate,
+            });
+        }, 
+        // Remove unwanted props
+        defaultValue: undefined, onChange: undefined }));
+});
+
+export { EvervaultInput, EvervaultInputContext, mask };

package/build/{ThreeDSecure → esm/ThreeDSecure}/Frame.d.ts

@@ -3,4 +3,3 @@ export interface ThreeDSecureFrameProps {
     style?: StyleProp<ViewStyle>;
 }
 export declare function ThreeDSecureFrame({ style }: ThreeDSecureFrameProps): import("react/jsx-runtime").JSX.Element | null;
-//# sourceMappingURL=Frame.d.ts.map

package/build/esm/ThreeDSecure/Frame.js

@@ -0,0 +1,35 @@
+import { jsx } from 'react/jsx-runtime';
+import { useContext, useMemo } from 'react';
+import { StyleSheet } from 'react-native';
+import { useEvervault } from '../useEvervault.js';
+import { WebView } from 'react-native-webview';
+import { CHALLENGE_DOMAIN_3DS } from './config.js';
+import { ThreeDSecureContext } from './context.js';
+
+function ThreeDSecureFrame({ style }) {
+    const evervault = useEvervault();
+    const context = useContext(ThreeDSecureContext);
+    if (!context) {
+        throw new Error("`ThreeDSecure.Frame` must be used within a `ThreeDSecure` component.");
+    }
+    const uri = useMemo(() => {
+        if (!context.session)
+            return null;
+        const params = new URLSearchParams();
+        params.set("session", context.session.sessionId);
+        params.set("app", evervault.appId);
+        params.set("team", evervault.teamId);
+        return `https://${CHALLENGE_DOMAIN_3DS}/?${params.toString()}`;
+    }, [context.session, evervault.appId, evervault.teamId]);
+    if (!uri)
+        return null;
+    return (jsx(WebView, { containerStyle: [defaultStyles.webView, style], source: { uri }, hideKeyboardAccessoryView: true, overScrollMode: "content" }));
+}
+const defaultStyles = StyleSheet.create({
+    webView: {
+        flex: 1,
+        width: "100%",
+    },
+});
+
+export { ThreeDSecureFrame };

package/build/{ThreeDSecure → esm/ThreeDSecure}/Root.d.ts

@@ -7,4 +7,3 @@ export interface ThreeDSecureProps extends PropsWithChildren {
     state: ThreeDSecureState;
 }
 export declare function ThreeDSecure({ state, children }: ThreeDSecureProps): import("react/jsx-runtime").JSX.Element | null;
-//# sourceMappingURL=Root.d.ts.map

package/build/esm/ThreeDSecure/Root.js

@@ -0,0 +1,12 @@
+import { jsx } from 'react/jsx-runtime';
+import { useEvervault } from '../useEvervault.js';
+import { ThreeDSecureContext } from './context.js';
+
+function ThreeDSecure({ state, children }) {
+    useEvervault();
+    if (!state.session)
+        return null;
+    return (jsx(ThreeDSecureContext.Provider, { value: state, children: state.isVisible && children }));
+}
+
+export { ThreeDSecure };

package/build/{ThreeDSecure → esm/ThreeDSecure}/config.d.ts

@@ -1,3 +1,2 @@
 export declare const EV_API_DOMAIN: string;
 export declare const CHALLENGE_DOMAIN_3DS: string;
-//# sourceMappingURL=config.d.ts.map

package/build/esm/ThreeDSecure/config.js

@@ -0,0 +1,4 @@
+const EV_API_DOMAIN = process.env.EV_API_DOMAIN || "api.evervault.com";
+const CHALLENGE_DOMAIN_3DS = process.env.CHALLENGE_DOMAIN_3DS || "3ds.evervault.com";
+
+export { CHALLENGE_DOMAIN_3DS, EV_API_DOMAIN };

package/build/{ThreeDSecure → esm/ThreeDSecure}/context.d.ts

@@ -1,3 +1,2 @@
 import { ThreeDSecureState } from "./types";
 export declare const ThreeDSecureContext: import("react").Context<ThreeDSecureState | null>;
-//# sourceMappingURL=context.d.ts.map

package/build/esm/ThreeDSecure/context.js

@@ -0,0 +1,5 @@
+import { createContext } from 'react';
+
+const ThreeDSecureContext = createContext(null);
+
+export { ThreeDSecureContext };

package/build/{ThreeDSecure → esm/ThreeDSecure}/event.d.ts

@@ -8,4 +8,3 @@ export declare class ThreeDSecureEvent {
     preventDefault(): void;
     get defaultPrevented(): boolean;
 }
-//# sourceMappingURL=event.d.ts.map

package/build/esm/ThreeDSecure/event.js

@@ -0,0 +1,18 @@
+class ThreeDSecureEvent {
+    type;
+    session;
+    _defaultPrevented;
+    constructor(type, session, _defaultPrevented = false) {
+        this.type = type;
+        this.session = session;
+        this._defaultPrevented = _defaultPrevented;
+    }
+    preventDefault() {
+        this._defaultPrevented = true;
+    }
+    get defaultPrevented() {
+        return this._defaultPrevented;
+    }
+}
+
+export { ThreeDSecureEvent };

package/build/{ThreeDSecure → esm/ThreeDSecure}/index.d.ts

@@ -7,4 +7,3 @@ export type { ThreeDSecureProps } from "./Root";
 export type { ThreeDSecureFrameProps } from "./Frame";
 export type { ThreeDSecureState, ThreeDSecureSession, ThreeDSecureCallbacks, } from "./types";
 export { useThreeDSecure } from "./useThreeDSecure";
-//# sourceMappingURL=index.d.ts.map

package/build/esm/ThreeDSecure/index.js

@@ -0,0 +1,9 @@
+import { ThreeDSecure as ThreeDSecure$1 } from './Root.js';
+import { ThreeDSecureFrame } from './Frame.js';
+export { useThreeDSecure } from './useThreeDSecure.js';
+
+const ThreeDSecure = Object.assign(ThreeDSecure$1, {
+    Frame: ThreeDSecureFrame,
+});
+
+export { ThreeDSecure };

package/build/{ThreeDSecure → esm/ThreeDSecure}/session.d.ts

@@ -3,4 +3,3 @@ export declare function stopPolling(intervalRef: React.MutableRefObject<NodeJS.T
 export declare function startSession(session: ThreeDSecureSession, options: ThreeDSecureOptions | undefined, intervalRef: React.MutableRefObject<NodeJS.Timeout | null>, setIsVisible: (show: boolean) => void): Promise<void>;
 export declare function pollSession(session: ThreeDSecureSession, options: ThreeDSecureOptions | undefined, intervalRef: React.MutableRefObject<NodeJS.Timeout | null>, setIsVisible: (show: boolean) => void, interval?: number): void;
 export declare function threeDSecureSession({ sessionId, appId, options, intervalRef, setIsVisible, }: ThreeDSecureSessionsParams): ThreeDSecureSession;
-//# sourceMappingURL=session.d.ts.map

package/build/esm/ThreeDSecure/session.js

@@ -0,0 +1,136 @@
+import { EV_API_DOMAIN } from './config.js';
+import { ThreeDSecureEvent } from './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 = new ThreeDSecureEvent("requestChallenge", session);
+                options?.onRequestChallenge?.(event);
+                if (event.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 = new ThreeDSecureEvent("requestChallenge", session);
+                    options?.onRequestChallenge?.(event);
+                    if (event.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://${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://${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,
+    };
+}
+
+export { pollSession, startSession, stopPolling, threeDSecureSession };

package/build/{ThreeDSecure → esm/ThreeDSecure}/types.d.ts

@@ -66,4 +66,3 @@ export interface ThreeDSecureState extends ThreeDSecureInitialState {
      */
     start(sessionId: string, options?: ThreeDSecureOptions): void;
 }
-//# sourceMappingURL=types.d.ts.map

package/build/esm/ThreeDSecure/types.js

@@ -0,0 +1 @@
+

package/build/{ThreeDSecure → esm/ThreeDSecure}/useThreeDSecure.d.ts

@@ -3,4 +3,3 @@ export interface UseThreeDSecureOptions {
     failOnChallenge?: boolean | (() => Promise<boolean>);
 }
 export declare function useThreeDSecure(options?: UseThreeDSecureOptions): ThreeDSecureState;
-//# sourceMappingURL=useThreeDSecure.d.ts.map

package/build/esm/ThreeDSecure/useThreeDSecure.js

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

package/build/{__mocks__ → esm/__mocks__}/NativeEvervault.d.ts

@@ -1,4 +1,3 @@
 import type { Spec } from "../specs/NativeEvervault";
 export declare const encryptedValue = "ev:W98t:uu98aas09udya863ty9372y7y23h97rg6gfs678987";
 export declare const NativeEvervault: Spec;
-//# sourceMappingURL=NativeEvervault.d.ts.map

package/build/esm/__mocks__/NativeEvervault.js

@@ -0,0 +1,11 @@
+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(),
+};
+
+export { NativeEvervault, encryptedValue };

package/build/{__mocks__ → esm/__mocks__}/react-native-webview.d.ts

@@ -1,3 +1,2 @@
 import type { WebViewProps } from "react-native-webview";
 export declare function WebView(props: WebViewProps): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=react-native-webview.d.ts.map

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

@@ -0,0 +1,8 @@
+import { jsx } from 'react/jsx-runtime';
+import { View } from 'react-native';
+
+function WebView(props) {
+    return jsx(View, { testID: "webview", ...props });
+}
+
+export { WebView };

package/build/{context.d.ts → esm/context.d.ts}

@@ -6,4 +6,3 @@ export interface EvervaultContextValue {
     encrypt: EncryptFn;
 }
 export declare const EvervaultContext: import("react").Context<EvervaultContextValue | null>;
-//# sourceMappingURL=context.d.ts.map

package/build/esm/context.js

@@ -0,0 +1,5 @@
+import { createContext } from 'react';
+
+const EvervaultContext = createContext(null);
+
+export { EvervaultContext };

package/build/{index.d.ts → esm/index.d.ts}

@@ -6,4 +6,3 @@ export { useEvervault } from "./useEvervault";
 export type { EvervaultInput, BaseEvervaultInputProps as EvervaultInputProps, } from "./Input";
 export * from "./Card";
 export * from "./ThreeDSecure";
-//# sourceMappingURL=index.d.ts.map