@reverbia/sdk 1.0.0 → 1.1.0-next.20251230221037

package/dist/next/index.cjs

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next/index.ts
+var index_exports = {};
+__export(index_exports, {
+  withReverbia: () => withReverbia
+});
+module.exports = __toCommonJS(index_exports);
+var withReverbia = (nextConfig = {}) => {
+  return {
+    ...nextConfig,
+    serverExternalPackages: [
+      ...nextConfig.serverExternalPackages || [],
+      "sharp"
+    ],
+    webpack: (config, options) => {
+      const { isServer } = options;
+      if (!isServer) {
+        config.resolve.alias = {
+          ...config.resolve.alias,
+          sharp: false
+        };
+      }
+      config.module.rules.push({
+        test: /\.node$/,
+        type: "asset/resource"
+      });
+      config.resolve.fallback = {
+        ...config.resolve.fallback,
+        fs: false,
+        net: false,
+        tls: false,
+        child_process: false,
+        "node:fs": false,
+        "node:path": false
+      };
+      if (typeof nextConfig.webpack === "function") {
+        return nextConfig.webpack(config, options);
+      }
+      return config;
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withReverbia
+});

package/dist/next/index.d.mts

@@ -0,0 +1,23 @@
+/**
+ * Next.js configuration plugin for @reverbia/sdk
+ *
+ * Use this to automatically configure Webpack aliases and server exclusions
+ * needed for the SDK's dependencies.
+ *
+ * @example
+ * ```ts
+ * // next.config.ts
+ * import { withReverbia } from "@reverbia/sdk/next";
+ *
+ * const nextConfig = {
+ *   // your config...
+ * };
+ *
+ * export default withReverbia(nextConfig);
+ * ```
+ *
+ * @module
+ */
+declare const withReverbia: (nextConfig?: any) => any;
+
+export { withReverbia };

package/dist/next/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Next.js configuration plugin for @reverbia/sdk
+ *
+ * Use this to automatically configure Webpack aliases and server exclusions
+ * needed for the SDK's dependencies.
+ *
+ * @example
+ * ```ts
+ * // next.config.ts
+ * import { withReverbia } from "@reverbia/sdk/next";
+ *
+ * const nextConfig = {
+ *   // your config...
+ * };
+ *
+ * export default withReverbia(nextConfig);
+ * ```
+ *
+ * @module
+ */
+declare const withReverbia: (nextConfig?: any) => any;
+
+export { withReverbia };

package/dist/next/index.mjs

@@ -0,0 +1,39 @@
+// src/next/index.ts
+var withReverbia = (nextConfig = {}) => {
+  return {
+    ...nextConfig,
+    serverExternalPackages: [
+      ...nextConfig.serverExternalPackages || [],
+      "sharp"
+    ],
+    webpack: (config, options) => {
+      const { isServer } = options;
+      if (!isServer) {
+        config.resolve.alias = {
+          ...config.resolve.alias,
+          sharp: false
+        };
+      }
+      config.module.rules.push({
+        test: /\.node$/,
+        type: "asset/resource"
+      });
+      config.resolve.fallback = {
+        ...config.resolve.fallback,
+        fs: false,
+        net: false,
+        tls: false,
+        child_process: false,
+        "node:fs": false,
+        "node:path": false
+      };
+      if (typeof nextConfig.webpack === "function") {
+        return nextConfig.webpack(config, options);
+      }
+      return config;
+    }
+  };
+};
+export {
+  withReverbia
+};

package/dist/polyfills/index.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/polyfills/index.ts
+var index_exports = {};
+__export(index_exports, {
+  needsTextDecoderStreamPolyfill: () => needsPolyfill
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/polyfills/textDecoderStream.ts
+var needsPolyfill = typeof globalThis.TextDecoderStream === "undefined";
+if (needsPolyfill && typeof globalThis.TransformStream !== "undefined") {
+  class TextDecoderStreamPolyfill {
+    constructor(label = "utf-8", options) {
+      this.decoder = new TextDecoder(label, options);
+      const decoder = this.decoder;
+      this.transform = new TransformStream({
+        transform(chunk, controller) {
+          const text = decoder.decode(chunk, { stream: true });
+          if (text) {
+            controller.enqueue(text);
+          }
+        },
+        flush(controller) {
+          const text = decoder.decode();
+          if (text) {
+            controller.enqueue(text);
+          }
+        }
+      });
+    }
+    get readable() {
+      return this.transform.readable;
+    }
+    get writable() {
+      return this.transform.writable;
+    }
+  }
+  globalThis.TextDecoderStream = TextDecoderStreamPolyfill;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  needsTextDecoderStreamPolyfill
+});

package/dist/polyfills/index.d.mts

@@ -0,0 +1,9 @@
+/**
+ * TextDecoderStream polyfill for React Native compatibility.
+ *
+ * React Native doesn't have TextDecoderStream, but it does have TextDecoder.
+ * This polyfill creates a TransformStream that uses TextDecoder internally.
+ */
+declare const needsPolyfill: boolean;
+
+export { needsPolyfill as needsTextDecoderStreamPolyfill };

package/dist/polyfills/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TextDecoderStream polyfill for React Native compatibility.
+ *
+ * React Native doesn't have TextDecoderStream, but it does have TextDecoder.
+ * This polyfill creates a TransformStream that uses TextDecoder internally.
+ */
+declare const needsPolyfill: boolean;
+
+export { needsPolyfill as needsTextDecoderStreamPolyfill };

package/dist/polyfills/index.mjs

@@ -0,0 +1,34 @@
+// src/lib/polyfills/textDecoderStream.ts
+var needsPolyfill = typeof globalThis.TextDecoderStream === "undefined";
+if (needsPolyfill && typeof globalThis.TransformStream !== "undefined") {
+  class TextDecoderStreamPolyfill {
+    constructor(label = "utf-8", options) {
+      this.decoder = new TextDecoder(label, options);
+      const decoder = this.decoder;
+      this.transform = new TransformStream({
+        transform(chunk, controller) {
+          const text = decoder.decode(chunk, { stream: true });
+          if (text) {
+            controller.enqueue(text);
+          }
+        },
+        flush(controller) {
+          const text = decoder.decode();
+          if (text) {
+            controller.enqueue(text);
+          }
+        }
+      });
+    }
+    get readable() {
+      return this.transform.readable;
+    }
+    get writable() {
+      return this.transform.writable;
+    }
+  }
+  globalThis.TextDecoderStream = TextDecoderStreamPolyfill;
+}
+export {
+  needsPolyfill as needsTextDecoderStreamPolyfill
+};

package/dist/react/chunk-KUFGQF6E.mjs

@@ -0,0 +1,290 @@
+import {
+  decryptData,
+  encryptData,
+  hasEncryptionKey
+} from "./chunk-T56Y62G7.mjs";
+
+// src/lib/backup/oauth/storage.ts
+var STORAGE_KEY_PREFIX = "oauth_token_";
+var ENCRYPTION_PREFIX = "enc:";
+var SESSION_KEY_STORAGE_KEY = "oauth_session_encryption_key";
+function getStorageKey(provider) {
+  return `${STORAGE_KEY_PREFIX}${provider}`;
+}
+function isEncrypted(value) {
+  return value.startsWith(ENCRYPTION_PREFIX);
+}
+async function getOrCreateSessionKey() {
+  if (typeof window === "undefined") {
+    throw new Error("Session key generation requires browser environment");
+  }
+  let sessionKey = sessionStorage.getItem(SESSION_KEY_STORAGE_KEY);
+  if (sessionKey) {
+    return sessionKey;
+  }
+  const keyBytes = crypto.getRandomValues(new Uint8Array(32));
+  sessionKey = Array.from(keyBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  sessionStorage.setItem(SESSION_KEY_STORAGE_KEY, sessionKey);
+  return sessionKey;
+}
+async function encryptWithSessionKey(plaintext) {
+  const sessionKeyHex = await getOrCreateSessionKey();
+  const keyBytes = hexToBytes(sessionKeyHex);
+  const key = await crypto.subtle.importKey(
+    "raw",
+    keyBytes.buffer,
+    { name: "AES-GCM" },
+    false,
+    ["encrypt", "decrypt"]
+  );
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const plaintextBytes = new TextEncoder().encode(plaintext);
+  const encryptedData = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    key,
+    plaintextBytes.buffer
+  );
+  const encryptedBytes = new Uint8Array(encryptedData);
+  const combined = new Uint8Array(iv.length + encryptedBytes.length);
+  combined.set(iv, 0);
+  combined.set(encryptedBytes, iv.length);
+  return Array.from(combined).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function decryptWithSessionKey(encryptedHex) {
+  const sessionKeyHex = sessionStorage.getItem(SESSION_KEY_STORAGE_KEY);
+  if (!sessionKeyHex) {
+    throw new Error("Session key not found");
+  }
+  const keyBytes = hexToBytes(sessionKeyHex);
+  const key = await crypto.subtle.importKey(
+    "raw",
+    keyBytes.buffer,
+    { name: "AES-GCM" },
+    false,
+    ["encrypt", "decrypt"]
+  );
+  const combined = hexToBytes(encryptedHex);
+  const iv = combined.slice(0, 12);
+  const encryptedData = combined.slice(12);
+  const decryptedData = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv },
+    key,
+    encryptedData
+  );
+  return new TextDecoder().decode(decryptedData);
+}
+function hexToBytes(hex) {
+  const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(cleanHex.length / 2);
+  for (let i = 0; i < cleanHex.length; i += 2) {
+    bytes[i / 2] = parseInt(cleanHex.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+async function reEncryptUnencryptedTokens(walletAddress) {
+  if (typeof window === "undefined") return;
+  if (!hasEncryptionKey(walletAddress)) return;
+  const providers = ["google-drive", "dropbox"];
+  for (const provider of providers) {
+    try {
+      const stored = localStorage.getItem(getStorageKey(provider));
+      if (!stored) continue;
+      if (!isEncrypted(stored)) {
+        try {
+          const data = JSON.parse(stored);
+          if (data.accessToken) {
+            await storeTokenData(provider, data, walletAddress);
+          }
+        } catch {
+          continue;
+        }
+      } else {
+        const encryptedPayload = stored.slice(ENCRYPTION_PREFIX.length);
+        try {
+          const decrypted = await decryptWithSessionKey(encryptedPayload);
+          const data = JSON.parse(decrypted);
+          if (data.accessToken) {
+            await storeTokenData(provider, data, walletAddress);
+          }
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+}
+async function getStoredTokenData(provider, walletAddress) {
+  if (typeof window === "undefined") return null;
+  try {
+    const stored = localStorage.getItem(getStorageKey(provider));
+    if (!stored) return null;
+    if (isEncrypted(stored)) {
+      const encryptedPayload = stored.slice(ENCRYPTION_PREFIX.length);
+      if (walletAddress && hasEncryptionKey(walletAddress)) {
+        try {
+          const decrypted = await decryptData(encryptedPayload, walletAddress);
+          const data = JSON.parse(decrypted);
+          if (!data.accessToken) return null;
+          return data;
+        } catch {
+        }
+      }
+      try {
+        const decrypted = await decryptWithSessionKey(encryptedPayload);
+        const data = JSON.parse(decrypted);
+        if (!data.accessToken) return null;
+        if (walletAddress && hasEncryptionKey(walletAddress)) {
+          try {
+            await storeTokenData(provider, data, walletAddress);
+          } catch {
+            console.error(`Failed to re-encrypt OAuth token for ${provider}`);
+          }
+        }
+        return data;
+      } catch {
+        return null;
+      }
+    } else {
+      try {
+        const data = JSON.parse(stored);
+        if (!data.accessToken) return null;
+        if (walletAddress && hasEncryptionKey(walletAddress)) {
+          try {
+            await storeTokenData(provider, data, walletAddress);
+          } catch {
+            console.error(`Failed to re-encrypt OAuth token for ${provider}`);
+          }
+        } else {
+          try {
+            await storeTokenData(provider, data);
+          } catch {
+            console.error(`Failed to encrypt OAuth token for ${provider}`);
+          }
+        }
+        return data;
+      } catch {
+        return null;
+      }
+    }
+  } catch {
+    return null;
+  }
+}
+function getStoredTokenDataSync(provider) {
+  if (typeof window === "undefined") return null;
+  try {
+    const stored = localStorage.getItem(getStorageKey(provider));
+    if (!stored) return null;
+    if (isEncrypted(stored)) {
+      return null;
+    }
+    const data = JSON.parse(stored);
+    if (!data.accessToken) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+async function storeTokenData(provider, data, walletAddress) {
+  if (typeof window === "undefined") return;
+  const jsonData = JSON.stringify(data);
+  if (walletAddress && hasEncryptionKey(walletAddress)) {
+    try {
+      const encrypted = await encryptData(jsonData, walletAddress);
+      localStorage.setItem(getStorageKey(provider), `${ENCRYPTION_PREFIX}${encrypted}`);
+      return;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown encryption error";
+      throw new Error(`OAuth token encryption failed: ${message}`);
+    }
+  }
+  try {
+    const encrypted = await encryptWithSessionKey(jsonData);
+    localStorage.setItem(getStorageKey(provider), `${ENCRYPTION_PREFIX}${encrypted}`);
+  } catch (error) {
+    const sessionStorageAvailable = typeof window !== "undefined" && typeof window.sessionStorage !== "undefined" && typeof window.sessionStorage.getItem === "function" && typeof window.sessionStorage.setItem === "function";
+    if (!sessionStorageAvailable) {
+      localStorage.setItem(getStorageKey(provider), jsonData);
+    } else {
+      const message = error instanceof Error ? error.message : "Unknown encryption error";
+      throw new Error(`OAuth token encryption failed: ${message}`);
+    }
+  }
+}
+function clearTokenData(provider) {
+  if (typeof window === "undefined") return;
+  localStorage.removeItem(getStorageKey(provider));
+}
+function isTokenExpired(data, bufferSeconds = 60) {
+  if (!data) return true;
+  if (!data.expiresAt) return false;
+  const now = Date.now();
+  const bufferMs = bufferSeconds * 1e3;
+  return data.expiresAt - bufferMs <= now;
+}
+async function getValidAccessToken(provider, walletAddress) {
+  const data = await getStoredTokenData(provider, walletAddress);
+  if (!data) return null;
+  if (data.expiresAt && isTokenExpired(data)) {
+    return null;
+  }
+  return data.accessToken;
+}
+function getValidAccessTokenSync(provider) {
+  const data = getStoredTokenDataSync(provider);
+  if (!data) return null;
+  if (data.expiresAt && isTokenExpired(data)) {
+    return null;
+  }
+  return data.accessToken;
+}
+async function getRefreshToken(provider, walletAddress) {
+  const data = await getStoredTokenData(provider, walletAddress);
+  return data?.refreshToken ?? null;
+}
+function getRefreshTokenSync(provider) {
+  const data = getStoredTokenDataSync(provider);
+  return data?.refreshToken ?? null;
+}
+function hasStoredCredentialsSync(provider) {
+  if (typeof window === "undefined") return false;
+  const stored = localStorage.getItem(getStorageKey(provider));
+  if (!stored) return false;
+  if (isEncrypted(stored)) {
+    return true;
+  }
+  try {
+    const data = JSON.parse(stored);
+    return !!(data?.accessToken || data?.refreshToken);
+  } catch {
+    return false;
+  }
+}
+function tokenResponseToStoredData(accessToken, expiresIn, refreshToken, scope) {
+  const data = {
+    accessToken,
+    refreshToken,
+    scope
+  };
+  if (expiresIn) {
+    data.expiresAt = Date.now() + expiresIn * 1e3;
+  }
+  return data;
+}
+
+export {
+  reEncryptUnencryptedTokens,
+  getStoredTokenData,
+  getStoredTokenDataSync,
+  storeTokenData,
+  clearTokenData,
+  isTokenExpired,
+  getValidAccessToken,
+  getValidAccessTokenSync,
+  getRefreshToken,
+  getRefreshTokenSync,
+  hasStoredCredentialsSync,
+  tokenResponseToStoredData
+};