@koine/dom 2.0.0-beta.14 → 2.0.0-beta.16

package/{isHidden.mjs → isHidden.js}

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

package/isInViewport.d.ts

@@ -1,10 +1,2 @@
-/**
- * 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,10 @@
+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

@@ -1,7 +1,2 @@
-/**
- * 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,9 @@
+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

@@ -1,8 +1,2 @@
-/**
- * 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,4 @@
+export function isTotallyScrolled(el) {
+    return el ? el.scrollHeight - el.scrollTop <= el.clientHeight : false;
+}
+export default isTotallyScrolled;

package/listen.d.ts

@@ -1,13 +1,4 @@
-import { type EventCallback } from "./_listen-delegation";
-import type { AnyDOMEventTarget, AnyDOMEventType } from "./types";
-/**
- * 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
- */
+import { type EventCallback } from "./_listen-delegation.js";
+import type { AnyDOMEventTarget, AnyDOMEventType } from "./types.js";
 export declare function listen<TTypes extends AnyDOMEventType, TTarget extends AnyDOMEventTarget = AnyDOMEventTarget>(types: TTypes, selector: string, callback: EventCallback<TTarget, TTypes>): void;
 export default listen;

package/listen.js

@@ -0,0 +1,19 @@
+import { activeEvents, eventHandler, } from "./_listen-delegation.js";
+import { on } from "./on.js";
+export function listen(types, selector, callback) {
+    if (!selector || !callback)
+        return;
+    types.split(",").forEach(function (type) {
+        var _a;
+        type = type.trim();
+        if (!activeEvents[type]) {
+            activeEvents[type] = [];
+            on(window, type, eventHandler, true);
+        }
+        (_a = activeEvents[type]) === null || _a === void 0 ? void 0 : _a.push({
+            selector: selector,
+            callback: callback,
+        });
+    });
+}
+export default listen;

package/listenLoaded.d.ts

@@ -1,7 +1,2 @@
-/**
- * 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,5 @@
+import { on } from "./on.js";
+export function listenLoaded(handler) {
+    on(document, "DOMContentLoaded", handler);
+}
+export default listenLoaded;

package/listenOnce.d.ts

@@ -1,12 +1,3 @@
-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
- */
+import { type EventCallback } from "./_listen-delegation.js";
 export declare function listenOnce(types: string, selector: string, callback: EventCallback): void;
 export default listenOnce;

package/listenOnce.js

@@ -0,0 +1,11 @@
+import { getRunTarget } from "./_listen-delegation.js";
+import { listen } from "./listen.js";
+import { unlisten } from "./unlisten.js";
+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

@@ -1,8 +1,3 @@
-import type { AnyDOMEventTargetLoose } from "./types";
-/**
- * Listen element's (`window` by default) _scroll_ event
- *
- * @returns An automatic unbinding function to run to deregister the listener upon call
- */
+import type { AnyDOMEventTargetLoose } from "./types.js";
 export declare const listenResize: (handler: () => void, el?: AnyDOMEventTargetLoose) => () => void;
 export default listenResize;

package/listenResize.js

@@ -0,0 +1,3 @@
+import { on } from "./on.js";
+export var listenResize = function (handler, el) { return on(el || window, "resize", handler); };
+export default listenResize;

package/listenResizeDebounced.d.ts

@@ -1,8 +1,3 @@
-import listenResize from "./listenResize";
-/**
- * Listen element's (`window` by default) _resize_ event debouncing the callback
- *
- * @returns An automatic unbinding function to run to deregister the listener upon call
- */
+import listenResize from "./listenResize.js";
 export declare const listenResizeDebounced: (el?: Parameters<typeof listenResize>[1], fn: (...args: any[]) => any, wait?: number | undefined, immediate?: boolean | undefined) => () => void;
 export default listenResizeDebounced;

package/listenResizeDebounced.js

@@ -0,0 +1,10 @@
+import { debounce } from "@koine/utils";
+import listenResize from "./listenResize.js";
+export var listenResizeDebounced = function (el) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return listenResize(debounce.apply(void 0, args), el);
+};
+export default listenResizeDebounced;

package/listenResizeThrottled.d.ts

@@ -1,8 +1,3 @@
-import { listenResize } from "./listenResize";
-/**
- * Listen element's (`window` by default) _resize_ event throttling the callback
- *
- * @returns An automatic unbinding function to run to deregister the listener upon call
- */
+import { listenResize } from "./listenResize.js";
 export declare const listenResizeThrottled: (el?: Parameters<typeof listenResize>[1], fn: Function, limit: number, context?: unknown) => () => void;
 export default listenResizeThrottled;

package/listenResizeThrottled.js

@@ -0,0 +1,10 @@
+import { throttle } from "@koine/utils";
+import { listenResize } from "./listenResize.js";
+export var listenResizeThrottled = function (el) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return listenResize(throttle.apply(void 0, args), el);
+};
+export default listenResizeThrottled;

package/listenScroll.d.ts

@@ -1,8 +1,3 @@
-import type { AnyDOMEventTargetLoose } from "./types";
-/**
- * Listen element's (`window` by default) _scroll_ event
- *
- * @returns An automatic unbinding function to run to deregister the listener upon call
- */
+import type { AnyDOMEventTargetLoose } from "./types.js";
 export declare const listenScroll: (handler: () => void, el?: AnyDOMEventTargetLoose) => () => void;
 export default listenScroll;

package/listenScroll.js

@@ -0,0 +1,8 @@
+import { on } from "./on.js";
+export var listenScroll = function (handler, el) {
+    return on(el || window, "scroll", handler, {
+        capture: true,
+        passive: true,
+    });
+};
+export default listenScroll;

package/listenScrollDebounced.d.ts

@@ -1,8 +1,3 @@
-import { listenScroll } from "./listenScroll";
-/**
- * Listen element's (`window` by default) _scroll_ event debouncing the callback
- *
- * @returns An automatic unbinding function to run to deregister the listener upon call
- */
+import { listenScroll } from "./listenScroll.js";
 export declare const listenScrollDebounced: (el?: Parameters<typeof listenScroll>[1], fn: (...args: any[]) => any, wait?: number | undefined, immediate?: boolean | undefined) => () => void;
 export default listenScrollDebounced;

package/listenScrollDebounced.js

@@ -0,0 +1,10 @@
+import { debounce } from "@koine/utils";
+import { listenScroll } from "./listenScroll.js";
+export var listenScrollDebounced = function (el) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return listenScroll(debounce.apply(void 0, args), el);
+};
+export default listenScrollDebounced;

package/listenScrollThrottled.d.ts

@@ -1,8 +1,3 @@
-import { listenScroll } from "./listenScroll";
-/**
- * Listen element's (`window` by default) _scroll_ event throttling the callback
- *
- * @returns An automatic unbinding function to run to deregister the listener upon call
- */
+import { listenScroll } from "./listenScroll.js";
 export declare const listenScrollThrottled: (el?: Parameters<typeof listenScroll>[1], fn: Function, limit: number, context?: unknown) => () => void;
 export default listenScrollThrottled;

package/listenScrollThrottled.js

@@ -0,0 +1,10 @@
+import { throttle } from "@koine/utils";
+import { listenScroll } from "./listenScroll.js";
+export var listenScrollThrottled = function (el) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return listenScroll(throttle.apply(void 0, args), el);
+};
+export default listenScrollThrottled;

package/off.d.ts

@@ -1,6 +1,3 @@
-import type { AnyDOMEvent, AnyDOMEventTargetLoose, AnyDOMEventType } from "./types";
-/**
- * Shortcut for `removeEventListener`
- */
+import type { AnyDOMEvent, AnyDOMEventTargetLoose, AnyDOMEventType } from "./types.js";
 export declare function off<TType extends AnyDOMEventType>(el: AnyDOMEventTargetLoose, type: TType, handler: (event: AnyDOMEvent<TType>) => void, options?: EventListenerOptions | boolean): void;
 export default off;

package/{off.mjs → off.js}

@@ -1,11 +1,11 @@
-/**
- * Shortcut for `removeEventListener`
- */ export function off(el, type, handler, options = false) {
+export function off(el, type, handler, options) {
+    if (options === void 0) { options = false; }
     if (process.env["NODE_ENV"] !== "production") {
         if (!el) {
             console.warn("[@koine/dom:off] unexisting DOM element");
         }
     }
-    if (el) el.removeEventListener(type, handler, options);
+    if (el)
+        el.removeEventListener(type, handler, options);
 }
 export default off;

package/on.d.ts

@@ -1,8 +1,3 @@
-import type { AnyDOMEvent, AnyDOMEventTargetLoose, AnyDOMEventType } from "./types";
-/**
- * Shortcut for `addEventListener`
- *
- * @returns An automatic unbinding function to run to deregister the listener upon call
- */
+import type { AnyDOMEvent, AnyDOMEventTargetLoose, AnyDOMEventType } from "./types.js";
 export declare function on<TType extends AnyDOMEventType>(el: AnyDOMEventTargetLoose, type: TType, handler: (event: AnyDOMEvent<TType>) => void, options?: AddEventListenerOptions | boolean): () => void;
 export default on;

package/on.js

@@ -0,0 +1,15 @@
+import off from "./off.js";
+export function on(el, type, handler, options) {
+    if (options === void 0) { options = false; }
+    if (process.env["NODE_ENV"] !== "production") {
+        if (!el) {
+            console.warn("[@koine/dom:on] unexisting DOM element");
+        }
+    }
+    if (el) {
+        el.addEventListener(type, handler, options);
+        return function () { return off(el, type, handler); };
+    }
+    return function () { return void 0; };
+}
+export default on;

package/onClickOutside.js

@@ -0,0 +1,16 @@
+import { off, on } from "./index.js";
+export function onClickOutside(element, callback, autoUnbind) {
+    if (autoUnbind === void 0) { autoUnbind = false; }
+    var bind = function (event) {
+        if (!element.contains(event.target)) {
+            callback(event);
+            if (autoUnbind)
+                unbind();
+        }
+    };
+    var unbind = function () {
+        off(document, "click", bind);
+    };
+    on(document, "click", bind);
+    return unbind;
+}

package/once.d.ts

@@ -1,7 +1,3 @@
-import { AnyDOMEventTargetLoose } from "./types";
-/**
- * One shot listener, it `addEventListener` and removes it first time is called
- * with `removeEventListener`
- */
+import { AnyDOMEventTargetLoose } from "./types.js";
 export declare function once(el: AnyDOMEventTargetLoose, type: string, handler: EventListener, options?: EventListenerOptions | boolean): () => void;
 export default once;

package/once.js

@@ -0,0 +1,11 @@
+import off from "./off.js";
+import on from "./on.js";
+export function once(el, type, handler, options) {
+    if (options === void 0) { options = false; }
+    var handlerWrapper = function (event) {
+        handler(event);
+        off(el, type, handlerWrapper);
+    };
+    return on(el, type, handlerWrapper, options);
+}
+export default once;

package/package.json

@@ -2,13 +2,154 @@
   "name": "@koine/dom",
   "sideEffects": false,
   "dependencies": {
-    "@koine/utils": "2.0.0-beta.14"
+    "@koine/utils": "2.0.0-beta.16"
   },
-  "module": "./index.mjs",
-  "main": "./index.js",
   "types": "./index.d.ts",
-  "peerDependencies": {
-    "type-fest": "^4.1.0"
+  "type": "module",
+  "module": "./index.js",
+  "exports": {
+    ".": {
+      "import": "./index.js"
+    },
+    "./$": {
+      "import": "./$.js"
+    },
+    "./$all": {
+      "import": "./$all.js"
+    },
+    "./$each": {
+      "import": "./$each.js"
+    },
+    "./addClass": {
+      "import": "./addClass.js"
+    },
+    "./calculateFixedOffset": {
+      "import": "./calculateFixedOffset.js"
+    },
+    "./createElement": {
+      "import": "./createElement.js"
+    },
+    "./emitEvent": {
+      "import": "./emitEvent.js"
+    },
+    "./escapeSelector": {
+      "import": "./escapeSelector.js"
+    },
+    "./exists": {
+      "import": "./exists.js"
+    },
+    "./forEach": {
+      "import": "./forEach.js"
+    },
+    "./getDataAttr": {
+      "import": "./getDataAttr.js"
+    },
+    "./getDocumentHeight": {
+      "import": "./getDocumentHeight.js"
+    },
+    "./getHeight": {
+      "import": "./getHeight.js"
+    },
+    "./getListeners": {
+      "import": "./getListeners.js"
+    },
+    "./getOffset": {
+      "import": "./getOffset.js"
+    },
+    "./getOffsetTop": {
+      "import": "./getOffsetTop.js"
+    },
+    "./getOffsetTopSlim": {
+      "import": "./getOffsetTopSlim.js"
+    },
+    "./getScrollbarWidth": {
+      "import": "./getScrollbarWidth.js"
+    },
+    "./getStyleValue": {
+      "import": "./getStyleValue.js"
+    },
+    "./getVisualBackgroundColor": {
+      "import": "./getVisualBackgroundColor.js"
+    },
+    "./injectCss": {
+      "import": "./injectCss.js"
+    },
+    "./isHidden": {
+      "import": "./isHidden.js"
+    },
+    "./isInViewport": {
+      "import": "./isInViewport.js"
+    },
+    "./isNodeList": {
+      "import": "./isNodeList.js"
+    },
+    "./isTotallyScrolled": {
+      "import": "./isTotallyScrolled.js"
+    },
+    "./listen": {
+      "import": "./listen.js"
+    },
+    "./listenLoaded": {
+      "import": "./listenLoaded.js"
+    },
+    "./listenOnce": {
+      "import": "./listenOnce.js"
+    },
+    "./listenResize": {
+      "import": "./listenResize.js"
+    },
+    "./listenResizeDebounced": {
+      "import": "./listenResizeDebounced.js"
+    },
+    "./listenResizeThrottled": {
+      "import": "./listenResizeThrottled.js"
+    },
+    "./listenScroll": {
+      "import": "./listenScroll.js"
+    },
+    "./listenScrollDebounced": {
+      "import": "./listenScrollDebounced.js"
+    },
+    "./listenScrollThrottled": {
+      "import": "./listenScrollThrottled.js"
+    },
+    "./off": {
+      "import": "./off.js"
+    },
+    "./on": {
+      "import": "./on.js"
+    },
+    "./onClickOutside": {
+      "import": "./onClickOutside.js"
+    },
+    "./once": {
+      "import": "./once.js"
+    },
+    "./removeClass": {
+      "import": "./removeClass.js"
+    },
+    "./scrollTo": {
+      "import": "./scrollTo.js"
+    },
+    "./setDataAttr": {
+      "import": "./setDataAttr.js"
+    },
+    "./setVendorCSS": {
+      "import": "./setVendorCSS.js"
+    },
+    "./siblings": {
+      "import": "./siblings.js"
+    },
+    "./toArray": {
+      "import": "./toArray.js"
+    },
+    "./types": {
+      "import": "./types.js"
+    },
+    "./unlisten": {
+      "import": "./unlisten.js"
+    }
   },
-  "version": "2.0.0-beta.14"
-}
+  "peerDependencies": {},
+  "version": "2.0.0-beta.16"
+}

package/removeClass.d.ts

@@ -1,5 +1,2 @@
-/**
- * Remove class shortcut
- */
 export declare function removeClass<T extends Element = HTMLElement>(el?: T, className?: string): void;
 export default removeClass;

package/removeClass.js

@@ -0,0 +1,12 @@
+export function removeClass(el, className) {
+    if (className === void 0) { className = ""; }
+    if (process.env["NODE_ENV"] !== "production") {
+        if (!el) {
+            ("[@koine/dom:removeClass] unexisting DOM element");
+            return;
+        }
+    }
+    if (el)
+        el.classList.remove(className);
+}
+export default removeClass;

package/scrollTo.d.ts

@@ -1,12 +1,2 @@
-/**
- * Native `scrollTo`, `"smooth"` and with callback
- *
- * @borrows https://stackoverflow.com/a/55686711/1938970
- *
- * @param offset - offset to scroll to
- * @param callback - callback function
- * @param [fallbackTimeout] - this appears to be needed in some hard to reproduce scenario on safari, where the callback seem to be never called
- * @param [behavior="smooth"]
- */
 export declare function scrollTo(destination: number, callback?: () => void, fallbackTimeout?: number, behavior?: ScrollBehavior): void;
 export default scrollTo;

package/scrollTo.js

@@ -0,0 +1,30 @@
+import { off } from "./off.js";
+import { on } from "./on.js";
+export function scrollTo(destination, callback, fallbackTimeout, behavior) {
+    var fixedDestination = destination.toFixed();
+    if (callback) {
+        var callbackFired_1 = false;
+        var onScroll_1 = function () {
+            if (window.pageYOffset.toFixed() === fixedDestination) {
+                off(window, "scroll", onScroll_1);
+                callbackFired_1 = true;
+                callback();
+            }
+        };
+        on(window, "scroll", onScroll_1);
+        onScroll_1();
+        if (fallbackTimeout) {
+            setTimeout(function () {
+                if (!callbackFired_1) {
+                    off(window, "scroll", onScroll_1);
+                    callback();
+                }
+            }, fallbackTimeout);
+        }
+    }
+    window.scrollTo({
+        top: destination,
+        behavior: behavior || "smooth",
+    });
+}
+export default scrollTo;

package/setDataAttr.d.ts

@@ -1,9 +1,2 @@
-/**
- * Set data attribute
- *
- * @param element
- * @param attribute The name of the `data-{attr}`
- * @param value The value to set, `null` or `undefined` will remove the attribute
- */
 export declare function setDataAttr(element: Element, attribute: string, value?: string | number | null | boolean): void;
 export default setDataAttr;

package/setDataAttr.js

@@ -0,0 +1,8 @@
+export function setDataAttr(element, attribute, value) {
+    if (value === null || typeof value === "undefined") {
+        element.removeAttribute("data-" + attribute);
+        return;
+    }
+    element.setAttribute("data-" + attribute, value.toString());
+}
+export default setDataAttr;

package/setVendorCSS.d.ts

@@ -1,9 +1,2 @@
-/**
- * Set vendor CSS rule
- *
- * @param element A single HTMLElement
- * @param prop CSS rule proerty
- * @param value The CSS value to set, it will be automatically vendor prefixed
- */
 export declare function setVendorCSS(element: HTMLElement, prop: string, value: string | number | boolean): void;
 export default setVendorCSS;

package/setVendorCSS.js

@@ -0,0 +1,9 @@
+export function setVendorCSS(element, prop, value) {
+    var propUpper = prop.charAt(0).toUpperCase() + prop.slice(1);
+    element.style["webkit" + propUpper] = value;
+    element.style["moz" + propUpper] = value;
+    element.style["ms" + propUpper] = value;
+    element.style["o" + propUpper] = value;
+    element.style[prop] = value;
+}
+export default setVendorCSS;

package/siblings.d.ts

@@ -1,7 +1,2 @@
-/**
- * Finds siblings nodes of the passed node.
- *
- * @borrows @glidejs/glide/src/utils/dom (source)
- */
 export declare function siblings(node: Element): Element[];
 export default siblings;