@tb-dev/prototype-dom 6.0.0 → 6.1.0

package/dist/index.d.ts

@@ -7,18 +7,20 @@ declare global {
         queryAsArray: <T = Element>(selector: string, valueSelector?: (element: Element) => T) => T[];
         queryAsSet: <T = Element>(selector: string, valueSelector?: (element: Element) => T) => Set<T>;
         queryAsMap: <T extends Element, K, V = T>(selector: string, keySelector: (element: T) => K, valueSelector?: (element: T) => V) => Map<K, V>;
+        waitChild: (selector: string, timeout?: number) => Promise<Element>;
     }
     interface Element {
         getAttributeStrict: <T extends string>(qualifiedName: string) => T;
         getAttributeAsFloatStrict: (qualifiedName: string, allowNegative?: boolean) => number;
         getAttributeAsIntStrict: (qualifiedName: string, radix?: number, allowNegative?: boolean) => number;
-        getTextContentStrict: <T extends string>() => T;
-        parseIntStrict: (radix?: number, allowNegative?: boolean) => number;
-        parseFloatStrict: (allowNegative?: boolean) => number;
+        getTextStrict: <T extends string>() => T;
+        getTextAsIntStrict: (radix?: number, allowNegative?: boolean) => number;
+        getTextAsFloatStrict: (allowNegative?: boolean) => number;
         queryAsArray: <T = Element>(selector: string, valueSelector?: (element: Element) => T) => T[];
         queryAsSet: <T = Element>(selector: string, valueSelector?: (element: Element) => T) => Set<T>;
         queryStrict: <T extends Element>(selector: string) => T;
         queryAsMap: <T extends Element, K, V = T>(selector: string, keySelector: (element: T) => K, valueSelector?: (element: T) => V) => Map<K, V>;
+        waitChild: (selector: string, timeout?: number) => Promise<Element>;
     }
     interface URLSearchParams {
         getStrict: <T extends string>(name: string) => T;

package/dist/index.js

@@ -27,6 +27,55 @@
         }
         return map;
     };
+    Document.prototype.waitChild = function (selector, timeoutMillis = 300_000) {
+        const el = this.querySelector(selector);
+        if (el)
+            return Promise.resolve(el);
+        return new Promise((resolve, reject) => {
+            let timeout = null;
+            let interval = null;
+            const observer = new MutationObserver((mutations) => {
+                const element = this.querySelector(selector);
+                if (element) {
+                    onElementFound(element);
+                    return;
+                }
+                for (const mutation of mutations) {
+                    if (mutation.type !== 'childList')
+                        continue;
+                    for (const node of Array.from(mutation.addedNodes)) {
+                        if (node instanceof Element && node.matches(`:has(${selector})`)) {
+                            onElementFound(node);
+                            return;
+                        }
+                    }
+                }
+            });
+            function onElementFound(element) {
+                if (typeof timeout === 'number')
+                    clearTimeout(timeout);
+                if (typeof interval === 'number')
+                    clearInterval(interval);
+                observer.disconnect();
+                resolve(element);
+            }
+            function onInterval() {
+                const element = this.querySelector(selector);
+                if (element) {
+                    onElementFound(element);
+                }
+            }
+            function onTimeout() {
+                if (typeof interval === 'number')
+                    clearInterval(interval);
+                observer.disconnect();
+                reject(new Error(`timeout waiting for element: ${selector}`));
+            }
+            interval = setInterval(onInterval.bind(this), 100);
+            timeout = setTimeout(onTimeout, timeoutMillis);
+            observer.observe(this, { childList: true, subtree: true });
+        });
+    };
     Element.prototype.getAttributeStrict = function (attribute) {
         const value = this.getAttribute(attribute)?.trim();
         if (typeof value !== 'string' || value.length === 0) {
@@ -49,23 +98,23 @@
         }
         return parsed;
     };
-    Element.prototype.getTextContentStrict = function () {
+    Element.prototype.getTextStrict = function () {
         const content = this.textContent?.trim();
         if (typeof content !== 'string' || content.length === 0) {
             throw new Error('element has no text content');
         }
         return content;
     };
-    Element.prototype.parseIntStrict = function (radix = 10) {
-        const content = this.getTextContentStrict();
+    Element.prototype.getTextAsIntStrict = function (radix = 10) {
+        const content = this.getTextStrict();
         const parsed = Number.parseInt(content.replace(/\D/g, ''), radix);
         if (!Number.isInteger(parsed)) {
             throw new TypeError('could not parse text content as integer');
         }
         return parsed;
     };
-    Element.prototype.parseFloatStrict = function () {
-        const content = this.getTextContentStrict();
+    Element.prototype.getTextAsFloatStrict = function () {
+        const content = this.getTextStrict();
         const parsed = Number.parseFloat(content);
         if (!Number.isFinite(parsed)) {
             throw new TypeError('could not parse text content as float');
@@ -98,6 +147,55 @@
         }
         return map;
     };
+    Element.prototype.waitChild = function (selector, timeoutMillis = 300_000) {
+        const el = this.querySelector(selector);
+        if (el)
+            return Promise.resolve(el);
+        return new Promise((resolve, reject) => {
+            let timeout = null;
+            let interval = null;
+            const observer = new MutationObserver((mutations) => {
+                const element = this.querySelector(selector);
+                if (element) {
+                    onElementFound(element);
+                    return;
+                }
+                for (const mutation of mutations) {
+                    if (mutation.type !== 'childList')
+                        continue;
+                    for (const node of Array.from(mutation.addedNodes)) {
+                        if (node instanceof Element && node.matches(`:has(${selector})`)) {
+                            onElementFound(node);
+                            return;
+                        }
+                    }
+                }
+            });
+            function onElementFound(element) {
+                if (typeof timeout === 'number')
+                    clearTimeout(timeout);
+                if (typeof interval === 'number')
+                    clearInterval(interval);
+                observer.disconnect();
+                resolve(element);
+            }
+            function onInterval() {
+                const element = this.querySelector(selector);
+                if (element) {
+                    onElementFound(element);
+                }
+            }
+            function onTimeout() {
+                if (typeof interval === 'number')
+                    clearInterval(interval);
+                observer.disconnect();
+                reject(new Error(`timeout waiting for element: ${selector}`));
+            }
+            interval = setInterval(onInterval.bind(this), 100);
+            timeout = setTimeout(onTimeout, timeoutMillis);
+            observer.observe(this, { childList: true, subtree: true });
+        });
+    };
     URLSearchParams.prototype.getStrict = function (name) {
         const item = this.get(name);
         if (item === null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tb-dev/prototype-dom",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "description": "Adds prototype methods to DOM objects",
   "packageManager": "pnpm@8.15.4",
   "license": "MIT",
@@ -25,7 +25,6 @@
   "devDependencies": {
     "@rollup/plugin-typescript": "^11.1.6",
     "@tb-dev/eslint-config": "^2.0.3",
-    "@types/node": "^20.11.20",
     "@vitest/ui": "^1.3.1",
     "eslint": "^8.57.0",
     "husky": "^9.0.11",