@deflectbot/deflect-sdk 1.0.7 → 1.0.8

package/.gitattributes

@@ -1,2 +1,2 @@
-# Auto detect text files and perform LF normalization
-* text=auto
+# Auto detect text files and perform LF normalization
+* text=auto

package/README.md

@@ -5,8 +5,46 @@
 
 Deflect is an antibot solution that works with Vue, React, NextJS, and other JavaScript frameworks.
 
-## Installation
+---
+
+## CDN Install (Auto-Updates)
+
+```bash
+Include in your project:
+<script src="https://cdn.jsdelivr.net/npm/@deflectbot/deflect-sdk/dist/index.min.js"></script>
+```
+
+---
+
+## NPM Install (Requires Manual Updates)
 
 ```bash
 npm install deflect
 ```
+
+---
+
+## Setup
+
+```ts
+import Deflect from "@deflectbot/deflect-sdk";
+
+Deflect.configure({
+  siteKey: "YOUR_SITE_KEY",
+  extraArgs: { mode: "strict" }, // Optional
+  forceRefresh: true, // Optional
+});
+```
+
+---
+
+## Solve Challenge
+
+```ts
+try {
+  const token = await Deflect.solveChallenge();
+  console.log("✅ Token received:", token);
+} catch (error) {
+  console.error("❌ Failed to solve challenge:", error);
+}
+```

package/dist/index.js

@@ -1,42 +1,42 @@
-class Deflect {
-    constructor() {
-        if (typeof window.Deflect === "undefined") {
-            window.Deflect = {};
-        }
-        window.Deflect.siteKey = "";
-    }
-    configure(params) {
-        if (!params.siteKey) {
-            throw new Error("siteKey is required in configuration");
-        }
-        window.Deflect.siteKey = params.siteKey;
-    }
-    solveChallenge() {
-        return new Promise((resolve, reject) => {
-            if (!window.Deflect.siteKey) {
-                return reject("API key (siteKey) is missing in configuration");
-            }
-            const scriptUrl = `https://js.deflect.bot/main.js?site=${window.Deflect.siteKey}`;
-            const script = document.createElement("script");
-            script.src = scriptUrl;
-            script.onload = () => {
-                if (typeof window.Deflect === "undefined" ||
-                    typeof window.Deflect.getToken !== "function") {
-                    return reject("Deflect script did not load properly");
-                }
-                window.Deflect.getToken()
-                    .then((token) => {
-                    resolve(token);
-                })
-                    .catch((err) => {
-                    reject(`Failed to get token: ${err.message}`);
-                });
-            };
-            script.onerror = () => {
-                reject("Failed to load the Deflect script");
-            };
-            document.head.appendChild(script);
-        });
-    }
-}
-export default new Deflect();
+class Deflect {
+    constructor() {
+        if (typeof window.Deflect === "undefined") {
+            window.Deflect = {};
+        }
+        window.Deflect.siteKey = "";
+    }
+    configure(params) {
+        if (!params.siteKey) {
+            throw new Error("siteKey is required in configuration");
+        }
+        window.Deflect.siteKey = params.siteKey;
+    }
+    solveChallenge() {
+        return new Promise((resolve, reject) => {
+            if (!window.Deflect.siteKey) {
+                return reject("API key (siteKey) is missing in configuration");
+            }
+            const scriptUrl = `https://js.deflect.bot/main.js?site=${window.Deflect.siteKey}`;
+            const script = document.createElement("script");
+            script.src = scriptUrl;
+            script.onload = () => {
+                if (typeof window.Deflect === "undefined" ||
+                    typeof window.Deflect.getToken !== "function") {
+                    return reject("Deflect script did not load properly");
+                }
+                window.Deflect.getToken()
+                    .then((token) => {
+                    resolve(token);
+                })
+                    .catch((err) => {
+                    reject(`Failed to get token: ${err.message}`);
+                });
+            };
+            script.onerror = () => {
+                reject("Failed to load the Deflect script");
+            };
+            document.head.appendChild(script);
+        });
+    }
+}
+export default new Deflect();

package/dist/types/index.d.ts

@@ -1,10 +1,10 @@
-interface DeflectConfig {
-  siteKey: string;
-}
-declare class Deflect {
-  constructor();
-  configure(params: DeflectConfig): void;
-  solveChallenge(): Promise<string>;
-}
-declare const _default: Deflect;
-export default _default;
+interface DeflectConfig {
+  siteKey: string;
+}
+declare class Deflect {
+  constructor();
+  configure(params: DeflectConfig): void;
+  solveChallenge(): Promise<string>;
+}
+declare const _default: Deflect;
+export default _default;

package/package.json

@@ -1,18 +1,21 @@
-{
-  "name": "@deflectbot/deflect-sdk",
-  "version": "1.0.7",
-  "description": "",
-  "main": "dist/index.js",
-  "types": "dist/types/index.d.ts",
-  "scripts": {
-    "build": "tsc"
-  },
-  "author": "Fredrik Rafn",
-  "license": "MIT",
-  "devDependencies": {
-    "typescript": "^5.7.3"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@deflectbot/deflect-sdk",
+  "version": "1.0.8",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "author": "Fredrik Rafn",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.7.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@deflectbot/deflect-sdk": "file:"
+  }
+}

package/src/index.ts

@@ -1,55 +1,149 @@
 interface DeflectConfig {
   siteKey: string;
+  extraArgs?: { [key: string]: string };
 }
 
 class Deflect {
+  private scriptLoadPromise: Promise<void> | null = null;
+  private cacheTTL: number = 10 * 60 * 1000;
+
   constructor() {
-    if (typeof window.Deflect === "undefined") {
-      window.Deflect = {};
-    }
-    window.Deflect.siteKey = "";
-    window.Deflect.sessionId = "";
+    window.Deflect = window.Deflect || {};
+    window.Deflect.siteKey = window.Deflect.siteKey || "";
+    window.Deflect.sessionId = window.Deflect.sessionId || "";
+    window.Deflect.extraArgs = window.Deflect.extraArgs || {};
   }
 
-  configure(params: DeflectConfig): void {
+  configure(params: DeflectConfig, forceRefresh = false): void {
     if (!params.siteKey) {
       throw new Error("siteKey is required in configuration");
     }
+  
     window.Deflect.siteKey = params.siteKey;
-  }
+    window.Deflect.extraArgs = params.extraArgs || {};  
+  
+    if (forceRefresh) {
+      console.log("Main.js force refreshed");
+      sessionStorage.removeItem("deflect_script");
+      localStorage.removeItem("deflect_script_timestamp");
 
-  async solveChallenge(): Promise<string> {
-    if (!window.Deflect.siteKey) {
-      throw new Error("API key (siteKey) is missing in configuration");
+      this.scriptLoadPromise = null;
+    }
+  
+    if (!this.scriptLoadPromise) {
+      this.scriptLoadPromise = this.loadDeflectScript();
     }
+  }
 
-    const scriptUrl = `https://js.deflect.bot/main.js?site=${window.Deflect.siteKey}`;
+  private loadDeflectScript(): Promise<void> {
+    const extraArgs = Object.keys(window.Deflect.extraArgs || {})
+      .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(window.Deflect.extraArgs[key])}`)
+      .join("&");
 
-    const response = await fetch(scriptUrl);
-    if (!response.ok) {
-      throw new Error("Failed to fetch the Deflect script");
-    }
+    const scriptUrl = `https://js.deflect.bot/main.js?site=${encodeURIComponent(window.Deflect.siteKey)}${extraArgs ? `&${extraArgs}` : ""}`;
 
-    const sessionId = response.headers.get("session_id");
-    if (sessionId) {
-      window.Deflect.sessionId = sessionId;
-    }
+    return new Promise((resolve, reject) => {
+      const cachedScript = sessionStorage.getItem("deflect_script");
+      const lastFetchTime = localStorage.getItem("deflect_script_timestamp");
+
+      // Check if we have a valid cache (within 10 minutes)
+      if (cachedScript && lastFetchTime && Date.now() - parseInt(lastFetchTime) < this.cacheTTL) {
+        console.log("✅ Using cached Deflect script");
+        this.injectScript(cachedScript, resolve, reject);
+        return;
+      }
+
+      console.log("⏳ Fetching new Deflect script...");
+
+      const workerCode = `
+        self.onmessage = async function(event) {
+          try {
+            const response = await fetch(event.data.url, { cache: "no-store" });
+            if (!response.ok) {
+              const errorText = await response.text();
+              self.postMessage({ error: 'Failed to fetch script. Status: ' + response.status + ' - ' + errorText });
+              return;
+            }
+            const sessionId = response.headers.get("session_id") || "";
+            const scriptText = await response.text();
+            self.postMessage({ scriptText: scriptText, sessionId: sessionId });
+          } catch (err) {
+            self.postMessage({ error: 'Error in worker: ' + (err instanceof Error ? err.message : String(err)) });
+          }
+        };
+      `;
+
+      const blob = new Blob([workerCode], { type: "application/javascript" });
+      const worker = new Worker(URL.createObjectURL(blob));
 
-    const scriptText = await response.text();
+      worker.onmessage = (event: MessageEvent<{ scriptText?: string; sessionId?: string; error?: string }>) => {
+        if (event.data.error) {
+          reject(new Error(event.data.error));
+          worker.terminate();
+          return;
+        }
+      
+        var scriptText = event.data.scriptText || "";
+        window.Deflect.sessionId = event.data.sessionId || "";
+      
+        // Cache script info
+        sessionStorage.setItem("deflect_script", scriptText);
+        localStorage.setItem("deflect_script_timestamp", Date.now().toString());
+      
+        this.injectScript(scriptText, resolve, reject);
+        worker.terminate();
+      };      
 
+      worker.onerror = function (event: ErrorEvent) {
+        reject(new Error("Worker encountered an error: " + event.message));
+        worker.terminate();
+      };
+
+      worker.postMessage({ url: scriptUrl });
+    });
+  }
+
+  private injectScript(scriptText: string, resolve: () => void, reject: (error: Error) => void) {
     const scriptEl = document.createElement("script");
     scriptEl.textContent = scriptText;
+    scriptEl.onload = () => {
+      console.log("✅ Deflect script loaded successfully.");
+      resolve();
+    };
+    scriptEl.onerror = () => {
+      reject(new Error("Failed to load Deflect script"));
+    };
     document.head.appendChild(scriptEl);
+  }
+
+  async solveChallenge(): Promise<string> {
+    if (!window.Deflect.siteKey) {
+      throw new Error("API key (siteKey) is missing in configuration");
+    }
+
+    try {
+      await this.scriptLoadPromise;
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        throw new Error("Deflect script failed to load: " + error.message);
+      }
+      throw new Error("Deflect script failed to load: " + String(error));
+    }
+    
+
+    if (typeof window.Deflect.getToken !== "function") {
+      throw new Error("Deflect script did not load properly or is not exposing getToken.");
+    }
 
-    if (
-      typeof window.Deflect === "undefined" ||
-      typeof window.Deflect.getToken !== "function"
-    ) {
-      throw new Error("Deflect script did not load properly");
+    try {
+      return await window.Deflect.getToken(window.Deflect.siteKey, window.Deflect.sessionId);
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        throw new Error("Error getting Deflect token: " + error.message);
+      }
+      throw new Error("Error getting Deflect token: " + String(error));
     }
 
-    const token = await window.Deflect.getToken();
-    return token;
   }
 }