treeloom 0.0.0-stage → 2.1.0

package/dist/events/functions/registerListeners.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const si_funciona_1=__importDefault(require("si-funciona")),documentItem_1=__importDefault(require("../../domItem/objects/documentItem")),registerListeners=(e,t=(0,documentItem_1.default)())=>(si_funciona_1.default.mergeObjectsMutable(t.eventActions,e),t);exports.default=registerListeners;

package/dist/events/functions/removeEventListener.d.ts

@@ -0,0 +1,18 @@
+import type { DomItem } from '../../domItem/types';
+import type { EventName, ListenerFunction, ListenerOptions } from '../types';
+/**
+ * Find and remove an event listener from a DomItem: detaches it from the element first (via
+ * {@link deactivateListener}) if it was active, then splices its descriptor out of eventListeners. A no-op if no
+ * matching listener is found.
+ *
+ * item is the last parameter (instead of customArgs/options having literal defaults) so this can be curried and
+ * piped directly - see {@link fullAddEventListener} for an example of the pattern.
+ * @param eventName - The name of the trigger event the listener was registered under.
+ * @param listenerFunction - The listener function to match against.
+ * @param customArgs - The custom args the listener was registered with.
+ * @param options - The options the listener was registered with.
+ * @param item - The DomItem to remove the listener from.
+ * @returns The same DomItem, with the matching listener removed if one was found.
+ */
+declare const removeEventListener: (eventName: EventName, listenerFunction: string | ListenerFunction, customArgs: object | null | undefined, options: ListenerOptions | null | undefined, item: DomItem) => DomItem;
+export default removeEventListener;

package/dist/events/functions/removeEventListener.js

@@ -0,0 +1,42 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const findEventListener_1 = __importDefault(require("./findEventListener"));
+const deactivateListener_1 = __importDefault(require("./deactivateListener"));
+/**
+ * Find and remove an event listener from a DomItem: detaches it from the element first (via
+ * {@link deactivateListener}) if it was active, then splices its descriptor out of eventListeners. A no-op if no
+ * matching listener is found.
+ *
+ * item is the last parameter (instead of customArgs/options having literal defaults) so this can be curried and
+ * piped directly - see {@link fullAddEventListener} for an example of the pattern.
+ * @param eventName - The name of the trigger event the listener was registered under.
+ * @param listenerFunction - The listener function to match against.
+ * @param customArgs - The custom args the listener was registered with.
+ * @param options - The options the listener was registered with.
+ * @param item - The DomItem to remove the listener from.
+ * @returns The same DomItem, with the matching listener removed if one was found.
+ */
+const removeEventListener = (eventName, listenerFunction, customArgs, options, item) => {
+  const [listenerIndex, foundListener] = (0, findEventListener_1.default)(eventName, listenerFunction, customArgs, options, item);
+  if (listenerIndex < 0 || typeof foundListener === 'undefined') {
+    // listener not found
+    return item;
+  }
+  if (foundListener.listenerActive === true) {
+    item = (0, deactivateListener_1.default)(eventName, foundListener, item);
+  }
+  item.eventListeners[eventName].splice(listenerIndex, 1);
+  return item;
+};
+exports.default = removeEventListener;

package/dist/events/functions/removeEventListener.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const findEventListener_1=__importDefault(require("./findEventListener")),deactivateListener_1=__importDefault(require("./deactivateListener")),removeEventListener=(e,t,r,i,n)=>{const[s,u]=(0,findEventListener_1.default)(e,t,r,i,n);return s<0||void 0===u||(!0===u.listenerActive&&(n=(0,deactivateListener_1.default)(e,u,n)),n.eventListeners[e].splice(s,1)),n};exports.default=removeEventListener;

package/dist/events/functions/retrieveListener.d.ts

@@ -0,0 +1,14 @@
+import type { DomItemRoot } from '../../domItem/types';
+import type { ListenerFunction } from '../types';
+/**
+ * Based on the provided function / listener name, retrieve the associated function from the root domEvents.DomItem.
+ * If a raw function is passed instead of a registered name, it is returned as-is - see {@link EventListener}'s
+ * listenerFunc property for the tradeoffs of that discretionary path. When the root has forwardEvents set (render-
+ * only mode - see setForwardEvents), every name resolves to a forwarder instead, whether or not it is registered in
+ * eventActions: see makeForwardingListener.
+ * @param listenerName - The name of one of the registered listener functions, or an
+ * already-resolved listener function.
+ * @param parent - The parent DomItem which is DomItemRoot which stores eventListeners property.
+ */
+declare const retrieveListener: (listenerName: string | ListenerFunction, parent?: DomItemRoot) => ListenerFunction;
+export default retrieveListener;

package/dist/events/functions/retrieveListener.js

@@ -0,0 +1,39 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+require("core-js/modules/es.array.includes.js");
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const documentItem_1 = __importDefault(require("../../domItem/objects/documentItem"));
+const makeForwardingListener_1 = __importDefault(require("./makeForwardingListener"));
+/**
+ * Based on the provided function / listener name, retrieve the associated function from the root domEvents.DomItem.
+ * If a raw function is passed instead of a registered name, it is returned as-is - see {@link EventListener}'s
+ * listenerFunc property for the tradeoffs of that discretionary path. When the root has forwardEvents set (render-
+ * only mode - see setForwardEvents), every name resolves to a forwarder instead, whether or not it is registered in
+ * eventActions: see makeForwardingListener.
+ * @param listenerName - The name of one of the registered listener functions, or an
+ * already-resolved listener function.
+ * @param parent - The parent DomItem which is DomItemRoot which stores eventListeners property.
+ */
+const retrieveListener = (listenerName, parent = (0, documentItem_1.default)()) => {
+  if (typeof listenerName === 'function') {
+    return listenerName;
+  }
+  if (parent.forwardEvents) {
+    return (0, makeForwardingListener_1.default)(listenerName, parent.forwardEvents);
+  }
+  if (!Object.keys(parent.eventActions).includes(listenerName)) {
+    throw new Error(`Undefined listener function on this DomItemRoot: ${listenerName}`);
+  }
+  return parent.eventActions[listenerName];
+};
+exports.default = retrieveListener;

package/dist/events/functions/retrieveListener.min.js

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/es.array.includes.js");var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const documentItem_1=__importDefault(require("../../domItem/objects/documentItem")),makeForwardingListener_1=__importDefault(require("./makeForwardingListener")),retrieveListener=(e,t=(0,documentItem_1.default)())=>{if("function"==typeof e)return e;if(t.forwardEvents)return(0,makeForwardingListener_1.default)(e,t.forwardEvents);if(!Object.keys(t.eventActions).includes(e))throw new Error(`Undefined listener function on this DomItemRoot: ${e}`);return t.eventActions[e]};exports.default=retrieveListener;

package/dist/events/functions/revokeActiveListeners.d.ts

@@ -0,0 +1,12 @@
+import type { DomItem } from '../../domItem/types';
+import type { EventName } from '../types';
+/**
+ * Detach every active listener for one event type from a DomItem's element, regardless of which EventListener
+ * descriptor each one belongs to, and clear that event's activeListeners bucket. Unlike {@link deactivateListener},
+ * this does not update the listenerActive/activeResponder state on the individual descriptors.
+ * @param eventName - The name of the trigger event whose active listeners will be revoked.
+ * @param item - The DomItem to revoke active listeners from.
+ * @returns The same DomItem, with all active listeners for this event detached.
+ */
+declare const revokeActiveListeners: (eventName: EventName, item: DomItem) => DomItem;
+export default revokeActiveListeners;

package/dist/events/functions/revokeActiveListeners.js

@@ -0,0 +1,54 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const si_funciona_1 = __importDefault(require("si-funciona"));
+const getListenerOptions_1 = __importDefault(require("../objects/options/getListenerOptions"));
+const numberToOptions_1 = __importDefault(require("../objects/options/numberToOptions"));
+const unassignListener_1 = __importDefault(require("./unassignListener"));
+/**
+ * Detach every active listener for one event type from a DomItem's element, regardless of which EventListener
+ * descriptor each one belongs to, and clear that event's activeListeners bucket. Unlike {@link deactivateListener},
+ * this does not update the listenerActive/activeResponder state on the individual descriptors.
+ * @param eventName - The name of the trigger event whose active listeners will be revoked.
+ * @param item - The DomItem to revoke active listeners from.
+ * @returns The same DomItem, with all active listeners for this event detached.
+ */
+const revokeActiveListeners = (eventName, item) => {
+  const listenerOptions = (0, getListenerOptions_1.default)();
+  const eventOptions = si_funciona_1.default.dotGet(item, `activeListeners.${eventName}`);
+  if (eventOptions === null) {
+    return item;
+  }
+  si_funciona_1.default.objectKeys(eventOptions).forEach(binaryOptions => {
+    const optionsToUse = (0, numberToOptions_1.default)(listenerOptions, parseInt(binaryOptions));
+    const usesSignal = !!optionsToUse.signal;
+    if (!usesSignal) {
+      // Abort signal must be undefined if it is not required.
+      delete optionsToUse.signal;
+    }
+    ;
+    item.activeListeners[eventName][Number(binaryOptions)].forEach(eventResponder => {
+      if (!eventResponder.assignedHandler) {
+        // never actually attached to the element, nothing to detach
+        return;
+      }
+      const finalOptions = usesSignal ? Object.assign({}, optionsToUse, {
+        signal: eventResponder.abort.signal
+      }) : optionsToUse;
+      (0, unassignListener_1.default)(eventName, item.element, eventResponder.assignedHandler, finalOptions);
+    });
+  });
+  delete item.activeListeners[eventName];
+  return item;
+};
+exports.default = revokeActiveListeners;

package/dist/events/functions/revokeActiveListeners.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const si_funciona_1=__importDefault(require("si-funciona")),getListenerOptions_1=__importDefault(require("../objects/options/getListenerOptions")),numberToOptions_1=__importDefault(require("../objects/options/numberToOptions")),unassignListener_1=__importDefault(require("./unassignListener")),revokeActiveListeners=(e,t)=>{const n=(0,getListenerOptions_1.default)(),s=si_funciona_1.default.dotGet(t,`activeListeners.${e}`);return null===s||(si_funciona_1.default.objectKeys(s).forEach(s=>{const i=(0,numberToOptions_1.default)(n,parseInt(s)),r=!!i.signal;r||delete i.signal,t.activeListeners[e][Number(s)].forEach(n=>{if(!n.assignedHandler)return;const s=r?Object.assign({},i,{signal:n.abort.signal}):i;(0,unassignListener_1.default)(e,t.element,n.assignedHandler,s)})}),delete t.activeListeners[e]),t};exports.default=revokeActiveListeners;

package/dist/events/functions/setForwardEvents.d.ts

@@ -0,0 +1,11 @@
+import type { DomItemRoot } from '../../domItem/types';
+import type { ForwardEventsFunction } from '../types';
+/**
+ * Switch the root item into render-only mode: every registered listener name resolves to a forwarder instead of a
+ * local function (see retrieveListener, makeForwardingListener), so no local listener functions need to be
+ * registered at all.
+ * @param transport - Called with the envelope of each forwarded event.
+ * @param parent - The parent DomItem which is DomItemRoot to switch into render-only mode.
+ */
+declare const setForwardEvents: (transport: ForwardEventsFunction, parent?: DomItemRoot) => DomItemRoot;
+export default setForwardEvents;

package/dist/events/functions/setForwardEvents.js

@@ -0,0 +1,26 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const documentItem_1 = __importDefault(require("../../domItem/objects/documentItem"));
+/**
+ * Switch the root item into render-only mode: every registered listener name resolves to a forwarder instead of a
+ * local function (see retrieveListener, makeForwardingListener), so no local listener functions need to be
+ * registered at all.
+ * @param transport - Called with the envelope of each forwarded event.
+ * @param parent - The parent DomItem which is DomItemRoot to switch into render-only mode.
+ */
+const setForwardEvents = (transport, parent = (0, documentItem_1.default)()) => {
+  parent.forwardEvents = transport;
+  return parent;
+};
+exports.default = setForwardEvents;

package/dist/events/functions/setForwardEvents.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const documentItem_1=__importDefault(require("../../domItem/objects/documentItem")),setForwardEvents=(e,t=(0,documentItem_1.default)())=>(t.forwardEvents=e,t);exports.default=setForwardEvents;

package/dist/events/functions/unassignListener.d.ts

@@ -0,0 +1,12 @@
+import type { EventHandler, ListenerOptions, ListenerTarget } from '../types';
+/**
+ * Provide compatibility for unassigning listeners.
+ * @param trigger - The name of the event which will trigger the listenerFunction on the element. (keyof HTMLElementEventMap)
+ * @param elem - An element to append the listener onto
+ * @param fn - The function which will be invoked when the
+ * event is triggered
+ * @param options - Additional options to how the event will be
+ * fired
+ */
+declare const unassignListener: (trigger: string, elem: ListenerTarget, fn: EventHandler, options?: ListenerOptions) => EventHandler;
+export default unassignListener;

package/dist/events/functions/unassignListener.js

@@ -0,0 +1,32 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const listenerOptions_1 = __importDefault(require("./listenerOptions"));
+/**
+ * Provide compatibility for unassigning listeners.
+ * @param trigger - The name of the event which will trigger the listenerFunction on the element. (keyof HTMLElementEventMap)
+ * @param elem - An element to append the listener onto
+ * @param fn - The function which will be invoked when the
+ * event is triggered
+ * @param options - Additional options to how the event will be
+ * fired
+ */
+const unassignListener = (trigger, elem, fn, options = false) => {
+  // Removing a listener may be done differently based on the browser support
+  if (elem.removeEventListener) {
+    // Latest support is provided from removeEventListener with the options parameter varying slightly
+    elem.removeEventListener(trigger, fn, (0, listenerOptions_1.default)(options));
+  }
+  return fn;
+};
+exports.default = unassignListener;

package/dist/events/functions/unassignListener.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const listenerOptions_1=__importDefault(require("./listenerOptions")),unassignListener=(e,t,n,r=!1)=>(t.removeEventListener&&t.removeEventListener(e,n,(0,listenerOptions_1.default)(r)),n);exports.default=unassignListener;

package/dist/events/index.d.ts

@@ -0,0 +1,37 @@
+declare const _default: {
+    activateListener: (eventName: import("./types").EventName, eventListener: import("./types").ListenerDescriptor, item: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    addEventListener: (eventName: import("./types").EventName, listenerFunction: string | import("./types").ListenerFunction, customArgs: object | null | undefined, options: import("./types").ListenerOptions | null | undefined, item: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    applyActiveListeners: (eventName: import("./types").EventName, item: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    assignListener: (trigger: string, elem: import("./types").ListenerTarget, fn: import("./types").EventHandler, options?: import("./types").ListenerOptions) => import("./types").EventHandler;
+    bindAllListeners: (item: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    bindElementListeners: (item: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    bindListeners: (item: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    deactivateListener: (eventName: import("./types").EventName, eventListener: import("./types").ListenerDescriptor, item: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    deactivateListeners: (item: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    findEventListener: (eventName: import("./types").EventName, listenerFunction: string | import("./types").ListenerFunction, customArgs: object | null | undefined, options: import("./types").ListenerOptions | null | undefined, item: import("../domItem/types").DomItem) => [number, import("./types").ListenerDescriptor | undefined];
+    fullAddEventListener: (eventName: import("./types").EventName, listener: import("./types").ListenerFunction, name: string | null | undefined, customArgs: object | null | undefined, options: import("./types").ListenerOptions | null | undefined, item: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    fullRemoveEventListener: (eventName: import("./types").EventName, listener: import("./types").ListenerFunction, name: string | null | undefined, customArgs: object | null | undefined, options: import("./types").ListenerOptions | null | undefined, item: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    listenerOptions: {
+        (options?: import("./types").ListenerOptions | null): import("./types").ListenerOptions | null;
+        supportsOptions?: boolean;
+    };
+    makeEventHandler: (listener: import("./types").ListenerFunction, item: import("../domItem/types").DomItem, ...args: unknown[]) => import("./types").EventHandler;
+    makeForwardingListener: (listenerName: string, transport: import("./types").ForwardEventsFunction) => import("./types").ListenerFunction;
+    receiveForwardedEvent: (root: import("../domItem/types").DomItemRoot, envelope: import("./types").ForwardedEvent, validator?: import("./functions/receiveForwardedEvent").ForwardedEventValidator) => void;
+    registerListener: (listener: import("./types").ListenerFunction, name?: string, parent?: import("../domItem/types").DomItemRoot) => Record<string, import("./types").ListenerFunction>;
+    registerListeners: (listeners: import("./types").ListenerFunction[] | Record<string, import("./types").ListenerFunction>, parent?: import("../domItem/types").DomItemRoot) => import("../domItem/types").DomItemRoot;
+    removeEventListener: (eventName: import("./types").EventName, listenerFunction: string | import("./types").ListenerFunction, customArgs: object | null | undefined, options: import("./types").ListenerOptions | null | undefined, item: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    retrieveListener: (listenerName: string | import("./types").ListenerFunction, parent?: import("../domItem/types").DomItemRoot) => import("./types").ListenerFunction;
+    revokeActiveListeners: (eventName: import("./types").EventName, item: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    setForwardEvents: (transport: import("./types").ForwardEventsFunction, parent?: import("../domItem/types").DomItemRoot) => import("../domItem/types").DomItemRoot;
+    unassignListener: (trigger: string, elem: import("./types").ListenerTarget, fn: import("./types").EventHandler, options?: import("./types").ListenerOptions) => import("./types").EventHandler;
+    createEventListener: ({ listenerFunc, listenerArgs, listenerOptions, listenerActive }?: Partial<import("./types").ListenerDescriptor>) => import("./types").ListenerDescriptor;
+    createEventProxy: (event: Event, item: import("../domItem/types").DomItem) => import("./types").EventProxy;
+    createEventResponder: (eventHandler: import("./types").EventHandler, abort?: AbortController | boolean | null) => import("./types").EventResponder;
+    options: {
+        getListenerOptions: () => import("./types").OptionsTemplate;
+        numberToOptions: (optionsTemplate: import("./types").OptionsTemplate, binaryOptions: number) => import("./types").OptionsObject;
+        optionsToNumber: (optionsTemplate: import("./types").OptionsTemplate, listenerOptions?: import("./types").ListenerOptions | null) => number;
+    };
+};
+export default _default;

package/dist/events/index.js

@@ -0,0 +1,72 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+/**
+ * Setting up and handling events for items in a Virtual DOM (DomItem tree)
+ */
+const activateListener_1 = __importDefault(require("./functions/activateListener"));
+const addEventListener_1 = __importDefault(require("./functions/addEventListener"));
+const applyActiveListeners_1 = __importDefault(require("./functions/applyActiveListeners"));
+const assignListener_1 = __importDefault(require("./functions/assignListener"));
+const bindAllListeners_1 = __importDefault(require("./functions/bindAllListeners"));
+const bindElementListeners_1 = __importDefault(require("./functions/bindElementListeners"));
+const bindListeners_1 = __importDefault(require("./functions/bindListeners"));
+const deactivateListener_1 = __importDefault(require("./functions/deactivateListener"));
+const deactivateListeners_1 = __importDefault(require("./functions/deactivateListeners"));
+const findEventListener_1 = __importDefault(require("./functions/findEventListener"));
+const fullAddEventListener_1 = __importDefault(require("./functions/fullAddEventListener"));
+const fullRemoveEventListener_1 = __importDefault(require("./functions/fullRemoveEventListener"));
+const listenerOptions_1 = __importDefault(require("./functions/listenerOptions"));
+const makeEventHandler_1 = __importDefault(require("./functions/makeEventHandler"));
+const makeForwardingListener_1 = __importDefault(require("./functions/makeForwardingListener"));
+const receiveForwardedEvent_1 = __importDefault(require("./functions/receiveForwardedEvent"));
+const registerListener_1 = __importDefault(require("./functions/registerListener"));
+const registerListeners_1 = __importDefault(require("./functions/registerListeners"));
+const removeEventListener_1 = __importDefault(require("./functions/removeEventListener"));
+const retrieveListener_1 = __importDefault(require("./functions/retrieveListener"));
+const revokeActiveListeners_1 = __importDefault(require("./functions/revokeActiveListeners"));
+const setForwardEvents_1 = __importDefault(require("./functions/setForwardEvents"));
+const unassignListener_1 = __importDefault(require("./functions/unassignListener"));
+const createEventListener_1 = __importDefault(require("./objects/createEventListener"));
+const createEventProxy_1 = __importDefault(require("./objects/createEventProxy"));
+const createEventResponder_1 = __importDefault(require("./objects/createEventResponder"));
+const options_1 = __importDefault(require("./objects/options"));
+exports.default = {
+  activateListener: activateListener_1.default,
+  addEventListener: addEventListener_1.default,
+  applyActiveListeners: applyActiveListeners_1.default,
+  assignListener: assignListener_1.default,
+  bindAllListeners: bindAllListeners_1.default,
+  bindElementListeners: bindElementListeners_1.default,
+  bindListeners: bindListeners_1.default,
+  deactivateListener: deactivateListener_1.default,
+  deactivateListeners: deactivateListeners_1.default,
+  findEventListener: findEventListener_1.default,
+  fullAddEventListener: fullAddEventListener_1.default,
+  fullRemoveEventListener: fullRemoveEventListener_1.default,
+  listenerOptions: listenerOptions_1.default,
+  makeEventHandler: makeEventHandler_1.default,
+  makeForwardingListener: makeForwardingListener_1.default,
+  receiveForwardedEvent: receiveForwardedEvent_1.default,
+  registerListener: registerListener_1.default,
+  registerListeners: registerListeners_1.default,
+  removeEventListener: removeEventListener_1.default,
+  retrieveListener: retrieveListener_1.default,
+  revokeActiveListeners: revokeActiveListeners_1.default,
+  setForwardEvents: setForwardEvents_1.default,
+  unassignListener: unassignListener_1.default,
+  createEventListener: createEventListener_1.default,
+  createEventProxy: createEventProxy_1.default,
+  createEventResponder: createEventResponder_1.default,
+  options: options_1.default
+};

package/dist/events/index.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const activateListener_1=__importDefault(require("./functions/activateListener")),addEventListener_1=__importDefault(require("./functions/addEventListener")),applyActiveListeners_1=__importDefault(require("./functions/applyActiveListeners")),assignListener_1=__importDefault(require("./functions/assignListener")),bindAllListeners_1=__importDefault(require("./functions/bindAllListeners")),bindElementListeners_1=__importDefault(require("./functions/bindElementListeners")),bindListeners_1=__importDefault(require("./functions/bindListeners")),deactivateListener_1=__importDefault(require("./functions/deactivateListener")),deactivateListeners_1=__importDefault(require("./functions/deactivateListeners")),findEventListener_1=__importDefault(require("./functions/findEventListener")),fullAddEventListener_1=__importDefault(require("./functions/fullAddEventListener")),fullRemoveEventListener_1=__importDefault(require("./functions/fullRemoveEventListener")),listenerOptions_1=__importDefault(require("./functions/listenerOptions")),makeEventHandler_1=__importDefault(require("./functions/makeEventHandler")),makeForwardingListener_1=__importDefault(require("./functions/makeForwardingListener")),receiveForwardedEvent_1=__importDefault(require("./functions/receiveForwardedEvent")),registerListener_1=__importDefault(require("./functions/registerListener")),registerListeners_1=__importDefault(require("./functions/registerListeners")),removeEventListener_1=__importDefault(require("./functions/removeEventListener")),retrieveListener_1=__importDefault(require("./functions/retrieveListener")),revokeActiveListeners_1=__importDefault(require("./functions/revokeActiveListeners")),setForwardEvents_1=__importDefault(require("./functions/setForwardEvents")),unassignListener_1=__importDefault(require("./functions/unassignListener")),createEventListener_1=__importDefault(require("./objects/createEventListener")),createEventProxy_1=__importDefault(require("./objects/createEventProxy")),createEventResponder_1=__importDefault(require("./objects/createEventResponder")),options_1=__importDefault(require("./objects/options"));exports.default={activateListener:activateListener_1.default,addEventListener:addEventListener_1.default,applyActiveListeners:applyActiveListeners_1.default,assignListener:assignListener_1.default,bindAllListeners:bindAllListeners_1.default,bindElementListeners:bindElementListeners_1.default,bindListeners:bindListeners_1.default,deactivateListener:deactivateListener_1.default,deactivateListeners:deactivateListeners_1.default,findEventListener:findEventListener_1.default,fullAddEventListener:fullAddEventListener_1.default,fullRemoveEventListener:fullRemoveEventListener_1.default,listenerOptions:listenerOptions_1.default,makeEventHandler:makeEventHandler_1.default,makeForwardingListener:makeForwardingListener_1.default,receiveForwardedEvent:receiveForwardedEvent_1.default,registerListener:registerListener_1.default,registerListeners:registerListeners_1.default,removeEventListener:removeEventListener_1.default,retrieveListener:retrieveListener_1.default,revokeActiveListeners:revokeActiveListeners_1.default,setForwardEvents:setForwardEvents_1.default,unassignListener:unassignListener_1.default,createEventListener:createEventListener_1.default,createEventProxy:createEventProxy_1.default,createEventResponder:createEventResponder_1.default,options:options_1.default};

package/dist/events/objects/createEventListener.d.ts

@@ -0,0 +1,13 @@
+import type { ListenerDescriptor } from '../types';
+/**
+ * Prepare an eventListener object to attach to a DOMItem
+ * @param listenerProperties
+ * @param listenerProperties.listenerFunc - The function or name (string) of the listener
+ * action - see {@link EventListener}'s listenerFunc property for when to use which.
+ * @param listenerProperties.listenerArgs - Additional parameters to apply to the function
+ * @param listenerProperties.listenerOptions - The listener options to apply to the element
+ * @param listenerProperties.listenerActive - Flag for listener applied to element
+ * @returns An EventListener descriptor ready to be pushed onto a DomItem's eventListeners
+ */
+declare const createEventListener: ({ listenerFunc, listenerArgs, listenerOptions, listenerActive }?: Partial<ListenerDescriptor>) => ListenerDescriptor;
+export default createEventListener;

package/dist/events/objects/createEventListener.js

@@ -0,0 +1,30 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+/**
+ * Prepare an eventListener object to attach to a DOMItem
+ * @param listenerProperties
+ * @param listenerProperties.listenerFunc - The function or name (string) of the listener
+ * action - see {@link EventListener}'s listenerFunc property for when to use which.
+ * @param listenerProperties.listenerArgs - Additional parameters to apply to the function
+ * @param listenerProperties.listenerOptions - The listener options to apply to the element
+ * @param listenerProperties.listenerActive - Flag for listener applied to element
+ * @returns An EventListener descriptor ready to be pushed onto a DomItem's eventListeners
+ */
+const createEventListener = ({
+  listenerFunc,
+  listenerArgs = null,
+  listenerOptions = false,
+  listenerActive = false
+} = {}) => ({
+  listenerFunc: listenerFunc,
+  listenerArgs,
+  listenerOptions,
+  listenerActive
+});
+exports.default = createEventListener;

package/dist/events/objects/createEventListener.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const createEventListener=({listenerFunc:e,listenerArgs:t=null,listenerOptions:s=!1,listenerActive:n=!1}={})=>({listenerFunc:e,listenerArgs:t,listenerOptions:s,listenerActive:n});exports.default=createEventListener;

package/dist/events/objects/createEventProxy.d.ts

@@ -0,0 +1,10 @@
+import type { DomItem } from '../../domItem/types';
+import type { EventProxy } from '../types';
+/**
+ * Return a modified version of the event: adds domItemTarget and currentDomItemTarget, next to the real DOM's own
+ * target and currentTarget.
+ * @param event
+ * @param item - The DomItem the listener is attached to (this event's currentTarget).
+ */
+declare const createEventProxy: (event: Event, item: DomItem) => EventProxy;
+export default createEventProxy;

package/dist/events/objects/createEventProxy.js

@@ -0,0 +1,48 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const getItemByElement_1 = __importDefault(require("../../domItem/query/getItemByElement"));
+/**
+ * Return a modified version of the event: adds domItemTarget and currentDomItemTarget, next to the real DOM's own
+ * target and currentTarget.
+ * @param event
+ * @param item - The DomItem the listener is attached to (this event's currentTarget).
+ */
+const createEventProxy = (event, item) => new Proxy(Object.defineProperties(event, {
+  immediatePropagationStopped: {
+    enumerable: true,
+    value: false,
+    writable: true
+  },
+  currentDomItemTarget: {
+    enumerable: true,
+    value: item,
+    writable: true
+  },
+  domItemTarget: {
+    enumerable: true,
+    value: (0, getItemByElement_1.default)(item, event.target),
+    writable: true
+  }
+}), {
+  get(thisEvent, prop) {
+    if (prop === 'stopImmediatePropagation') {
+      thisEvent.immediatePropagationStopped = true;
+    }
+    // Read from the event itself rather than the proxy: Event's methods and accessors rely on internal slots
+    // (private fields since Node 24), which throw when `this` is the proxy.
+    const value = Reflect.get(thisEvent, prop);
+    return typeof value === 'function' && prop !== 'constructor' ? value.bind(thisEvent) : value;
+  }
+});
+exports.default = createEventProxy;

package/dist/events/objects/createEventProxy.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const getItemByElement_1=__importDefault(require("../../domItem/query/getItemByElement")),createEventProxy=(e,t)=>new Proxy(Object.defineProperties(e,{immediatePropagationStopped:{enumerable:!0,value:!1,writable:!0},currentDomItemTarget:{enumerable:!0,value:t,writable:!0},domItemTarget:{enumerable:!0,value:(0,getItemByElement_1.default)(t,e.target),writable:!0}}),{get(e,t){"stopImmediatePropagation"===t&&(e.immediatePropagationStopped=!0);const r=Reflect.get(e,t);return"function"==typeof r&&"constructor"!==t?r.bind(e):r}});exports.default=createEventProxy;

package/dist/events/objects/createEventResponder.d.ts

@@ -0,0 +1,8 @@
+import type { EventHandler, EventResponder } from '../types';
+/**
+ * Store the handler function and associated abort controller instance if available to be used when events are triggered.
+ * @param eventHandler - The eventHandler wrapped function to be called for the event.
+ * @param abort - Assign an AbortSignal provided or create one (if true), otherwise null.
+ */
+declare const createEventResponder: (eventHandler: EventHandler, abort?: AbortController | boolean | null) => EventResponder;
+export default createEventResponder;

package/dist/events/objects/createEventResponder.js

@@ -0,0 +1,27 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+/**
+ * Store the handler function and associated abort controller instance if available to be used when events are triggered.
+ * @param eventHandler - The eventHandler wrapped function to be called for the event.
+ * @param abort - Assign an AbortSignal provided or create one (if true), otherwise null.
+ */
+const createEventResponder = (eventHandler, abort = null) => {
+  if (abort === true) {
+    abort = new AbortController();
+  }
+  if (abort === false) {
+    abort = null;
+  }
+  return Object.assign({}, {
+    handler: eventHandler,
+    abort,
+    assignedHandler: null
+  });
+};
+exports.default = createEventResponder;

package/dist/events/objects/createEventResponder.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const createEventResponder=(e,t=null)=>(!0===t&&(t=new AbortController),!1===t&&(t=null),Object.assign({},{handler:e,abort:t,assignedHandler:null}));exports.default=createEventResponder;

package/dist/events/objects/options/getListenerOptions.d.ts

@@ -0,0 +1,6 @@
+import type { OptionsTemplate } from '../../types';
+/**
+ * Retrieve the OptionsTemplate for EventListenerOptions.
+ */
+declare const getListenerOptions: () => OptionsTemplate;
+export default getListenerOptions;

package/dist/events/objects/options/getListenerOptions.js

@@ -0,0 +1,22 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const CAPTURE = 1;
+const ONCE = 2;
+const PASSIVE = 4;
+const SIGNAL = 8;
+/**
+ * Retrieve the OptionsTemplate for EventListenerOptions.
+ */
+const getListenerOptions = () => ({
+  capture: CAPTURE,
+  once: ONCE,
+  passive: PASSIVE,
+  signal: SIGNAL
+});
+exports.default = getListenerOptions;

package/dist/events/objects/options/getListenerOptions.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const CAPTURE=1,ONCE=2,PASSIVE=4,SIGNAL=8,getListenerOptions=()=>({capture:1,once:2,passive:4,signal:8});exports.default=getListenerOptions;

package/dist/events/objects/options/numberToOptions.d.ts

@@ -0,0 +1,8 @@
+import type { OptionsObject, OptionsTemplate } from '../../types';
+/**
+ * Take an integer representation of the listener options and convert them to the listener options object.
+ * @param optionsTemplate
+ * @param binaryOptions
+ */
+declare const numberToOptions: (optionsTemplate: OptionsTemplate, binaryOptions: number) => OptionsObject;
+export default numberToOptions;