@evervault/react-native 2.5.1 → 2.6.0

package/build/cjs/packages/card-validator/dist/evervault-card-validator.main.js

@@ -0,0 +1,349 @@
+'use strict';
+
+function g(e) {
+  let n = 0, t = false, s = e.length - 1, l;
+  for (; s >= 0; )
+    l = parseInt(e.charAt(s), 10), t && (l *= 2, l > 9 && (l = l % 10 + 1)), t = !t, n += l, s--;
+  return n % 10 === 0;
+}
+const h = [
+  {
+    name: "visa",
+    isLocal: false,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [4],
+      lengths: [16, 18, 19]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  },
+  {
+    name: "mastercard",
+    isLocal: false,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [[51, 55], [2221, 2229], [223, 229], [23, 26], [270, 271], 2720],
+      lengths: [16]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  },
+  {
+    name: "american-express",
+    isLocal: false,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [34, 37],
+      lengths: [15]
+    },
+    securityCodeValidationRules: {
+      lengths: [3, 4]
+    }
+  },
+  {
+    name: "diners-club",
+    isLocal: false,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [[300, 305], 3095, 36, 38, 39],
+      lengths: [14, 16, 19]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  },
+  {
+    name: "discover",
+    isLocal: false,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [6011, [644, 649], [65e4, 651999], [653150, 659999], 622],
+      lengths: [16, 19]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  },
+  {
+    name: "jcb",
+    isLocal: false,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [
+        2131,
+        1800,
+        [3088, 3094],
+        [3096, 3102],
+        [3112, 3120],
+        [3158, 3159],
+        [3337, 3349],
+        [3528, 3589]
+      ],
+      lengths: [16, 17, 18, 19]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  },
+  {
+    name: "unionpay",
+    isLocal: false,
+    numberValidationRules: {
+      luhnCheck: false,
+      ranges: [
+        620,
+        [62100, 62182],
+        [62184, 62187],
+        [62185, 62197],
+        [62200, 62205],
+        [622010, 622999],
+        622018,
+        [62207, 62209],
+        [623, 626],
+        6270,
+        6272,
+        6276,
+        [627700, 627779],
+        [627781, 627799],
+        [6282, 6289],
+        6291,
+        6292,
+        810,
+        [8110, 8131],
+        [8132, 8151],
+        [8152, 8163],
+        [8164, 8171]
+      ],
+      lengths: [14, 15, 16, 17, 18, 19]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  },
+  {
+    name: "maestro",
+    isLocal: false,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [
+        5018,
+        5020,
+        5038,
+        5893,
+        6101,
+        6304,
+        6759,
+        6761,
+        6762,
+        6763,
+        493698,
+        [5e5, 504174],
+        [504176, 506698],
+        [506779, 508999],
+        69
+      ],
+      lengths: [12, 13, 14, 15, 16, 17, 18, 19]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  },
+  {
+    name: "elo",
+    isLocal: true,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [
+        401178,
+        401179,
+        438935,
+        457631,
+        457632,
+        431274,
+        451416,
+        457393,
+        504175,
+        [506699, 506778],
+        [509e3, 509999],
+        627780,
+        636297,
+        636368,
+        [650031, 650033],
+        [650035, 650051],
+        [650405, 650439],
+        [650485, 650538],
+        [650541, 650598],
+        [650700, 650718],
+        [650720, 650727],
+        [650901, 650978],
+        [651652, 651679],
+        [655e3, 655019],
+        [655021, 655058]
+      ],
+      lengths: [16]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  },
+  {
+    name: "mir",
+    isLocal: true,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [[2200, 2204]],
+      lengths: [16, 17, 18, 19]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  },
+  {
+    name: "hiper",
+    isLocal: true,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [637095, 63737423, 63743358, 637568, 637599, 637609, 637612],
+      lengths: [16]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  },
+  {
+    name: "hipercard",
+    isLocal: true,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [606282],
+      lengths: [16]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  },
+  {
+    name: "szep",
+    isLocal: true,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [30867825, 61013170, 61013242],
+      lengths: [16]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  },
+  {
+    name: "uatp",
+    isLocal: false,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [1],
+      lengths: [15]
+    },
+    securityCodeValidationRules: {
+      lengths: [0]
+    }
+  },
+  {
+    name: "rupay",
+    isLocal: false,
+    numberValidationRules: {
+      luhnCheck: true,
+      ranges: [60, 81, 82, 508, [652100, 653149], [817200, 819899]],
+      lengths: [16]
+    },
+    securityCodeValidationRules: {
+      lengths: [3]
+    }
+  }
+];
+function m(e, n, t) {
+  const s = String(n).length, l = e.substring(0, s), a = parseInt(l, 10);
+  return l.length < s ? false : (n = parseInt(String(n).substring(0, l.length), 10), t = parseInt(String(t).substring(0, l.length), 10), a >= n && a <= t);
+}
+function V(e, n) {
+  return e.startsWith(String(n));
+}
+function f(e) {
+  return e.length < 16 ? e.substring(0, 6) : e.substring(0, 8);
+}
+function C(e) {
+  const n = String(e).replace(/\s/g, "");
+  if (!/^\d*$/.test(n))
+    return {
+      brand: null,
+      localBrands: [],
+      bin: null,
+      lastFour: null,
+      isValid: false
+    };
+  const t = h.filter((i) => i.numberValidationRules.ranges.some((r) => {
+    if (Array.isArray(r)) {
+      if (r[0] && r[1])
+        return m(n, r[0], r[1]);
+    } else
+      return V(n, r);
+    return false;
+  })), s = t.filter((i) => !i.isLocal), l = t.filter((i) => i.isLocal), a = t.length > 0 && t.every((i) => {
+    const { lengths: r, luhnCheck: o } = i.numberValidationRules, c = r.includes(n.length), d = !o || g(n);
+    return c && d;
+  }), u = e.length > 5;
+  return {
+    brand: s.length > 0 ? s[0].name : null,
+    localBrands: l.map((i) => i.name),
+    bin: u ? f(e) : null,
+    lastFour: a ? n.substring(n.length - 4) : null,
+    isValid: a
+  };
+}
+function R(e, n) {
+  if (!/^\d{3,4}$/.test(e))
+    return {
+      cvc: null,
+      isValid: false
+    };
+  if (!n)
+    return {
+      cvc: e,
+      isValid: true
+    };
+  const t = C(n);
+  if (!t.isValid)
+    return {
+      cvc: null,
+      isValid: false
+    };
+  const s = [];
+  t.brand && s.push(t.brand), t.localBrands && s.push(...t.localBrands);
+  const l = h.filter((a) => s.includes(a.name)).some((a) => a.securityCodeValidationRules.lengths.includes(e.length));
+  return {
+    cvc: l ? e : null,
+    isValid: l
+  };
+}
+function b(e) {
+  var i;
+  const n = /^(0[1-9]|1[[0-2]).*$/, t = e.match(n), s = t ? parseInt(t[1].toString(), 10) : null, l = /^(0[1-9]|1[[0-2])(\d{2})$/, a = e.match(l), u = a ? parseInt(a[2].toString(), 10) : null;
+  if (s) {
+    const r = (/* @__PURE__ */ new Date()).getFullYear() % 100, o = (/* @__PURE__ */ new Date()).getMonth() + 1, c = !u || u < r || u === r && s < o;
+    return {
+      month: s.toString().padStart(2, "0"),
+      year: ((i = u == null ? void 0 : u.toString()) == null ? void 0 : i.padStart(2, "0")) ?? null,
+      isValid: !c
+    };
+  }
+  return {
+    month: null,
+    year: null,
+    isValid: false
+  };
+}
+
+exports.validateCVC = R;
+exports.validateExpiry = b;
+exports.validateNumber = C;

package/build/cjs/sdk.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var NativeEvervault = require('./specs/NativeEvervault.js');
+
+function getModule() {
+    if (!NativeEvervault.NativeEvervault) {
+        throw new Error("NativeEvervault is not available.");
+    }
+    return NativeEvervault.NativeEvervault;
+}
+const sdk = {
+    verify() {
+        getModule();
+        return true;
+    },
+    initialize(teamId, appId) {
+        const evervault = getModule();
+        if (!teamId) {
+            throw new Error("Team ID is required.");
+        }
+        if (!appId) {
+            throw new Error("App ID is required.");
+        }
+        return evervault.initialize(teamId, appId);
+    },
+    async encrypt(instanceId, data) {
+        const evervault = getModule();
+        if (data === undefined) {
+            return undefined;
+        }
+        else if (data === null) {
+            return null;
+        }
+        else if (typeof data === "string") {
+            return (await evervault.encryptString(instanceId, data));
+        }
+        else if (typeof data === "number") {
+            return (await evervault.encryptNumber(instanceId, data));
+        }
+        else if (typeof data === "boolean") {
+            return (await evervault.encryptBoolean(instanceId, data));
+        }
+        else if (Array.isArray(data)) {
+            return (await evervault.encryptArray(instanceId, data));
+        }
+        else if (typeof data === "object") {
+            return (await evervault.encryptObject(instanceId, data));
+        }
+        throw new Error("Unsupported data type.");
+    },
+};
+
+exports.sdk = sdk;

package/build/cjs/specs/NativeEvervault.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var reactNative = require('react-native');
+
+const NativeEvervault = reactNative.TurboModuleRegistry.get("NativeEvervault");
+
+exports.NativeEvervault = NativeEvervault;

package/build/cjs/useEvervault.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var React = require('react');
+var context = require('./context.js');
+
+function useEvervault() {
+    const context$1 = React.useContext(context.EvervaultContext);
+    if (!context$1) {
+        throw new Error("`useEvervault` must be used within an `EvervaultProvider`.");
+    }
+    return context$1;
+}
+
+exports.useEvervault = useEvervault;

package/build/cjs/utils.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var React = require('react');
+
+// Taken from https://github.com/gregberge/react-merge-refs
+function mergeRefs(...refs) {
+    return (value) => {
+        refs.forEach((ref) => {
+            if (typeof ref === "function") {
+                ref(value);
+            }
+            else if (ref != null) {
+                ref.current = value;
+            }
+        });
+    };
+}
+class ErrorBoundary extends React.Component {
+    state = { hasError: false };
+    static getDerivedStateFromError() {
+        return { hasError: true };
+    }
+    componentDidCatch(error) {
+        this.props.onError?.(error);
+    }
+    render() {
+        if (this.state.hasError)
+            return null;
+        return this.props.children;
+    }
+}
+
+exports.ErrorBoundary = ErrorBoundary;
+exports.mergeRefs = mergeRefs;

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

@@ -9,4 +9,3 @@ export interface CardCvcProps extends BaseEvervaultInputProps {
 }
 export type CardCvc = EvervaultInput;
 export declare const CardCvc: import("react").ForwardRefExoticComponent<CardCvcProps & import("react").RefAttributes<EvervaultInput>>;
-//# sourceMappingURL=Cvc.d.ts.map

package/build/esm/Card/Cvc.js

@@ -0,0 +1,27 @@
+import { jsx } from 'react/jsx-runtime';
+import { forwardRef, useMemo } from 'react';
+import { mask, EvervaultInput } from '../Input.js';
+import { validateNumber as C } from '../packages/card-validator/dist/evervault-card-validator.main.js';
+import { useFormContext } from '../node_modules/react-hook-form/dist/index.esm.js';
+
+const DEFAULT_CARD_CVC_MASK = mask("[999]");
+const CARD_CVC_MASKS = {
+    "american-express": mask("[9999]"),
+};
+const CardCvc = forwardRef(function CardCvc(props, ref) {
+    const methods = useFormContext();
+    const number = methods.watch("number");
+    const mask = useMemo(() => {
+        if (!number) {
+            return DEFAULT_CARD_CVC_MASK;
+        }
+        const brand = C(number).brand;
+        if (brand && CARD_CVC_MASKS[brand]) {
+            return CARD_CVC_MASKS[brand];
+        }
+        return DEFAULT_CARD_CVC_MASK;
+    }, [number]);
+    return (jsx(EvervaultInput, { placeholder: "CVC", ...props, ref: ref, name: "cvc", mask: mask, inputMode: "numeric", autoComplete: "cc-csc", keyboardType: "number-pad" }));
+});
+
+export { CardCvc };

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

@@ -2,4 +2,3 @@ import { BaseEvervaultInputProps, EvervaultInput } from "../Input";
 export type CardExpiryProps = BaseEvervaultInputProps;
 export type CardExpiry = EvervaultInput;
 export declare const CardExpiry: import("react").ForwardRefExoticComponent<BaseEvervaultInputProps & import("react").RefAttributes<EvervaultInput>>;
-//# sourceMappingURL=Expiry.d.ts.map

package/build/esm/Card/Expiry.js

@@ -0,0 +1,10 @@
+import { jsx } from 'react/jsx-runtime';
+import { forwardRef } from 'react';
+import { mask, EvervaultInput } from '../Input.js';
+
+const CARD_EXPIRY_MASK = mask("99 / 99");
+const CardExpiry = forwardRef(function CardExpiry(props, ref) {
+    return (jsx(EvervaultInput, { placeholder: "MM / YY", ...props, ref: ref, name: "expiry", mask: CARD_EXPIRY_MASK, inputMode: "numeric", autoComplete: "cc-exp", keyboardType: "number-pad" }));
+});
+
+export { CardExpiry };

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

@@ -2,4 +2,3 @@ import { BaseEvervaultInputProps, EvervaultInput } from "../Input";
 export type CardHolderProps = BaseEvervaultInputProps;
 export type CardHolder = EvervaultInput;
 export declare const CardHolder: import("react").ForwardRefExoticComponent<BaseEvervaultInputProps & import("react").RefAttributes<EvervaultInput>>;
-//# sourceMappingURL=Holder.d.ts.map

package/build/esm/Card/Holder.js

@@ -0,0 +1,13 @@
+import { jsx } from 'react/jsx-runtime';
+import { Platform } from 'react-native';
+import { forwardRef } from 'react';
+import { EvervaultInput } from '../Input.js';
+
+const CardHolder = forwardRef(function CardHolder(props, ref) {
+    return (jsx(EvervaultInput, { placeholder: "Johnny Appleseed", ...props, ref: ref, name: "name", inputMode: "text", autoComplete: Platform.select({
+            ios: "cc-name",
+            default: "name",
+        }), keyboardType: "default" }));
+});
+
+export { CardHolder };

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

@@ -9,4 +9,3 @@ export interface CardNumberProps extends BaseEvervaultInputProps {
 }
 export type CardNumber = EvervaultInput;
 export declare const CardNumber: import("react").ForwardRefExoticComponent<CardNumberProps & import("react").RefAttributes<EvervaultInput>>;
-//# sourceMappingURL=Number.d.ts.map

package/build/esm/Card/Number.js

@@ -0,0 +1,25 @@
+import { jsx } from 'react/jsx-runtime';
+import { forwardRef, useCallback } from 'react';
+import { mask, EvervaultInput } from '../Input.js';
+import { validateNumber as C } from '../packages/card-validator/dist/evervault-card-validator.main.js';
+
+const DEFAULT_CARD_NUMBER_MASK = mask("9999 99[99 9999 9999]");
+const CARD_NUMBER_MASKS = {
+    unionpay: mask("9999 99[99 9999 9999 999]"),
+    "american-express": mask("9999 99[9999 99999]"),
+};
+const CardNumber = forwardRef(function CardNumber(props, ref) {
+    const mask = useCallback((text) => {
+        if (!text) {
+            return DEFAULT_CARD_NUMBER_MASK;
+        }
+        const brand = C(text).brand;
+        if (brand && CARD_NUMBER_MASKS[brand]) {
+            return CARD_NUMBER_MASKS[brand];
+        }
+        return DEFAULT_CARD_NUMBER_MASK;
+    }, []);
+    return (jsx(EvervaultInput, { placeholder: "1234 1234 1234 1234", ...props, ref: ref, name: "number", mask: mask, inputMode: "numeric", autoComplete: "cc-number", keyboardType: "number-pad" }));
+});
+
+export { CardNumber };

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

@@ -37,4 +37,3 @@ export interface Card {
     reset(): void;
 }
 export declare const Card: import("react").ForwardRefExoticComponent<CardProps & import("react").RefAttributes<Card>>;
-//# sourceMappingURL=Root.d.ts.map

package/build/esm/Card/Root.js

@@ -0,0 +1,68 @@
+import { jsx } from 'react/jsx-runtime';
+import { forwardRef, useMemo, useRef, useEffect, useImperativeHandle, useCallback } from 'react';
+import { useForm, FormProvider } from '../node_modules/react-hook-form/dist/index.esm.js';
+import { getCardFormSchema } from './schema.js';
+import { zodResolver as s } from '../node_modules/@hookform/resolvers/zod/dist/zod.js';
+import { useEvervault } from '../useEvervault.js';
+import { formatPayload } from './utils.js';
+import { EvervaultInputContext } from '../Input.js';
+
+const DEFAULT_ACCEPTED_BRANDS = [];
+const Card = forwardRef(function Card({ children, defaultValues, onChange, onError, acceptedBrands = DEFAULT_ACCEPTED_BRANDS, validationMode = "all", }, ref) {
+    const evervault = useEvervault();
+    const resolver = useMemo(() => {
+        const schema = getCardFormSchema(acceptedBrands);
+        return s(schema);
+    }, [acceptedBrands]);
+    const methods = useForm({
+        defaultValues,
+        resolver,
+        mode: validationMode,
+        shouldUseNativeValidation: false,
+    });
+    const inputContext = useMemo(() => ({
+        validationMode,
+    }), [validationMode]);
+    // Use refs to prevent closures from being captured
+    const onChangeRef = useRef(onChange);
+    onChangeRef.current = onChange;
+    const onErrorRef = useRef(onError);
+    onErrorRef.current = onError;
+    useEffect(() => {
+        if (!onChange)
+            return;
+        let abortController;
+        function handleChange(values) {
+            if (abortController) {
+                abortController.abort();
+            }
+            abortController = new AbortController();
+            const signal = abortController.signal;
+            requestAnimationFrame(async () => {
+                try {
+                    const payload = await formatPayload(values, {
+                        encrypt: evervault.encrypt,
+                        form: methods,
+                    });
+                    if (signal.aborted)
+                        return;
+                    onChangeRef.current?.(payload);
+                }
+                catch (error) {
+                    onErrorRef.current?.(error);
+                }
+            });
+        }
+        handleChange(methods.getValues());
+        const subscription = methods.watch(handleChange);
+        return () => subscription.unsubscribe();
+    }, [evervault.encrypt]);
+    useImperativeHandle(ref, useCallback(() => ({
+        reset() {
+            methods.reset();
+        },
+    }), []));
+    return (jsx(FormProvider, { ...methods, children: jsx(EvervaultInputContext.Provider, { value: inputContext, children: children }) }));
+});
+
+export { Card };

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

@@ -20,4 +20,3 @@ export { CardCvc };
 export type { CardNumberProps } from "./Number";
 export { CardNumber };
 export type { CardPayload, CardBrandName } from "./types";
-//# sourceMappingURL=index.d.ts.map

package/build/esm/Card/index.js

@@ -0,0 +1,14 @@
+import { Card as Card$1 } from './Root.js';
+import { CardHolder } from './Holder.js';
+import { CardExpiry } from './Expiry.js';
+import { CardCvc } from './Cvc.js';
+import { CardNumber } from './Number.js';
+
+const Card = Object.assign(Card$1, {
+    Holder: CardHolder,
+    Expiry: CardExpiry,
+    Cvc: CardCvc,
+    Number: CardNumber,
+});
+
+export { Card, CardCvc, CardExpiry, CardHolder, CardNumber };

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

@@ -17,4 +17,3 @@ export declare function getCardFormSchema(acceptedBrands: CardBrandName[]): z.Zo
     cvc: string;
 }>;
 export type CardFormValues = z.infer<ReturnType<typeof getCardFormSchema>>;
-//# sourceMappingURL=schema.d.ts.map