powerpagestoolkit 2.7.1443 → 2.8.2

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

@@ -1,4 +1,7 @@
 /// <reference path="../globals.d.ts" />
+interface ODataJSON extends object {
+    [key: `${string}@odata.bind` | string]: any;
+}
 /**
  * Provides abstract class `API` that allows basic create, read, and update operations in DataVerse via the PowerPages API
  * @method `createRecord` - Create a record in DataVerse
@@ -12,7 +15,7 @@ declare abstract class API {
      * @param data The JSON of the fields and data that are to be updated on the targeted record
      * @returns a Promise resolving the successful results *[record id]* of the POST request, or rejecting the failed results *[error]* of the POST request.
      */
-    static createRecord(tableSetName: string, data: JSON): Promise<string>;
+    static createRecord(tableSetName: string, data: ODataJSON): Promise<string>;
     /**
      *
      * @param tableSetName The DataVerse SET name of the table being queried
@@ -35,6 +38,6 @@ declare abstract class API {
      * @param data The JSON of the fields and data that are to be updated on the targeted record
      * @returns A Promise with the results of the API execution
      */
-    static updateRecord(tableSetName: string, recordId: string, data: object): Promise<any>;
+    static updateRecord(tableSetName: string, recordId: string, data: ODataJSON): Promise<any>;
 }
 export default API;

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

@@ -4,11 +4,12 @@ export default class DOMNodeReference {
     target: Element | string;
     logicalName?: string;
     root: Element;
-    protected [s.debounceTime]: number;
+    protected timeoutMs: number;
     protected isLoaded: boolean;
     protected defaultDisplay: string;
-    protected [s.observers]: Array<MutationObserver>;
+    protected [s.observers]: Array<MutationObserver | ResizeObserver>;
     protected [s.boundEventListeners]: Array<BoundEventListener>;
+    protected dependents: Dependants;
     protected isRadio: boolean;
     protected radioType: RadioType | null;
     /**
@@ -24,6 +25,7 @@ export default class DOMNodeReference {
     element: HTMLElement;
     protected visibilityController: HTMLElement;
     checked: boolean;
+    radioParent: DOMNodeReference | null;
     /**
      * Represents the 'yes' option of a boolean radio field.
      * This property is only available when the parent node
@@ -42,7 +44,7 @@ export default class DOMNodeReference {
      * @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, debounceTime: number);
+    /******/ /******/ constructor(target: Element | string, root: Element | undefined, timeoutMs: number);
     private extractLogicalName;
     [s.init](): Promise<void>;
     /**
@@ -70,6 +72,8 @@ export default class DOMNodeReference {
      * @public
      */
     updateValue(e?: Event): void;
+    protected triggerDependentsHandlers(): Promise<void>;
+    protected validateValue(value: any): any;
     /**
      * Sets up an event listener based on the specified event type, executing the specified
      * event handler
@@ -147,7 +151,7 @@ export default class DOMNodeReference {
     after(...elements: HTMLElement[]): DOMNodeReference;
     /**
      * Retrieves the label associated with the HTML element.
-     * @returns {HTMLElement} The label element associated with this element.
+     * @returns The label element associated with this element.
      */
     getLabel(): HTMLElement | null;
     /**
@@ -166,7 +170,7 @@ export default class DOMNodeReference {
     addTooltip(innerHTML: string, containerStyle?: Partial<CSSStyleDeclaration>): DOMNodeReference;
     /**
      * Sets the inner HTML content of the HTML element.
-     * @param {string} string - The text to set as the inner HTML of the element.
+     * @param string - The text to set as the inner HTML of the element.
      * @returns - Instance of this [provides option to method chain]
      */
     setInnerHTML(string: string): this;
@@ -189,49 +193,21 @@ export default class DOMNodeReference {
      * Applies a business rule to manage visibility, required state, value, and disabled state dynamically.
      * @see {@link BusinessRule}
      * @param rule The business rule containing conditions for various actions.
-     * @param dependencies For re-evaluation conditions when the state of the dependencies change
+     * @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;
-    /**
-     * Configures conditional rendering for the target element based on a condition
-     * and the visibility of one or more trigger elements.
-     * @deprecated Use the new 'applyBusinessRule Method
-     * @param condition A function that returns a boolean to determine
-     * the visibility of the target element. If `condition()` returns true, the element is shown;
-     * otherwise, it is hidden.
-     * @param dependencies - An array of `DOMNodeReference` instances. Event listeners are
-     * registered on each to toggle the visibility of the target element based on the `condition` and the visibility of
-     * the target node.
-     * @throws When there's an error in setting up conditional rendering
-     * @returns Instance of this [provides option to method chain]
-     */
-    configureConditionalRendering(condition: () => boolean, dependencies?: Array<DOMNodeReference>, clearValuesOnHide?: boolean): DOMNodeReference;
-    /**
-     * Sets up validation and requirement rules for the field with enhanced error handling and dynamic updates.
-     * @deprecated Use the new 'applyBusinessRule Method
-     * @param isRequired Function determining if field is required
-     * @param isValid Function validating field input
-     * @param fieldDisplayName Display name for error messages
-     * @param dependencies Fields that trigger requirement/validation updates
-     * @returns Instance of this
-     * @throws If validation setup fails
-     */
-    configureValidationAndRequirements(isRequired: () => boolean, isValid: () => boolean, fieldDisplayName: string, dependencies: Array<DOMNodeReference>): DOMNodeReference;
+    protected createValidator(evaluationFunction: () => boolean): HTMLSpanElement;
     /**
      * Sets up tracking for dependencies using both event listeners and mutation observers.
      * @protected
      * @param handler The function to execute when dependencies change
      * @param dependencies Array of dependent DOM nodes to track
-     * @param options Additional configuration options. clearValuesOnHide defaults to false.
      * all other options defaults to true
      */
-    protected _configDependencyTracking(handler: () => void, dependencies: Array<DOMNodeReference>, options?: {
-        clearValuesOnHide?: boolean;
-        observeVisibility?: boolean;
-        trackInputEvents?: boolean;
-        trackRadioButtons?: boolean;
-    }): void;
+    protected _configDependencyTracking(handler: DependencyHandlerFunction, dependencies: Array<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/globals.d.ts

@@ -1,5 +1,7 @@
 /// <reference path="../core/DOMNodeReference.ts"/>
 
+declare type EventCallback = () => any;
+
 declare interface CreationOptions {
   /**
    * Should this call return an array of instantiated references, or just a single?
@@ -68,41 +70,47 @@ declare interface Form extends Partial<SystemForm> {
   formxml: string;
 }
 
+declare type IsValid = (
+  this: DOMNodeReference,
+  isRequired: ReturnType<Condition>
+) => boolean;
+
 declare interface BusinessRule {
   /**
    * @param condition A function that returns a boolean to determine
    * the visibility of the target element. If `condition()` returns true, the element is shown;
    * otherwise, it is hidden.
    
-   * @param clearValuesOnHide Should the values in the targeted field be cleared when hidden? Defaults to true
    */
-  setVisibility?: [
-    condition: (this: DOMNodeReference) => boolean,
-    clearValuesOnHide?: boolean
-  ];
+  setVisibility?: (this: DOMNodeReference) => boolean;
   /**
-   * @param isRequired Function determining if field is required
-   * @param isValid Function validating field input.
+   * 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 isValid - Function validating field input.
+   * @param isValid.this - Reference to this DOMNodeReference
+   * @param isValid.isRequiredResult - Only available if 'isRequired' is also returned from the configuration function
    */
-  setRequired?: [
-    isRequired: () => boolean,
-    isValid: (this: DOMNodeReference, isRequired: boolean) => boolean
-  ];
+  setRequirements?: () => {
+    isRequired?: (this: DOMNodeReference) => boolean;
+    isValid?: (this: DOMNodeReference, isRequiredResult?: boolean) => boolean;
+  };
+
   /**
    * @param condition A function to determine if the value provided should be applied to this field
    * @param value The value to set for the HTML element.
    * for parents of boolean radios, pass true or false as value, or
    * an expression returning a boolean
    */
-  setValue?: [
-    condition: (this: DOMNodeReference) => boolean,
-    value: () => any | any
-  ];
+  setValue?: () => {
+    condition: (this: DOMNodeReference) => 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?: () => boolean;
+  setDisabled?: (this: DOMNodeReference) => boolean;
 }
 
 declare interface CreationOptions {
@@ -126,6 +134,16 @@ declare interface CreationOptions {
   timeoutMs?: number;
 }
 
+declare type DependencyHandlerFunction = () => Promise<void>;
+
+declare type Dependants = Map<DOMNodeReference, DependencyHandlerFunction>;
+
+declare type ValueElement =
+  | HTMLInputElement
+  | HTMLSelectElement
+  | HTMLTextAreaElement
+  | HTMLOptionElement;
+
 declare const Page_Validators: any[];
 
 declare interface ElementValue {