powerpagestoolkit 3.0.3 → 3.0.311

package/README.md

@@ -21,13 +21,13 @@ npm install powerpagestoolkit
 
 # Core Modules
 
-### DOMNodeReference
+### PowerPagesElement
 
 A powerful class for managing DOM elements with automatic value synchronization and event handling.
 
 #### Basic Usage
 
-DOMNodeReferences are instantiated with the help of the following factory function: `createRef`
+PowerPagesElements are instantiated with the help of the following factory function: `createRef`
 
 ```typescript
 createRef(
@@ -37,7 +37,7 @@ createRef(
     root: HTMLElement,
     timeoutMs:number
   }
-): Promise<DOMNodeReference | DOMNodeReference[]>;
+): Promise<PowerPagesElement | PowerPagesElement[]>;
 ```
 
 createRef takes two main arguments:
@@ -76,13 +76,13 @@ createRef takes two main arguments:
   </tbody>
 </table>
 
-Import the utility function for creating DOMNodeReference(s)
+Import the utility function for creating PowerPagesElement(s)
 
 ```typescript
 import { createRef } from "powerpagestoolkit";
 ```
 
-Instantiate one, or multiple instances of a DOMNodeReference, and optionally configure advanced options
+Instantiate one, or multiple instances of a PowerPagesElement, and optionally configure advanced options
 
 ```javascript
 // Create a single reference (i.e. 'querySelector')
@@ -120,8 +120,8 @@ const nodes2 = await createRef("#target", {
 | value    | any                      | Current synchronized value of the element     |
 | isLoaded | boolean                  | Element load status                           |
 | target   | HTMLElement \| string    | Original target selector or element           |
-| yesRadio | DOMNodeReference \| null | Reference to 'yes' radio (for boolean fields) |
-| noRadio  | DOMNodeReference \| null | Reference to 'no' radio (for boolean fields)  |
+| yesRadio | PowerPagesElement \| null | Reference to 'yes' radio (for boolean fields) |
+| noRadio  | PowerPagesElement \| null | Reference to 'no' radio (for boolean fields)  |
 | checked  | boolean                  | Checkbox/radio checked state                  |
 
 #### Key Methods
@@ -151,8 +151,8 @@ _Method Signature:_
 ```typescript
 applyBusinessRule(
   rule: BusinessRule,
-  dependencies: DOMNodeReference[]
-): DOMNodeReference; /* Instance of this is returned for optional
+  dependencies: PowerPagesElement[]
+): PowerPagesElement; /* Instance of this is returned for optional
  method chaining */
 ```
 
@@ -370,7 +370,7 @@ bindForm("form-guid").then((form) => {
  * @param formGuid Unique identifier for the form
  * @returns Promise resolving to form element references
  */
-function bindForm(formGuid: string): Promise<DOMNodeReferenceArray & Record<string: DOMNodeReference>>;
+function bindForm(formGuid: string): Promise<PowerPagesElementArray & Record<string: PowerPagesElement>>;
 ```
 
 ##### Benefits
@@ -447,7 +447,7 @@ await API.updateRecord("contacts", "record-guid", {
 
 ## Best Practices
 
-1. Always await DOMNodeReference creation:
+1. Always await PowerPagesElement creation:
 
 ```typescript
 const node = await createRef("#element");

package/dist/src/{core → ancillary}/DOMNodeReference.d.ts

@@ -1,4 +1,7 @@
 /// <reference path="../globals.d.ts" />
+import type VisibilityManager from "../ancillary/VisibilityManager.d.ts";
+import type EventManager from "../ancillary/EventManager.d.ts";
+import type ValueManager from "../ancillary/ValueManager.d.ts";
 export default class DOMNodeReference {
     static instances: DOMNodeReference[];
     [key: symbol]: (...arg: any[]) => any;
@@ -7,38 +10,32 @@ export default class DOMNodeReference {
     root: Element;
     protected timeoutMs: number;
     protected isLoaded: boolean;
-    protected defaultDisplay: string;
-    protected observers: Array<MutationObserver | ResizeObserver>;
-    protected boundListeners: Array<BoundEventListener>;
-    protected dependents: Dependents;
-    protected isRadio: boolean;
-    protected radioType: RadioType | null;
     /**
      * The value of the element that this node represents
      * stays in syncs with the live DOM elements?.,m  via event handler
      */
-    value: any;
+    get value(): any;
+    set value(newValue: any);
+    get checked(): boolean;
     /**
      * The element targeted when instantiating DOMNodeReference.
      * Made available in order to perform normal DOM traversal,
      * or access properties not available through this class.
      */
     element: HTMLElement;
-    protected visibilityController: HTMLElement;
-    checked: boolean;
-    radioParent: DOMNodeReference | null;
+    visibilityManager: VisibilityManager | null;
+    valueManager: ValueManager | null;
+    eventManager: EventManager | null;
     /**
      * Represents the 'yes' option of a boolean radio field.
      * This property is only available when the parent node
      * is a main field for a boolean radio input.
      */
-    yesRadio: DOMNodeReference | null;
     /**
      * Represents the 'no' option of a boolean radio field.
      * This property is only available when the parent node
      * is a main field for a boolean radio input.
      */
-    noRadio: DOMNodeReference | null;
     /**
      * Creates an instance of DOMNodeReference.
      * @param target - The CSS selector to find the desired DOM element.
@@ -55,16 +52,7 @@ export default class DOMNodeReference {
     protected _determineEventType(): keyof HTMLElementEventMap;
     protected _isDateInput(): boolean;
     protected _isValidFormElement(element: Element): element is FormElement;
-    protected _registerEventListener(element: Element, eventType: keyof HTMLElementEventMap, handler: (e: Event) => unknown): void;
     protected _dateSync(element: HTMLInputElement): Promise<void>;
-    /**
-     * Gets the current value of the element based on its type
-     * @protected
-     * @returns Object containing value and optional checked state
-     */
-    protected _getElementValue(): Promise<ElementValue>;
-    protected _attachVisibilityController(): void;
-    protected _attachRadioButtons(): Promise<void>;
     protected _bindMethods(): void;
     /**
      * Updates the value and checked state based on element type
@@ -72,7 +60,6 @@ export default class DOMNodeReference {
      */
     updateValue(e?: Event): Promise<void>;
     protected triggerDependentsHandlers(): void;
-    protected _validateValue(value: any): any;
     /**
      * Sets up an event listener based on the specified event type, executing the specified
      * event handler
@@ -115,13 +102,10 @@ export default class DOMNodeReference {
      * Clears all values and states of the element.
      * Handles different input types appropriately, and can be called
      * on an element containing N child inputs to clear all
-     *
-     * @returns - Instance of this [provides option to method chain]
-     * @throws If clearing values fails
      */
-    clearValue(): Promise<DOMNodeReference>;
+    clearValue(): void;
     protected _getChildren(): DOMNodeReference[] | null;
-    protected callAgainstChildInputs(func: (child: DOMNodeReference) => any): void;
+    protected callAgainstChildrenInputs(callback: (child: DOMNodeReference) => any): void;
     /**
      * Enables the element so that users can input data
      * @returns - Instance of this [provides option to method chain]
@@ -181,15 +165,11 @@ export default class DOMNodeReference {
      */
     remove(): this;
     /**
-     * @param options and object containing the styles you want to set : {key: value} e.g.: {'display': 'block'}
-     * @returns - Instance of this [provides option to method chain]
+     * Sets inline CSS styles on the element.
+     * @param options - An object containing CSS property-value pairs, e.g., { display: 'block' }.
+     * @returns The instance, enabling method chaining.
      */
     setStyle(options: Partial<CSSStyleDeclaration>): this;
-    /**
-     * Unchecks both the yes and no radio buttons if they exist.
-     * @returns - Instance of this [provides option to method chain]
-     */
-    uncheckRadios(): DOMNodeReference;
     /**
      * Applies a business rule to manage visibility, required state, value, and disabled state dynamically.
      * @see {@link BusinessRule}
@@ -197,7 +177,7 @@ export default class DOMNodeReference {
      * @param dependencies For re-evaluation of conditions when the state of the dependencies change
      * @returns Instance of this for method chaining.
      */
-    applyBusinessRule(rule: BusinessRule, dependencies: DOMNodeReference[]): DOMNodeReference;
+    applyBusinessRule(rule: BusinessRule, dependencies: DependencyArray<DOMNodeReference>): DOMNodeReference;
     protected _returnBusinessRuleHandler(rule: BusinessRule): BusinessRuleHandler;
     protected _createValidator(evaluationFunction: () => boolean): void;
     /**
@@ -208,8 +188,6 @@ export default class DOMNodeReference {
      * all other options defaults to true
      */
     protected _configureDependencyTracking(handler: DependencyHandler, dependencies: DOMNodeReference[]): void;
-    protected _getVisibility(): boolean;
-    protected _receiveNotification(): void;
     /**
      * Sets the required level for the field by adding or removing the "required-field" class on the label.
      *

package/dist/src/ancillary/EventManager.d.ts

@@ -0,0 +1,25 @@
+/// <reference path="../globals.d.ts" />
+import type DOMNodeReference from "./DOMNodeReference.d.ts";
+declare type EventType = string;
+declare type Handler = (this: DOMNodeReference, ...args: any[]) => void;
+/********/ /********/ export default class EventManager {
+    private readonly events;
+    private readonly listeners;
+    private readonly dependencyHandlers;
+    private observers;
+    private boundListeners;
+    constructor();
+    dispatchDependencyHandlers(): void;
+    registerDependent(dependency: DOMNodeReference, handler: Handler): true | false;
+    registerEvent(event: EventType, handler: Handler): true | false;
+    registerListener(event: EventType, listener: DOMNodeReference): true | false;
+    emit(eventType: EventType, ...args: any[]): void;
+    stopListening(listener: DOMNodeReference): void;
+    registerObserver(observer: MutationObserver | ResizeObserver, observerOptions: {
+        nodeToObserve: Element;
+        options: Partial<ResizeObserverOptions> | Partial<MutationObserverInit>;
+    }): void;
+    registerDOMEventListener(element: Element, eventType: keyof HTMLElementEventMap, handler: (e: Event) => unknown): void;
+    destroy(): void;
+}
+export {};

package/dist/src/ancillary/Radio.d.ts

@@ -0,0 +1,8 @@
+/// <reference path="../globals.d.ts" />
+import DOMNodeReference from "./DOMNodeReference.d.ts";
+export default class Radio extends DOMNodeReference {
+    [key: symbol]: (...arg: any[]) => any;
+    protected radioType: RadioType | null;
+    radioParent: DOMNodeReference | undefined;
+    constructor(parent: DOMNodeReference, target: Element | string, root: Element | undefined, timeoutMs: number, radioType: RadioType);
+}

package/dist/src/ancillary/ValueManager.d.ts

@@ -0,0 +1,27 @@
+/// <reference path="../globals.d.ts" />
+import type DOMNodeReference from "./DOMNodeReference.d.ts";
+import Radio from "./Radio.d.ts";
+declare interface ValueManagerProps {
+    element: HTMLElement;
+    noRadio?: Radio;
+    yesRadio?: Radio;
+    radioParent?: DOMNodeReference;
+    isRadio: boolean;
+}
+export default class ValueManager {
+    value: any;
+    checked: true | false;
+    private element;
+    private noRadio?;
+    private yesRadio?;
+    radioParent?: DOMNodeReference | undefined;
+    private isRadio;
+    constructor(properties: ValueManagerProps);
+    setValue(value: any): void;
+    updateValue(e?: Event): Promise<void>;
+    getElementValue(): Promise<ElementValue>;
+    protected _validateValue(value: any): any;
+    clearValue(): void;
+    destroy(): void;
+}
+export {};

package/dist/src/ancillary/VisibilityManager.d.ts

@@ -0,0 +1,11 @@
+/// <reference path="../globals.d.ts" />
+export default class VisibilityManager {
+    private visibilityController;
+    private defaultVisibility;
+    constructor(target: HTMLElement);
+    hide(): void;
+    show(): void;
+    toggleVisibility(shouldShow: boolean): void;
+    getVisibility(): true | false;
+    destroy(): void;
+}

package/dist/src/constants/EventTypes.d.ts

@@ -1,7 +1,7 @@
 /// <reference path="../globals.d.ts" />
 /**
- * For use in setting up event management in the instances of DOMNodeReference
- * @see {@link DOMNodeReference}
+ * For use in setting up event management in the instances of PowerPagesElement
+ * @see {@link PowerPagesElement}
  */
 export declare const EventTypes: {
     readonly CHECKBOX: "click";

package/dist/src/core/PowerPagesElement.d.ts

@@ -0,0 +1,32 @@
+/// <reference path="../globals.d.ts" />
+import DOMNodeReference from "../ancillary/DOMNodeReference.d.ts";
+import Radio from "../ancillary/Radio.d.ts";
+export default class PowerPagesElement extends DOMNodeReference {
+    [key: symbol]: (...arg: any[]) => any;
+    /**
+     * Represents the 'yes' option of a boolean radio field.
+     * This property is only available when the parent node
+     * is a main field for a boolean radio input.
+     */
+    yesRadio: Radio | undefined;
+    /**
+     * Represents the 'no' option of a boolean radio field.
+     * This property is only available when the parent node
+     * is a main field for a boolean radio input.
+     */
+    noRadio: Radio | undefined;
+    /**
+     * Creates an instance of PowerPagesElement.
+     * @param target - The CSS selector to find the desired DOM element.
+     * @param root - Optionally specify the element within to search for the element targeted by 'target'
+     * Defaults to 'document.body'
+     */
+    /******/ /******/ constructor(target: Element | string, root: Element | undefined, timeoutMs: number);
+    protected _attachRadioButtons(): Promise<void>;
+    clearValue(): void;
+    /**
+     * Unchecks both the yes and no radio buttons if they exist.
+     * @returns - Instance of this [provides option to method chain]
+     */
+    uncheckRadios(): DOMNodeReference;
+}

package/dist/src/core/PowerPagesElementArray.d.ts

@@ -0,0 +1,12 @@
+/// <reference path="../globals.d.ts" />
+import type PowerPagesElement from "./PowerPagesElement.d.ts";
+export default class PowerPagesElementArray extends Array<PowerPagesElement> {
+    /**
+     * Hides all the containers of the PowerPagesElement instances in the array.
+     */
+    hideAll(this: PowerPagesElementArray): PowerPagesElementArray;
+    /**
+     * Shows all the containers of the PowerPagesElement instances in the array.
+     */
+    showAll(this: PowerPagesElementArray): PowerPagesElementArray;
+}

package/dist/src/core/bindForm.d.ts

@@ -1,14 +1,14 @@
 /// <reference path="../globals.d.ts" />
-import type DOMNodeReference from "./DOMNodeReference.d.ts";
-import type DOMNodeReferenceArray from "./DOMNodeReferenceArray.d.ts";
+import type PowerPagesElementArray from "./PowerPagesElementArray.d.ts";
+import type PowerPagesElement from "./PowerPagesElement.d.ts";
 /**
  * When loading into a page in PowerPages that has a form,
  * you can use this function by passing in the GUID of the form, and you will receive an array/record
- * of {@link DOMNodeReference}s that represent all fields, sections, sub-grids, and tabs of the given form.
+ * of {@link PowerPagesElement}s that represent all fields, sections, sub-grids, and tabs of the given form.
  * Access these properties of the {@link BoundForm} using the logical name of the control you need to access: form['logical_name']
- * you can then execute all the methods available from DOMNodeReference
+ * you can then execute all the methods available from PowerPagesElement
  * @param formId - The string GUID of the form you want to bind to
- * @returns An array of DOMNodeReferences, accessible as properties of a Record<string, DOMNodeReference> i.e. formProp = form["some_logicalName"]
+ * @returns An array of PowerPagesElements, accessible as properties of a Record<string, PowerPagesElement> i.e. formProp = form["some_logicalName"]
  * @example
  * ```js
  * bindForm("form-guid-0000").then((form) => {
@@ -23,6 +23,6 @@ import type DOMNodeReferenceArray from "./DOMNodeReferenceArray.d.ts";
  * const form = await bindForm("form-guid-0000")
  * ```
  *  @see {@link BoundForm}
- *  @see {@link DOMNodeReference}
+ *  @see {@link PowerPagesElement}
  */
-export default function bindForm(formId: string): Promise<DOMNodeReferenceArray & Record<string, DOMNodeReference>>;
+export default function bindForm(formId: string): Promise<PowerPagesElementArray & Record<string, PowerPagesElement>>;

package/dist/src/core/{createDOMNodeReferences.d.ts → getPowerPagesElement.d.ts}

@@ -1,21 +1,21 @@
 /// <reference path="../globals.d.ts" />
-import DOMNodeReference from "./DOMNodeReference.d.ts";
-import type DOMNodeReferenceArray from "./DOMNodeReferenceArray.d.ts";
+import type PowerPagesElementArray from "./PowerPagesElementArray.d.ts";
+import PowerPagesElement from "./PowerPagesElement.d.ts";
 /**
- * Creates and initializes a DOMNodeReference instance.
+ * Creates and initializes a PowerPagesElement instance.
  * @see {@link CreationOptions}
- * @param  **target** - The selector, using `querySelector` syntax, for the desired DOM element. Or, the `HTMLElement` itself for which to create a DOMNodeReference.
+ * @param  **target** - The selector, using `querySelector` syntax, for the desired DOM element. Or, the `HTMLElement` itself for which to create a PowerPagesElement.
  * @param **options** - Options for advanced retrieval of elements
  * @param **options.multiple** - Should this call return an array of instantiated references, or just a single? Defaults to false, returning a single instance
  * @param **options.root** - Optionally specify the element within to search for the element targeted by 'target'. Defaults to `document.body`
  * @param **options.timeoutMs** - Optionally specify the amount of time that should be waited to find the targeted element before throwing error - useful for async DOM loading. Relies on MutationObserver.  ***WARNING***: Implementing multiple references with timeout can result in infinite loading.
- * @returns  A promise that resolves to a Proxy of the initialized DOMNodeReference instance.
+ * @returns  A promise that resolves to a Proxy of the initialized PowerPagesElement instance.
  *
- * @see {@link DOMNodeReference}
- * @see {@link DOMNodeReferenceArray}
+ * @see {@link PowerPagesElement}
+ * @see {@link PowerPagesElementArray}
  * @see {@link enhanceArray}
  */
-export default function createDOMNodeReference(target: string | HTMLElement, options?: {
+export default function createPowerPagesElement(target: string | HTMLElement, options?: {
     /**
      * Should this call return an array of instantiated references, or just a single?
      * Defaults to false, returning a single instance.
@@ -32,8 +32,8 @@ export default function createDOMNodeReference(target: string | HTMLElement, opt
      * WARNING: Implementing multiple references with timeout can result in infinite loading.
      */
     timeoutMs?: number;
-}): Promise<DOMNodeReference>;
-export default function createDOMNodeReference(target: string, options?: {
+}): Promise<PowerPagesElement>;
+export default function createPowerPagesElement(target: string, options?: {
     /**
      * Should this call return an array of instantiated references, or just a single?
      * Defaults to false, returning a single instance.
@@ -50,8 +50,8 @@ export default function createDOMNodeReference(target: string, options?: {
      * WARNING: Implementing multiple references with timeout can result in infinite loading.
      */
     timeoutMs?: number;
-}): Promise<DOMNodeReference>;
-export default function createDOMNodeReference(target: Element, options?: {
+}): Promise<PowerPagesElement>;
+export default function createPowerPagesElement(target: Element, options?: {
     /**
      * Optionally specify the element within which to search for the element targeted by 'target'.
      * Defaults to 'document.body'.
@@ -63,8 +63,8 @@ export default function createDOMNodeReference(target: Element, options?: {
      * WARNING: Implementing multiple references with timeout can result in infinite loading.
      */
     timeoutMs?: number;
-}): Promise<DOMNodeReference>;
-export default function createDOMNodeReference(target: string, options?: {
+}): Promise<PowerPagesElement>;
+export default function createPowerPagesElement(target: string, options?: {
     /**
      * Should this call return an array of instantiated references, or just a single?
      * Defaults to false, returning a single instance.
@@ -81,8 +81,8 @@ export default function createDOMNodeReference(target: string, options?: {
      * WARNING: Implementing multiple references with timeout can result in infinite loading.
      */
     timeoutMs?: number;
-}): Promise<DOMNodeReferenceArray>;
+}): Promise<PowerPagesElementArray>;
 export declare function validateOptions(options: Partial<CreationOptions>): void;
 export declare function createProxyHandler(): {
-    get: (target: DOMNodeReference, prop: string | symbol) => any;
+    get: (target: PowerPagesElement, prop: string | symbol) => any;
 };

package/dist/src/errors/errors.d.ts

@@ -1,14 +1,37 @@
 /// <reference path="../globals.d.ts" />
-import type DOMNodeReference from "../core/DOMNodeReference.d.ts";
-export declare class DOMNodeInitializationError extends Error {
-    constructor(instance: DOMNodeReference, error: string);
+import type DOMNodeReference from "../ancillary/DOMNodeReference.d.ts";
+declare class CustomError extends Error {
+    node: DOMNodeReference;
+    constructor(node: DOMNodeReference, message: string);
 }
-export declare class DOMNodeNotFoundError extends Error {
-    constructor(instance: DOMNodeReference);
+declare class InitializationError extends CustomError {
+    constructor(node: DOMNodeReference, error: string);
 }
-export declare class ConditionalRenderingError extends Error {
-    constructor(instance: DOMNodeReference, error: string);
+declare class NodeNotFoundError extends CustomError {
+    constructor(node: DOMNodeReference);
 }
-export declare class ValidationConfigError extends Error {
-    constructor(node: DOMNodeReference, message: string);
+declare class Page_ValidatorsNotFoundError extends CustomError {
+    constructor(node: DOMNodeReference);
+}
+declare class BusinessRuleError extends CustomError {
+    constructor(node: DOMNodeReference);
+}
+declare class SelfReferenceError extends CustomError {
+    constructor(node: DOMNodeReference);
+}
+declare class LabelNotFoundError extends CustomError {
+    constructor(node: DOMNodeReference);
+}
+declare class IncorrectParameterError extends CustomError {
+    constructor(node: DOMNodeReference, functionName: string, argName: string, expectedTypes: string[], receivedType: any);
 }
+declare const Errors: {
+    NodeNotFoundError: typeof NodeNotFoundError;
+    InitializationError: typeof InitializationError;
+    Page_ValidatorsNotFoundError: typeof Page_ValidatorsNotFoundError;
+    BusinessRuleError: typeof BusinessRuleError;
+    SelfReferenceError: typeof SelfReferenceError;
+    LabelNotFoundError: typeof LabelNotFoundError;
+    IncorrectParameterError: typeof IncorrectParameterError;
+};
+export default Errors;

package/dist/src/globals.d.ts

@@ -1,4 +1,4 @@
-/// <reference path="../core/DOMNodeReference.ts"/>
+/// <reference path="../core/PowerPagesElement.ts"/>
 
 declare type EventCallback = () => any;
 
@@ -77,18 +77,18 @@ declare interface BusinessRule {
    * otherwise, it is hidden.
    
    */
-  setVisibility?: (this: DOMNodeReference) => boolean;
+  setVisibility?: (this: PowerPagesElement) => boolean;
   /**
    * Configuration function for determining the required level, and field validity of the given fields
    * @param isRequired - Function determining if field is required
-   * @param isRequired.this - Reference to this DOMNodeReference
+   * @param isRequired.this - Reference to this PowerPagesElement
    * @param isValid - Function validating field input.
-   * @param isValid.this - Reference to this DOMNodeReference
+   * @param isValid.this - Reference to this PowerPagesElement
    * @param isValid.isRequiredResult - Only available if 'isRequired' is also returned from the configuration function
    */
   setRequirements?: () => {
-    isRequired?: (this: DOMNodeReference) => boolean;
-    isValid?: (this: DOMNodeReference, isRequiredResult?: boolean) => boolean;
+    isRequired?: (this: PowerPagesElement) => boolean;
+    isValid?: (this: PowerPagesElement, isRequiredResult?: boolean) => boolean;
   };
 
   /**
@@ -98,16 +98,18 @@ declare interface BusinessRule {
    * an expression returning a boolean
    */
   setValue?: () => {
-    condition: (this: DOMNodeReference) => boolean;
+    condition: (this: PowerPagesElement) => boolean;
     value: (() => any) | any;
   };
   /**
    * @param condition A function to determine if this field
    * should be enabled in a form, or disabled. True || 1 = disabled. False || 0 = enabled
    */
-  setDisabled?: (this: DOMNodeReference) => boolean;
+  setDisabled?: (this: PowerPagesElement) => boolean;
 }
 
+declare type DependencyArray<T> = [T, ...T[]];
+
 declare interface CreationOptions {
   /**
    * Should this call return an array of instantiated references, or just a single?
@@ -133,7 +135,7 @@ declare type DependencyHandler = () => void;
 
 declare interface BusinessRuleHandler extends DependencyHandler {}
 
-declare type Dependents = Map<DOMNodeReference, DependencyHandler>;
+declare type Dependents = Map<PowerPagesElement, DependencyHandler>;
 
 declare type ValueElement =
   | HTMLInputElement

package/dist/src/index.d.ts

@@ -1,5 +1,5 @@
 import API from "./core/API.d.ts";
-import createRef from "./core/createDOMNodeReferences.d.ts";
+import get from "./core/getPowerPagesElement.d.ts";
 import waitFor from "./core/waitFor.d.ts";
 import bindForm from "./core/bindForm.d.ts";
-export { API, bindForm, createRef, waitFor };
+export { API, bindForm, get, waitFor };