powerpagestoolkit 2.7.104 → 2.7.121-2.1

package/README.md

@@ -35,7 +35,7 @@ createRef(
   options: {
     multiple: (() => boolean) | boolean = false,
     root: HTMLElement,
-    timeout: number
+    timeoutMs:number
   }
 ): Promise<DOMNodeReference | DOMNodeReference[]>;
 ```
@@ -66,7 +66,7 @@ createRef takes two main arguments:
         <pre><code class="language-javascript">{
   multiple: () => boolean | boolean,
   root: HTMLElement,
-  timeout: number
+  timeoutMs:number
 }</code></pre>
       </td>
       <td style="border: 1px solid #ddd; padding: 8px;">
@@ -98,7 +98,7 @@ const nodes = await createRef(".my-class", { multiple: true });
 
 // If the node you are targeting is not available at the initial execution
 // of the script, set a timeout for 2 seconds
-const node2 = await createRef("#target", { timeout: 2000 });
+const node2 = await createRef("#target", { timeoutMs:2000 });
 
 // need to target a node within a specific node? use that node as the root
 const otherElement = document.getElementById("id");
@@ -107,7 +107,7 @@ const node3 = await createRef("#target", { root: otherElement });
 // implement all options:
 const nodes2 = await createRef("#target", {
   multiple: true,
-  timeout: 4000,
+  timeoutMs:4000,
   root: otherElement,
 });
 ```

package/dist/bundle.js

@@ -102,11 +102,11 @@ var API = {
 };
 var API_default = API;
 
-// src/utils/waitFor.ts
+// src/core/waitFor.ts
 function waitFor(target, root = document, multiple = false, debounceTime2) {
   return new Promise((resolve, reject) => {
     if (multiple) {
-      let timeout;
+      let timeoutMs;
       const observedElements = [];
       const observedSet = /* @__PURE__ */ new Set();
       if (debounceTime2 < 1) {
@@ -122,8 +122,8 @@ function waitFor(target, root = document, multiple = false, debounceTime2) {
             observedElements.push(element);
           }
         });
-        clearTimeout(timeout);
-        timeout = setTimeout(() => {
+        clearTimeout(timeoutMs);
+        timeoutMs = setTimeout(() => {
           if (observedElements.length > 0) {
             observer.disconnect();
             resolve(observedElements);

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

@@ -1,4 +1,31 @@
 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: () => 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;
+};
 export default class DOMNodeReference {
     target: Element | string;
     logicalName?: string;
@@ -251,3 +278,4 @@ export default class DOMNodeReference {
      */
     onceLoaded(callback: (instance: DOMNodeReference) => any): any;
 }
+export {};

package/dist/{core → types/core}/bindForm.d.ts

@@ -1,11 +1,13 @@
 import DOMNodeReference from "./DOMNodeReference.js";
 import DOMNodeReferenceArray from "./DOMNodeReferenceArray.js";
+declare type BoundForm = DOMNodeReferenceArray & Record<string, DOMNodeReference>;
 /**
- * @function
  * Get all controls related to the form for manipulating with the
  * DOMNodeReference class. Rather than having to instantiate each fields that you need manually,
  * you can call this method once with the form ID and gain access to all fields
  * @param formId The string GUID of the form you want to bind to
- * @returns An array of DOMNodeReferences
+ * @returns An array of DOMNodeReferences, accessible as properties of a Record<string, DOMNodeReference> i.e. formProp = form["some_logicalName"]
+ * @see {@link BoundForm}
  */
-export default function bindForm<T extends string>(formId: string): Promise<DOMNodeReferenceArray & Record<T, DOMNodeReference>>;
+export default function bindForm(formId: string): Promise<BoundForm>;
+export {};

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

@@ -1,5 +1,33 @@
 import DOMNodeReference from "./DOMNodeReference.js";
 import DOMNodeReferenceArray from "./DOMNodeReferenceArray.js";
+/**
+ * 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 results in infinite loading.
+ * @returns  A promise that resolves to a Proxy of the initialized DOMNodeReference instance.
+ */
+export default function createDOMNodeReference(target: string | HTMLElement, options?: {
+    /**
+     * 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;
+}): Promise<DOMNodeReference>;
 export default function createDOMNodeReference(target: string, options?: {
     /**
      * Should this call return an array of instantiated references, or just a single?

package/dist/{index.d.ts → types/index.d.ts}

@@ -1,6 +1,6 @@
 import "./style.css";
 import API from "./core/API.js";
 import createRef from "./core/createDOMNodeReferences.js";
-import waitFor from "./utils/waitFor.js";
+import waitFor from "./core/waitFor.js";
 import bindForm from "./core/bindForm.js";
 export { API, createRef, waitFor, bindForm };

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "powerpagestoolkit",
-  "version": "2.7.104",
+  "version": "2.7.1212.001",
   "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/index.js",
+  "main": "./dist/bundle.js",
   "types": "./dist/index.d.ts",
   "scripts": {
     "typecheck": "tsc",
     "node:build": "node build.js",
     "clean": "rimraf dist",
-    "build:types": "tsc --emitDeclarationOnly --declaration",
-    "build": "npm run clean && npm run typecheck && npm run node:build && npm run build:types",
+    "build:types": "tsc --emitDeclarationOnly --declaration --declarationDir ./dist/types",
+    "build": "npm run clean && npm run build:types && npm run node:build",
     "dev": "tsc --watch"
   },
   "devDependencies": {
@@ -59,15 +59,14 @@
   ],
   "files": [
     "dist/bundle.js",
-    "dist/index.js",
     "dist/bundle.css",
-    "dist/**/*.d.ts",
+    "dist/types/**/*.d.ts",
     "assets/**"
   ],
   "exports": {
     ".": {
       "import": "./dist/bundle.js",
-      "types": "./@types/index.d.ts"
+      "types": "./dist/types/index.d.ts"
     },
     "./createDOMNodeReference": {
       "import": "./dist/createDOMNodeReference.js",

package/dist/index.js

@@ -1,8 +0,0 @@
-/// <reference path="../@types/index.d.ts" />
-import "./style.css";
-import API from "./core/API.js";
-import createRef from "./core/createDOMNodeReferences.js";
-import waitFor from "./utils/waitFor.js";
-import bindForm from "./core/bindForm.js";
-export { API, createRef, waitFor, bindForm };
-//# sourceMappingURL=index.js.map