@design.estate/dees-domtools 2.5.3 → 2.5.6

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@design.estate/dees-domtools',
-    version: '2.5.3',
+    version: '2.5.6',
     description: 'A package providing tools to simplify complex CSS structures and web development tasks, featuring TypeScript support and integration with various web technologies.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSw4QkFBOEI7SUFDcEMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHFLQUFxSztDQUNuTCxDQUFBIn0=

package/dist_ts/domtools.classes.domtools.d.ts

@@ -4,6 +4,9 @@ import { Scroller } from './domtools.classes.scroller.js';
 import { WebSetup } from '@push.rocks/websetup';
 import { ThemeManager } from './domtools.classes.thememanager.js';
 import { Keyboard } from './domtools.classes.keyboard.js';
+declare global {
+    var deesDomTools: DomTools | undefined;
+}
 export interface IDomToolsState {
     virtualViewport: TViewport;
     jwt: string;
@@ -39,19 +42,25 @@ export declare class DomTools {
     scroller: Scroller;
     themeManager: ThemeManager;
     keyboard: Keyboard | null;
+    disposed: boolean;
     domToolsReady: plugins.smartpromise.Deferred<unknown>;
     domReady: plugins.smartpromise.Deferred<unknown>;
     globalStylesReady: plugins.smartpromise.Deferred<unknown>;
+    private readonly initializationPromise;
+    private readonly managedDomNodes;
+    private readonly readyStateChangedFunc;
     constructor(optionsArg: IDomToolsContructorOptions);
-    private runOnceTrackerStringMap;
-    private runOnceResultMap;
-    private runOnceErrorMap;
+    private runOncePromiseMap;
+    private initialize;
+    private tryMarkDomReady;
+    private trackManagedDomNode;
+    private getHeadOrBodyElement;
     /**
      * run a function once and always get the Promise of the first execution
      * @param identifierArg the indentifier arg identifies functions. functions with the same identifier are considered equal
      * @param funcArg the actual func arg to run
      */
-    runOnce<T>(identifierArg: string, funcArg: () => Promise<T>): Promise<unknown>;
+    runOnce<T>(identifierArg: string, funcArg: () => Promise<T>): Promise<T>;
     /**
      * allows to set global styles
      * @param stylesText the css text you want to set
@@ -72,4 +81,5 @@ export declare class DomTools {
      * @param optionsArg the website info
      */
     setWebsiteInfo(optionsArg: plugins.websetup.IWebSetupConstructorOptions): Promise<void>;
+    dispose(): void;
 }

package/dist_ts/domtools.classes.domtools.js

@@ -13,59 +13,39 @@ export class DomTools {
      * setups domtools
      */
     static async setupDomTools(optionsArg = {}) {
-        // If initialization is already in progress and we're not ignoring global, wait for it
-        if (!optionsArg.ignoreGlobal && DomTools.initializationPromise) {
-            return await DomTools.initializationPromise;
+        if (optionsArg.ignoreGlobal) {
+            const domToolsInstance = new DomTools(optionsArg);
+            await domToolsInstance.initializationPromise;
+            return domToolsInstance;
         }
-        // Create initialization promise to prevent race conditions
-        if (!optionsArg.ignoreGlobal) {
-            DomTools.initializationPromise = (async () => {
-                let domToolsInstance;
-                if (!globalThis.deesDomTools) {
-                    globalThis.deesDomTools = new DomTools(optionsArg);
-                    domToolsInstance = globalThis.deesDomTools;
-                    // lets make sure the dom is ready
-                    const readyStateChangedFunc = () => {
-                        if (document.readyState === 'interactive' || document.readyState === 'complete') {
-                            domToolsInstance.elements.headElement = document.querySelector('head');
-                            domToolsInstance.elements.bodyElement = document.querySelector('body');
-                            // Initialize keyboard now that document.body exists
-                            domToolsInstance.keyboard = new Keyboard(document.body);
-                            domToolsInstance.domReady.resolve();
-                        }
-                    };
-                    // Check current state immediately to avoid race condition
-                    if (document.readyState === 'interactive' || document.readyState === 'complete') {
-                        readyStateChangedFunc();
-                    }
-                    else {
-                        document.addEventListener('readystatechange', readyStateChangedFunc);
-                    }
-                    domToolsInstance.domToolsReady.resolve();
-                }
-                else {
-                    domToolsInstance = globalThis.deesDomTools;
-                }
-                await domToolsInstance.domToolsReady.promise;
-                return domToolsInstance;
-            })();
-            return await DomTools.initializationPromise;
+        if (globalThis.deesDomTools && !globalThis.deesDomTools.disposed) {
+            await globalThis.deesDomTools.initializationPromise;
+            return globalThis.deesDomTools;
         }
-        else {
-            // ignoreGlobal case - create isolated instance
+        if (!DomTools.initializationPromise) {
             const domToolsInstance = new DomTools(optionsArg);
-            return domToolsInstance;
+            globalThis.deesDomTools = domToolsInstance;
+            DomTools.initializationPromise = domToolsInstance.initializationPromise
+                .then(() => domToolsInstance)
+                .catch((error) => {
+                if (globalThis.deesDomTools === domToolsInstance) {
+                    globalThis.deesDomTools = undefined;
+                }
+                DomTools.initializationPromise = null;
+                throw error;
+            });
         }
+        return await DomTools.initializationPromise;
     }
     /**
      * if you can, use the static asysnc .setupDomTools() function instead since it is safer to use.
      */
     static getGlobalDomToolsSync() {
         const globalDomTools = globalThis.deesDomTools;
-        if (!globalDomTools) {
+        if (!globalDomTools || globalDomTools.disposed) {
             throw new Error('You tried to access domtools synchronously too early');
         }
-        return globalThis.deesDomTools;
+        return globalDomTools;
     }
     // ========
     // INSTANCE
@@ -98,46 +78,71 @@ export class DomTools {
     scroller = new Scroller(this);
     themeManager = new ThemeManager(this);
     keyboard = null; // Initialized after DOM ready to avoid accessing document.body before it exists
+    disposed = false;
     domToolsReady = plugins.smartpromise.defer();
     domReady = plugins.smartpromise.defer();
     globalStylesReady = plugins.smartpromise.defer();
-    constructor(optionsArg) { }
-    runOnceTrackerStringMap = new plugins.lik.Stringmap();
-    runOnceResultMap = new plugins.lik.FastMap();
-    runOnceErrorMap = new plugins.lik.FastMap();
+    initializationPromise;
+    managedDomNodes = [];
+    readyStateChangedFunc = () => {
+        this.tryMarkDomReady();
+    };
+    constructor(optionsArg) {
+        this.initializationPromise = this.initialize();
+    }
+    runOncePromiseMap = new Map();
+    async initialize() {
+        this.tryMarkDomReady();
+        if (this.domReady.status === 'pending') {
+            document.addEventListener('readystatechange', this.readyStateChangedFunc);
+        }
+        if (this.domToolsReady.status === 'pending') {
+            this.domToolsReady.resolve();
+        }
+    }
+    tryMarkDomReady() {
+        if (this.disposed || this.domReady.status !== 'pending') {
+            return;
+        }
+        if (document.readyState !== 'interactive' && document.readyState !== 'complete') {
+            return;
+        }
+        if (!document.head || !document.body) {
+            return;
+        }
+        this.elements.headElement = document.head;
+        this.elements.bodyElement = document.body;
+        if (!this.keyboard) {
+            this.keyboard = new Keyboard(document.body);
+        }
+        document.removeEventListener('readystatechange', this.readyStateChangedFunc);
+        this.domReady.resolve();
+    }
+    trackManagedDomNode(elementArg) {
+        this.managedDomNodes.push(elementArg);
+        return elementArg;
+    }
+    getHeadOrBodyElement() {
+        const targetElement = this.elements.headElement || document.head || this.elements.bodyElement || document.body;
+        if (!targetElement) {
+            throw new Error('DomTools could not find a DOM target element to attach resources to');
+        }
+        return targetElement;
+    }
     /**
      * run a function once and always get the Promise of the first execution
      * @param identifierArg the indentifier arg identifies functions. functions with the same identifier are considered equal
      * @param funcArg the actual func arg to run
      */
     async runOnce(identifierArg, funcArg) {
-        const runningId = `${identifierArg}+runningCheck`;
-        if (!this.runOnceTrackerStringMap.checkString(identifierArg)) {
-            this.runOnceTrackerStringMap.addString(identifierArg);
-            this.runOnceTrackerStringMap.addString(runningId);
-            try {
-                const result = await funcArg();
-                this.runOnceResultMap.addToMap(identifierArg, result);
-            }
-            catch (error) {
-                // Store error so waiting callers can receive it
-                this.runOnceErrorMap.addToMap(identifierArg, error);
-            }
-            finally {
-                // Always remove running flag to prevent permanent stuck state
-                this.runOnceTrackerStringMap.removeString(runningId);
-            }
+        let runOncePromise = this.runOncePromiseMap.get(identifierArg);
+        if (!runOncePromise) {
+            runOncePromise = Promise.resolve().then(async () => {
+                return await funcArg();
+            });
+            this.runOncePromiseMap.set(identifierArg, runOncePromise);
         }
-        return await this.runOnceTrackerStringMap.registerUntilTrue((stringMap) => {
-            return !stringMap?.includes(runningId);
-        }, () => {
-            // Check if there was an error and re-throw it
-            const error = this.runOnceErrorMap.getByKey(identifierArg);
-            if (error) {
-                throw error;
-            }
-            return this.runOnceResultMap.getByKey(identifierArg);
-        });
+        return await runOncePromise;
     }
     // setStuff
     /**
@@ -146,10 +151,10 @@ export class DomTools {
      */
     async setGlobalStyles(stylesText) {
         await this.domReady.promise;
-        const styleElement = document.createElement('style');
+        const styleElement = this.trackManagedDomNode(document.createElement('style'));
         styleElement.type = 'text/css';
         styleElement.appendChild(document.createTextNode(stylesText));
-        this.elements.headElement.appendChild(styleElement);
+        this.getHeadOrBodyElement().appendChild(styleElement);
     }
     /**
      * allows to set global styles
@@ -158,13 +163,15 @@ export class DomTools {
     async setExternalScript(scriptLinkArg) {
         await this.domReady.promise;
         const done = plugins.smartpromise.defer();
-        const script = document.createElement('script');
+        const script = this.trackManagedDomNode(document.createElement('script'));
         script.src = scriptLinkArg;
-        script.addEventListener('load', function () {
+        script.addEventListener('load', () => {
             done.resolve();
         });
-        const parentNode = document.head || document.body;
-        parentNode.append(script);
+        script.addEventListener('error', () => {
+            done.reject(new Error(`Failed to load external script: ${scriptLinkArg}`));
+        });
+        this.getHeadOrBodyElement().append(script);
         await done.promise;
     }
     /**
@@ -172,11 +179,20 @@ export class DomTools {
      * @param cssLinkArg a url to an external stylesheet
      */
     async setExternalCss(cssLinkArg) {
-        const cssTag = document.createElement('link');
+        await this.domReady.promise;
+        const done = plugins.smartpromise.defer();
+        const cssTag = this.trackManagedDomNode(document.createElement('link'));
         cssTag.rel = 'stylesheet';
         cssTag.crossOrigin = 'anonymous';
         cssTag.href = cssLinkArg;
-        document.head.append(cssTag);
+        cssTag.addEventListener('load', () => {
+            done.resolve();
+        });
+        cssTag.addEventListener('error', () => {
+            done.reject(new Error(`Failed to load external stylesheet: ${cssLinkArg}`));
+        });
+        this.getHeadOrBodyElement().append(cssTag);
+        await done.promise;
     }
     /**
      * allows setting of website infos
@@ -186,5 +202,24 @@ export class DomTools {
         await this.websetup.setup(optionsArg);
         await this.websetup.readyPromise;
     }
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        document.removeEventListener('readystatechange', this.readyStateChangedFunc);
+        this.keyboard?.dispose();
+        this.keyboard = null;
+        this.scroller.dispose();
+        this.themeManager.dispose();
+        for (const managedDomNode of this.managedDomNodes) {
+            managedDomNode.remove();
+        }
+        this.managedDomNodes.length = 0;
+        if (globalThis.deesDomTools === this) {
+            globalThis.deesDomTools = undefined;
+            DomTools.initializationPromise = null;
+        }
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"domtools.classes.domtools.js","sourceRoot":"","sources":["../ts/domtools.classes.domtools.ts"],"names":[],"mappings":"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"}

package/dist_ts/domtools.classes.keyboard.d.ts

@@ -119,6 +119,7 @@ export declare class Keyboard {
     private domNode;
     private mapCombosToHandlers;
     private pressedKeys;
+    private listening;
     constructor(domNode: Element | Document);
     keyEnum: typeof Key;
     on(keys: Key[]): plugins.smartrx.rxjs.Subject<KeyboardEvent>;
@@ -126,9 +127,17 @@ export declare class Keyboard {
     startListening(): void;
     stopListening(): void;
     clear(): void;
+    dispose(): void;
     private handleKeyDown;
     private checkMatchingKeyboardSubjects;
     private handleKeyUp;
     private areAllKeysPressed;
     private registerKeys;
+    private normalizeKeys;
+    private resolveKey;
+    private resolveKeyFromCode;
+    private resolveKeyFromKey;
+    private resolveKeyFromKeyCode;
+    private createKeyboardEvent;
+    private getKeyDescriptor;
 }