@koine/dom 1.0.80

package/injectCss.js

@@ -0,0 +1,16 @@
+/**
+ * Inject css
+ */
+export function injectCss(id, cssString, root) {
+    if (cssString === void 0) { cssString = ""; }
+    if (root === void 0) { root = document; }
+    var styleblock;
+    styleblock = root.getElementById(id);
+    if (!styleblock) {
+        styleblock = root.createElement("style");
+        styleblock.id = id;
+        root.body.appendChild(styleblock);
+    }
+    styleblock.innerHTML = cssString;
+}
+export default injectCss;

package/isHidden.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Is element hidden?
+ */
+export declare function isHidden(el?: HTMLElement): boolean;
+export default isHidden;

package/isHidden.js

@@ -0,0 +1,7 @@
+/**
+ * Is element hidden?
+ */
+export function isHidden(el) {
+    return !el || el.offsetParent === null;
+}
+export default isHidden;

package/isInViewport.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Determine if an element is in the viewport
+ *
+ * @borrows (c) 2017 Chris Ferdinandi, MIT License, https://gomakethings.com
+ *
+ * @param elem The element
+ * @return Returns true if element is in the viewport
+ */
+export declare function isInViewport(elem: Element): boolean;
+export default isInViewport;

package/isInViewport.js

@@ -0,0 +1,18 @@
+/**
+ * Determine if an element is in the viewport
+ *
+ * @borrows (c) 2017 Chris Ferdinandi, MIT License, https://gomakethings.com
+ *
+ * @param elem The element
+ * @return Returns true if element is in the viewport
+ */
+export function isInViewport(elem) {
+    var distance = elem.getBoundingClientRect();
+    return (distance.top >= 0 &&
+        distance.left >= 0 &&
+        distance.bottom <=
+            (window.innerHeight || document.documentElement.clientHeight) &&
+        distance.right <=
+            (window.innerWidth || document.documentElement.clientWidth));
+}
+export default isInViewport;

package/isNodeList.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Is node list
+ *
+ * @param nodes The object to check
+ */
+export declare function isNodeList<T>(nodes: any): nodes is NodeList;
+export default isNodeList;

package/isNodeList.js

@@ -0,0 +1,14 @@
+/**
+ * Is node list
+ *
+ * @param nodes The object to check
+ */
+export function isNodeList(nodes) {
+    var stringRepr = Object.prototype.toString.call(nodes);
+    return (typeof nodes === "object" &&
+        /^\[object (HTMLCollection|NodeList|Object)\]$/.test(stringRepr) &&
+        typeof nodes.length === "number" &&
+        (nodes.length === 0 ||
+            (typeof nodes[0] === "object" && nodes[0].nodeType > 0)));
+}
+export default isNodeList;

package/isTotallyScrolled.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Is element totally scrolled
+ *
+ * @see https://github.com/willmcpo/body-scroll-lock/blob/master/src/bodyScrollLock.js#L116
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight#Problems_and_solutions
+ */
+export declare function isTotallyScrolled(el?: HTMLElement): boolean;
+export default isTotallyScrolled;

package/isTotallyScrolled.js

@@ -0,0 +1,10 @@
+/**
+ * Is element totally scrolled
+ *
+ * @see https://github.com/willmcpo/body-scroll-lock/blob/master/src/bodyScrollLock.js#L116
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight#Problems_and_solutions
+ */
+export function isTotallyScrolled(el) {
+    return el ? el.scrollHeight - el.scrollTop <= el.clientHeight : false;
+}
+export default isTotallyScrolled;

package/listen.d.ts

@@ -0,0 +1,12 @@
+import { type EventCallback } from "./_listen-delegation";
+/**
+ * Listen an event
+ *
+ * @category listen-delegation
+ *
+ * @param types The event type or types (comma separated)
+ * @param selector The selector to run the event on
+ * @param callback The function to run when the event fires
+ */
+export declare function listen(types: string, selector: string, callback: EventCallback): void;
+export default listen;

package/listen.js

@@ -0,0 +1,32 @@
+import { activeEvents, eventHandler, } from "./_listen-delegation";
+import { on } from "./on";
+/**
+ * Listen an event
+ *
+ * @category listen-delegation
+ *
+ * @param types The event type or types (comma separated)
+ * @param selector The selector to run the event on
+ * @param callback The function to run when the event fires
+ */
+export function listen(types, selector, callback) {
+    // Make sure there's a selector and callback
+    if (!selector || !callback)
+        return;
+    // Loop through each event type
+    types.split(",").forEach(function (type) {
+        // Remove whitespace
+        type = type.trim();
+        // If no event of this type yet, setup
+        if (!activeEvents[type]) {
+            activeEvents[type] = [];
+            on(window, type, eventHandler, true);
+        }
+        // Push to active events
+        activeEvents[type].push({
+            selector: selector,
+            callback: callback,
+        });
+    });
+}
+export default listen;

package/listenLoaded.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Fires a callback when the DOM content is loaded
+ *
+ * @see https://mathiasbynens.be/notes/settimeout-onload
+ */
+export declare function listenLoaded(handler: (event: Event) => any): void;
+export default listenLoaded;

package/listenLoaded.js

@@ -0,0 +1,11 @@
+import { on } from "./on";
+/**
+ * Fires a callback when the DOM content is loaded
+ *
+ * @see https://mathiasbynens.be/notes/settimeout-onload
+ */
+export function listenLoaded(handler) {
+    on(document, "DOMContentLoaded", handler);
+    // document.addEventListener("DOMContentLoaded", setTimeout(handler, 4));
+}
+export default listenLoaded;

package/listenOnce.d.ts

@@ -0,0 +1,12 @@
+import { type EventCallback } from "./_listen-delegation";
+/**
+ * Listen an event, and automatically unlisten it after it's first run
+ *
+ * @category listen-delegation
+ *
+ * @param types The event type or types (comma separated)
+ * @param selector The selector to run the event on
+ * @param callback The function to run when the event fires
+ */
+export declare function listenOnce(types: string, selector: string, callback: EventCallback): void;
+export default listenOnce;

package/listenOnce.js

@@ -0,0 +1,20 @@
+import { getRunTarget } from "./_listen-delegation";
+import { listen } from "./listen";
+import { unlisten } from "./unlisten";
+/**
+ * Listen an event, and automatically unlisten it after it's first run
+ *
+ * @category listen-delegation
+ *
+ * @param types The event type or types (comma separated)
+ * @param selector The selector to run the event on
+ * @param callback The function to run when the event fires
+ */
+export function listenOnce(types, selector, callback) {
+    listen(types, selector, function temp(event) {
+        var target = getRunTarget(event.target, selector);
+        callback(event, target || window);
+        unlisten(types, selector, temp);
+    });
+}
+export default listenOnce;

package/listenResize.d.ts

@@ -0,0 +1,8 @@
+import { debounce } from "@koine/utils";
+/**
+ * Listen window resize event debouncing the given handler
+ *
+ * @returns An automatic unbinding function to run to deregister the listener upon call
+ */
+export declare function listenResize(...args: Parameters<typeof debounce>): () => void;
+export default listenResize;

package/listenResize.js

@@ -0,0 +1,25 @@
+import { debounce } from "@koine/utils";
+import { on } from "./on";
+import { off } from "./off";
+/**
+ * Listen window resize event debouncing the given handler
+ *
+ * @returns An automatic unbinding function to run to deregister the listener upon call
+ */
+export function listenResize() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var handler = debounce.apply(void 0, args);
+    on(window, "resize", handler);
+    /**
+     * Unbind the previously attached scroll handler
+     */
+    function unbinder() {
+        handler.cancel();
+        off(window, "resize", handler);
+    }
+    return unbinder;
+}
+export default listenResize;

package/listenScroll.d.ts

@@ -0,0 +1,8 @@
+import { debounce } from "@koine/utils";
+/**
+ * Listen window scroll event debouncing the given handler
+ *
+ * @returns An automatic unbinding function to run to deregister the listener upon call
+ */
+export declare function listenScroll(...args: Parameters<typeof debounce>): () => void;
+export default listenScroll;

package/listenScroll.js

@@ -0,0 +1,28 @@
+import { debounce } from "@koine/utils";
+import { on } from "./on";
+import { off } from "./off";
+/**
+ * Listen window scroll event debouncing the given handler
+ *
+ * @returns An automatic unbinding function to run to deregister the listener upon call
+ */
+export function listenScroll() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var handler = debounce.apply(void 0, args);
+    on(window, "scroll", handler, {
+        capture: true,
+        passive: true,
+    });
+    /**
+     * Unbind the previously attached scroll handler
+     */
+    function unbinder() {
+        handler.cancel();
+        off(window, "scroll", handler);
+    }
+    return unbinder;
+}
+export default listenScroll;

package/node/$$.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$$ = void 0;
+/**
+ * Sizzle/jQuery like DOM nodes shortcut for `document.querySelectorAll`
+ * To avoid an extra function call we inline the above `escape`
+ *
+ * @param string selector DOM selector
+ * @param parent It falls back to `window.document`
+ * @param avoidEscape Whether to avoid escaping `:` in the selector string
+ */
+function $$(selector, parent, avoidEscape) {
+    return (parent ? parent : document).querySelectorAll(avoidEscape ? selector : selector.replace(/:/g, "\\:"));
+}
+exports.$$ = $$;
+exports.default = $$;

package/node/$.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$ = void 0;
+/**
+ * Sizzle/jQuery like DOM nodes shortcut for `document.querySelector`
+ * To avoid an extra function call we inline the above `escape`
+ *
+ * @param selector DOM selector
+ * @param parent It falls back to `window.document`
+ * @param avoidEscape Whether to avoid escaping `:` in the selector string
+ * @example <caption>Basic DOM selection</caption>
+ * const $container = $(".my-section:");
+ * const $el = $("[data-some-attr]", $container);
+ */
+function $(selector, parent, avoidEscape) {
+    return (parent ? parent : document).querySelector(avoidEscape ? selector : selector.replace(/:/g, "\\:"));
+}
+exports.$ = $;
+exports.default = $;

package/node/$each.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$each = void 0;
+var tslib_1 = require("tslib");
+var __1 = tslib_1.__importDefault(require("./$$"));
+/**
+ * Each shortcut, iterate through a NodeList of HTMLElements retrieved with the
+ * given selector (and optionally a parent container passed as thrid arguement)
+ *
+ * @param selector DOM selector
+ * @param callback
+ * @param parent It falls back to `window.document`
+ * @param scope
+ */
+function $each(selector, callback, parent, scope) {
+    var nodes = (0, __1.default)(selector, parent);
+    for (var i = 0; i < nodes.length; i++) {
+        callback.call(scope, nodes[i], i);
+    }
+}
+exports.$each = $each;
+exports.default = $each;

package/node/_listen-delegation.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventHandler = exports.getRunTarget = exports.getIndex = exports.activeEvents = void 0;
+/**
+ * Listen: events delegation system
+ *
+ * From:
+ * https://github.com/cferdinandi/events
+ * https://github.com/cferdinandi/events/blob/master/src/js/events/events.js
+ *
+ * @fileoverview
+ */
+var utils_1 = require("@koine/utils");
+var escapeSelector_1 = require("./escapeSelector");
+/**
+ * Active events
+ *
+ * @internal
+ */
+exports.activeEvents = {};
+/**
+ * Get the index for the listener
+ *
+ * @internal
+ */
+function getIndex(arr, selector, callback) {
+    for (var i = 0; i < arr.length; i++) {
+        if (arr[i].selector === selector &&
+            arr[i].callback.toString() === callback.toString())
+            return i;
+    }
+    return -1;
+}
+exports.getIndex = getIndex;
+/**
+ * Check if the listener callback should run or not
+ *
+ * @internal
+ * @param target The event.target
+ * @param selector The selector/element to check the target against
+ * @return If not false, run listener and pass the targeted element to use in the callback
+ */
+function getRunTarget(target, selector) {
+    // @ts-expect-error FIXME: type
+    if (["*", "window", window].includes(selector)) {
+        return window;
+    }
+    if ([
+        "document",
+        "document.documentElement",
+        document,
+        document.documentElement,
+        // @ts-expect-error FIXME: type
+    ].includes(selector))
+        return document;
+    if ((0, utils_1.isString)(selector)) {
+        return target.closest((0, escapeSelector_1.escapeSelector)(selector));
+    }
+    // @ts-expect-error FIXME: type
+    if (typeof selector !== "string" && selector.contains) {
+        if (selector === target) {
+            return target;
+        }
+        // @ts-expect-error FIXME: type
+        if (selector.contains(target)) {
+            return selector;
+        }
+        return false;
+    }
+    return false;
+}
+exports.getRunTarget = getRunTarget;
+/**
+ * Handle listeners after event fires
+ *
+ * @internal
+ */
+function eventHandler(event) {
+    if (!exports.activeEvents[event.type])
+        return;
+    exports.activeEvents[event.type].forEach(function (listener) {
+        var target = getRunTarget(event.target, listener.selector);
+        if (!target) {
+            return;
+        }
+        listener.callback(event, target);
+    });
+}
+exports.eventHandler = eventHandler;

package/node/addClass.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addClass = void 0;
+/**
+ * Add class shortcut
+ */
+function addClass(el, className) {
+    if (className === void 0) { className = ""; }
+    if (process.env["NODE_ENV"] !== "production") {
+        if (!el) {
+            console.warn("[@koine/dom:addClass] unexisting DOM element");
+            return;
+        }
+    }
+    if (el)
+        el.classList.add(className);
+}
+exports.addClass = addClass;
+exports.default = addClass;

package/node/calculateFixedOffset.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFixedOffset = void 0;
+var _each_1 = require("./$each");
+function calculateFixedOffset(selector) {
+    if (selector === void 0) { selector = "[data-fixed]"; }
+    var fixedOffset = 0;
+    (0, _each_1.$each)(selector, function ($el) {
+        fixedOffset += $el.offsetHeight;
+    });
+    return fixedOffset;
+}
+exports.calculateFixedOffset = calculateFixedOffset;
+exports.default = calculateFixedOffset;

package/node/createElement.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createElement = void 0;
+var tslib_1 = require("tslib");
+var addClass_1 = tslib_1.__importDefault(require("./addClass"));
+/**
+ * Shortcut for `document.createElement`, allowing to to create an HTML element
+ * with a given className directly (a very common use case)
+ *
+ * @param type
+ * @param className
+ */
+function createElement(type, className) {
+    var el = document.createElement(type);
+    if (className) {
+        (0, addClass_1.default)(el, className);
+    }
+    return el;
+}
+exports.createElement = createElement;
+exports.default = createElement;

package/node/emitEvent.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitEvent = void 0;
+/**
+ * Emit event (use only if the targeted browser supports `CustomEvent`s)
+ */
+function emitEvent(type, detail) {
+    if (type === void 0) { type = "customEvent"; }
+    if (detail === void 0) { detail = {}; }
+    if (typeof window.CustomEvent !== "function")
+        return;
+    document.dispatchEvent(new CustomEvent(type, {
+        bubbles: true,
+        detail: detail,
+    }));
+}
+exports.emitEvent = emitEvent;
+exports.default = emitEvent;

package/node/escapeSelector.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeSelector = void 0;
+/**
+ * Escape colons to allow use class names as `.module:block__element`
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelector#Escaping_special_characters
+ *
+ * @param selector
+ */
+function escapeSelector(selector) {
+    return selector.replace(/:/g, "\\:");
+}
+exports.escapeSelector = escapeSelector;
+exports.default = escapeSelector;

package/node/exists.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exists = void 0;
+/**
+ * Checks if passed node exist and is a valid element.
+ *
+ * @borrows @glidejs/glide/src/utils/dom (source)
+ */
+function exists(node) {
+    if (node && node instanceof window.HTMLElement) {
+        return true;
+    }
+    return false;
+}
+exports.exists = exists;
+exports.default = exists;

package/node/forEach.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEach = void 0;
+/**
+ * For each, iterate through a NodeList of HTMLElements
+ *
+ * @param nodes DOM nodes collection
+ * @param callback
+ * @param scope
+ */
+function forEach(nodes, callback, scope) {
+    for (var i = 0; i < nodes.length; i++) {
+        callback.call(scope, nodes[i], i);
+    }
+}
+exports.forEach = forEach;
+exports.default = forEach;

package/node/getDataAttr.js

@@ -0,0 +1,17 @@
+"use strict";
+// TODO: maybe move to `dataset` API but consider the comment about Safari here
+// https://stackoverflow.com/a/9201264/1938970
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDataAttr = void 0;
+/**
+ * Get data attribute
+ *
+ * @param element
+ * @param attribute The name of the `data-{attr}`
+ */
+function getDataAttr(element, attribute) {
+    // return element.dataset[attribute];
+    return element.getAttribute("data-" + attribute);
+}
+exports.getDataAttr = getDataAttr;
+exports.default = getDataAttr;

package/node/getDocumentHeight.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDocumentHeight = void 0;
+/**
+ * Determine the document's height
+ *
+ * @see https://github.com/cferdinandi/smooth-scroll (credits)
+ */
+function getDocumentHeight() {
+    var body = document.body, documentElement = document.documentElement;
+    return Math.max(body.scrollHeight, documentElement.scrollHeight, body.offsetHeight, documentElement.offsetHeight, body.clientHeight, documentElement.clientHeight);
+}
+exports.getDocumentHeight = getDocumentHeight;
+exports.default = getDocumentHeight;

package/node/getHeight.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHeight = void 0;
+/**
+ * Get element height
+ */
+function getHeight(element) {
+    return parseInt(window.getComputedStyle(element).height, 10);
+}
+exports.getHeight = getHeight;
+exports.default = getHeight;

package/node/getListeners.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getListeners = void 0;
+var _listen_delegation_1 = require("./_listen-delegation");
+/**
+ * Get an immutable copy of all active event listeners
+ *
+ * @category listen-delegation
+ *
+ * @return Active event listeners
+ */
+function getListeners() {
+    var obj = {};
+    for (var type in _listen_delegation_1.activeEvents) {
+        // if (activeEvents.hasOwnProperty(type)) {
+        obj[type] = _listen_delegation_1.activeEvents[type];
+        // }
+    }
+    return obj;
+}
+exports.getListeners = getListeners;
+exports.default = getListeners;

package/node/getOffset.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOffset = void 0;
+/**
+ * Get an element's distance from the top and left of the Document.
+ *
+ * @param elem The HTML node element
+ * @return Distance from the top and left in pixels
+ */
+function getOffset(elem) {
+    var left = 0;
+    var top = 0;
+    while (elem && !isNaN(elem.offsetLeft) && !isNaN(elem.offsetTop)) {
+        left += elem.offsetLeft - elem.scrollLeft;
+        top += elem.offsetTop - elem.scrollTop;
+        // @ts-expect-error nevermind?
+        elem = elem.offsetParent;
+    }
+    return { top: top, left: left };
+}
+exports.getOffset = getOffset;
+exports.default = getOffset;