@deflectbot/deflect-sdk 1.0.8 → 1.0.10

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/dist/index.js

@@ -1,42 +1,133 @@
-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();
+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() {
+        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, 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();
+        }
+    }
+    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) => {
+            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;
+                }
+                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) {
+                reject(new Error("Worker encountered an error: " + event.message));
+                worker.terminate();
+            };
+            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));
+            }
+        });
+    }
+}
+export default new Deflect();

package/dist/types/index.d.ts

@@ -1,10 +1,17 @@
-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;
+    extraArgs?: {
+        [key: string]: string;
+    };
+}
+declare class Deflect {
+    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,6 +1,6 @@
 {
   "name": "@deflectbot/deflect-sdk",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",
@@ -10,7 +10,11 @@
   "author": "Fredrik Rafn",
   "license": "MIT",
   "devDependencies": {
-    "typescript": "^5.7.3"
+    "@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"

package/src/index.ts

@@ -1,6 +1,7 @@
 interface DeflectConfig {
   siteKey: string;
   extraArgs?: { [key: string]: string };
+  forceRefresh?: boolean;
 }
 
 class Deflect {
@@ -14,22 +15,22 @@ class Deflect {
     window.Deflect.extraArgs = window.Deflect.extraArgs || {};
   }
 
-  configure(params: DeflectConfig, forceRefresh = false): void {
+  configure(params: DeflectConfig): void {
     if (!params.siteKey) {
       throw new Error("siteKey is required in configuration");
     }
-  
+
     window.Deflect.siteKey = params.siteKey;
-    window.Deflect.extraArgs = params.extraArgs || {};  
-  
-    if (forceRefresh) {
+    window.Deflect.extraArgs = params.extraArgs || {};
+
+    if (params.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();
     }
@@ -37,17 +38,28 @@ class Deflect {
 
   private loadDeflectScript(): Promise<void> {
     const extraArgs = Object.keys(window.Deflect.extraArgs || {})
-      .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(window.Deflect.extraArgs[key])}`)
+      .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}` : ""}`;
+    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) {
+      if (
+        cachedScript &&
+        lastFetchTime &&
+        Date.now() - parseInt(lastFetchTime) < this.cacheTTL
+      ) {
         console.log("✅ Using cached Deflect script");
         this.injectScript(cachedScript, resolve, reject);
         return;
@@ -76,23 +88,29 @@ class Deflect {
       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 }>) => {
+      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 || "";
+
+        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));
@@ -103,7 +121,11 @@ class Deflect {
     });
   }
 
-  private injectScript(scriptText: string, resolve: () => void, reject: (error: Error) => void) {
+  private injectScript(
+    scriptText: string,
+    resolve: () => void,
+    reject: (error: Error) => void
+  ) {
     const scriptEl = document.createElement("script");
     scriptEl.textContent = scriptText;
     scriptEl.onload = () => {
@@ -129,21 +151,24 @@ class Deflect {
       }
       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.");
+      throw new Error(
+        "Deflect script did not load properly or is not exposing getToken."
+      );
     }
 
     try {
-      return await window.Deflect.getToken(window.Deflect.siteKey, window.Deflect.sessionId);
+      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));
     }
-
   }
 }