@evervault/react-native 2.6.0 → 2.6.2

package/src/specs/NativeEvervault.ts

@@ -0,0 +1,67 @@
+import { TurboModule, TurboModuleRegistry } from "react-native";
+
+export interface Spec extends TurboModule {
+  /**
+   * Initialize the Evervault SDK.
+   *
+   * @param teamId - The team ID.
+   * @param appId - The app ID.
+   *
+   * @returns A unique identifier for the SDK instance.
+   */
+  initialize(teamId: string, appId: string): string;
+
+  /**
+   * Encrypt a string.
+   *
+   * @param instanceId - The unique identifier for the SDK instance.
+   * @param data - The string to encrypt.
+   *
+   * @returns The encrypted string.
+   */
+  encryptString(instanceId: string, data: string): Promise<string>;
+
+  /**
+   * Encrypt a number.
+   *
+   * @param instanceId - The unique identifier for the SDK instance.
+   * @param data - The number to encrypt.
+   *
+   * @returns The encrypted number.
+   */
+  encryptNumber(instanceId: string, data: number): Promise<string>;
+
+  /**
+   * Encrypt a boolean.
+   *
+   * @param instanceId - The unique identifier for the SDK instance.
+   * @param data - The boolean to encrypt.
+   *
+   * @returns The encrypted boolean.
+   */
+  encryptBoolean(instanceId: string, data: boolean): Promise<string>;
+
+  /**
+   * Encrypt an object.
+   *
+   * @param instanceId - The unique identifier for the SDK instance.
+   * @param data - The object to encrypt.
+   *
+   * @returns The encrypted object.
+   */
+  encryptObject(instanceId: string, data: Object): Promise<Object>;
+
+  /**
+   * Encrypt an array.
+   *
+   * @param instanceId - The unique identifier for the SDK instance.
+   * @param data - The array to encrypt.
+   *
+   * @returns The encrypted array.
+   */
+  encryptArray(instanceId: string, data: Array<any>): Promise<Array<any>>;
+}
+
+export const NativeEvervault = TurboModuleRegistry.get<Spec>(
+  "NativeEvervault"
+) as Spec | null;

package/src/useEvervault.test.tsx

@@ -0,0 +1,31 @@
+import { renderHook } from "@testing-library/react-native";
+import { useEvervault } from "./useEvervault";
+import { EvervaultProvider } from "./EvervaultProvider";
+import { PropsWithChildren } from "react";
+import { ErrorBoundary } from "./utils";
+
+it("throws an error if used outside of EvervaultProvider", () => {
+  const onError = vi.fn();
+  const wrapper = ({ children }: PropsWithChildren) => (
+    <ErrorBoundary onError={onError}>{children}</ErrorBoundary>
+  );
+
+  renderHook(() => useEvervault(), { wrapper });
+  expect(onError).toHaveBeenCalledWith(
+    new Error("`useEvervault` must be used within an `EvervaultProvider`.")
+  );
+});
+
+it("returns the config when used within EvervaultProvider", () => {
+  const wrapper = ({ children }: PropsWithChildren) => (
+    <EvervaultProvider teamId="team_123" appId="app_123">
+      {children}
+    </EvervaultProvider>
+  );
+
+  const { result } = renderHook(() => useEvervault(), { wrapper });
+
+  expect(result.current.appId).toBe("app_123");
+  expect(result.current.teamId).toBe("team_123");
+  expect(result.current.encrypt).toStrictEqual(expect.any(Function));
+});

package/src/useEvervault.ts

@@ -0,0 +1,14 @@
+import { useContext } from "react";
+import { EvervaultContext } from "./context";
+
+export function useEvervault() {
+  const context = useContext(EvervaultContext);
+
+  if (!context) {
+    throw new Error(
+      "`useEvervault` must be used within an `EvervaultProvider`."
+    );
+  }
+
+  return context;
+}

package/src/utils.ts

@@ -0,0 +1,41 @@
+import {
+  Component,
+  LegacyRef,
+  MutableRefObject,
+  PropsWithChildren,
+  RefCallback,
+} from "react";
+
+// Taken from https://github.com/gregberge/react-merge-refs
+export function mergeRefs<T = any>(
+  ...refs: Array<MutableRefObject<T> | LegacyRef<T> | undefined | null>
+): RefCallback<T> {
+  return (value) => {
+    refs.forEach((ref) => {
+      if (typeof ref === "function") {
+        ref(value);
+      } else if (ref != null) {
+        (ref as MutableRefObject<T | null>).current = value;
+      }
+    });
+  };
+}
+
+export class ErrorBoundary extends Component<
+  PropsWithChildren<{ onError?(error: Error): void }>
+> {
+  state = { hasError: false };
+
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+
+  componentDidCatch(error: Error) {
+    this.props.onError?.(error);
+  }
+
+  render() {
+    if (this.state.hasError) return null;
+    return this.props.children;
+  }
+}