treeloom 0.0.0-stage → 2.0.0

package/dist/events/functions/fullRemoveEventListener.js

@@ -0,0 +1,37 @@
+"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 removeEventListener_1 = __importDefault(require("./removeEventListener"));
+/**
+ * Find and remove a listener that was registered by name (e.g. via {@link fullAddEventListener}) - the counterpart
+ * to fullAddEventListener. Resolves name the same way fullAddEventListener defaults it, so a caller only needs the
+ * original listener function (not the internal name string it was registered under) to remove it:
+ * 1. Resolve name (defaults to listener.name, same as {@link fullAddEventListener}).
+ * 2. {@link removeEventListener} - find the descriptor by that name, detach it from the element if active, and
+ *    splice it out of item.eventListeners.
+ *
+ * Does not remove the function from the root DomItem's eventActions registry, since that name may still be shared
+ * by other DomItems - see {@link registerListener}.
+ * @param eventName - The name of the trigger event (e.g. 'click').
+ * @param listener - The same function originally passed to fullAddEventListener.
+ * @param name - The name the listener was registered under in eventActions.
+ * @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 fullRemoveEventListener = (eventName, listener, name, customArgs, options, item) => {
+  const listenerName = name ?? listener.name;
+  return (0, removeEventListener_1.default)(eventName, listenerName, customArgs, options, item);
+};
+exports.default = fullRemoveEventListener;

package/dist/events/functions/fullRemoveEventListener.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 removeEventListener_1=__importDefault(require("./removeEventListener")),fullRemoveEventListener=(e,t,r,n,o,u)=>{const s=r??t.name;return(0,removeEventListener_1.default)(e,s,n,o,u)};exports.default=fullRemoveEventListener;

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

@@ -0,0 +1,12 @@
+import type { ListenerOptions } from '../types';
+/** The options which will be used, and a flag remembering whether the browser understands an options object. */
+type ListenerOptionsSupport = {
+    (options?: ListenerOptions | null): ListenerOptions | null;
+    supportsOptions?: boolean;
+};
+/**
+ * Provide compatibility for using the options parameter of addEventListener
+ * @param options - An object or boolean with the listener options
+ */
+declare const listenerOptions: ListenerOptionsSupport;
+export default listenerOptions;

package/dist/events/functions/listenerOptions.js

@@ -0,0 +1,31 @@
+"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
+});
+/**
+ * Provide compatibility for using the options parameter of addEventListener
+ * @param options - An object or boolean with the listener options
+ */
+const listenerOptions = options => {
+  if (typeof listenerOptions.supportsOptions === 'undefined') {
+    // Check if supportsOptions has been defined. This is a compatibility checking flag.
+    listenerOptions.supportsOptions = true;
+    try {
+      // If it is possible to use OptionsObject, then set our flag to true
+      window.addEventListener('test', null, {
+        capture: false,
+        once: false,
+        passive: false
+      });
+    } catch (err) {
+      // When using an OptionsObjects fails, it is only possible to pass the boolean UseCapture as the option
+      listenerOptions.supportsOptions = false;
+    }
+  }
+  return typeof options === 'object' && listenerOptions.supportsOptions ? options : false;
+};
+exports.default = listenerOptions;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const listenerOptions=t=>{if(void 0===listenerOptions.supportsOptions){listenerOptions.supportsOptions=!0;try{window.addEventListener("test",null,{capture:!1,once:!1,passive:!1})}catch(t){listenerOptions.supportsOptions=!1}}return!("object"!=typeof t||!listenerOptions.supportsOptions)&&t};exports.default=listenerOptions;

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

@@ -0,0 +1,10 @@
+import type { DomItem } from '../../domItem/types';
+import type { EventHandler, ListenerFunction } from '../types';
+/**
+ * Prepare a listener to be used before assigning to an element.
+ * @param listener
+ * @param item
+ * @param args
+ */
+declare const makeEventHandler: (listener: ListenerFunction, item: DomItem, ...args: unknown[]) => EventHandler;
+export default makeEventHandler;

package/dist/events/functions/makeEventHandler.js

@@ -0,0 +1,23 @@
+"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 a listener to be used before assigning to an element.
+ * @param listener
+ * @param item
+ * @param args
+ */
+const makeEventHandler = (listener, item, ...args) => {
+  return event => {
+    if (!event || event.immediatePropagationStopped) {
+      return event;
+    }
+    return listener(event, item, ...args);
+  };
+};
+exports.default = makeEventHandler;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const makeEventHandler=(e,t,...a)=>o=>!o||o.immediatePropagationStopped?o:e(o,t,...a);exports.default=makeEventHandler;

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

@@ -0,0 +1,11 @@
+import type { ForwardEventsFunction, ListenerFunction } from '../types';
+/**
+ * Build the listener function used in render-only mode: instead of running real logic locally, it packages the
+ * event as a plain envelope (the id of the item it fired on, the event type, the registered listener name, any
+ * custom args, and any live target state - see captureTargetState) and hands it to the injected transport
+ * function. See retrieveListener.
+ * @param listenerName - The registered name this forwarder stands in for.
+ * @param transport - Where the envelope is sent (set on the root item with setForwardEvents).
+ */
+declare const makeForwardingListener: (listenerName: string, transport: ForwardEventsFunction) => ListenerFunction;
+export default makeForwardingListener;

package/dist/events/functions/makeForwardingListener.js

@@ -0,0 +1,46 @@
+"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");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+/** Form-control elements whose state a listener might read directly off the event target. */
+const FORM_CONTROL_TAGS = ['INPUT', 'SELECT', 'TEXTAREA'];
+/**
+ * Whatever live state a listener commonly reads directly off the real event's target - a checkbox's checked, an
+ * input's value - captured here since the receiving end's corresponding element is otherwise an independent object
+ * with no way to know what the user actually set. Omitted for anything that is not a form control (every element
+ * has a non-undefined value or checked is not a safe enough check on its own - a plain button also has a value,
+ * defaulting to '', and any input has checked defaulting to false even when it is not a checkbox).
+ * @param target
+ */
+const captureTargetState = target => {
+  const element = target;
+  if (!element || !FORM_CONTROL_TAGS.includes(element.tagName)) {
+    return undefined;
+  }
+  return element.type === 'checkbox' || element.type === 'radio' ? {
+    checked: element.checked
+  } : {
+    value: element.value
+  };
+};
+/**
+ * Build the listener function used in render-only mode: instead of running real logic locally, it packages the
+ * event as a plain envelope (the id of the item it fired on, the event type, the registered listener name, any
+ * custom args, and any live target state - see captureTargetState) and hands it to the injected transport
+ * function. See retrieveListener.
+ * @param listenerName - The registered name this forwarder stands in for.
+ * @param transport - Where the envelope is sent (set on the root item with setForwardEvents).
+ */
+const makeForwardingListener = (listenerName, transport) => (event, item, ...args) => transport({
+  itemId: (event.domItemTarget ?? item).id,
+  eventType: event.type,
+  listenerFunc: listenerName,
+  data: args,
+  targetState: captureTargetState(event.target)
+});
+exports.default = makeForwardingListener;

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

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/es.array.includes.js"),Object.defineProperty(exports,"__esModule",{value:!0});const FORM_CONTROL_TAGS=["INPUT","SELECT","TEXTAREA"],captureTargetState=e=>{const t=e;if(t&&FORM_CONTROL_TAGS.includes(t.tagName))return"checkbox"===t.type||"radio"===t.type?{checked:t.checked}:{value:t.value}},makeForwardingListener=(e,t)=>(r,a,...c)=>t({itemId:(r.domItemTarget??a).id,eventType:r.type,listenerFunc:e,data:c,targetState:captureTargetState(r.target)});exports.default=makeForwardingListener;

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

@@ -0,0 +1,23 @@
+import type { DomItem, DomItemRoot } from '../../domItem/types';
+import type { ForwardedEvent } from '../types';
+/**
+ * Decides whether a resolved, incoming envelope may actually be dispatched. See receiveForwardedEvent's own
+ * validator parameter - an id only makes resolution correct, not authorized, so anything that needs to check
+ * who an id actually belongs to (not just that it resolves to a real item) plugs in here.
+ */
+export type ForwardedEventValidator = (resolvedItem: DomItem, envelope: ForwardedEvent) => boolean;
+/**
+ * The receiving end of makeForwardingListener's envelope: resolve the item it was built for, replay any live target
+ * state it carried onto that item's real element (see captureTargetState in makeForwardingListener), then dispatch
+ * a real event of the same type on it. The resolved item's own, already-bound listener runs exactly as it would for
+ * a genuine local event - nothing here needs to know what that listener does.
+ * @param root - The tree to resolve the envelope's itemId against. Its listeners must be the real ones (not
+ * itself set up with setForwardEvents), or this would just forward the event again instead of running it.
+ * @param envelope - As produced by makeForwardingListener on the sending end.
+ * @param validator - Optional: when given and it returns false for the resolved item, the event is never
+ * dispatched. Resolving by id is correct (it finds the right item even if this root's own tree shape differs
+ * from the sender's), but not authorized on its own - a validator is the one place to plug an ownership check
+ * in, instead of every caller re-deriving "resolve first, then check, then dispatch" by hand.
+ */
+declare const receiveForwardedEvent: (root: DomItemRoot, envelope: ForwardedEvent, validator?: ForwardedEventValidator) => void;
+export default receiveForwardedEvent;

package/dist/events/functions/receiveForwardedEvent.js

@@ -0,0 +1,40 @@
+"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 itemIdIndex_1 = require("../../domItem/tree/itemIdIndex");
+/**
+ * The receiving end of makeForwardingListener's envelope: resolve the item it was built for, replay any live target
+ * state it carried onto that item's real element (see captureTargetState in makeForwardingListener), then dispatch
+ * a real event of the same type on it. The resolved item's own, already-bound listener runs exactly as it would for
+ * a genuine local event - nothing here needs to know what that listener does.
+ * @param root - The tree to resolve the envelope's itemId against. Its listeners must be the real ones (not
+ * itself set up with setForwardEvents), or this would just forward the event again instead of running it.
+ * @param envelope - As produced by makeForwardingListener on the sending end.
+ * @param validator - Optional: when given and it returns false for the resolved item, the event is never
+ * dispatched. Resolving by id is correct (it finds the right item even if this root's own tree shape differs
+ * from the sender's), but not authorized on its own - a validator is the one place to plug an ownership check
+ * in, instead of every caller re-deriving "resolve first, then check, then dispatch" by hand.
+ */
+const receiveForwardedEvent = (root, envelope, validator) => {
+  const resolvedItem = (0, itemIdIndex_1.getItemById)(root, envelope.itemId);
+  if (validator && !validator(resolvedItem, envelope)) {
+    return;
+  }
+  const element = resolvedItem.element;
+  if (!element) {
+    throw new Error('The resolved item has no element to dispatch the event on.');
+  }
+  if (envelope.targetState) {
+    Object.assign(element, envelope.targetState);
+  }
+  element.dispatchEvent(new Event(envelope.eventType, {
+    bubbles: true,
+    cancelable: true
+  }));
+};
+exports.default = receiveForwardedEvent;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const itemIdIndex_1=require("../../domItem/tree/itemIdIndex"),receiveForwardedEvent=(e,t,r)=>{const n=(0,itemIdIndex_1.getItemById)(e,t.itemId);if(r&&!r(n,t))return;const d=n.element;if(!d)throw new Error("The resolved item has no element to dispatch the event on.");t.targetState&&Object.assign(d,t.targetState),d.dispatchEvent(new Event(t.eventType,{bubbles:!0,cancelable:!0}))};exports.default=receiveForwardedEvent;

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

@@ -0,0 +1,11 @@
+import type { DomItemRoot } from '../../domItem/types';
+import type { ListenerFunction } from '../types';
+/**
+ * Register a single listener function as part of the root domEvents.DomItem.
+ * @param listener - Provide a function which will be called
+ * when a Dom event is triggered.
+ * @param name - The name of the listener to be used.
+ * @param parent - The parent DomItem which is DomItemRoot which stores eventListeners property.
+ */
+declare const registerListener: (listener: ListenerFunction, name?: string, parent?: DomItemRoot) => Record<string, ListenerFunction>;
+export default registerListener;

package/dist/events/functions/registerListener.js

@@ -0,0 +1,25 @@
+"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"));
+/**
+ * Register a single listener function as part of the root domEvents.DomItem.
+ * @param listener - Provide a function which will be called
+ * when a Dom event is triggered.
+ * @param name - The name of the listener to be used.
+ * @param parent - The parent DomItem which is DomItemRoot which stores eventListeners property.
+ */
+const registerListener = (listener, name = listener.name, parent = (0, documentItem_1.default)()) => Object.assign(parent.eventActions, {
+  [name]: listener
+});
+exports.default = registerListener;

package/dist/events/functions/registerListener.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")),registerListener=(e,t=e.name,r=(0,documentItem_1.default)())=>Object.assign(r.eventActions,{[t]:e});exports.default=registerListener;

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

@@ -0,0 +1,10 @@
+import type { DomItemRoot } from '../../domItem/types';
+import type { ListenerFunction } from '../types';
+/**
+ * Register multiple listeners from an array of functions.
+ * @param listeners - An array of functions to be
+ * used as the registered event listeners.
+ * @param parent - The parent DomItem which is DomItemRoot which has eventActions property.
+ */
+declare const registerListeners: (listeners: ListenerFunction[] | Record<string, ListenerFunction>, parent?: DomItemRoot) => DomItemRoot;
+export default registerListeners;

package/dist/events/functions/registerListeners.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 si_funciona_1 = __importDefault(require("si-funciona"));
+const documentItem_1 = __importDefault(require("../../domItem/objects/documentItem"));
+/**
+ * Register multiple listeners from an array of functions.
+ * @param listeners - An array of functions to be
+ * used as the registered event listeners.
+ * @param parent - The parent DomItem which is DomItemRoot which has eventActions property.
+ */
+const registerListeners = (listeners, parent = (0, documentItem_1.default)()) => {
+  si_funciona_1.default.mergeObjectsMutable(parent.eventActions, listeners);
+  return parent;
+};
+exports.default = registerListeners;

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;