powerpagestoolkit 2.7.135 → 2.7.211

package/dist/import_map.json

@@ -0,0 +1,6 @@
+{
+  "imports": {
+    "powerpagestoolkit/": "./",
+    "powerpagestoolkit": "./index.js"
+  }
+}

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

@@ -0,0 +1,7 @@
+/// <reference path="../globals.d.ts" />
+/**
+ * For use in setting up event management in the instances of DOMNodeReference
+ * @see {@link DOMNodeReference}
+ */
+declare const eventMapping: Record<string, keyof HTMLElementEventMap>;
+export default eventMapping;

package/dist/{types → src}/constants/symbols.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="../globals.d.ts" />
 export declare const init: unique symbol;
 export declare const destroy: unique symbol;
 export declare const valueSync: unique symbol;

package/dist/{types → src}/core/API.d.ts

@@ -1,10 +1,18 @@
-declare const API: {
+/// <reference path="../globals.d.ts" />
+/**
+ * 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
+ * @method `getRecord<T>` - Get a record by ID from DataVerse
+ * @method `getMultiple` - Get multiple records from DataVerse; with optional OData filtering
+ * @method `updateRecord` - Update a record by ID in DataVerse
+ */
+declare abstract class API {
     /**
      * @param tableSetName The dataverse set name for the table that you are updating a record in
      * @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.
      */
-    createRecord(tableSetName: string, data: object): Promise<string>;
+    static createRecord(tableSetName: string, data: JSON): Promise<string>;
     /**
      *
      * @param tableSetName The DataVerse SET name of the table being queried
@@ -12,14 +20,14 @@ declare const API: {
      * @param selectColumns *OPTIONAL* if desired, enter your own custom OData query for advanced GET results. Format = select=column1,column2,column3...
      * @returns a Promise resolving the successful results of the GET request, or rejecting the failed results of the GET request
      */
-    getRecord<T>(tableSetName: string, recordID: string, selectColumns?: string): Promise<T>;
+    static getRecord<T>(tableSetName: string, recordID: string, selectColumns?: string): Promise<T>;
     /**
      *
      * @param tableSetName The dataverse set name of the table being queried
      * @param queryParameters *OPTIONAL* the OData query parameters for refining search results: *format = $filter=filters&$select=columns*
      * @returns a Promise resolving the successful results of the GET request, or rejecting the failed results of the GET request
      */
-    getMultiple(tableSetName: string, queryParameters?: string): Promise<Array<object>>;
+    static getMultiple(tableSetName: string, queryParameters?: string): Promise<Array<object>>;
     /**
      *
      * @param tableSetName The dataverse set name for the table that you are updating a record in
@@ -27,6 +35,6 @@ declare const 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
      */
-    updateRecord(tableSetName: string, recordId: string, data: object): Promise<any>;
-};
+    static updateRecord(tableSetName: string, recordId: string, data: object): Promise<any>;
+}
 export default API;

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

@@ -1,34 +1,5 @@
-import * as s from "@/constants/symbols.js";
-declare type 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: () => boolean, clearValuesOnHide?: boolean];
-    /**
-     * @param isRequired Function determining if field is required
-     * @param isValid Function validating field input.
-     */
-    setRequired?: [
-        isRequired: () => boolean,
-        isValid: (isRequired: 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: () => 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;
-};
+/// <reference path="../globals.d.ts" />
+import * as s from "../constants/symbols.d.ts";
 export default class DOMNodeReference {
     target: Element | string;
     logicalName?: string;
@@ -99,6 +70,7 @@ export default class DOMNodeReference {
      * @public
      */
     updateValue(e?: Event): void;
+    protected validateValue(value: any): any;
     /**
      * Sets up an event listener based on the specified event type, executing the specified
      * event handler
@@ -119,7 +91,6 @@ export default class DOMNodeReference {
      */
     show(): DOMNodeReference;
     /**
-     *
      * @param shouldShow - Either a function that returns true or false,
      * or a natural boolean to determine the visibility of this
      * @returns - Instance of this [provides option to method chain]
@@ -153,7 +124,6 @@ export default class DOMNodeReference {
      */
     enable(): DOMNodeReference;
     /**
-     *
      * @param elements - The elements to prepend to the element targeted by this.
      * @returns - Instance of this [provides option to method chain]
      */
@@ -207,7 +177,6 @@ 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]
      */
@@ -225,31 +194,6 @@ export default class DOMNodeReference {
      * @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;
     /**
      * Sets up tracking for dependencies using both event listeners and mutation observers.
      * @protected
@@ -281,4 +225,3 @@ export default class DOMNodeReference {
      */
     onceLoaded(callback: (instance: DOMNodeReference) => any): any;
 }
-export {};

package/dist/{types → src}/core/DOMNodeReferenceArray.d.ts

@@ -1,4 +1,5 @@
-import DOMNodeReference from "./DOMNodeReference.js";
+/// <reference path="../globals.d.ts" />
+import type DOMNodeReference from "./DOMNodeReference.d.ts";
 export default class DOMNodeReferenceArray extends Array<DOMNodeReference> {
     /**
      * Hides all the containers of the DOMNodeReference instances in the array.

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

@@ -0,0 +1,13 @@
+/// <reference path="../globals.d.ts" />
+export default class List {
+    private static _instance;
+    private _root;
+    private _listItems;
+    private _observer;
+    private constructor();
+    static get(): List;
+    private _observe;
+    private _update;
+    private _destroy;
+    destroy(): void;
+}

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

@@ -0,0 +1,28 @@
+/// <reference path="../globals.d.ts" />
+import type DOMNodeReference from "./DOMNodeReference.d.ts";
+import type DOMNodeReferenceArray from "./DOMNodeReferenceArray.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.
+ * 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
+ * @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"]
+ * @example
+ * ```js
+ * bindForm("form-guid-0000").then((form) => {
+ *    //...use the form
+ *    const field = form["field_logical_name"]
+ *    // or
+ *    form["other_logical_name"].someMethod()
+ * })
+ *
+ * // or
+ *
+ * const form = await bindForm("form-guid-0000")
+ * ```
+ *  @see {@link BoundForm}
+ *  @see {@link DOMNodeReference}
+ */
+export default function bindForm(formId: string): Promise<DOMNodeReferenceArray & Record<string, DOMNodeReference>>;

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

@@ -1,14 +1,19 @@
-import DOMNodeReference from "./DOMNodeReference.js";
-import DOMNodeReferenceArray from "./DOMNodeReferenceArray.js";
+/// <reference path="../globals.d.ts" />
+import DOMNodeReference from "./DOMNodeReference.d.ts";
+import type DOMNodeReferenceArray from "./DOMNodeReferenceArray.d.ts";
 /**
  * Creates and initializes a DOMNodeReference instance.
  * @see {@link CreationOptions}
- * @param  target The CSS selector for the desired DOM element, or, optionally, the element itself for which to create a DOMNodeReference.
- * @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.
+ * @param  **target** - The selector, using `querySelector` syntax, for the desired DOM element. Or, the `HTMLElement` itself for which to create a DOMNodeReference.
+ * @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.
+ *
+ * @see {@link DOMNodeReference}
+ * @see {@link DOMNodeReferenceArray}
+ * @see {@link enhanceArray}
  */
 export default function createDOMNodeReference(target: string | HTMLElement, options?: {
     /**

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

@@ -0,0 +1,9 @@
+/// <reference path="../globals.d.ts" />
+/**
+ * Provides an async way to capture DOM elements; for when querySelector cannot capture the target due to async DOM content loading
+ * @param **target** - basic querySelector syntax to select an element
+ * @param **root** - optional parameter to replace document as the root from which to perform the node search
+ * @returns the element(s) targeted by the `querySelector` string
+ */
+export default function waitFor(target: string, root: Element | Document, multiple: false, debounceTime: number): Promise<HTMLElement>;
+export default function waitFor(target: string, root: Element | Document, multiple: true, debounceTime: number): Promise<HTMLElement[]>;

package/dist/{types → src}/errors/errors.d.ts

@@ -1,4 +1,5 @@
-import DOMNodeReference from "../core/DOMNodeReference.js";
+/// <reference path="../globals.d.ts" />
+import type DOMNodeReference from "../core/DOMNodeReference.d.ts";
 export declare class DOMNodeInitializationError extends Error {
     constructor(instance: DOMNodeReference, error: string);
 }

package/dist/src/globals.d.ts

@@ -0,0 +1,152 @@
+/// <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?
+   * Defaults to false, returning a single instance.
+   */
+  multiple?: (() => boolean) | boolean;
+
+  /**
+   * Optionally specify the element within which to search for the element targeted by 'target'.
+   * Defaults to 'document.body'.
+   */
+  root?: HTMLElement;
+
+  /**
+   * Optionally specify the amount of time that should be waited to find the targeted element before throwing an error.
+   * Useful for async DOM loading. Relies on MutationObserver.
+   * WARNING: Implementing multiple references with timeout can result in infinite loading.
+   */
+  timeoutMs?: number;
+}
+
+declare interface SystemForm extends Object {
+  "@odata.context": string;
+  "@odata.etag": string;
+  "overwritetime@OData.Community.Display.V1.FormattedValue": string;
+  overwritetime: Date;
+  "isdesktopenabled@OData.Community.Display.V1.FormattedValue": string;
+  isdesktopenabled: boolean;
+  "publishedon@OData.Community.Display.V1.FormattedValue": Date;
+  publishedon: Date;
+  "_organizationid_value@OData.Community.Display.V1.FormattedValue": string;
+  "_organizationid_value@Microsoft.Dynamics.CRM.associatednavigationproperty": string;
+  "_organizationid_value@Microsoft.Dynamics.CRM.lookuplogicalname": string;
+  _organizationid_value: string;
+  formxml: string;
+  introducedversion: string;
+  "isairmerged@OData.Community.Display.V1.FormattedValue": string;
+  isairmerged: boolean;
+  "istabletenabled@OData.Community.Display.V1.FormattedValue": string;
+  istabletenabled: boolean;
+  solutionid: string;
+  formidunique: string;
+  "ismanaged@OData.Community.Display.V1.FormattedValue": string;
+  ismanaged: boolean;
+  "isdefault@OData.Community.Display.V1.FormattedValue": string;
+  isdefault: boolean;
+  "objecttypecode@OData.Community.Display.V1.FormattedValue": string;
+  objecttypecode: string;
+  "type@OData.Community.Display.V1.FormattedValue": string;
+  type: number;
+  "componentstate@OData.Community.Display.V1.FormattedValue": string;
+  componentstate: number;
+  "formpresentation@OData.Community.Display.V1.FormattedValue": string;
+  formpresentation: number;
+  "formactivationstate@OData.Community.Display.V1.FormattedValue": string;
+  formactivationstate: number;
+  name: string;
+  "versionnumber@OData.Community.Display.V1.FormattedValue": string;
+  versionnumber: number;
+  formjson: string;
+  description: string;
+  formid: string;
+}
+
+declare interface Form extends Partial<SystemForm> {
+  formxml: string;
+}
+
+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
+  ];
+  /**
+   * @param isRequired Function determining if field is required
+   * @param isValid Function validating field input.
+   */
+  setRequired?: [
+    isRequired: () => boolean,
+    isValid: (this: DOMNodeReference, isRequired: 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
+  ];
+  /**
+   * @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;
+}
+
+declare interface CreationOptions {
+  /**
+   * Should this call return an array of instantiated references, or just a single?
+   * Defaults to false, returning a single instance.
+   */
+  multiple?: (() => boolean) | boolean;
+
+  /**
+   * Optionally specify the element within which to search for the element targeted by 'target'.
+   * Defaults to 'document.body'.
+   */
+  root?: HTMLElement;
+
+  /**
+   * Optionally specify the amount of time that should be waited to find the targeted element before throwing an error.
+   * Useful for async DOM loading. Relies on MutationObserver.
+   * WARNING: Implementing multiple references with timeout can result in infinite loading.
+   */
+  timeoutMs?: number;
+}
+
+declare const Page_Validators: any[];
+
+declare interface ElementValue {
+  value: any;
+  checked?: boolean;
+}
+
+declare type RadioType = "truthy" | "falsy";
+
+declare interface BoundEventListener {
+  element: Element;
+  event: keyof HTMLElementEventMap;
+  handler: (e: Event) => unknown;
+}
+
+declare type FormElement =
+  | HTMLInputElement
+  | HTMLSelectElement
+  | HTMLTextAreaElement
+  | HTMLSpanElement
+  | HTMLButtonElement
+  | HTMLFieldSetElement;

package/dist/src/index.d.ts

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