powerpagestoolkit 2.0.110 → 2.0.111

package/dist/API.d.ts

@@ -0,0 +1,32 @@
+declare const API: {
+    /**
+     *
+     * @param {Schema} schema an instance of a schema class, containing the desired information for the POST request
+     * @returns a Promise resolving the successful results *[record id]* of the POST request, or rejecting the failed results *[error]* of the POST request.
+     */
+    createRecord(schema: Schema): Promise<string>;
+    /**
+     *
+     * @param tableSetName The DataVerse SET name of the table being queried
+     * @param recordID the GUID of the records to be retrieved
+     * @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(tableSetName: string, recordID: string, selectColumns?: string): Promise<object>;
+    /**
+     *
+     * @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>>;
+    /**
+     *
+     * @param tableSetName The dataverse set name for the table that you are updating a record in
+     * @param recordId The GUID of the record that is being updated
+     * @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>;
+};
+export default API;

package/dist/DOMNodeReference.d.ts

@@ -0,0 +1,197 @@
+export declare const _init: unique symbol;
+/******/ /******/ /******/ export default class DOMNodeReference {
+    target: HTMLElement | string;
+    private isLoaded;
+    private defaultDisplay;
+    /**
+     * The value of the element that this node represents
+     * stays in syncs with the live DOM elements?.,m  via event handler
+     * @type {any}
+     */
+    value: any;
+    /**
+     * The element targeted when instantiating DOMNodeReference.
+     * Made available in order to perform normal DOM traversal,
+     * or access properties not available through this class.
+     * @property {HTMLElement | null}
+     */
+    element: HTMLElement;
+    private visibilityController;
+    checked: boolean;
+    /**
+     * 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.
+     * @property {DOMNodeReferenceProxy | null}
+     */
+    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.
+     * @property {DOMNodeReferenceProxy | null}
+     */
+    noRadio?: DOMNodeReference | null;
+    /**
+     * Creates an instance of DOMNodeReference.
+     * @param {string} target - The CSS selector to find the desired DOM element.
+     */
+    /******/ /******/ constructor(target: HTMLElement | string);
+    [_init](): Promise<void>;
+    private _initValueSync;
+    updateValue(): void;
+    private _observeValueChanges;
+    private _attachVisibilityController;
+    private _attachRadioButtons;
+    /**
+     * Sets up an event listener based on the specified event type, executing the specified
+     * event handler
+     * @param {string} eventType - The DOM event to watch for
+     * @param {(this: DOMNodeReference, e: Event) => void} eventHandler - The callback function that runs when the
+     * specified event occurs
+     * @returns - Instance of this
+     */
+    on(eventType: string, eventHandler: (e: Event) => void): DOMNodeReference;
+    /**
+     * Hides the element by setting its display style to "none".
+     * @returns - Instance of this
+     */
+    hide(): DOMNodeReference;
+    /**
+     * Shows the element by restoring its default display style.
+     * @returns - Instance of this
+     */
+    show(): DOMNodeReference;
+    /**
+     *
+     * @param {function(this: DOMNodeReference): boolean | boolean} shouldShow - Either a function that returns true or false,
+     * or a natural boolean to determine the visibility of this
+     * @returns - Instance of this
+     */
+    toggleVisibility(shouldShow: Function | boolean): DOMNodeReference;
+    /**
+     * Sets the value of the HTML element.
+     * @param {() => any} 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
+     * @returns - Instance of this
+     */
+    setValue(value: any): DOMNodeReference;
+    /**
+     * Disables the element so that users cannot input any data
+     * @returns - Instance of this
+     */
+    disable(): DOMNodeReference;
+    /**
+     * Enables the element so that users can input data
+     * @returns - Instance of this
+     */
+    enable(): DOMNodeReference;
+    /**
+     *
+     * @param {...HTMLElement} elements - The elements to prepend to the element targeted by this.
+     * @returns - Instance of this
+     */
+    prepend(...elements: HTMLElement[]): DOMNodeReference;
+    /**
+     * Appends child elements to the HTML element.
+     * @param {...HTMLElement} elements - The elements to append to the element targeted by this.
+     * @returns - Instance of this
+     */
+    append(...elements: HTMLElement[]): DOMNodeReference;
+    /**
+     * Inserts elements before the HTML element.
+     * @param {...HTMLElement} elements - The elements to insert before the HTML element.
+     * @returns - Instance of this
+     */
+    before(...elements: HTMLElement[]): DOMNodeReference;
+    /**
+     * Inserts elements after the HTML element.
+     * @param {...HTMLElement} elements - The elements to insert after the HTML element.
+     * @returns - Instance of this
+     */
+    after(...elements: HTMLElement[]): DOMNodeReference;
+    /**
+     * Retrieves the label associated with the HTML element.
+     * @returns {HTMLElement} The label element associated with this element.
+     */
+    getLabel(): HTMLElement | null;
+    /**
+     * Appends child elements to the label associated with the HTML element.
+     * @param {...HTMLElement} elements - The elements to append to the label.
+     * @returns - Instance of this
+     */
+    appendToLabel(...elements: HTMLElement[]): DOMNodeReference;
+    /**
+     * Adds a tooltip with specified text to the label associated with the HTML element.
+     * @param {string} text - The text to display in the tooltip.
+     * @returns - Instance of this
+     */
+    addLabelTooltip(text: string): DOMNodeReference;
+    /**
+     * Adds a tooltip with the specified text to the element
+     * @param {string} text - The text to display in the tooltip
+     * @returns - Instance of this
+     */
+    addTooltip(text: string): DOMNodeReference;
+    /**
+     * Sets the inner HTML content of the HTML element.
+     * @param {string} string - The text to set as the inner HTML of the element.
+     * @returns - Instance of this
+     */
+    setInnerHTML(string: string): this;
+    /**
+     * Removes this element from the DOM
+     * @returns - Instance of this
+     */
+    remove(): this;
+    /**
+     *
+     * @param {Partial<CSSStyleDeclaration} options and object containing the styles you want to set : {key: value} e.g.: {'display': 'block'}
+     * @returns - Instance of this
+     */
+    setStyle(options: Partial<CSSStyleDeclaration>): this;
+    /**
+     * Unchecks both the yes and no radio buttons if they exist.
+     * @returns - Instance of this
+     */
+    uncheckRadios(): DOMNodeReference;
+    /**
+     * Configures conditional rendering for the target element based on a condition
+     * and the visibility of one or more trigger elements.
+     *
+     * @param {(this: DOMNodeReference) => boolean} 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 {Array<DOMNodeReference>} [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.
+     * @returns - Instance of this
+     */
+    configureConditionalRendering(condition: () => boolean, dependencies: Array<DOMNodeReference>): DOMNodeReference;
+    /**
+     * Sets up validation and requirement rules for the field. This function dynamically updates the field's required status and validates its input based on the specified conditions.
+     *
+     * @param {function(this: DOMNodeReference): boolean} isRequired - A function that determines whether the field should be required. Returns `true` if required, `false` otherwise.
+     * @param {function(this: DOMNodeReference): boolean} isValid - A function that checks if the field's input is valid. Returns `true` if valid, `false` otherwise.
+     * @param {string} fieldDisplayName - The name of the field, used in error messages if validation fails.
+     * @param {Array<DOMNodeReference>} [dependencies] Other fields that this field’s requirement depends on. When these fields change, the required status of this field is re-evaluated. Make sure any DOMNodeReference used in `isRequired` or `isValid` is included in this array.
+     * @returns - Instance of this
+     */
+    configureValidationAndRequirements(isRequired: (instance: DOMNodeReference) => boolean, isValid: (instance: DOMNodeReference) => boolean, fieldDisplayName: string, dependencies: Array<DOMNodeReference>): DOMNodeReference;
+    /**
+     * Sets the required level for the field by adding or removing the "required-field" class on the label.
+     *
+     * @param {boolean} isRequired - Determines whether the field should be marked as required.
+     * If true, the "required-field" class is added to the label; if false, it is removed.
+     * @returns - Instance of this
+     */
+    setRequiredLevel(isRequired: Function | boolean): DOMNodeReference;
+    /**
+     * Executes a callback function once the element is fully loaded.
+     * If the element is already loaded, the callback is called immediately.
+     * Otherwise, a MutationObserver is used to detect when the element is added to the DOM.
+     * @param {Function} callback - A callback function to execute once the element is loaded.
+     */
+    onceLoaded(callback: (instance: DOMNodeReference) => any): any;
+}

package/dist/createDOMNodeReferences.d.ts

@@ -0,0 +1,15 @@
+import DOMNodeReference from "./DOMNodeReference.js";
+/**
+ * Creates and initializes a DOMNodeReference instance.
+ * @async
+ * @param {string | HTMLElement} target - The CSS selector for the desired DOM element, or, optionally, the element itself for which to create a DOMNodeReference.
+ * @returns {Promise<DOMNodeReference>} A promise that resolves to a Proxy of the initialized DOMNodeReference instance.
+ */
+export declare function createDOMNodeReference(target: HTMLElement | string): Promise<DOMNodeReference>;
+/**
+ * Creates and initializes multiple DOMNodeReference instances.
+ * @async
+ * @param {string} querySelector - The CSS selector for the desired DOM elements.
+ * @returns {Promise<DOMNodeReference[]>} A promise that resolves to an array of Proxies of initialized DOMNodeReference instances.
+ */
+export declare function createMultipleDOMNodeReferences(querySelector: string): Promise<DOMNodeReference[]>;

package/dist/createInfoElement.d.ts

@@ -0,0 +1 @@
+export default function CreateInfoEl(titleString: string): HTMLSpanElement;

package/dist/errors.d.ts

@@ -0,0 +1,10 @@
+import DOMNodeReference from "./DOMNodeReference.js";
+export declare class DOMNodeInitializationError extends Error {
+    constructor(instance: DOMNodeReference, error: string);
+}
+export declare class DOMNodeNotFoundError extends Error {
+    constructor(instance: DOMNodeReference);
+}
+export declare class ConditionalRenderingError extends Error {
+    constructor(instance: DOMNodeReference, error: string);
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import API from "./API.js";
+import { createDOMNodeReference, createMultipleDOMNodeReferences } from "./createDOMNodeReferences.js";
+import "./style.css";
+export { API, createDOMNodeReference, createMultipleDOMNodeReferences };

package/dist/safeAjax.d.ts

@@ -0,0 +1 @@
+export default function safeAjax(ajaxOptions: any): any;

package/dist/waitFor.d.ts

@@ -0,0 +1 @@
+export default function waitFor(target: HTMLElement | string): Promise<HTMLElement>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powerpagestoolkit",
-  "version": "2.0.110",
+  "version": "2.0.111",
   "description": "Reference, manipulate, and engage with Power Pages sites through the nodes in the DOM; use a variety of custom methods that allow customizing your power pages site quicker and easier.  ",
   "main": "./dist/bundle.js",
   "types": "./dist/index.d.ts",
@@ -55,12 +55,12 @@
   ],
   "files": [
     "dist/bundle.js",
-    "dist/@types"
+    "dist/**/*.d.ts"
   ],
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "types": "./dist/**/*.d.ts"
+      "types": "./dist/index.d.ts"
     },
     "./createDOMNodeReference": {
       "import": "./dist/createDOMNodeReference.js",