treeloom 0.0.0-stage → 2.1.0

package/dist/domItem/tree/setParentItemReferences.js

@@ -0,0 +1,24 @@
+"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
+});
+/**
+ * For each child of this item, set the parentItem references.
+ * @param item - The DomItem to have parent references applied.
+ */
+const setParentItemReferences = item => {
+  if (!item.children || !item.children.length) {
+    item.children = [];
+    return item;
+  }
+  item.children.forEach(child => {
+    child.parentItem = item;
+    setParentItemReferences(child);
+  });
+  return item;
+};
+exports.default = setParentItemReferences;

package/dist/domItem/tree/setParentItemReferences.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const setParentItemReferences=e=>e.children&&e.children.length?(e.children.forEach(t=>{t.parentItem=e,setParentItemReferences(t)}),e):(e.children=[],e);exports.default=setParentItemReferences;

package/dist/domItem/types.d.ts

@@ -0,0 +1,131 @@
+import type { EventListeners, EventName, EventResponder, ForwardEventsFunction, ListenerFunction } from '../events/types';
+/** CSS property names (written in camelCase, like element.style) and their values. */
+export type StyleValues = {
+    [property: string]: string;
+};
+/** A value an attribute can have. Objects are only used for the style attribute. */
+export type AttributeValue = string | number | boolean | StyleValues | null | undefined;
+/** All the HTML attributes of an element (className, style, id, innerHTML, data attributes, ...). */
+export type Attributes = {
+    className?: string;
+    style?: StyleValues;
+    /** The native custom element name (a customized built-in): <button is="fancy-button">. */
+    is?: string;
+    [attribute: string]: AttributeValue;
+};
+/** A real node which a DomItem is mirrored onto. */
+export type DomElement = HTMLElement | Text | Comment | Document;
+/** The path from the root to an item: each level's index among its parent's children, top-down. An empty array
+ * means the item is the root itself. See getItemPath, getItemByPath. */
+export type ItemPath = number[];
+/** The parent of the root DomItem is an empty object (a null parent means the item is detached). */
+export type EmptyParent = Record<string, never>;
+/**
+ * The traits an item can have, and the data each one puts on it. treeloom has one - render - and other libraries
+ * add theirs by declaration merging:
+ *
+ *     declare module 'treeloom/dist/domItem/types' {
+ *       interface TraitRegistry { 'matrix.row': { axis: 'y' } }
+ *     }
+ */
+export interface TraitRegistry {
+    /** The item has a place for a real element (it stays null until the item is rendered). */
+    render: RenderProperties;
+}
+/** The name of a trait. */
+export type TraitName = keyof TraitRegistry;
+/** The traits an item has: a map of trait name to true. */
+export type HasMap = {
+    [Trait in TraitName]?: true;
+};
+/** What the render trait puts on an item. */
+export type RenderProperties = {
+    /** The real node this item is mirrored onto, or null while there is none. */
+    element: DomElement | null;
+    /** Generated: the listeners which are attached to the element, by event name. */
+    activeListeners?: Record<EventName, Record<number, EventResponder[]>>;
+};
+type UnionToIntersection<Union> = (Union extends unknown ? (member: Union) => void : never) extends (member: infer All) => void ? All : never;
+/** What an item gains from having all of these traits: they are in its has map, and their data is on it. */
+export type WithTraits<Trait extends TraitName> = {
+    has: {
+        [Name in Trait]: true;
+    };
+} & UnionToIntersection<TraitRegistry[Trait]>;
+/** The properties every item has, whatever traits it carries. */
+export type CoreProperties = {
+    attributes: Attributes;
+    /** All the events to be registered for the element. */
+    eventListeners: Record<EventName, EventListeners>;
+    /** The traits this item has (see TraitRegistry). */
+    has: HasMap;
+    /** Assigned once at creation (see createCoreItem) and never reassigned, including across a clone or a JSON
+     * round-trip: the stable identity getItemById resolves by, independent of the item's current position in
+     * the tree (which a client's own tree may not match exactly - see ForwardedEvent's itemId). */
+    id: number;
+    /** Property names to leave out when converting to json. */
+    jsonExclusions: string[];
+    /** Any document node name: a tag name, #text, #comment or #document. */
+    nodeName: string;
+    /** The text of a text or comment node, null for elements. */
+    nodeValue: string | null;
+    /** Attach a child to this item. */
+    appendChild(child: CoreItem): CoreItem;
+    /** Detach a child from this item (and its element, when it has one). */
+    removeChild(child: CoreItem): CoreItem[];
+};
+/**
+ * The generic item: one node of a tree, with the traits it carries. A back-end item which is never rendered is a
+ * CoreItem; use hasTrait to find out what else it has.
+ */
+export type CoreItem = CoreProperties & {
+    children: CoreItem[];
+    /** The parent item: an empty object for the root, null for an item which is not attached. */
+    parentItem: CoreItem | EmptyParent | null;
+};
+/**
+ * An item with the render trait: the item treeloom mirrors onto a real element (render) and reads back from one
+ * (sync). Its children have the render trait too.
+ */
+export type DomItem = CoreProperties & WithTraits<'render'> & {
+    children: DomItem[];
+    parentItem: DomItem | EmptyParent | null;
+    appendChild(child: DomItem): DomItem;
+    removeChild(child: DomItem): DomItem[];
+};
+/**
+ * What can be given to build an item: any of its properties (the children may be plain configs as well), plus any
+ * custom data. Whatever is left out gets its default.
+ */
+export type DomItemConfig = Partial<Omit<CoreProperties, 'appendChild' | 'removeChild'>> & Partial<RenderProperties> & {
+    children?: DomItemConfig[];
+    parentItem?: CoreItem | EmptyParent | null;
+    [custom: string]: unknown;
+};
+/** The extra properties of the root of a Virtual DOM. */
+export type RootProperties = {
+    /** Registered listener functions, by name. */
+    eventActions: Record<string, ListenerFunction>;
+    /** Set with setForwardEvents to switch into render-only mode: every listener name resolves to a forwarder which
+     * sends this function an envelope instead of running local logic. See retrieveListener. */
+    forwardEvents?: ForwardEventsFunction;
+    head: DomItem;
+    body: DomItem;
+};
+/** The root of a Virtual DOM (the #document): the head and body items and the registered named listeners. */
+export type DomItemRoot = DomItem & RootProperties;
+/** What a trait is at runtime: which properties it puts on an item, and whether they belong in json. */
+export type TraitDefinition = {
+    /** The properties the trait puts on an item. */
+    keys: string[];
+    /** False for properties which only make sense where the item lives (an element): they are left out of json. */
+    serializable?: boolean;
+    /** The data a new item gets when it is given the trait. */
+    defaults?: () => Record<string, unknown>;
+};
+/**
+ * Decides which items below (and including) an item are wanted. It receives the item being tested and everything
+ * gathered so far, and returns the gathered results with the item added if it qualifies.
+ */
+export type ChildTest = (item: DomItem, gatheredResults: DomItem[]) => DomItem[];
+export {};

package/dist/domItem/types.js

@@ -0,0 +1,8 @@
+"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
+});

package/dist/domItem/types.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});

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

@@ -0,0 +1,10 @@
+import type { DomItem } from '../../domItem/types';
+import type { EventName, ListenerDescriptor } from '../types';
+/**
+ * Activate listener by pushing it to activeListeners.
+ * @param eventName
+ * @param eventListener
+ * @param item
+ */
+declare const activateListener: (eventName: EventName, eventListener: ListenerDescriptor, item: DomItem) => DomItem;
+export default activateListener;

package/dist/events/functions/activateListener.js

@@ -0,0 +1,45 @@
+"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 getTopParentItem_1 = __importDefault(require("../../domItem/tree/getTopParentItem"));
+const makeEventHandler_1 = __importDefault(require("./makeEventHandler"));
+const createEventResponder_1 = __importDefault(require("../objects/createEventResponder"));
+const getListenerOptions_1 = __importDefault(require("../objects/options/getListenerOptions"));
+const optionsToNumber_1 = __importDefault(require("../objects/options/optionsToNumber"));
+const retrieveListener_1 = __importDefault(require("./retrieveListener"));
+/**
+ * Activate listener by pushing it to activeListeners.
+ * @param eventName
+ * @param eventListener
+ * @param item
+ */
+const activateListener = (eventName, eventListener, item) => {
+  const listenerOptions = (0, getListenerOptions_1.default)();
+  if (typeof item.activeListeners === 'undefined') {
+    item.activeListeners = {};
+  }
+  if (!(eventName in item.activeListeners)) {
+    item.activeListeners[eventName] = {};
+  }
+  const optionIdentifier = (0, optionsToNumber_1.default)(listenerOptions, eventListener.listenerOptions);
+  if (!(optionIdentifier in item.activeListeners[eventName])) {
+    item.activeListeners[eventName][optionIdentifier] = [];
+  }
+  const listenerFunc = (0, retrieveListener_1.default)(eventListener.listenerFunc, (0, getTopParentItem_1.default)(item));
+  const eventHandler = (0, makeEventHandler_1.default)(listenerFunc, item, eventListener.listenerArgs);
+  const eventResponder = (0, createEventResponder_1.default)(eventHandler, !!(optionIdentifier & listenerOptions.signal));
+  item.activeListeners[eventName][optionIdentifier].push(eventResponder);
+  eventListener.activeResponder = eventResponder;
+  return item;
+};
+exports.default = activateListener;

package/dist/events/functions/activateListener.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 getTopParentItem_1=__importDefault(require("../../domItem/tree/getTopParentItem")),makeEventHandler_1=__importDefault(require("./makeEventHandler")),createEventResponder_1=__importDefault(require("../objects/createEventResponder")),getListenerOptions_1=__importDefault(require("../objects/options/getListenerOptions")),optionsToNumber_1=__importDefault(require("../objects/options/optionsToNumber")),retrieveListener_1=__importDefault(require("./retrieveListener")),activateListener=(e,t,r)=>{const i=(0,getListenerOptions_1.default)();void 0===r.activeListeners&&(r.activeListeners={}),e in r.activeListeners||(r.activeListeners[e]={});const n=(0,optionsToNumber_1.default)(i,t.listenerOptions);n in r.activeListeners[e]||(r.activeListeners[e][n]=[]);const s=(0,retrieveListener_1.default)(t.listenerFunc,(0,getTopParentItem_1.default)(r)),o=(0,makeEventHandler_1.default)(s,r,t.listenerArgs),a=(0,createEventResponder_1.default)(o,!!(n&i.signal));return r.activeListeners[e][n].push(a),t.activeResponder=a,r};exports.default=activateListener;

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

@@ -0,0 +1,23 @@
+import type { DomItem } from '../../domItem/types';
+import type { EventName, ListenerFunction, ListenerOptions } from '../types';
+/**
+ * Create an EventListener descriptor and push it onto a DomItem's eventListeners for the given event name.
+ * Does not attach anything to the real element - see {@link bindListeners} or {@link fullAddEventListener} for that.
+ *
+ * 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.
+ *
+ * Prefer calling this through {@link fullAddEventListener} with a registered name (see {@link registerListener}).
+ * Passing a raw function directly here works, but logs a console warning - see {@link EventListener}'s
+ * listenerFunc property for what that discretionary path gives up.
+ * @param eventName - The name of the trigger event (e.g. 'click').
+ * @param listenerFunction - Preferably a name registered via
+ * {@link registerListener}; a raw listener function is also accepted, at the caller's discretion.
+ * @param customArgs - Additional args passed through to the listener when called.
+ * @param options - Options to be used when the listener is attached
+ * to the element.
+ * @param item - The DomItem which will receive the event listener.
+ * @returns The same DomItem, with the new EventListener descriptor appended.
+ */
+declare const addEventListener: (eventName: EventName, listenerFunction: string | ListenerFunction, customArgs: object | null | undefined, options: ListenerOptions | null | undefined, item: DomItem) => DomItem;
+export default addEventListener;

package/dist/events/functions/addEventListener.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 createEventListener_1 = __importDefault(require("../objects/createEventListener"));
+/**
+ * Create an EventListener descriptor and push it onto a DomItem's eventListeners for the given event name.
+ * Does not attach anything to the real element - see {@link bindListeners} or {@link fullAddEventListener} for that.
+ *
+ * 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.
+ *
+ * Prefer calling this through {@link fullAddEventListener} with a registered name (see {@link registerListener}).
+ * Passing a raw function directly here works, but logs a console warning - see {@link EventListener}'s
+ * listenerFunc property for what that discretionary path gives up.
+ * @param eventName - The name of the trigger event (e.g. 'click').
+ * @param listenerFunction - Preferably a name registered via
+ * {@link registerListener}; a raw listener function is also accepted, at the caller's discretion.
+ * @param customArgs - Additional args passed through to the listener when called.
+ * @param options - Options to be used when the listener is attached
+ * to the element.
+ * @param item - The DomItem which will receive the event listener.
+ * @returns The same DomItem, with the new EventListener descriptor appended.
+ */
+const addEventListener = (eventName, listenerFunction, customArgs, options, item) => {
+  customArgs = customArgs ?? null;
+  options = options ?? false;
+  if (typeof listenerFunction === 'function') {
+    console.warn(`addEventListener: attaching a raw function directly for "${eventName}" instead of a name registered via ` + 'registerListener. This works, but the listener will not be discoverable via eventActions, cannot be ' + 'shared by name across DomItems, and will be silently dropped by domItemToJson (JSON.stringify omits ' + 'function values). Prefer fullAddEventListener with a name unless this one-off behavior is intentional.');
+  }
+  if (typeof item.eventListeners === 'undefined') {
+    item.eventListeners = {};
+  }
+  if (typeof item.eventListeners[eventName] === 'undefined') {
+    item.eventListeners[eventName] = [];
+  }
+  // check if the listener already exists and don't add if it does
+  item.eventListeners[eventName].push((0, createEventListener_1.default)({
+    listenerFunc: listenerFunction,
+    listenerArgs: customArgs,
+    listenerOptions: options
+  }));
+  return item;
+};
+exports.default = addEventListener;

package/dist/events/functions/addEventListener.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 createEventListener_1=__importDefault(require("../objects/createEventListener")),addEventListener=(e,t,n,s,i)=>(n=n??null,s=s??!1,"function"==typeof t&&console.warn(`addEventListener: attaching a raw function directly for "${e}" instead of a name registered via registerListener. This works, but the listener will not be discoverable via eventActions, cannot be shared by name across DomItems, and will be silently dropped by domItemToJson (JSON.stringify omits function values). Prefer fullAddEventListener with a name unless this one-off behavior is intentional.`),void 0===i.eventListeners&&(i.eventListeners={}),void 0===i.eventListeners[e]&&(i.eventListeners[e]=[]),i.eventListeners[e].push((0,createEventListener_1.default)({listenerFunc:t,listenerArgs:n,listenerOptions:s})),i);exports.default=addEventListener;

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

@@ -0,0 +1,9 @@
+import type { DomItem } from '../../domItem/types';
+import type { EventName } from '../types';
+/**
+ * Apply each active event listener for event type to the DOM Item's element.
+ * @param eventName
+ * @param item
+ */
+declare const applyActiveListeners: (eventName: EventName, item: DomItem) => DomItem;
+export default applyActiveListeners;

package/dist/events/functions/applyActiveListeners.js

@@ -0,0 +1,52 @@
+"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 assignListener_1 = __importDefault(require("./assignListener"));
+const createEventProxy_1 = __importDefault(require("../objects/createEventProxy"));
+/**
+ * Apply each active event listener for event type to the DOM Item's element.
+ * @param eventName
+ * @param item
+ */
+const applyActiveListeners = (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) {
+        // already attached to the element
+        return;
+      }
+      const finalOptions = usesSignal ? Object.assign({}, optionsToUse, {
+        signal: eventResponder.abort.signal
+      }) : optionsToUse;
+      eventResponder.assignedHandler = e => eventResponder.handler((0, createEventProxy_1.default)(e, item));
+      (0, assignListener_1.default)(eventName, item.element, eventResponder.assignedHandler, finalOptions);
+    });
+  });
+  return item;
+};
+exports.default = applyActiveListeners;

package/dist/events/functions/applyActiveListeners.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")),assignListener_1=__importDefault(require("./assignListener")),createEventProxy_1=__importDefault(require("../objects/createEventProxy")),applyActiveListeners=(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;n.assignedHandler=e=>n.handler((0,createEventProxy_1.default)(e,t)),(0,assignListener_1.default)(e,t.element,n.assignedHandler,s)})}),t};exports.default=applyActiveListeners;

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

@@ -0,0 +1,12 @@
+import type { EventHandler, ListenerOptions, ListenerTarget } from '../types';
+/**
+ * Provide compatibility for assigning 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 assignListener: (trigger: string, elem: ListenerTarget, fn: EventHandler, options?: ListenerOptions) => EventHandler;
+export default assignListener;

package/dist/events/functions/assignListener.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/. */
+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 assigning 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 assignListener = (trigger, elem, fn, options = false) => {
+  // Attaching a listener may be done differently based on the browser support
+  if (elem.addEventListener) {
+    // Latest support is provided from addEventListener with the options parameter varying slightly
+    elem.addEventListener(trigger, fn, (0, listenerOptions_1.default)(options));
+  } else if (elem.attachEvent) {
+    // Older browsers, especially Internet Explorer
+    elem.attachEvent(`on${trigger}`, fn);
+  } else {
+    // General support for adding a new function onto the element which can be called to trigger the function
+    ;
+    elem[`on${trigger}`] = fn;
+  }
+  return fn;
+};
+exports.default = assignListener;

package/dist/events/functions/assignListener.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")),assignListener=(e,t,n,s=!1)=>(t.addEventListener?t.addEventListener(e,n,(0,listenerOptions_1.default)(s)):t.attachEvent?t.attachEvent(`on${e}`,n):t[`on${e}`]=n,n);exports.default=assignListener;

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

@@ -0,0 +1,10 @@
+import type { DomItem } from '../../domItem/types';
+/**
+ * Based on the eventListeners property of the provided item, bind the listeners to the associated element property
+ * for each item in the domEvents.DomItem structure.
+ * WARNING: This is a recursive function.
+ * @param item - The DomItem with an associated HTMLElement to have a listener
+ * assigned
+ */
+declare const bindAllListeners: (item: DomItem) => DomItem;
+export default bindAllListeners;

package/dist/events/functions/bindAllListeners.js

@@ -0,0 +1,28 @@
+"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 bindListeners_1 = __importDefault(require("./bindListeners"));
+/**
+ * Based on the eventListeners property of the provided item, bind the listeners to the associated element property
+ * for each item in the domEvents.DomItem structure.
+ * WARNING: This is a recursive function.
+ * @param item - The DomItem with an associated HTMLElement to have a listener
+ * assigned
+ */
+const bindAllListeners = item => {
+  for (const child of item.children) {
+    bindAllListeners(child);
+  }
+  return (0, bindListeners_1.default)(item);
+};
+exports.default = bindAllListeners;

package/dist/events/functions/bindAllListeners.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 bindListeners_1=__importDefault(require("./bindListeners")),bindAllListeners=e=>{for(const t of e.children)bindAllListeners(t);return(0,bindListeners_1.default)(e)};exports.default=bindAllListeners;

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

@@ -0,0 +1,7 @@
+import type { DomItem } from '../../domItem/types';
+/**
+ * Receive a DomItem with eventListeners and apply the event listeners onto the Dom element.
+ * @param item - The DomItem which has eventListeners to apply to its element
+ */
+declare const bindElementListeners: (item: DomItem) => DomItem;
+export default bindElementListeners;

package/dist/events/functions/bindElementListeners.js

@@ -0,0 +1,34 @@
+"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 activateListener_1 = __importDefault(require("./activateListener"));
+const applyActiveListeners_1 = __importDefault(require("./applyActiveListeners"));
+/**
+ * Receive a DomItem with eventListeners and apply the event listeners onto the Dom element.
+ * @param item - The DomItem which has eventListeners to apply to its element
+ */
+const bindElementListeners = item => {
+  for (const eventName in item.eventListeners) {
+    const listeners = item.eventListeners[eventName];
+    listeners.forEach(eventAttributes => {
+      if (eventAttributes.listenerActive) {
+        return;
+      }
+      item = (0, activateListener_1.default)(eventName, eventAttributes, item);
+      eventAttributes.listenerActive = true;
+    });
+    item = (0, applyActiveListeners_1.default)(eventName, item);
+  }
+  return item;
+};
+exports.default = bindElementListeners;

package/dist/events/functions/bindElementListeners.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("./activateListener")),applyActiveListeners_1=__importDefault(require("./applyActiveListeners")),bindElementListeners=e=>{for(const t in e.eventListeners){e.eventListeners[t].forEach(i=>{i.listenerActive||(e=(0,activateListener_1.default)(t,i,e),i.listenerActive=!0)}),e=(0,applyActiveListeners_1.default)(t,e)}return e};exports.default=bindElementListeners;

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

@@ -0,0 +1,9 @@
+import type { DomItem } from '../../domItem/types';
+/**
+ * Based on the eventListeners property of the provided item, bind the
+ * listeners to the associated element property for the provided domEvents.DomItem.
+ * @param item - The DomItem which may have eventListeners to apply to its
+ * element
+ */
+declare const bindListeners: (item: DomItem) => DomItem;
+export default bindListeners;

package/dist/events/functions/bindListeners.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/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const bindElementListeners_1 = __importDefault(require("./bindElementListeners"));
+const si_funciona_1 = __importDefault(require("si-funciona"));
+/**
+ * Based on the eventListeners property of the provided item, bind the
+ * listeners to the associated element property for the provided domEvents.DomItem.
+ * @param item - The DomItem which may have eventListeners to apply to its
+ * element
+ */
+const bindListeners = item => !si_funciona_1.default.emptyObject(item.eventListeners) && item.element ? (0, bindElementListeners_1.default)(item) : item;
+exports.default = bindListeners;

package/dist/events/functions/bindListeners.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 bindElementListeners_1=__importDefault(require("./bindElementListeners")),si_funciona_1=__importDefault(require("si-funciona")),bindListeners=e=>!si_funciona_1.default.emptyObject(e.eventListeners)&&e.element?(0,bindElementListeners_1.default)(e):e;exports.default=bindListeners;

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

@@ -0,0 +1,13 @@
+import type { DomItem } from '../../domItem/types';
+import type { EventName, ListenerDescriptor } from '../types';
+/**
+ * Deactivate a single listener: detach it from the element (if it was actually attached) and remove it from
+ * activeListeners, without disturbing any other listener sharing the same options bucket.
+ * @param eventName - The name of the trigger event the listener was activated under.
+ * @param eventListener - The EventListener descriptor to deactivate, as found via
+ * {@link findEventListener} or returned from {@link activateListener}.
+ * @param item - The DomItem the listener is attached to.
+ * @returns The same DomItem, with this listener detached and marked inactive.
+ */
+declare const deactivateListener: (eventName: EventName, eventListener: ListenerDescriptor, item: DomItem) => DomItem;
+export default deactivateListener;