@deflectbot/deflect-sdk 1.2.1 → 1.2.3

package/dist/index.js

@@ -9,188 +9,118 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 class Deflect {
     constructor() {
-        this.config = null;
-        this.scriptCache = null;
-        this.isWarmupInProgress = false;
-        this.initializeGlobalState();
-        this.setupAutomaticWarmup();
-    }
-    initializeGlobalState() {
-        if (typeof window === "undefined")
-            return;
+        this._prefetchedScriptText = null;
+        this._hasUsedPrefetch = false;
+        this._customScriptUrl = null;
         window.Deflect = window.Deflect || {};
         window.Deflect.extraArgs = window.Deflect.extraArgs || {};
-    }
-    setupAutomaticWarmup() {
-        if (typeof window === "undefined")
-            return;
-        if (document.readyState === "loading") {
-            document.addEventListener("DOMContentLoaded", () => this.tryWarmup());
-        }
-        else {
-            setTimeout(() => this.tryWarmup(), 100);
+        if (typeof window !== "undefined") {
+            window.addEventListener("load", () => {
+                setTimeout(() => {
+                    this._warmupScript();
+                }, 500);
+            });
         }
     }
-    tryWarmup() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (!((_a = this.config) === null || _a === void 0 ? void 0 : _a.actionId) || this.isWarmupInProgress || this.scriptCache) {
-                return;
-            }
-            this.isWarmupInProgress = true;
-            try {
-                this.scriptCache = yield this.fetchScript();
-            }
-            catch (_b) {
-            }
-            finally {
-                this.isWarmupInProgress = false;
-            }
-        });
-    }
-    buildScriptUrl(actionId) {
-        var _a, _b;
-        const baseUrl = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.scriptUrl) || "https://js.deflect.bot/main.js";
-        if ((_b = this.config) === null || _b === void 0 ? void 0 : _b.scriptUrl) {
-            return baseUrl;
-        }
+    _getScriptUrl() {
         const nonce = Date.now().toString();
-        return `${baseUrl}?action_id=${actionId}&_=${nonce}`;
-    }
-    fetchScript() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (!((_a = this.config) === null || _a === void 0 ? void 0 : _a.actionId)) {
-                throw new Error("actionId is required");
-            }
-            const url = this.buildScriptUrl(this.config.actionId);
-            const response = yield fetch(url, { cache: "no-store" });
-            if (!response.ok) {
-                throw new Error(`Failed to fetch script: ${response.status}`);
-            }
-            return {
-                content: yield response.text(),
-                sessionId: response.headers.get("session_id") || undefined,
-            };
-        });
-    }
-    executeScript(script) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (script.sessionId && typeof window !== "undefined") {
-                window.Deflect.sessionId = script.sessionId;
-            }
-            const readyPromise = this.createReadyPromise();
-            const blobUrl = this.createScriptBlob(script.content);
-            const scriptElement = yield this.loadScriptElement(blobUrl);
-            try {
-                yield readyPromise;
-                const token = yield this.getTokenFromScript();
-                return token;
-            }
-            finally {
-                this.cleanup(blobUrl, scriptElement);
-            }
-        });
-    }
-    createReadyPromise() {
-        return new Promise((resolve) => {
-            if (typeof window !== "undefined") {
-                window.Deflect.ready = {
-                    promise: new Promise((innerResolve) => {
-                        window.Deflect.ready.resolve = innerResolve;
-                    }),
-                    resolve: () => resolve(),
-                };
-            }
-        });
-    }
-    createScriptBlob(content) {
-        const blob = new Blob([content], { type: "text/javascript" });
-        return URL.createObjectURL(blob);
-    }
-    loadScriptElement(blobUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const script = document.createElement("script");
-                script.type = "module";
-                script.src = blobUrl;
-                script.onload = () => resolve(script);
-                script.onerror = () => reject(new Error("Script failed to load"));
-                document.head.appendChild(script);
-            });
-        });
+        if (this._customScriptUrl) {
+            const separator = this._customScriptUrl.includes("?") ? "&" : "?";
+            return `${this._customScriptUrl}${separator}action_id=${window.Deflect.actionId}&_=${nonce}`;
+        }
+        return `https://js.deflect.bot/main.js?action_id=${window.Deflect.actionId}&_=${nonce}`;
     }
-    getTokenFromScript() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (typeof window === "undefined" ||
-                typeof ((_a = window.Deflect) === null || _a === void 0 ? void 0 : _a.getToken) !== "function") {
-                throw new Error("Script did not load properly - getToken not available");
-            }
-            try {
-                return yield window.Deflect.getToken();
-            }
-            catch (error) {
-                throw new Error(`Script execution failed: ${error}`);
-            }
+    _warmupScript() {
+        if (!window.Deflect.actionId)
+            return;
+        const scriptUrl = this._getScriptUrl();
+        fetch(scriptUrl, { cache: "no-store" })
+            .then((res) => __awaiter(this, void 0, void 0, function* () {
+            if (!res.ok)
+                return;
+            this._prefetchedScriptText = yield res.text();
+        }))
+            .catch(() => { });
+    }
+    _refetchScript() {
+        this._hasUsedPrefetch = false;
+        this._prefetchedScriptText = null;
+        setTimeout(() => {
+            this._warmupScript();
+        }, 100);
+    }
+    setupReady() {
+        let resolveFn;
+        const promise = new Promise((resolve) => {
+            resolveFn = resolve;
         });
-    }
-    cleanup(blobUrl, scriptElement) {
-        var _a;
-        URL.revokeObjectURL(blobUrl);
-        scriptElement.remove();
-        if (typeof window !== "undefined" && ((_a = window.Deflect) === null || _a === void 0 ? void 0 : _a.getToken)) {
-            delete window.Deflect.getToken;
-        }
+        window.Deflect.ready = {
+            promise,
+            resolve: () => resolveFn(),
+        };
     }
     configure(params) {
-        var _a;
-        if (!((_a = params.actionId) === null || _a === void 0 ? void 0 : _a.trim())) {
-            throw new Error("actionId is required and cannot be empty");
+        if (!params.actionId) {
+            throw new Error("actionId is required in configuration");
         }
-        this.config = Object.assign({}, params);
-        if (typeof window !== "undefined") {
-            window.Deflect.actionId = params.actionId;
-            if (params.extraArgs) {
-                window.Deflect.extraArgs = Object.assign({}, params.extraArgs);
-            }
+        window.Deflect.actionId = params.actionId;
+        if (params.scriptUrl) {
+            this._customScriptUrl = params.scriptUrl;
         }
-        this.tryWarmup();
     }
     solveChallenge() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (!((_a = this.config) === null || _a === void 0 ? void 0 : _a.actionId)) {
-                throw new Error("Must call configure() before solveChallenge()");
+            if (!window.Deflect.actionId) {
+                throw new Error("actionId is missing in configuration");
             }
-            let script;
-            if (this.scriptCache && !this.isWarmupInProgress) {
-                script = this.scriptCache;
-                this.scriptCache = null;
+            this.setupReady();
+            let scriptText;
+            let sessionId = null;
+            if (this._prefetchedScriptText && !this._hasUsedPrefetch) {
+                scriptText = this._prefetchedScriptText;
+                this._hasUsedPrefetch = true;
             }
             else {
-                script = yield this.fetchScript();
-            }
-            return this.executeScript(script);
-        });
-    }
-    warmup() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (!((_a = this.config) === null || _a === void 0 ? void 0 : _a.actionId)) {
-                return false;
+                const scriptUrl = this._getScriptUrl();
+                const response = yield fetch(scriptUrl, { cache: "no-store" });
+                if (!response.ok) {
+                    throw new Error("Failed to fetch the Deflect script");
+                }
+                sessionId = response.headers.get("session_id");
+                scriptText = yield response.text();
+            }
+            if (sessionId) {
+                window.Deflect.sessionId = sessionId;
+            }
+            const blob = new Blob([scriptText], { type: "text/javascript" });
+            const blobUrl = URL.createObjectURL(blob);
+            const scriptEl = document.createElement("script");
+            scriptEl.type = "module";
+            scriptEl.src = blobUrl;
+            document.head.appendChild(scriptEl);
+            yield new Promise((resolve, reject) => {
+                scriptEl.onload = () => resolve();
+                scriptEl.onerror = () => reject("Failed to load the Deflect script");
+            });
+            yield ((_a = window.Deflect.ready) === null || _a === void 0 ? void 0 : _a.promise);
+            if (typeof window.Deflect === "undefined" ||
+                typeof window.Deflect.getToken !== "function") {
+                throw new Error("Deflect script did not load properly");
             }
+            let token;
             try {
-                yield this.tryWarmup();
-                return this.scriptCache !== null;
+                token = yield window.Deflect.getToken();
             }
-            catch (_b) {
-                return false;
+            catch (error) {
+                throw new Error(`Deflect script execution failed: ${error}`);
             }
+            this._refetchScript();
+            URL.revokeObjectURL(blobUrl);
+            scriptEl.remove();
+            delete window.Deflect.getToken;
+            return token;
         });
     }
-    clearCache() {
-        this.scriptCache = null;
-    }
 }
 export default new Deflect();

package/dist/types/index.d.ts

@@ -1,28 +1,21 @@
 interface DeflectConfig {
     actionId: string;
     scriptUrl?: string;
-    extraArgs?: Record<string, string>;
+    extraArgs?: {
+        [key: string]: string;
+    };
 }
 declare class Deflect {
-    private config;
-    private scriptCache;
-    private isWarmupInProgress;
+    private _prefetchedScriptText;
+    private _hasUsedPrefetch;
+    private _customScriptUrl;
     constructor();
-    private initializeGlobalState;
-    private setupAutomaticWarmup;
-    private tryWarmup;
-    private buildScriptUrl;
-    private fetchScript;
-    private executeScript;
-    private createReadyPromise;
-    private createScriptBlob;
-    private loadScriptElement;
-    private getTokenFromScript;
-    private cleanup;
+    private _getScriptUrl;
+    private _warmupScript;
+    private _refetchScript;
+    private setupReady;
     configure(params: DeflectConfig): void;
     solveChallenge(): Promise<string>;
-    warmup(): Promise<boolean>;
-    clearCache(): void;
 }
 declare const _default: Deflect;
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deflectbot/deflect-sdk",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "SDK for deflect.bot - Use it for seamless captcha integration on any website.",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",

package/src/index.ts

@@ -1,217 +1,147 @@
 interface DeflectConfig {
   actionId: string;
   scriptUrl?: string;
-  extraArgs?: Record<string, string>;
-}
-
-interface DeflectScript {
-  sessionId?: string;
-  content: string;
+  extraArgs?: { [key: string]: string };
 }
 
 class Deflect {
-  private config: DeflectConfig | null = null;
-  private scriptCache: DeflectScript | null = null;
-  private isWarmupInProgress = false;
+  private _prefetchedScriptText: string | null = null;
+  private _hasUsedPrefetch = false;
+  private _customScriptUrl: string | null = null;
 
   constructor() {
-    this.initializeGlobalState();
-    this.setupAutomaticWarmup();
-  }
-
-  private initializeGlobalState(): void {
-    if (typeof window === "undefined") return;
-
     window.Deflect = window.Deflect || {};
     window.Deflect.extraArgs = window.Deflect.extraArgs || {};
-  }
 
-  private setupAutomaticWarmup(): void {
-    if (typeof window === "undefined") return;
-
-    if (document.readyState === "loading") {
-      document.addEventListener("DOMContentLoaded", () => this.tryWarmup());
-    } else {
-      setTimeout(() => this.tryWarmup(), 100);
+    if (typeof window !== "undefined") {
+      window.addEventListener("load", () => {
+        setTimeout(() => {
+          this._warmupScript();
+        }, 500);
+      });
     }
   }
 
-  private async tryWarmup(): Promise<void> {
-    if (!this.config?.actionId || this.isWarmupInProgress || this.scriptCache) {
-      return;
+  private _getScriptUrl(): string {
+    const nonce = Date.now().toString();
+    if (this._customScriptUrl) {
+      const separator = this._customScriptUrl.includes("?") ? "&" : "?";
+      return `${this._customScriptUrl}${separator}action_id=${window.Deflect.actionId}&_=${nonce}`;
     }
+    return `https://js.deflect.bot/main.js?action_id=${window.Deflect.actionId}&_=${nonce}`;
+  }
 
-    this.isWarmupInProgress = true;
+  private _warmupScript(): void {
+    if (!window.Deflect.actionId) return;
 
-    try {
-      this.scriptCache = await this.fetchScript();
-    } catch {
-      /* empty */
-    } finally {
-      this.isWarmupInProgress = false;
-    }
+    const scriptUrl = this._getScriptUrl();
+    fetch(scriptUrl, { cache: "no-store" })
+      .then(async (res) => {
+        if (!res.ok) return;
+        this._prefetchedScriptText = await res.text();
+      })
+      .catch(() => {});
   }
 
-  private buildScriptUrl(actionId: string): string {
-    const baseUrl = this.config?.scriptUrl || "https://js.deflect.bot/main.js";
+  private _refetchScript(): void {
+    this._hasUsedPrefetch = false;
+    this._prefetchedScriptText = null;
 
-    if (this.config?.scriptUrl) {
-      return baseUrl;
-    }
+    setTimeout(() => {
+      this._warmupScript();
+    }, 100);
+  }
 
-    const nonce = Date.now().toString();
-    return `${baseUrl}?action_id=${actionId}&_=${nonce}`;
+  private setupReady(): void {
+    let resolveFn: () => void;
+    const promise = new Promise<void>((resolve) => {
+      resolveFn = resolve;
+    });
+    window.Deflect.ready = {
+      promise,
+      resolve: () => resolveFn(),
+    };
   }
 
-  private async fetchScript(): Promise<DeflectScript> {
-    if (!this.config?.actionId) {
-      throw new Error("actionId is required");
+  configure(params: DeflectConfig): void {
+    if (!params.actionId) {
+      throw new Error("actionId is required in configuration");
     }
+    window.Deflect.actionId = params.actionId;
 
-    const url = this.buildScriptUrl(this.config.actionId);
-    const response = await fetch(url, { cache: "no-store" });
-
-    if (!response.ok) {
-      throw new Error(`Failed to fetch script: ${response.status}`);
+    if (params.scriptUrl) {
+      this._customScriptUrl = params.scriptUrl;
     }
-
-    return {
-      content: await response.text(),
-      sessionId: response.headers.get("session_id") || undefined,
-    };
   }
 
-  private async executeScript(script: DeflectScript): Promise<string> {
-    if (script.sessionId && typeof window !== "undefined") {
-      window.Deflect.sessionId = script.sessionId;
+  async solveChallenge(): Promise<string> {
+    if (!window.Deflect.actionId) {
+      throw new Error("actionId is missing in configuration");
     }
 
-    const readyPromise = this.createReadyPromise();
-
-    const blobUrl = this.createScriptBlob(script.content);
-    const scriptElement = await this.loadScriptElement(blobUrl);
+    this.setupReady();
 
-    try {
-      await readyPromise;
+    let scriptText: string;
+    let sessionId: string | null = null;
 
-      const token = await this.getTokenFromScript();
+    if (this._prefetchedScriptText && !this._hasUsedPrefetch) {
+      scriptText = this._prefetchedScriptText;
+      this._hasUsedPrefetch = true;
+    } else {
+      const scriptUrl = this._getScriptUrl();
+      const response = await fetch(scriptUrl, { cache: "no-store" });
 
-      this.prefetchNextScript();
+      if (!response.ok) {
+        throw new Error("Failed to fetch the Deflect script");
+      }
 
-      return token;
-    } finally {
-      this.cleanup(blobUrl, scriptElement);
+      sessionId = response.headers.get("session_id");
+      scriptText = await response.text();
     }
-  }
 
-  private prefetchNextScript(): void {
-    this.tryWarmup().catch(() => {});
-  }
+    if (sessionId) {
+      window.Deflect.sessionId = sessionId;
+    }
 
-  private createReadyPromise(): Promise<void> {
-    return new Promise<void>((resolve) => {
-      if (typeof window !== "undefined") {
-        window.Deflect.ready = {
-          promise: new Promise<void>((innerResolve) => {
-            window.Deflect.ready.resolve = innerResolve;
-          }),
-          resolve: () => resolve(),
-        };
-      }
-    });
-  }
+    const blob = new Blob([scriptText], { type: "text/javascript" });
+    const blobUrl = URL.createObjectURL(blob);
 
-  private createScriptBlob(content: string): string {
-    const blob = new Blob([content], { type: "text/javascript" });
-    return URL.createObjectURL(blob);
-  }
+    const scriptEl = document.createElement("script");
+    scriptEl.type = "module";
+    scriptEl.src = blobUrl;
 
-  private async loadScriptElement(blobUrl: string): Promise<HTMLScriptElement> {
-    return new Promise((resolve, reject) => {
-      const script = document.createElement("script");
-      script.type = "module";
-      script.src = blobUrl;
+    document.head.appendChild(scriptEl);
 
-      script.onload = () => resolve(script);
-      script.onerror = () => reject(new Error("Script failed to load"));
-
-      document.head.appendChild(script);
+    await new Promise<void>((resolve, reject) => {
+      scriptEl.onload = () => resolve();
+      scriptEl.onerror = () => reject("Failed to load the Deflect script");
     });
-  }
 
-  private async getTokenFromScript(): Promise<string> {
+    await window.Deflect.ready?.promise;
+
     if (
-      typeof window === "undefined" ||
-      typeof window.Deflect?.getToken !== "function"
+      typeof window.Deflect === "undefined" ||
+      typeof window.Deflect.getToken !== "function"
     ) {
-      throw new Error("Script did not load properly - getToken not available");
+      throw new Error("Deflect script did not load properly");
     }
 
+    let token: string;
+
     try {
-      return await window.Deflect.getToken();
+      token = await window.Deflect.getToken();
     } catch (error) {
-      throw new Error(`Script execution failed: ${error}`);
-    }
-  }
-
-  private cleanup(blobUrl: string, scriptElement: HTMLScriptElement): void {
-    URL.revokeObjectURL(blobUrl);
-    scriptElement.remove();
-
-    if (typeof window !== "undefined" && window.Deflect?.getToken) {
-      delete window.Deflect.getToken;
-    }
-  }
-
-  public configure(params: DeflectConfig): void {
-    if (!params.actionId?.trim()) {
-      throw new Error("actionId is required and cannot be empty");
+      throw new Error(`Deflect script execution failed: ${error}`);
     }
 
-    this.config = { ...params };
-
-    if (typeof window !== "undefined") {
-      window.Deflect.actionId = params.actionId;
-      if (params.extraArgs) {
-        window.Deflect.extraArgs = { ...params.extraArgs };
-      }
-    }
+    this._refetchScript();
 
-    this.tryWarmup();
-  }
-
-  public async solveChallenge(): Promise<string> {
-    if (!this.config?.actionId) {
-      throw new Error("Must call configure() before solveChallenge()");
-    }
-
-    let script: DeflectScript;
-
-    if (this.scriptCache && !this.isWarmupInProgress) {
-      script = this.scriptCache;
-      this.scriptCache = null;
-    } else {
-      script = await this.fetchScript();
-    }
-
-    return this.executeScript(script);
-  }
-
-  public async warmup(): Promise<boolean> {
-    if (!this.config?.actionId) {
-      return false;
-    }
+    URL.revokeObjectURL(blobUrl);
+    scriptEl.remove();
 
-    try {
-      await this.tryWarmup();
-      return this.scriptCache !== null;
-    } catch {
-      return false;
-    }
-  }
+    delete window.Deflect.getToken;
 
-  public clearCache(): void {
-    this.scriptCache = null;
+    return token;
   }
 }