@deflectbot/deflect-sdk 1.0.7 → 1.0.9

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,41 +1,132 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 class Deflect {
     constructor() {
-        if (typeof window.Deflect === "undefined") {
-            window.Deflect = {};
-        }
-        window.Deflect.siteKey = "";
+        this.scriptLoadPromise = null;
+        this.cacheTTL = 10 * 60 * 1000;
+        window.Deflect = window.Deflect || {};
+        window.Deflect.siteKey = window.Deflect.siteKey || "";
+        window.Deflect.sessionId = window.Deflect.sessionId || "";
+        window.Deflect.extraArgs = window.Deflect.extraArgs || {};
     }
-    configure(params) {
+    configure(params, forceRefresh = false) {
         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");
+            this.scriptLoadPromise = null;
+        }
+        if (!this.scriptLoadPromise) {
+            this.scriptLoadPromise = this.loadDeflectScript();
+        }
     }
-    solveChallenge() {
+    loadDeflectScript() {
+        const extraArgs = Object.keys(window.Deflect.extraArgs || {})
+            .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(window.Deflect.extraArgs[key])}`)
+            .join("&");
+        const scriptUrl = `https://js.deflect.bot/main.js?site=${encodeURIComponent(window.Deflect.siteKey)}${extraArgs ? `&${extraArgs}` : ""}`;
         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");
+            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));
+            worker.onmessage = (event) => {
+                if (event.data.error) {
+                    reject(new Error(event.data.error));
+                    worker.terminate();
+                    return;
                 }
-                window.Deflect.getToken()
-                    .then((token) => {
-                    resolve(token);
-                })
-                    .catch((err) => {
-                    reject(`Failed to get token: ${err.message}`);
-                });
+                const 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();
             };
-            script.onerror = () => {
-                reject("Failed to load the Deflect script");
+            worker.onerror = function (event) {
+                reject(new Error("Worker encountered an error: " + event.message));
+                worker.terminate();
             };
-            document.head.appendChild(script);
+            worker.postMessage({ url: scriptUrl });
+        });
+    }
+    injectScript(scriptText, resolve, reject) {
+        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);
+    }
+    solveChallenge() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!window.Deflect.siteKey) {
+                throw new Error("API key (siteKey) is missing in configuration");
+            }
+            try {
+                yield this.scriptLoadPromise;
+            }
+            catch (error) {
+                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.");
+            }
+            try {
+                return yield window.Deflect.getToken(window.Deflect.siteKey, window.Deflect.sessionId);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error("Error getting Deflect token: " + error.message);
+                }
+                throw new Error("Error getting Deflect token: " + String(error));
+            }
         });
     }
 }

package/dist/types/index.d.ts

@@ -1,10 +1,17 @@
 interface DeflectConfig {
-  siteKey: string;
+    siteKey: string;
+    extraArgs?: {
+        [key: string]: string;
+    };
 }
 declare class Deflect {
-  constructor();
-  configure(params: DeflectConfig): void;
-  solveChallenge(): Promise<string>;
+    private scriptLoadPromise;
+    private cacheTTL;
+    constructor();
+    configure(params: DeflectConfig, forceRefresh?: boolean): void;
+    private loadDeflectScript;
+    private injectScript;
+    solveChallenge(): Promise<string>;
 }
 declare const _default: Deflect;
 export default _default;

package/eslint.config.mjs

@@ -0,0 +1,12 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  {files: ["**/*.{js,mjs,cjs,ts}"]},
+  {languageOptions: { globals: globals.browser }},
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+];

package/package.json

@@ -1,18 +1,25 @@
-{
-  "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.9",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "author": "Fredrik Rafn",
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/js": "^9.22.0",
+    "eslint": "^9.22.0",
+    "globals": "^16.0.0",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.27.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@deflectbot/deflect-sdk": "file:"
+  }
+}

package/src/index.ts

@@ -1,55 +1,173 @@
 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;
-  }
 
-  async solveChallenge(): Promise<string> {
-    if (!window.Deflect.siteKey) {
-      throw new Error("API key (siteKey) is missing in configuration");
-    }
+    window.Deflect.siteKey = params.siteKey;
+    window.Deflect.extraArgs = params.extraArgs || {};
 
-    const scriptUrl = `https://js.deflect.bot/main.js?site=${window.Deflect.siteKey}`;
+    if (forceRefresh) {
+      console.log("Main.js force refreshed");
+      sessionStorage.removeItem("deflect_script");
+      localStorage.removeItem("deflect_script_timestamp");
 
-    const response = await fetch(scriptUrl);
-    if (!response.ok) {
-      throw new Error("Failed to fetch the Deflect script");
+      this.scriptLoadPromise = null;
     }
 
-    const sessionId = response.headers.get("session_id");
-    if (sessionId) {
-      window.Deflect.sessionId = sessionId;
+    if (!this.scriptLoadPromise) {
+      this.scriptLoadPromise = this.loadDeflectScript();
     }
+  }
+
+  private loadDeflectScript(): Promise<void> {
+    const extraArgs = Object.keys(window.Deflect.extraArgs || {})
+      .map(
+        (key) =>
+          `${encodeURIComponent(key)}=${encodeURIComponent(
+            window.Deflect.extraArgs[key]
+          )}`
+      )
+      .join("&");
+
+    const scriptUrl = `https://js.deflect.bot/main.js?site=${encodeURIComponent(
+      window.Deflect.siteKey
+    )}${extraArgs ? `&${extraArgs}` : ""}`;
+
+    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 scriptText = await response.text();
+      const blob = new Blob([workerCode], { type: "application/javascript" });
+      const worker = new Worker(URL.createObjectURL(blob));
 
+      worker.onmessage = (
+        event: MessageEvent<{
+          scriptText?: string;
+          sessionId?: string;
+          error?: string;
+        }>
+      ) => {
+        if (event.data.error) {
+          reject(new Error(event.data.error));
+          worker.terminate();
+          return;
+        }
+
+        const 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);
+  }
 
-    if (
-      typeof window.Deflect === "undefined" ||
-      typeof window.Deflect.getToken !== "function"
-    ) {
-      throw new Error("Deflect script did not load properly");
+  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."
+      );
     }
 
-    const token = await window.Deflect.getToken();
-    return token;
+    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));
+    }
   }
 }