@scalemule/nextjs 0.1.33 → 0.1.34

package/dist/client.js

@@ -1,400 +1,8 @@
 'use strict';
 
-// node_modules/@scalemule/sdk/dist/index.mjs
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var upload_resume_exports = {};
-__export(upload_resume_exports, {
-  UploadResumeStore: () => UploadResumeStore
-});
-var DB_NAME;
-var STORE_NAME;
-var DB_VERSION;
-var MAX_AGE_MS;
-var UploadResumeStore;
-var init_upload_resume = __esm({
-  "src/services/upload-resume.ts"() {
-    DB_NAME = "sm_upload_sessions_v1";
-    STORE_NAME = "sessions";
-    DB_VERSION = 1;
-    MAX_AGE_MS = 24 * 60 * 60 * 1e3;
-    UploadResumeStore = class {
-      constructor() {
-        this.db = null;
-      }
-      /** Generate a deterministic resume key from upload identity */
-      static async generateResumeKey(appId, userId, filename, size, lastModified) {
-        const raw = `${appId}:${userId}:${filename}:${size}:${lastModified ?? 0}`;
-        if (typeof crypto !== "undefined" && crypto.subtle) {
-          const buffer = new TextEncoder().encode(raw);
-          const hash2 = await crypto.subtle.digest("SHA-256", buffer);
-          return Array.from(new Uint8Array(hash2)).map((b) => b.toString(16).padStart(2, "0")).join("");
-        }
-        let hash = 0;
-        for (let i = 0; i < raw.length; i++) {
-          const chr = raw.charCodeAt(i);
-          hash = (hash << 5) - hash + chr;
-          hash |= 0;
-        }
-        return `fallback_${Math.abs(hash).toString(36)}`;
-      }
-      /** Open the IndexedDB store. No-ops if IndexedDB is unavailable. */
-      async open() {
-        if (typeof indexedDB === "undefined") return;
-        return new Promise((resolve, reject) => {
-          const request = indexedDB.open(DB_NAME, DB_VERSION);
-          request.onupgradeneeded = () => {
-            const db = request.result;
-            if (!db.objectStoreNames.contains(STORE_NAME)) {
-              const store = db.createObjectStore(STORE_NAME, { keyPath: "key" });
-              store.createIndex("updated_at", "updated_at");
-            }
-          };
-          request.onsuccess = () => {
-            this.db = request.result;
-            resolve();
-          };
-          request.onerror = () => {
-            reject(request.error);
-          };
-        });
-      }
-      /** Get a resume session by key. Returns null if not found or stale. */
-      async get(key) {
-        if (!this.db) return null;
-        return new Promise((resolve) => {
-          const tx = this.db.transaction(STORE_NAME, "readonly");
-          const store = tx.objectStore(STORE_NAME);
-          const request = store.get(key);
-          request.onsuccess = () => {
-            const entry = request.result;
-            if (!entry) {
-              resolve(null);
-              return;
-            }
-            if (Date.now() - entry.updated_at > MAX_AGE_MS) {
-              this.remove(key).catch(() => {
-              });
-              resolve(null);
-              return;
-            }
-            resolve(entry.session);
-          };
-          request.onerror = () => resolve(null);
-        });
-      }
-      /** Save a new resume session. */
-      async save(key, session) {
-        if (!this.db) return;
-        return new Promise((resolve, reject) => {
-          const tx = this.db.transaction(STORE_NAME, "readwrite");
-          const store = tx.objectStore(STORE_NAME);
-          const entry = {
-            key,
-            session: { ...session, created_at: Date.now() },
-            updated_at: Date.now()
-          };
-          const request = store.put(entry);
-          request.onsuccess = () => resolve();
-          request.onerror = () => reject(request.error);
-        });
-      }
-      /** Update a single completed part in an existing session. */
-      async updatePart(key, partNumber, etag) {
-        if (!this.db) return;
-        return new Promise((resolve) => {
-          const tx = this.db.transaction(STORE_NAME, "readwrite");
-          const store = tx.objectStore(STORE_NAME);
-          const getRequest = store.get(key);
-          getRequest.onsuccess = () => {
-            const entry = getRequest.result;
-            if (!entry) {
-              resolve();
-              return;
-            }
-            const existing = entry.session.completed_parts.find((p) => p.part_number === partNumber);
-            if (!existing) {
-              entry.session.completed_parts.push({ part_number: partNumber, etag });
-            }
-            entry.updated_at = Date.now();
-            const putRequest = store.put(entry);
-            putRequest.onsuccess = () => resolve();
-            putRequest.onerror = () => resolve();
-          };
-          getRequest.onerror = () => resolve();
-        });
-      }
-      /** Remove a resume session (e.g., after successful completion). */
-      async remove(key) {
-        if (!this.db) return;
-        return new Promise((resolve) => {
-          const tx = this.db.transaction(STORE_NAME, "readwrite");
-          const store = tx.objectStore(STORE_NAME);
-          const request = store.delete(key);
-          request.onsuccess = () => resolve();
-          request.onerror = () => resolve();
-        });
-      }
-      /** Purge all stale entries (older than MAX_AGE_MS). */
-      async purgeStale() {
-        if (!this.db) return 0;
-        return new Promise((resolve) => {
-          const cutoff = Date.now() - MAX_AGE_MS;
-          const tx = this.db.transaction(STORE_NAME, "readwrite");
-          const store = tx.objectStore(STORE_NAME);
-          const index = store.index("updated_at");
-          const range = IDBKeyRange.upperBound(cutoff);
-          const request = index.openCursor(range);
-          let count = 0;
-          request.onsuccess = () => {
-            const cursor = request.result;
-            if (cursor) {
-              cursor.delete();
-              count++;
-              cursor.continue();
-            } else {
-              resolve(count);
-            }
-          };
-          request.onerror = () => resolve(0);
-        });
-      }
-      /** Close the database connection. */
-      close() {
-        if (this.db) {
-          this.db.close();
-          this.db = null;
-        }
-      }
-    };
-  }
-});
-var upload_compression_exports = {};
-__export(upload_compression_exports, {
-  maybeCompressImage: () => maybeCompressImage
-});
-async function maybeCompressImage(file, userConfig, sessionId, telemetry) {
-  const type = file.type?.toLowerCase() || "";
-  if (!type.startsWith("image/")) return null;
-  if (SKIP_TYPES.has(type)) {
-    telemetry?.emit(sessionId, "upload.compression.skipped", { reason: "format", type });
-    return null;
-  }
-  if (!COMPRESSIBLE_TYPES.has(type)) {
-    telemetry?.emit(sessionId, "upload.compression.skipped", { reason: "unsupported_type", type });
-    return null;
-  }
-  if (file.size < MIN_COMPRESS_SIZE) {
-    telemetry?.emit(sessionId, "upload.compression.skipped", { reason: "too_small", size: file.size });
-    return null;
-  }
-  const networkType = getNetworkEffectiveType();
-  const defaultProfile = { maxWidth: 3840, maxHeight: 3840, quality: 0.85, maxSizeMB: 5 };
-  const networkProfile = NETWORK_PROFILES[networkType] ?? defaultProfile;
-  const config = {
-    maxWidth: userConfig?.maxWidth ?? networkProfile.maxWidth,
-    maxHeight: userConfig?.maxHeight ?? networkProfile.maxHeight,
-    quality: userConfig?.quality ?? networkProfile.quality,
-    maxSizeMB: userConfig?.maxSizeMB ?? networkProfile.maxSizeMB
-  };
-  telemetry?.emit(sessionId, "upload.compression.started", {
-    original_size: file.size,
-    network: networkType,
-    target_quality: config.quality
-  });
-  try {
-    const imageCompression = await loadImageCompression();
-    if (!imageCompression) {
-      telemetry?.emit(sessionId, "upload.compression.skipped", { reason: "library_unavailable" });
-      return null;
-    }
-    const compressed = await imageCompression(file, {
-      maxSizeMB: config.maxSizeMB,
-      maxWidthOrHeight: Math.max(config.maxWidth, config.maxHeight),
-      initialQuality: config.quality,
-      useWebWorker: true,
-      fileType: type === "image/png" ? "image/webp" : void 0
-    });
-    if (compressed.size >= file.size * 0.95) {
-      telemetry?.emit(sessionId, "upload.compression.skipped", {
-        reason: "no_size_reduction",
-        original_size: file.size,
-        compressed_size: compressed.size
-      });
-      return null;
-    }
-    telemetry?.emit(sessionId, "upload.compression.completed", {
-      original_size: file.size,
-      compressed_size: compressed.size,
-      ratio: (compressed.size / file.size).toFixed(2)
-    });
-    return compressed;
-  } catch (err) {
-    telemetry?.emit(sessionId, "upload.compression.skipped", {
-      reason: "error",
-      error: err instanceof Error ? err.message : "Unknown compression error"
-    });
-    return null;
-  }
-}
-async function loadImageCompression() {
-  if (cachedImport === false) return null;
-  if (cachedImport) return cachedImport;
-  try {
-    const mod = await Function('return import("browser-image-compression")')();
-    cachedImport = mod.default || mod;
-    return cachedImport;
-  } catch {
-    cachedImport = false;
-    return null;
-  }
-}
-function getNetworkEffectiveType() {
-  if (typeof navigator !== "undefined" && "connection" in navigator) {
-    const conn = navigator.connection;
-    return conn?.effectiveType || "4g";
-  }
-  return "4g";
-}
-var MIN_COMPRESS_SIZE;
-var COMPRESSIBLE_TYPES;
-var SKIP_TYPES;
-var NETWORK_PROFILES;
-var cachedImport;
-var STORAGE_KEYS = {
-  SESSION: "scalemule_session",
-  USER_ID: "scalemule_user_id",
-  WORKSPACE_ID: "scalemule_workspace_id",
-  ANONYMOUS_ID: "scalemule_anonymous_id",
-  SESSION_POOL: "scalemule_session_pool",
-  ACTIVE_ACCOUNT: "scalemule_active_account",
-  KNOWN_ACCOUNTS: "scalemule_known_accounts",
-  OFFLINE_QUEUE: "scalemule_offline_queue"
-};
-var LEGACY_ANONYMOUS_ID_KEYS = ["sm_anonymous_id"];
-function generateAnonymousId() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
-}
-var inFlight = /* @__PURE__ */ new WeakMap();
-function ensureAnonymousId(storage) {
-  const existing = inFlight.get(storage);
-  if (existing) return existing;
-  const promise = (async () => {
-    try {
-      return await resolveAnonymousId(storage);
-    } finally {
-      inFlight.delete(storage);
-    }
-  })();
-  inFlight.set(storage, promise);
-  return promise;
-}
-async function resolveAnonymousId(storage) {
-  const canonical = await storage.getItem(STORAGE_KEYS.ANONYMOUS_ID);
-  if (canonical) {
-    for (const legacyKey of LEGACY_ANONYMOUS_ID_KEYS) {
-      const legacy = await storage.getItem(legacyKey);
-      if (legacy !== canonical) {
-        try {
-          await storage.setItem(legacyKey, canonical);
-        } catch {
-        }
-      }
-    }
-    return canonical;
-  }
-  for (const legacyKey of LEGACY_ANONYMOUS_ID_KEYS) {
-    const legacy = await storage.getItem(legacyKey);
-    if (legacy) {
-      try {
-        await storage.setItem(STORAGE_KEYS.ANONYMOUS_ID, legacy);
-      } catch {
-      }
-      return legacy;
-    }
-  }
-  const fresh = generateAnonymousId();
-  try {
-    await storage.setItem(STORAGE_KEYS.ANONYMOUS_ID, fresh);
-  } catch {
-  }
-  for (const legacyKey of LEGACY_ANONYMOUS_ID_KEYS) {
-    try {
-      await storage.setItem(legacyKey, fresh);
-    } catch {
-    }
-  }
-  return fresh;
-}
-var PHONE_COUNTRIES = [
-  { code: "US", name: "United States", dialCode: "+1" },
-  { code: "CA", name: "Canada", dialCode: "+1" },
-  { code: "GB", name: "United Kingdom", dialCode: "+44" },
-  { code: "AU", name: "Australia", dialCode: "+61" },
-  { code: "DE", name: "Germany", dialCode: "+49" },
-  { code: "FR", name: "France", dialCode: "+33" },
-  { code: "IT", name: "Italy", dialCode: "+39" },
-  { code: "ES", name: "Spain", dialCode: "+34" },
-  { code: "NL", name: "Netherlands", dialCode: "+31" },
-  { code: "BE", name: "Belgium", dialCode: "+32" },
-  { code: "CH", name: "Switzerland", dialCode: "+41" },
-  { code: "AT", name: "Austria", dialCode: "+43" },
-  { code: "SE", name: "Sweden", dialCode: "+46" },
-  { code: "NO", name: "Norway", dialCode: "+47" },
-  { code: "DK", name: "Denmark", dialCode: "+45" },
-  { code: "FI", name: "Finland", dialCode: "+358" },
-  { code: "IE", name: "Ireland", dialCode: "+353" },
-  { code: "PT", name: "Portugal", dialCode: "+351" },
-  { code: "PL", name: "Poland", dialCode: "+48" },
-  { code: "CZ", name: "Czech Republic", dialCode: "+420" },
-  { code: "GR", name: "Greece", dialCode: "+30" },
-  { code: "RU", name: "Russia", dialCode: "+7" },
-  { code: "JP", name: "Japan", dialCode: "+81" },
-  { code: "KR", name: "South Korea", dialCode: "+82" },
-  { code: "CN", name: "China", dialCode: "+86" },
-  { code: "HK", name: "Hong Kong", dialCode: "+852" },
-  { code: "TW", name: "Taiwan", dialCode: "+886" },
-  { code: "SG", name: "Singapore", dialCode: "+65" },
-  { code: "MY", name: "Malaysia", dialCode: "+60" },
-  { code: "TH", name: "Thailand", dialCode: "+66" },
-  { code: "VN", name: "Vietnam", dialCode: "+84" },
-  { code: "PH", name: "Philippines", dialCode: "+63" },
-  { code: "ID", name: "Indonesia", dialCode: "+62" },
-  { code: "IN", name: "India", dialCode: "+91" },
-  { code: "PK", name: "Pakistan", dialCode: "+92" },
-  { code: "BD", name: "Bangladesh", dialCode: "+880" },
-  { code: "AE", name: "UAE", dialCode: "+971" },
-  { code: "SA", name: "Saudi Arabia", dialCode: "+966" },
-  { code: "IL", name: "Israel", dialCode: "+972" },
-  { code: "TR", name: "Turkey", dialCode: "+90" },
-  { code: "EG", name: "Egypt", dialCode: "+20" },
-  { code: "ZA", name: "South Africa", dialCode: "+27" },
-  { code: "NG", name: "Nigeria", dialCode: "+234" },
-  { code: "KE", name: "Kenya", dialCode: "+254" },
-  { code: "BR", name: "Brazil", dialCode: "+55" },
-  { code: "MX", name: "Mexico", dialCode: "+52" },
-  { code: "AR", name: "Argentina", dialCode: "+54" },
-  { code: "CL", name: "Chile", dialCode: "+56" },
-  { code: "CO", name: "Colombia", dialCode: "+57" },
-  { code: "PE", name: "Peru", dialCode: "+51" },
-  { code: "NZ", name: "New Zealand", dialCode: "+64" }
-];
-[...PHONE_COUNTRIES].sort((a, b) => b.dialCode.length - a.dialCode.length);
-init_upload_resume();
+var sdk = require('@scalemule/sdk');
+
+// src/client.ts
 
 // src/types/index.ts
 var ScaleMuleApiError = class extends Error {
@@ -412,9 +20,9 @@ var GATEWAY_URLS = {
   dev: "https://api-dev.scalemule.com",
   prod: "https://api.scalemule.com"
 };
-var SESSION_STORAGE_KEY2 = STORAGE_KEYS.SESSION;
-var USER_ID_STORAGE_KEY2 = STORAGE_KEYS.USER_ID;
-var WORKSPACE_STORAGE_KEY2 = STORAGE_KEYS.WORKSPACE_ID;
+var SESSION_STORAGE_KEY = sdk.STORAGE_KEYS.SESSION;
+var USER_ID_STORAGE_KEY = sdk.STORAGE_KEYS.USER_ID;
+var WORKSPACE_STORAGE_KEY = sdk.STORAGE_KEYS.WORKSPACE_ID;
 var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -764,9 +372,9 @@ var ScaleMuleClient = class {
   setWorkspaceContext(id) {
     this.workspaceId = id;
     if (id) {
-      this.storage.setItem(WORKSPACE_STORAGE_KEY2, id);
+      this.storage.setItem(WORKSPACE_STORAGE_KEY, id);
     } else {
-      this.storage.removeItem(WORKSPACE_STORAGE_KEY2);
+      this.storage.removeItem(WORKSPACE_STORAGE_KEY);
     }
   }
   /**
@@ -813,11 +421,11 @@ var ScaleMuleClient = class {
    * Initialize client by loading persisted session
    */
   async initialize() {
-    const token = await this.storage.getItem(SESSION_STORAGE_KEY2);
-    const userId = await this.storage.getItem(USER_ID_STORAGE_KEY2);
+    const token = await this.storage.getItem(SESSION_STORAGE_KEY);
+    const userId = await this.storage.getItem(USER_ID_STORAGE_KEY);
     if (token) this.sessionToken = token;
     if (userId) this.userId = userId;
-    const wsId = await this.storage.getItem(WORKSPACE_STORAGE_KEY2);
+    const wsId = await this.storage.getItem(WORKSPACE_STORAGE_KEY);
     if (wsId) this.workspaceId = wsId;
     try {
       await this.ensureAnonymousId();
@@ -847,7 +455,7 @@ var ScaleMuleClient = class {
   async ensureAnonymousId() {
     if (this.anonymousId) return this.anonymousId;
     if (!this.anonymousIdPromise) {
-      this.anonymousIdPromise = ensureAnonymousId(this.storage).then((id) => {
+      this.anonymousIdPromise = sdk.ensureAnonymousId(this.storage).then((id) => {
         this.anonymousId = id;
         return id;
       }).finally(() => {
@@ -862,8 +470,8 @@ var ScaleMuleClient = class {
   async setSession(token, userId) {
     this.sessionToken = token;
     this.userId = userId;
-    await this.storage.setItem(SESSION_STORAGE_KEY2, token);
-    await this.storage.setItem(USER_ID_STORAGE_KEY2, userId);
+    await this.storage.setItem(SESSION_STORAGE_KEY, token);
+    await this.storage.setItem(USER_ID_STORAGE_KEY, userId);
     if (this.debug) {
       console.log("[ScaleMule] Session set for user:", userId);
     }
@@ -893,9 +501,9 @@ var ScaleMuleClient = class {
     this.sessionToken = null;
     this.userId = null;
     this.workspaceId = null;
-    await this.storage.removeItem(SESSION_STORAGE_KEY2);
-    await this.storage.removeItem(USER_ID_STORAGE_KEY2);
-    await this.storage.removeItem(WORKSPACE_STORAGE_KEY2);
+    await this.storage.removeItem(SESSION_STORAGE_KEY);
+    await this.storage.removeItem(USER_ID_STORAGE_KEY);
+    await this.storage.removeItem(WORKSPACE_STORAGE_KEY);
     if (this.debug) {
       console.log("[ScaleMule] Session cleared");
     }