inviton-powerduck 0.0.165 → 0.0.166

package/common/history-extended.ts

@@ -1,3 +1,5 @@
+import { globalState } from '../app/global-state';
+
 export interface HistoryChangedData {
 	from: any;
 	to: any;
@@ -23,8 +25,8 @@ interface HistoryOnSteroids extends History {
 	removeHistoryChangedListener: (listener: HistoryChangedListener) => void;
 }
 
-const history: HistoryOnSteroids = window.history as any;
-if (!history.__historyExtendedInitialized) {
+const history: HistoryOnSteroids = globalState.history as any;
+if (history != null && !history.__historyExtendedInitialized) {
 	history.__historyExtendedInitialized = true;
 
 	(function () {
@@ -44,9 +46,9 @@ if (!history.__historyExtendedInitialized) {
 		let silentMode = false; // Flag to suppress events
 
 		// Function to log state into history
-		function logState(state, index) {
+		const logState = (state: any, index: number) => {
 			stateHistory[index] = { ...state, __heindex: index };
-		}
+		};
 
 		// Override pushState
 		history.pushState = function (
@@ -102,7 +104,7 @@ if (!history.__historyExtendedInitialized) {
 		};
 
 		// Popstate listener to detect navigation direction
-		window.addEventListener('popstate', (event) => {
+		globalState.addEventListener('popstate', (event) => {
 			const previousIndex = currentIndex;
 			previousState = stateHistory[previousIndex] || null;
 
@@ -162,7 +164,7 @@ if (!history.__historyExtendedInitialized) {
 		});
 
 		// Preserve current state on load and add index
-		window.addEventListener('load', () => {
+		globalState.addEventListener('load', () => {
 			const initialState = history.state || {};
 			if (!initialState.__heindex) {
 				history.replaceState({ ...initialState, __heindex: currentIndex }, '');
@@ -212,18 +214,34 @@ if (!history.__historyExtendedInitialized) {
 
 export default class HistoryExtended {
 	static addPopstateListener(handler: HistoryChangedListener) {
+		if (!history) {
+			return;
+		}
+
 		history.addHistoryChangedListener(handler);
 	}
 
 	static removePopstateListener(handler: HistoryChangedListener) {
+		if (!history) {
+			return;
+		}
+
 		history.removeHistoryChangedListener(handler);
 	}
 
 	static nextBackWillNavigateAway(): boolean {
+		if (!history) {
+			return;
+		}
+
 		return history.nextBackWillNavigateAway();
 	}
 
 	static back(args?: { silent?: boolean }): void {
+		if (!history) {
+			return;
+		}
+
 		if (args?.silent == true) {
 			history.silentBack();
 		} else {
@@ -232,10 +250,18 @@ export default class HistoryExtended {
 	}
 
 	static forward(): void {
+		if (!history) {
+			return;
+		}
+
 		history.forward();
 	}
 
 	static go(delta?: number): void {
+		if (!history) {
+			return;
+		}
+
 		history.go(delta);
 	}
 
@@ -244,6 +270,10 @@ export default class HistoryExtended {
 		unused: string,
 		url?: string | URL | null,
 	): void {
+		if (!history) {
+			return;
+		}
+
 		history.pushState(
 			data,
 			unused,
@@ -256,6 +286,10 @@ export default class HistoryExtended {
 		unused: string,
 		url?: string | URL | null,
 	): void {
+		if (!history) {
+			return;
+		}
+
 		history.replaceState(
 			data,
 			unused,
@@ -264,6 +298,10 @@ export default class HistoryExtended {
 	}
 
 	static clearForward() {
+		if (!history) {
+			return;
+		}
+
 		history.clearForward();
 	}
 }

package/common/history-handler.ts

@@ -1,21 +1,29 @@
+import { globalState } from '../app/global-state';
 import { ModalUtils } from './../components/modal/modal-utils';
 import HistoryExtended from './history-extended';
 
 export const initHistory = () => {
+	if (globalState.windowExists) {
+		return;
+	}
+
 	const randomString = (length: number): string => {
 		let result = '';
 		const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-		for (let i = length; i > 0; --i) { result += chars[Math.floor(Math.random() * chars.length)]; }
+		for (let i = length; i > 0; --i) {
+			result += chars[Math.floor(Math.random() * chars.length)];
+		}
+
 		return result;
 	};
 
 	const initializer = {
 		intializeModalListener() {
-			if ((window as any).__historyPowerduckInitialized == true) {
+			if (globalState.__historyPowerduckInitialized == true) {
 				return;
 			}
 
-			(window as any).__historyPowerduckInitialized = true;
+			globalState.__historyPowerduckInitialized = true;
 			$(document).on(
 				'show.bs.modal',
 				'.modal',
@@ -35,11 +43,7 @@ export const initHistory = () => {
 				},
 			);
 
-			$(document).on('fdd-show', function (
-				this: any,
-				e: any,
-				elem: HTMLElement,
-			) {
+			$(document).on('fdd-show', (e: any, elem: HTMLElement) => {
 				if (elem.getAttribute('data-preventhistory') == 'true') {
 					return;
 				}
@@ -78,11 +82,7 @@ export const initHistory = () => {
 				},
 			);
 
-			$(document).on('fdd-hide', function (
-				this: any,
-				e: any,
-				elem: HTMLElement,
-			) {
+			$(document).on('fdd-hide', (e: any, elem: HTMLElement) => {
 				if (elem.getAttribute('data-preventhistory') == 'true') {
 					return;
 				}
@@ -131,11 +131,11 @@ export const initHistory = () => {
 			});
 		},
 		initBackdropFix() {
-			if ((window as any).__backdropFixInitialized == true) {
+			if (globalState.__backdropFixInitialized == true) {
 				return;
 			}
 
-			(window as any).__backdropFixInitialized = true;
+			globalState.__backdropFixInitialized = true;
 			$(document).on(
 				'show.bs.modal',
 				'.modal',

package/common/keyboard-open-tracker.ts

@@ -1,23 +1,37 @@
+import { globalState } from '../app/global-state';
+
 export default class KeyboardOpenTracker {
 	static bind() {
-		if ((window as any)._keyboardOpenTrackerBound == true) {
+		if (globalState._keyboardOpenTrackerBound == true) {
 			return;
 		}
 
-		(window as any)._keyboardOpenTrackerBound = true;
+		globalState._keyboardOpenTrackerBound = true;
 
 		const getOrientation = () => {
-			return window.matchMedia('(orientation: portrait)').matches ? 'portrait' : 'landscape';
+			if (!globalState.matchMedia) {
+				return 'portrait';
+			}
+
+			return globalState.matchMedia('(orientation: portrait)').matches ? 'portrait' : 'landscape';
 		};
 
 		const getScreenHeight = () => {
-			return window.screen.height; // Constant physical screen height
+			if (!globalState.screen) {
+				return 0;
+			}
+
+			return globalState.screen.height; // Constant physical screen height
 		};
 
 		let lastOrientation = getOrientation();
 		const handleResize = () => {
+			if (!globalState.windowExists) {
+				return;
+			}
+
 			const currentOrientation = getOrientation();
-			const currentInnerHeight = window.visualViewport?.height ?? window.innerHeight;
+			const currentInnerHeight = globalState.visualViewport?.height ?? globalState.innerHeight;
 			const screenHeight = getScreenHeight();
 
 			// Different thresholds for portrait/landscape
@@ -38,7 +52,7 @@ export default class KeyboardOpenTracker {
 			document.body.classList.toggle('powerduck-keyboard-open', isKeyboardOpen);
 		};
 
-		window.addEventListener('resize', handleResize);
+		globalState.addEventListener('resize', handleResize);
 		handleResize(); // Run initially
 	}
 }

package/common/ladda-lite.ts

@@ -1,3 +1,4 @@
+import { globalState } from '../app/global-state';
 import './css/ladda-themeless-zoomin.min.css';
 
 /*! Ladda http://lab.hakim.se/ladda MIT licensed Copyright (C) 2016 Hakim El Hattab, http://hakim.se ....Lightweight adaptation for Inviton API needs */
@@ -316,7 +317,7 @@ namespace laddaLiteUtils {
 	function createSpinner(button: any) {
 		let height = button.offsetHeight;
 		if (height === 0) {
-			height = parseFloat(<any>window.getComputedStyle(button).height);
+			height = parseFloat(globalState.getComputedStyle(button).height);
 		}
 
 		if (height > 32) {
@@ -354,6 +355,10 @@ namespace laddaLiteUtils {
 	}
 
 	export function createLaddaInstance(button: any) {
+        if (!globalState.windowExists) {
+            return;
+        }
+
 		const laddaLabel = document.createElement('span');
 		laddaLabel.setAttribute('class', 'ladda-label');
 
@@ -389,6 +394,10 @@ export class LaddaLite {
 			return;
 		}
 
+        if (!globalState.windowExists) {
+            return;
+        }
+
 		let laddaInstance;
 		const button = laddaLiteUtils.getTarget(target);
 		const instanceId = laddaLiteUtils.getInstanceId(button);
@@ -410,6 +419,10 @@ export class LaddaLite {
 			return;
 		}
 
+        if (!globalState.windowExists) {
+            return;
+        }
+
 		const button = laddaLiteUtils.getTarget(target);
 		const instanceId = laddaLiteUtils.getInstanceId(button);
 		const laddaInstance = laddaLiteUtils.instanceCache[instanceId];

package/common/local-storage-shim.ts

@@ -1,52 +1,90 @@
-const storage = window.localStorage;
-delete (window as any).localStorage;
-(window as any).localStorage = {};
+import { globalState } from '../app/global-state';
 
-export class LocalStorageImpl {
+// Shim for SSR
+class LocalStorageInMemory {
+	private _storage: any = {};
 	get length(): number {
-		return storage.length;
+		return this._storage.length;
 	}
 
 	clear(): void {
-		storage.clear();
+		this._storage = {};
 	}
 
 	getItem(key: string): string | null {
-		return storage.getItem(`public.${key}`);
+		return this._storage[key];
 	}
 
 	key(index: number): string | null {
-		return storage.key(index);
+		return Object.keys(this._storage)[index];
 	}
 
 	removeItem(key: string): void {
-		storage.removeItem(`public.${key}`);
+		this._storage[key] = null;
 	}
 
 	setItem(key: string, value: string): void {
-		storage.setItem(`public.${key}`, value);
+		this._storage[key] = value;
 	}
 }
 
-let newStorage = new LocalStorageImpl();
-if (window.Proxy && window.Reflect) {
-	newStorage = new window.Proxy(newStorage, {
-		get(target, prop: any) {
-			if ((storage as any)[prop] != null) {
-				return window.Reflect.get(target, prop);
-			} else {
-				return storage.getItem(`public.${prop}`);
+const storage = globalState.localStorage ?? new LocalStorageInMemory();
+if (!(storage as unknown as any).isPatched && globalState.localStorage != null) {
+	try {
+		delete (globalState as any).localStorage;
+		(globalState as any).localStorage = {};
+
+		class LocalStorageImpl {
+			isPatched = true;
+
+			get length(): number {
+				return storage.length;
 			}
-		},
-		set(
-			target,
-			prop,
-			value,
-		) {
-			storage.setItem(`public.${prop as any}`, value);
-			return true;
-		},
-	});
+
+			clear(): void {
+				storage.clear();
+			}
+
+			getItem(key: string): string | null {
+				return storage.getItem(`public.${key.replace('public.', '')}`);
+			}
+
+			key(index: number): string | null {
+				return storage.key(index);
+			}
+
+			removeItem(key: string): void {
+				storage.removeItem(`public.${key}`);
+			}
+
+			setItem(key: string, value: string): void {
+				storage.setItem(`public.${key}`, value);
+			}
+		}
+
+		let newStorage = new LocalStorageImpl();
+		if (globalState.Proxy && globalState.Reflect) {
+			newStorage = new globalState.Proxy(newStorage, {
+				get(target, prop: any) {
+					if ((storage as any)[prop] != null) {
+						return globalState.Reflect.get(target, prop);
+					} else {
+						return storage.getItem(`public.${prop}`);
+					}
+				},
+				set(
+					target,
+					prop,
+					value,
+				) {
+					storage.setItem(`public.${prop as any}`, value);
+					return true;
+				},
+			});
+		}
+
+		(globalState as any).localStorage = newStorage;
+	} catch (error) { }
 }
 
 /**
@@ -132,5 +170,3 @@ export default class StorageProvider {
 		StorageProvider.setString(key, storeVal);
 	}
 }
-
-(window as any).localStorage = newStorage;

package/common/resource-helper.ts

@@ -1,83 +1,89 @@
+import { globalState } from "../app/global-state";
+
 export default class ResourceHelper {
-	static loadResourcesDynamically(files: { src: string; type: 'js' | 'css'; mode?: 'normal' | 'module' }[]): Promise<boolean> {
-		return new Promise((resolve) => {
-			const loadScript = (
-				src: string,
-				mode?: 'normal' | 'module',
-				retries = 3,
-			) => {
-				return new Promise((resolve, reject) => {
-					const attemptLoad = (attempt) => {
-						const script = document.createElement('script');
-						script.src = src;
-						script.async = true;
+    static loadResourcesDynamically(files: { src: string; type: 'js' | 'css'; mode?: 'normal' | 'module' }[]): Promise<boolean> {
+        return new Promise((resolve) => {
+            const loadScript = (
+                src: string,
+                mode?: 'normal' | 'module',
+                retries = 3,
+            ) => {
+                return new Promise((resolve, reject) => {
+                    if (!globalState.windowExists) {
+                        resolve('Not supported for SSR');
+                    }
+
+                    const attemptLoad = (attempt) => {
+                        const script = document.createElement('script');
+                        script.src = src;
+                        script.async = true;
 
-						if (mode == 'module') {
-							script.type = 'module';
-						}
+                        if (mode == 'module') {
+                            script.type = 'module';
+                        }
 
-						script.onload = () => resolve(`Loaded: ${src}`);
-						script.onerror = () => {
-							if (attempt < retries) {
-								const delay = Math.floor(Math.random() * (1200 - 500 + 1)) + 500;
-								console.warn(`Retrying ${src} in ${delay}ms... (${attempt + 1}/${retries})`);
-								setTimeout(() => attemptLoad(attempt + 1), delay);
-							} else {
-								reject(new Error(`Failed to load: ${src}`));
-							}
-						};
+                        script.onload = () => resolve(`Loaded: ${src}`);
+                        script.onerror = () => {
+                            if (attempt < retries) {
+                                const delay = Math.floor(Math.random() * (1200 - 500 + 1)) + 500;
+                                console.warn(`Retrying ${src} in ${delay}ms... (${attempt + 1}/${retries})`);
+                                setTimeout(() => attemptLoad(attempt + 1), delay);
+                            } else {
+                                reject(new Error(`Failed to load: ${src}`));
+                            }
+                        };
 
-						document.head.appendChild(script);
-					};
+                        document.head.appendChild(script);
+                    };
 
-					attemptLoad(0);
-				});
-			};
+                    attemptLoad(0);
+                });
+            };
 
-			const loadCSS = (href: string, retries = 3) => {
-				return new Promise((resolve, reject) => {
-					const attemptLoad = (attempt) => {
-						const link = document.createElement('link');
-						link.rel = 'stylesheet';
-						link.href = href;
+            const loadCSS = (href: string, retries = 3) => {
+                return new Promise((resolve, reject) => {
+                    const attemptLoad = (attempt) => {
+                        const link = document.createElement('link');
+                        link.rel = 'stylesheet';
+                        link.href = href;
 
-						link.onload = () => resolve(`Loaded: ${href}`);
-						link.onerror = () => {
-							if (attempt < retries) {
-								const delay = Math.floor(Math.random() * (1200 - 500 + 1)) + 500;
-								console.warn(`Retrying ${href} in ${delay}ms... (${attempt + 1}/${retries})`);
-								setTimeout(() => attemptLoad(attempt + 1), delay);
-							} else {
-								reject(new Error(`Failed to load: ${href}`));
-							}
-						};
+                        link.onload = () => resolve(`Loaded: ${href}`);
+                        link.onerror = () => {
+                            if (attempt < retries) {
+                                const delay = Math.floor(Math.random() * (1200 - 500 + 1)) + 500;
+                                console.warn(`Retrying ${href} in ${delay}ms... (${attempt + 1}/${retries})`);
+                                setTimeout(() => attemptLoad(attempt + 1), delay);
+                            } else {
+                                reject(new Error(`Failed to load: ${href}`));
+                            }
+                        };
 
-						document.head.appendChild(link);
-					};
+                        document.head.appendChild(link);
+                    };
 
-					attemptLoad(0);
-				});
-			};
+                    attemptLoad(0);
+                });
+            };
 
-			Promise.all(files.map((file) => {
-				if (file.type == 'js') {
-					return loadScript(file.src, file.mode).then(result => ({ status: 'fulfilled', value: result }), error => ({ status: 'rejected', reason: error }));
-				} else if (file.type == 'css') {
-					return loadCSS(file.src).then(result => ({ status: 'fulfilled', value: result }), error => ({ status: 'rejected', reason: error }));
-				} else {
-					return Promise.resolve({ status: 'rejected', reason: new Error(`Unsupported file type: ${file}`) });
-				}
-			})).then((results) => {
-				let allOk = true;
-				results.forEach((result) => {
-					if (result.status != 'fulfilled') {
-						console.error((result as any).reason);
-						allOk = false;
-					}
-				});
+            Promise.all(files.map((file) => {
+                if (file.type == 'js') {
+                    return loadScript(file.src, file.mode).then(result => ({ status: 'fulfilled', value: result }), error => ({ status: 'rejected', reason: error }));
+                } else if (file.type == 'css') {
+                    return loadCSS(file.src).then(result => ({ status: 'fulfilled', value: result }), error => ({ status: 'rejected', reason: error }));
+                } else {
+                    return Promise.resolve({ status: 'rejected', reason: new Error(`Unsupported file type: ${file}`) });
+                }
+            })).then((results) => {
+                let allOk = true;
+                results.forEach((result) => {
+                    if (result.status != 'fulfilled') {
+                        console.error((result as any).reason);
+                        allOk = false;
+                    }
+                });
 
-				resolve(allOk);
-			});
-		});
-	}
+                resolve(allOk);
+            });
+        });
+    }
 }

package/common/scroll-utils.ts

@@ -1,4 +1,5 @@
 import type { Vue } from 'vue-facing-decorator';
+import { globalState } from '../app/global-state';
 import PowerduckState from '../app/powerduck-state';
 import TemporalUtils from './utils/temporal-utils';
 
@@ -36,7 +37,7 @@ export default class ScrollUtils {
 		animated?: boolean,
 		instant?: boolean,
 	): void {
-		if (elem == null) {
+		if (elem == null || !globalState.scrollTo) {
 			return;
 		}
 
@@ -46,7 +47,7 @@ export default class ScrollUtils {
 			otherHeaderHeight = $('header').height();
 		}
 
-		if (($(window).width() as number < 768 && mobileOffset != false) || otherHeaderHeight > 0) {
+		if (($(globalState).width() as number < 768 && mobileOffset != false) || otherHeaderHeight > 0) {
 			if ((mobileOffset as number) > 1) {
 				offset = mobileOffset as number;
 			} else {
@@ -87,15 +88,19 @@ export default class ScrollUtils {
 		animated?: boolean,
 		instant?: boolean,
 	): void {
+		if (!globalState.scrollTo) {
+			return;
+		}
+
 		if (instant != true) {
 			setTimeout(() => {
-				(context?.length > 0 ? context[0] : window).scrollTo({
+				(context?.length > 0 ? context[0] : globalState).scrollTo({
 					top: position,
 					behavior: (animated != false ? 'smooth' : 'instant') as any,
 				});
 			});
 		} else {
-			(context?.length > 0 ? context[0] : window).scrollTo({
+			(context?.length > 0 ? context[0] : globalState).scrollTo({
 				top: position,
 				behavior: (animated != false ? 'smooth' : 'instant') as any,
 			});

package/common/set-current-url.ts

@@ -1,10 +1,11 @@
 import type { Vue } from 'vue-facing-decorator';
+import { globalState } from '../app/global-state';
 import PowerduckState from '../app/powerduck-state';
 
 type VueType = typeof Vue.prototype;
-export function setCurrentUrl(instance: VueType, url: string) {
-	const newUrl = new URL(url, window.location.origin);
-	const currentUrl = new URL(window.location.href);
+export const setCurrentUrl = (instance: VueType, url: string) => {
+	const newUrl = new URL(url, globalState.location.origin);
+	const currentUrl = new URL(globalState.location.href);
 	const router = PowerduckState.getRouter();
 	const route = PowerduckState.getCurrentRouteQuery();
 
@@ -14,7 +15,9 @@ export function setCurrentUrl(instance: VueType, url: string) {
 
 	let nextTick = instance?.$nextTick;
 	if (nextTick == null) {
-		nextTick = (cb) => { cb(); };
+		nextTick = (cb) => {
+			cb();
+		};
 	}
 
 	if (currentUrl.href != newUrl.href) {
@@ -35,4 +38,4 @@ export function setCurrentUrl(instance: VueType, url: string) {
 			}
 		}, 500);
 	}
-}
+};

package/common/utils/checkbox-utils.ts

@@ -1,3 +1,5 @@
+import { globalState } from "../../app/global-state";
+
 export default class CheckboxUtils {
 	private static shiftClickBound: boolean = false;
 
@@ -5,6 +7,10 @@ export default class CheckboxUtils {
 		if (!CheckboxUtils.shiftClickBound) {
 			CheckboxUtils.shiftClickBound = true;
 
+            if (!globalState.windowExists) {
+                return;
+            }
+
 			$(document).on(
 				'click',
 				'.dt-selection-checkbox .inv-chckb-clickable',