@tb-dev/prototype-dom 5.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Andrew Ferreira
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+```
+pnpm add @tb-dev/prototype-dom
+```

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+declare global {
+    interface ArrayConstructor {
+        fromElements: <T extends Element[] | NodeList | string, V>(source: T, valueSelector: (element: Element) => V) => V[];
+    }
+    interface Document {
+        queryStrict: <T extends Element>(selector: string) => T;
+        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>;
+    }
+    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;
+        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>;
+    }
+    interface URLSearchParams {
+        getStrict: <T extends string>(name: string) => T;
+        getAsInteger: (name: string, radix?: number) => number | null;
+        getAsIntegerStrict: (name: string, radix?: number) => number;
+    }
+    interface MapConstructor {
+        fromElements: <T extends Element[] | NodeList | string, K, V>(source: T, keySelector: (element: Element) => K, valueSelector: (element: Element) => V) => Map<K, V>;
+    }
+    interface SetConstructor {
+        fromElements: <T extends Element[] | NodeList | string, K>(source: T, valueSelector: (element: Element) => K) => Set<K>;
+    }
+}
+export {};

package/dist/index.js

@@ -0,0 +1,175 @@
+(function () {
+    'use strict';
+
+    Document.prototype.queryStrict = function (selector) {
+        const element = this.querySelector(selector);
+        if (!element)
+            throw new Error(`No element found for selector "${selector}"`);
+        return element;
+    };
+    Document.prototype.queryAsArray = function (selector, valueSelector) {
+        valueSelector ??= (element) => element;
+        const elements = this.querySelectorAll(selector);
+        return Array.from(elements, valueSelector);
+    };
+    Document.prototype.queryAsSet = function (selector, valueSelector) {
+        valueSelector ??= (element) => element;
+        const elements = this.queryAsArray(selector, valueSelector);
+        return new Set(elements);
+    };
+    Document.prototype.queryAsMap = function (selector, keySelector, valueSelector = (el) => el) {
+        const elements = this.queryAsArray(selector);
+        const map = new Map();
+        for (const element of elements) {
+            const key = keySelector(element);
+            const value = valueSelector(element);
+            map.set(key, value);
+        }
+        return map;
+    };
+    Element.prototype.getAttributeStrict = function (attribute) {
+        const value = this.getAttribute(attribute)?.trim();
+        if (typeof value !== 'string' || value.length === 0) {
+            throw new Error(`attribute "${attribute}" not found`);
+        }
+        return value;
+    };
+    Element.prototype.getAttributeAsFloatStrict = function (attribute) {
+        const value = this.getAttributeStrict(attribute);
+        const parsed = Number.parseFloat(value);
+        if (!Number.isFinite(parsed))
+            throw new Error(`could not parse attribute "${attribute}" as float`);
+        return parsed;
+    };
+    Element.prototype.getAttributeAsIntStrict = function (attribute, radix = 10) {
+        const value = this.getAttributeStrict(attribute);
+        const parsed = Number.parseInt(value.replace(/\D/g, ''), radix);
+        if (!Number.isInteger(parsed)) {
+            throw new TypeError(`could not parse attribute "${attribute}" as integer`);
+        }
+        return parsed;
+    };
+    Element.prototype.getTextContentStrict = 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();
+        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();
+        const parsed = Number.parseFloat(content);
+        if (!Number.isFinite(parsed)) {
+            throw new TypeError('could not parse text content as float');
+        }
+        return parsed;
+    };
+    Element.prototype.queryStrict = function (selector) {
+        const element = this.querySelector(selector);
+        if (!element)
+            throw new Error(`no element found for selector "${selector}"`);
+        return element;
+    };
+    Element.prototype.queryAsArray = function (selector, valueSelector) {
+        valueSelector ??= (element) => element;
+        const elements = this.querySelectorAll(selector);
+        return Array.from(elements, valueSelector);
+    };
+    Element.prototype.queryAsSet = function (selector, valueSelector) {
+        valueSelector ??= (element) => element;
+        const elements = this.queryAsArray(selector, valueSelector);
+        return new Set(elements);
+    };
+    Element.prototype.queryAsMap = function (selector, keySelector, valueSelector = (el) => el) {
+        const elements = this.queryAsArray(selector);
+        const map = new Map();
+        for (const element of elements) {
+            const key = keySelector(element);
+            const value = valueSelector(element);
+            map.set(key, value);
+        }
+        return map;
+    };
+    URLSearchParams.prototype.getStrict = function (name) {
+        const item = this.get(name);
+        if (item === null) {
+            throw new Error(`key "${name}" not found in URL search parameters`);
+        }
+        return item;
+    };
+    URLSearchParams.prototype.getAsInteger = function (name, radix = 10) {
+        const item = this.get(name);
+        if (item === null)
+            return item;
+        return Number.parseInt(item, radix);
+    };
+    URLSearchParams.prototype.getAsIntegerStrict = function (name, radix = 10) {
+        const item = this.getStrict(name);
+        const parsed = Number.parseInt(item, radix);
+        if (!Number.isInteger(parsed)) {
+            throw new TypeError(`could not parse "${item}" as an integer`);
+        }
+        return parsed;
+    };
+    Array.fromElements = function (source, valueSelector) {
+        isValidElementSource(source);
+        const elements = parseElementSource(source);
+        return Array.from(elements, valueSelector);
+    };
+    Map.fromElements = function (source, keySelector, valueSelector) {
+        isValidElementSource(source);
+        const elements = parseElementSource(source);
+        const map = new Map();
+        for (const element of elements) {
+            if (!(element instanceof Element)) {
+                throw new TypeError('item in source array is not an element');
+            }
+            const key = keySelector(element);
+            const value = valueSelector(element);
+            map.set(key, value);
+        }
+        return map;
+    };
+    Set.fromElements = function (source, valueSelector) {
+        isValidElementSource(source);
+        const elements = parseElementSource(source);
+        const set = new Set();
+        for (const element of elements) {
+            if (!(element instanceof Element)) {
+                throw new TypeError('item in source array is not an element');
+            }
+            const value = valueSelector(element);
+            set.add(value);
+        }
+        return set;
+    };
+    function isValidElementSource(source) {
+        if (!Array.isArray(source) &&
+            !(source instanceof NodeList) &&
+            (typeof source !== 'string' || source.length === 0)) {
+            throw new TypeError('source must be an array, a NodeList or a string');
+        }
+        return true;
+    }
+    function parseElementSource(source) {
+        if (typeof source === 'string') {
+            return document.queryAsArray(source);
+        }
+        else if (Array.isArray(source)) {
+            return source;
+        }
+        else if (source instanceof NodeList) {
+            return Array.from(source);
+        }
+        throw new TypeError('source must be an array, a NodeList or a string');
+    }
+
+})();

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@tb-dev/prototype-dom",
+  "version": "5.2.2",
+  "description": "Adds prototype methods to DOM objects",
+  "packageManager": "pnpm@8.15.4",
+  "license": "MIT",
+  "type": "module",
+  "author": {
+    "name": "Andrew Ferreira",
+    "email": "andrew.shien2@gmail.com",
+    "url": "https://github.com/ferreira-tb"
+  },
+  "homepage": "https://tb.dev.br/prototype-dom",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ferreira-tb/prototype-dom.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ferreira-tb/prototype-dom/issues",
+    "email": "andrew.shien2@gmail.com"
+  },
+  "lint-staged": {
+    "*.{?(c|m)@(j|t)s,css,vue,md,json}": "prettier --write"
+  },
+  "scripts": {
+    "build": "rollup --config rollup.config.js",
+    "docs": "typedoc --plugin typedoc-plugin-mdn-links",
+    "format": "prettier . --write",
+    "format-check": "prettier . --check",
+    "prepare": "husky",
+    "release": "pnpm run build && pnpm publish",
+    "type-check": "tsc --noEmit"
+  },
+  "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",
+    "lint-staged": "^15.2.2",
+    "prettier": "^3.2.5",
+    "rollup": "^4.12.0",
+    "tslib": "^2.6.2",
+    "typedoc": "^0.25.8",
+    "typedoc-plugin-mdn-links": "^3.1.17",
+    "typescript": "5.3.3",
+    "vitest": "^1.3.1"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}