ggez-banking-sdk 0.2.10 → 0.2.12

package/dist/helper/storage/cookiesHelper.d.ts

@@ -5,9 +5,36 @@ declare class CookiesHelper {
     private domain;
     private programId;
     private Cookies;
+    private useCookieStore;
     private errorHandler;
     private clientHelper;
-    constructor(programId: string, errorHandler: (error: any) => void);
+    constructor(programId: string, domain: string, errorHandler: (error: any) => void);
+    /**
+     * Format domain to ensure proper cookie setting
+     * Adds leading dot if domain doesn't start with one and is not localhost
+     */
+    private formatDomain;
+    /**
+     * Check if CookieStore API is available
+     * CookieStore requires secure context (HTTPS or localhost)
+     */
+    private isCookieStoreAvailable;
+    /**
+     * Check if we're in a secure context (HTTPS or localhost)
+     */
+    private isSecureContext;
+    /**
+     * Fallback method to set cookie using document.cookie
+     */
+    private setCookieFallback;
+    /**
+     * Fallback method to get cookie using document.cookie
+     */
+    private getCookieFallback;
+    /**
+     * Fallback method to delete cookie using document.cookie
+     */
+    private deleteCookieFallback;
     GetIID(): Promise<string>;
     SetIID(): Promise<string>;
     ValidateIID(installationId: string): Promise<boolean>;

package/dist/helper/storage/cookiesHelper.js

@@ -7,18 +7,109 @@ class CookiesHelper {
     eventHandlers = new Map();
     domain = undefined;
     programId = "0";
-    Cookies = window.cookieStore;
+    Cookies = null;
+    useCookieStore = false;
     errorHandler;
     clientHelper;
     // #endregion
     // #region "Constructor"
-    constructor(programId, errorHandler) {
+    constructor(programId, domain, errorHandler) {
         this.key = v4();
         this.programId = programId;
         this.errorHandler = errorHandler;
-        this.Cookies = window.cookieStore;
         this.clientHelper = new ClientHelper();
-        this.domain = "vvtx.com";
+        // Format domain properly (add leading dot for subdomain sharing if not present)
+        this.domain = this.formatDomain(domain);
+        // Check if cookieStore API is available (requires HTTPS or localhost)
+        this.useCookieStore = this.isCookieStoreAvailable();
+        if (this.useCookieStore && window.cookieStore) {
+            this.Cookies = window.cookieStore;
+        }
+    }
+    /**
+     * Format domain to ensure proper cookie setting
+     * Adds leading dot if domain doesn't start with one and is not localhost
+     */
+    formatDomain(domain) {
+        if (!domain)
+            return undefined;
+        // Don't modify localhost or IP addresses
+        if (domain === "localhost" || /^\d+\.\d+\.\d+\.\d+/.test(domain)) {
+            return domain;
+        }
+        // If domain doesn't start with dot, add it for subdomain sharing
+        if (!domain.startsWith(".")) {
+            return `.${domain}`;
+        }
+        return domain;
+    }
+    /**
+     * Check if CookieStore API is available
+     * CookieStore requires secure context (HTTPS or localhost)
+     */
+    isCookieStoreAvailable() {
+        return (typeof window !== "undefined" &&
+            "cookieStore" in window &&
+            window.cookieStore !== null &&
+            window.cookieStore !== undefined);
+    }
+    /**
+     * Check if we're in a secure context (HTTPS or localhost)
+     */
+    isSecureContext() {
+        if (typeof window === "undefined")
+            return false;
+        return (window.location.protocol === "https:" ||
+            window.location.hostname === "localhost" ||
+            window.location.hostname === "127.0.0.1");
+    }
+    /**
+     * Fallback method to set cookie using document.cookie
+     */
+    setCookieFallback(name, value, expires, domain) {
+        let cookieString = `${name}=${encodeURIComponent(value)}`;
+        if (expires) {
+            const date = new Date(expires);
+            cookieString += `; expires=${date.toUTCString()}`;
+        }
+        cookieString += `; path=/`;
+        if (domain) {
+            cookieString += `; domain=${domain}`;
+        }
+        // Set secure flag only in HTTPS
+        if (this.isSecureContext()) {
+            cookieString += `; secure`;
+        }
+        cookieString += `; samesite=lax`;
+        document.cookie = cookieString;
+    }
+    /**
+     * Fallback method to get cookie using document.cookie
+     */
+    getCookieFallback(name) {
+        if (typeof document === "undefined")
+            return "";
+        const nameEQ = name + "=";
+        const ca = document.cookie.split(";");
+        for (let i = 0; i < ca.length; i++) {
+            let c = ca[i];
+            while (c.charAt(0) === " ")
+                c = c.substring(1, c.length);
+            if (c.indexOf(nameEQ) === 0) {
+                return decodeURIComponent(c.substring(nameEQ.length, c.length));
+            }
+        }
+        return "";
+    }
+    /**
+     * Fallback method to delete cookie using document.cookie
+     */
+    deleteCookieFallback(name, domain) {
+        let cookieString = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/`;
+        if (domain) {
+            cookieString += `; domain=${domain}`;
+        }
+        document.cookie = cookieString;
     }
     // #endregion
     // #region "IID"
@@ -271,27 +362,69 @@ class CookiesHelper {
     // #endregion
     // #region "Getters & Setters"
     async GET(key) {
-        const cookie = await this.Cookies.get({ name: key, url: this.domain });
-        return cookie?.value || "";
+        try {
+            if (this.useCookieStore && this.Cookies) {
+                const cookie = await this.Cookies.get({ name: key });
+                return cookie?.value || "";
+            }
+            else {
+                // Fallback to document.cookie
+                return this.getCookieFallback(key);
+            }
+        }
+        catch (error) {
+            // If cookieStore fails, fallback to document.cookie
+            this.errorHandler(error);
+            return this.getCookieFallback(key);
+        }
     }
     async SET(key, value, expires) {
-        const defaultExpireDate = Date.now() + 1000 * 60 * 60 * 24 * 365;
-        await this.Cookies.set({
-            name: key,
-            value: value,
-            domain: this.domain,
-            expires: expires || defaultExpireDate,
-            path: "/",
-            sameSite: "lax",
-            secure: true,
-        });
+        try {
+            const defaultExpireDate = Date.now() + 1000 * 60 * 60 * 24 * 365;
+            const expireTime = expires || defaultExpireDate;
+            const isSecure = this.isSecureContext();
+            if (this.useCookieStore && this.Cookies) {
+                await this.Cookies.set({
+                    name: key,
+                    value: value,
+                    domain: this.domain,
+                    expires: expireTime,
+                    path: "/",
+                    sameSite: "lax",
+                    secure: isSecure,
+                });
+            }
+            else {
+                // Fallback to document.cookie
+                this.setCookieFallback(key, value, expireTime, this.domain);
+            }
+        }
+        catch (error) {
+            // If cookieStore fails, fallback to document.cookie
+            this.errorHandler(error);
+            const defaultExpireDate = Date.now() + 1000 * 60 * 60 * 24 * 365;
+            this.setCookieFallback(key, value, expires || defaultExpireDate, this.domain);
+        }
     }
     async REMOVE(key) {
-        await this.Cookies.delete({
-            name: key,
-            domain: this.domain,
-            path: "/",
-        });
+        try {
+            if (this.useCookieStore && this.Cookies) {
+                await this.Cookies.delete({
+                    name: key,
+                    domain: this.domain,
+                    path: "/",
+                });
+            }
+            else {
+                // Fallback to document.cookie
+                this.deleteCookieFallback(key, this.domain);
+            }
+        }
+        catch (error) {
+            // If cookieStore fails, fallback to document.cookie
+            this.errorHandler(error);
+            this.deleteCookieFallback(key, this.domain);
+        }
     }
     // #endregion
     // #region "Cookie Change Event Listener"
@@ -361,15 +494,20 @@ class CookiesHelper {
         }
     }
     addOnChangeEventListener(params) {
-        const handler = (e) => this.cookieEventHandler(e, params);
-        this.eventHandlers.set(this.key, handler);
-        this.Cookies.addEventListener("change", handler);
+        if (this.useCookieStore && this.Cookies) {
+            const handler = (e) => this.cookieEventHandler(e, params);
+            this.eventHandlers.set(this.key, handler);
+            this.Cookies.addEventListener("change", handler);
+        }
+        // Note: document.cookie doesn't support change events, so this only works with cookieStore
     }
     removeOnChangeEventListener() {
-        const handler = this.eventHandlers.get(this.key);
-        if (handler) {
-            this.Cookies.removeEventListener("change", handler);
-            this.eventHandlers.delete(this.key);
+        if (this.useCookieStore && this.Cookies) {
+            const handler = this.eventHandlers.get(this.key);
+            if (handler) {
+                this.Cookies.removeEventListener("change", handler);
+                this.eventHandlers.delete(this.key);
+            }
         }
     }
     // #endregion

package/dist/helper/storage/storageHelper.d.ts

@@ -4,7 +4,7 @@ declare class StorageHelper {
     cookiesHelper: CookiesHelper;
     localStorageHelper: LocalStorageHelper;
     errorHandler: (error: any) => void;
-    constructor(programId: string, errorHandler: (error: any) => void);
+    constructor(programId: string, domain: string, errorHandler: (error: any) => void);
     GetCookiesHelper(): CookiesHelper;
     GetLocalStorageHelper(): LocalStorageHelper;
 }

package/dist/helper/storage/storageHelper.js

@@ -7,9 +7,9 @@ class StorageHelper {
     errorHandler;
     // #endregion
     // #region "Constructor"
-    constructor(programId, errorHandler) {
+    constructor(programId, domain, errorHandler) {
         this.errorHandler = errorHandler;
-        this.cookiesHelper = new CookiesHelper(programId, this.errorHandler);
+        this.cookiesHelper = new CookiesHelper(programId, domain, this.errorHandler);
         this.localStorageHelper = new LocalStorageHelper(this.cookiesHelper, this.errorHandler);
     }
     // #endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ggez-banking-sdk",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "A Node.js package to handle GGEZ Banking API endpoints, Simplify the process of managing CRUD operations with this efficient and easy-to-use package.",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",