@abgov/react-components 6.5.0-alpha.3 → 6.5.0-alpha.4

package/index.mjs

@@ -1,5 +1,15 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _PublicFormController_instances, updateObjectListState_fn, dispatchError_fn;
 import { jsxs, jsx } from "react/jsx-runtime";
-import { useRef, useEffect, useLayoutEffect } from "react";
+import { useRef, useEffect, useLayoutEffect, useState, useCallback } from "react";
 import { G, a } from "./icon-CoYGOp1V.mjs";
 function GoabAccordion({
   open,
@@ -3767,6 +3777,326 @@ const GoabFilterChip = ({
     }
   );
 };
+class PublicFormController {
+  constructor(type) {
+    __privateAdd(this, _PublicFormController_instances);
+    __publicField(this, "state");
+    __publicField(this, "_formData");
+    __publicField(this, "_formRef");
+    this.type = type;
+  }
+  // Obtain reference to the form element
+  init(e) {
+    if (this._formRef) {
+      console.warn("init: form element has already been set");
+      return;
+    }
+    this._formRef = e.detail.el;
+    this.state = {
+      uuid: crypto.randomUUID(),
+      form: {},
+      history: [],
+      editting: "",
+      status: "not-started"
+    };
+  }
+  initList(e) {
+    this._formRef = e.detail.el;
+    this.state = [];
+  }
+  // Public method to allow for the initialization of the state
+  initState(state, callback) {
+    relay(this._formRef, "external::init:state", state);
+    if (typeof state === "string") {
+      this.state = JSON.parse(state);
+    } else if (!Array.isArray(state)) {
+      this.state = state;
+    }
+    if (callback) {
+      setTimeout(callback, 200);
+    }
+  }
+  updateListState(e) {
+    const detail = e.detail;
+    if (!Array.isArray(detail.data)) {
+      return;
+    }
+    this.state = detail.data;
+  }
+  updateObjectState(e) {
+    var _a, _b;
+    if (Array.isArray(this.state)) {
+      return;
+    }
+    const detail = e.detail;
+    if (detail.type === "list") {
+      this.state = {
+        ...this.state,
+        form: { ...((_a = this.state) == null ? void 0 : _a.form) || {}, [detail.id]: detail.data }
+      };
+    } else {
+      this.state = {
+        ...this.state,
+        ...detail.data,
+        form: { ...((_b = this.state) == null ? void 0 : _b.form) || {}, ...detail.data.form },
+        history: detail.data.history
+      };
+    }
+  }
+  getStateList() {
+    if (!this.state) {
+      return [];
+    }
+    if (!Array.isArray(this.state)) {
+      console.warn(
+        "Utils:getStateList: unable to update the state of a non-multi form type",
+        this.state
+      );
+      return [];
+    }
+    if (this.state.length === 0) {
+      return [];
+    }
+    return this.state.map((s) => {
+      return Object.values(s.form).filter((item) => {
+        var _a;
+        return ((_a = item == null ? void 0 : item.data) == null ? void 0 : _a.type) === "details";
+      }).map((item) => {
+        var _a;
+        return item.data.type === "details" && ((_a = item.data) == null ? void 0 : _a.fieldsets) || {};
+      }).reduce(
+        (acc, item) => {
+          for (const [key, value] of Object.entries(item)) {
+            acc[key] = value.value;
+          }
+          return acc;
+        },
+        {}
+      );
+    });
+  }
+  // getStateItems(group: string): Record<string, FieldsetItemState>[] {
+  //   if (Array.isArray(this.state)) {
+  //     console.error(
+  //       "Utils:getStateItems: unable to update the state of a multi form type",
+  //     );
+  //     return [];
+  //   }
+  //   if (!this.state) {
+  //     console.error("Utils:getStateItems: state has not yet been set");
+  //     return [];
+  //   }
+  //
+  //   const data = this.state.form[group].data;
+  //   if (data.type !== "list") {
+  //     return [];
+  //   }
+  //
+  //   return data.items.;
+  // }
+  // Public method to allow for the retrieval of the state value
+  getStateValue(group, key) {
+    if (Array.isArray(this.state)) {
+      console.error("getStateValue: unable to update the state of a multi form type");
+      return "";
+    }
+    if (!this.state) {
+      console.error("getStateValue: state has not yet been set");
+      return "";
+    }
+    const data = this.state.form[group].data;
+    if (data.type !== "details") {
+      return "";
+    }
+    return data.fieldsets[key].value;
+  }
+  // Public method to allow for the continuing to the next page
+  continueTo(next) {
+    if (!next) {
+      console.error("continueTo [name] is undefined");
+      return;
+    }
+    relay(this._formRef, "external::continue", { next });
+  }
+  // Public method to perform validation and send the appropriate messages to the form elements
+  validate(e, field, validators, options) {
+    var _a;
+    const { el, state, cancelled } = e.detail;
+    const value = (_a = state == null ? void 0 : state[field]) == null ? void 0 : _a.value;
+    window.scrollTo({ top: 0, behavior: "smooth" });
+    if (cancelled) {
+      return [true, value];
+    }
+    for (const validator of validators) {
+      const msg = validator(value);
+      __privateMethod(this, _PublicFormController_instances, dispatchError_fn).call(this, el, field, msg, options);
+      if (msg) {
+        return [false, ""];
+      }
+    }
+    return [true, value];
+  }
+  /**
+   * Validates a group of fields ensuring that at least `minPassCount` of the items within the group
+   * passes. This is useful in the scenario when n number fields are required out of n+m number of fields.
+   *
+   * @param {string[]} fields - An array of field names to be validated.
+   * @param {Event} e - The event object associated with the validation trigger.
+   * @param {FieldValidator[]} validators - An array of validator functions to apply to the fields.
+   * @return {[number, Record<string, boolean>]} - Returns back the number of fields that passed and a record of the fields and their pass status.
+   */
+  validateGroup(e, fields, validators) {
+    let passCount = 0;
+    const validGroups = {};
+    for (const field of fields) {
+      const [_valid] = this.validate(e, field, validators, { grouped: true });
+      if (_valid) {
+        validGroups[field] = true;
+        passCount++;
+      }
+    }
+    return [passCount, validGroups];
+  }
+  edit(index) {
+    relay(this._formRef, "external::alter:state", { index, operation: "edit" });
+  }
+  remove(index) {
+    relay(this._formRef, "external::alter:state", {
+      index,
+      operation: "remove"
+    });
+  }
+  // removes any data collected that doesn't correspond with the final history path
+  clean(data) {
+    return data.history.reduce((acc, fieldsetId) => {
+      acc[fieldsetId] = data.form[fieldsetId];
+      return acc;
+    }, {});
+  }
+}
+_PublicFormController_instances = new WeakSet();
+updateObjectListState_fn = function(detail) {
+  var _a;
+  if (!Array.isArray(detail.data)) {
+    return;
+  }
+  if (Array.isArray(this.state)) {
+    return;
+  }
+  this.state = {
+    ...this.state,
+    form: {
+      ...((_a = this.state) == null ? void 0 : _a.form) || {},
+      [detail.id]: detail.data
+    }
+  };
+};
+// Private method to dispatch the error message to the form element
+dispatchError_fn = function(el, name, msg, options) {
+  el.dispatchEvent(
+    new CustomEvent("msg", {
+      composed: true,
+      detail: {
+        action: "external::set:error",
+        data: {
+          name,
+          msg,
+          grouped: options == null ? void 0 : options.grouped
+        }
+      }
+    })
+  );
+};
+function relay(el, eventName, data, opts) {
+  if (!el) {
+    console.error("dispatch element is null");
+    return;
+  }
+  el.dispatchEvent(
+    new CustomEvent("msg", {
+      composed: true,
+      bubbles: opts == null ? void 0 : opts.bubbles,
+      detail: {
+        action: eventName,
+        data
+      }
+    })
+  );
+}
+function usePublicFormController(type = "details") {
+  const controllerRef = useRef(new PublicFormController(type));
+  const [state, setState] = useState(void 0);
+  useEffect(() => {
+    var _a, _b;
+    const originalStateGetter = (_a = Object.getOwnPropertyDescriptor(
+      Object.getPrototypeOf(controllerRef.current),
+      "state"
+    )) == null ? void 0 : _a.get;
+    const originalStateSetter = (_b = Object.getOwnPropertyDescriptor(
+      Object.getPrototypeOf(controllerRef.current),
+      "state"
+    )) == null ? void 0 : _b.set;
+    if (originalStateGetter && originalStateSetter) {
+      Object.defineProperty(controllerRef.current, "state", {
+        get: function() {
+          return originalStateGetter.call(this);
+        },
+        set: function(value) {
+          originalStateSetter.call(this, value);
+          setState(value);
+        },
+        configurable: true
+      });
+    }
+  }, []);
+  const init = useCallback((e) => {
+    var _a;
+    if (!((_a = e.detail) == null ? void 0 : _a.el)) {
+      console.error("El is null during initialization");
+      return;
+    }
+    controllerRef.current.init(e);
+  }, []);
+  const initList = useCallback((e) => {
+    var _a;
+    const customEvent = e;
+    if (!((_a = customEvent == null ? void 0 : customEvent.detail) == null ? void 0 : _a.el)) {
+      console.error("El is null during list initialization");
+      return;
+    }
+    controllerRef.current.initList(e);
+  }, []);
+  const initState = useCallback((state2, callback) => {
+    if (!controllerRef.current._formRef) {
+      console.error("Form ref not set.");
+      return;
+    }
+    controllerRef.current.initState(state2, callback);
+  }, []);
+  const continueTo = useCallback((next) => {
+    controllerRef.current.continueTo(next);
+  }, []);
+  const validate = useCallback((e, field, validators) => {
+    return controllerRef.current.validate(e, field, validators);
+  }, []);
+  const getStateValue = useCallback((group, key) => {
+    return controllerRef.current.getStateValue(group, key);
+  }, []);
+  const getStateList = useCallback(() => {
+    return controllerRef.current.getStateList();
+  }, []);
+  return {
+    state,
+    init,
+    initList,
+    initState,
+    continueTo,
+    validate,
+    getStateValue,
+    getStateList,
+    controller: controllerRef.current
+  };
+}
 export {
   GoALinkButton,
   GoabAccordion,
@@ -3851,6 +4181,7 @@ export {
   GoabTextArea as GoabTextarea,
   GoabThreeColumnLayout,
   GoabTooltip,
-  GoabTwoColumnLayout
+  GoabTwoColumnLayout,
+  usePublicFormController
 };
 //# sourceMappingURL=index.mjs.map