@xyo-network/react-form-group 2.81.9 → 2.82.0

package/dist/node/index.cjs

@@ -1,8 +1,11 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,6 +18,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -41,7 +52,7 @@ var import_react_shared = require("@xyo-network/react-shared");
 var FormGroupBaseContext = (0, import_react_shared.createContextEx)();
 
 // src/context/Provider.tsx
-var import_react = require("react");
+var import_react = __toESM(require("react"), 1);
 
 // src/FormGroup.ts
 var import_forget3 = require("@xylabs/forget");
@@ -52,104 +63,110 @@ var import_forget2 = require("@xylabs/forget");
 // src/control/accessor/ControlValueAccessorBase.ts
 var import_forget = require("@xylabs/forget");
 var import_module_abstract = require("@xyo-network/module-abstract");
-var DefaultSetOptions = { disableEmit: false };
-var ControlValueAccessorBase = class extends import_module_abstract.BaseEmitter {
+var DefaultSetOptions = {
+  disableEmit: false
+};
+var _ControlValueAccessorBase = class _ControlValueAccessorBase extends import_module_abstract.BaseEmitter {
+  config;
+  _error;
+  _previousValue;
+  _serializeSettings;
+  _touched;
+  _value;
   constructor(config) {
     super({});
     this.config = config;
+    this._error = "";
+    this._previousValue = void 0;
+    this._serializeSettings = {
+      sensitive: false,
+      serializable: false
+    };
+    this._touched = false;
+    this._value = void 0;
+    this.onChange = (_) => {
+    };
+    this.onErrorChange = () => {
+    };
+    this.onTouched = (_isTouched) => {
+    };
   }
-  _error = "";
-  _previousValue = void 0;
-  _serializeSettings = { sensitive: false, serializable: false };
-  _touched = false;
-  _value = void 0;
   /**
-   * The error message for the control.
-   */
+  * The error message for the control.
+  */
   get error() {
     return this._error;
   }
   /**
-   * The "previous value" of the input element.
-   */
+  * The "previous value" of the input element.
+  */
   get previousValue() {
     return this._previousValue;
   }
   /**
-   * The serialize settings of the input element.
-   */
+  * The serialize settings of the input element.
+  */
   get serializeSettings() {
     return this._serializeSettings;
   }
   /**
-   * The "touched" state of the input element.
-   */
+  * The "touched" state of the input element.
+  */
   get touched() {
     return this._touched;
   }
   /**
-   * The current value of the input element.
-   */
+  * The current value of the input element.
+  */
   get value() {
     return this._value;
   }
+  onChange;
+  onErrorChange;
+  onTouched;
   /**
-   * The registered callback function called when a change or input event occurs on the input
-   * element.
-   */
-  onChange = (_) => {
-  };
-  /**
-   * Registers a function called when the control error changes.
-   */
-  onErrorChange = () => {
-  };
-  /**
-   * The registered callback function called when a blur event occurs on the input element.
-   */
-  onTouched = (_isTouched) => {
-  };
-  /**
-   * Registers a function called when the control value changes.
-   * @param  {(_value:ValidControlValue)=>void} fn
-   * @returns void
-   */
+  * Registers a function called when the control value changes.
+  * @param  {(_value:ValidControlValue)=>void} fn
+  * @returns void
+  */
   registerOnChange(fn) {
     this.onChange = fn;
   }
   /**
-   * Registers a function called when the control error changes.
-   * @param  {(error:string)=>void} fn
-   */
+  * Registers a function called when the control error changes.
+  * @param  {(error:string)=>void} fn
+  */
   registerOnErrorChange(fn) {
     this.onErrorChange = fn;
   }
   /**
-   * Registers a function called when the control is touched.
-   * @param  {(isTouched:boolean)=>void} fn
-   * @returns void
-   */
+  * Registers a function called when the control is touched.
+  * @param  {(isTouched:boolean)=>void} fn
+  * @returns void
+  */
   registerOnTouched(fn) {
     this.onTouched = fn;
   }
   /**
-   * Sets the "touched" state of the input element.
-   * @param  {boolean} isTouched
-   */
+  * Sets the "touched" state of the input element.
+  * @param  {boolean} isTouched
+  */
   setTouched(isTouched) {
     if (this.touched !== isTouched) {
       this._touched = isTouched;
       this.onTouched(isTouched);
       if (this.config.disableEvents) return;
-      const emit = async () => await this.emit("touchChanged", { touched: isTouched });
+      const emit = /* @__PURE__ */ __name(async () => await this.emit("touchChanged", {
+        touched: isTouched
+      }), "emit");
       (0, import_forget.forget)(emit());
     }
   }
   /**
-   * Sets the "value" property on the input element.
-   * @param  {ValidControlValue} value
-   * @returns void
-   */
+  * Sets the "value" property on the input element.
+  * @param  {ValidControlValue} value
+  * @returns void
+  */
   setValue(value, options = DefaultSetOptions) {
     this._previousValue = this._value;
     const normalizedValue = value == null ? "" : value;
@@ -157,39 +174,45 @@ var ControlValueAccessorBase = class extends import_module_abstract.BaseEmitter
       this._value = normalizedValue;
       this.onChange(normalizedValue);
       if (this.config.disableEvents || options.disableEmit) return;
-      const emit = async () => await this.emit("valueChanged", { value: normalizedValue });
+      const emit = /* @__PURE__ */ __name(async () => await this.emit("valueChanged", {
+        value: normalizedValue
+      }), "emit");
       (0, import_forget.forget)(emit());
     }
   }
   /**
-   * Set the error message for the control.
-   * @param  {string} error
-   */
+  * Set the error message for the control.
+  * @param  {string} error
+  */
   setError(error) {
     if (this.error !== error) {
       this._error = error;
       this.onErrorChange(error);
       if (this.config.disableEvents) return;
-      const emit = async () => await this.emit("errorChanged", { error });
+      const emit = /* @__PURE__ */ __name(async () => await this.emit("errorChanged", {
+        error
+      }), "emit");
       (0, import_forget.forget)(emit());
     }
   }
   /**
-   * Sets the "previous value" of the input element.
-   * @param  {ValidControlValue} value
-   * @returns void
-   */
+  * Sets the "previous value" of the input element.
+  * @param  {ValidControlValue} value
+  * @returns void
+  */
   setPreviousValue(value) {
     this._previousValue = value;
   }
   /**
-   * Sets the serialize settings  of the input element.
-   * @param  {ControlSerializeSettings} settings
-   */
+  * Sets the serialize settings  of the input element.
+  * @param  {ControlSerializeSettings} settings
+  */
   setSerializeSettings(settings) {
     this._serializeSettings = settings;
   }
 };
+__name(_ControlValueAccessorBase, "ControlValueAccessorBase");
+var ControlValueAccessorBase = _ControlValueAccessorBase;
 
 // src/control/accessor/FormControlStatus.ts
 var VALID = "VALID";
@@ -198,70 +221,70 @@ var PENDING = "PENDING";
 var DISABLED = "DISABLED";
 
 // src/control/AbstractControl.ts
-var AbstractControl = class extends ControlValueAccessorBase {
+var _AbstractControl = class _AbstractControl extends ControlValueAccessorBase {
   _status = void 0;
   constructor() {
     super({});
   }
   /**
-   * A control is `disabled` when its `status` is `DISABLED`.
-   *
-   * Disabled controls are exempt from validation checks and
-   * are not included in the aggregate value of their ancestor
-   * controls.
-   *
-   * @returns True if the control is disabled, false otherwise.
-   */
+  * A control is `disabled` when its `status` is `DISABLED`.
+  *
+  * Disabled controls are exempt from validation checks and
+  * are not included in the aggregate value of their ancestor
+  * controls.
+  *
+  * @returns True if the control is disabled, false otherwise.
+  */
   /** @deprecated - disabled functionality not implemented */
   get disabled() {
     return this.status === DISABLED;
   }
   /**
-   * A control is `enabled` as long as its `status` is not `DISABLED`.
-   *
-   * @returns True if the control has any status other than 'DISABLED',
-   * false if the status is 'DISABLED'.
-   */
+  * A control is `enabled` as long as its `status` is not `DISABLED`.
+  *
+  * @returns True if the control has any status other than 'DISABLED',
+  * false if the status is 'DISABLED'.
+  */
   get enabled() {
     return this.status !== DISABLED;
   }
   /**
-   * A control is `invalid` when its `status` is `INVALID`.
-   
-   *
-   * @returns True if this control has failed one or more of its validation checks,
-   * false otherwise.
-   */
+     * A control is `invalid` when its `status` is `INVALID`.
+  
+     *
+     * @returns True if this control has failed one or more of its validation checks,
+     * false otherwise.
+     */
   get invalid() {
     return this.status === INVALID;
   }
   /**
-   * A control is `pending` when its `status` is `PENDING`.
-   *
-   * @returns True if this control is in the process of conducting a validation check,
-   * false otherwise.
-   */
+  * A control is `pending` when its `status` is `PENDING`.
+  *
+  * @returns True if this control is in the process of conducting a validation check,
+  * false otherwise.
+  */
   get pending() {
     return this.status == PENDING;
   }
   /**
-   * The raw value of the control.
-   */
+  * The raw value of the control.
+  */
   get rawValue() {
     return this.value;
   }
   /**
-   * The current status of the control.
-   */
+  * The current status of the control.
+  */
   get status() {
     return this._status;
   }
   /**
-   * A control is `valid` when its `status` is `VALID`.
-   *
-   * @returns True if the control has passed all of its validation tests,
-   * false otherwise.
-   */
+  * A control is `valid` when its `status` is `VALID`.
+  *
+  * @returns True if the control has passed all of its validation tests,
+  * false otherwise.
+  */
   get valid() {
     return this.status === VALID;
   }
@@ -272,21 +295,28 @@ var AbstractControl = class extends ControlValueAccessorBase {
   setStatus(status) {
     if (this._status === status) return;
     this._status = status;
-    const emit = async () => await this.emit("statusChanged", { status });
+    const emit = /* @__PURE__ */ __name(async () => await this.emit("statusChanged", {
+      status
+    }), "emit");
     (0, import_forget2.forget)(emit());
   }
   validate() {
     return true;
   }
 };
+__name(_AbstractControl, "AbstractControl");
+var AbstractControl = _AbstractControl;
 
 // src/control/FormControlBase.ts
 var AllowAllRegex = /^.*$/s;
-var FormControlBase = class extends AbstractControl {
+var _FormControlBase = class _FormControlBase extends AbstractControl {
   /**
-   * The current and previous cursor position of the input element.
-   */
-  cursorPosition = { current: void 0, previous: void 0 };
+  * The current and previous cursor position of the input element.
+  */
+  cursorPosition = {
+    current: void 0,
+    previous: void 0
+  };
   invalidMessage = "Invalid input";
   pattern = AllowAllRegex;
   patternStrict = AllowAllRegex;
@@ -302,8 +332,8 @@ var FormControlBase = class extends AbstractControl {
   get rawValue() {
     return this.unmask && this.value ? this.unmask(this.value) : this.value;
   }
-  onCursorChange = () => {
-  };
+  onCursorChange = /* @__PURE__ */ __name(() => {
+  }, "onCursorChange");
   setValue(value = "", setOptions) {
     var _a, _b;
     if (this.unmask && this.pattern) {
@@ -335,17 +365,24 @@ var FormControlBase = class extends AbstractControl {
     this._name = name;
   }
 };
+__name(_FormControlBase, "FormControlBase");
+var FormControlBase = _FormControlBase;
 
 // src/FormGroup.ts
-var FormGroup = class extends AbstractControl {
+var _FormGroup = class _FormGroup extends AbstractControl {
+  fgParams;
+  _controls;
+  serializeListeners;
+  serializedSensitiveState;
+  serializedState;
   constructor(fgParams) {
     super();
     this.fgParams = fgParams;
+    this._controls = {};
+    this.serializeListeners = {};
+    this.serializedSensitiveState = {};
+    this.serializedState = {};
   }
-  _controls = {};
-  serializeListeners = {};
-  serializedSensitiveState = {};
-  serializedState = {};
   get errorSummary() {
     const errorSummary = {
       errorMessage: "",
@@ -455,7 +492,7 @@ var FormGroup = class extends AbstractControl {
     if (!shouldSerialize && (storage || sensitiveStorage)) console.warn("storage medium set but serialize is not enabled");
     if (shouldSerialize && control.serializeSettings.serializable) {
       this.setStateValueFromStorage(name, control);
-      const listener = ({ value }) => {
+      const listener = /* @__PURE__ */ __name(({ value }) => {
         if (control.serializeSettings.serializable) {
           const targetStorage = control.serializeSettings.sensitive ? sensitiveStorage : storage;
           const targetState = control.serializeSettings.sensitive ? this.serializedSensitiveState : this.serializedState;
@@ -464,48 +501,63 @@ var FormGroup = class extends AbstractControl {
           payloadWithTimestamp.timestamp = Date.now();
           this.serializeValues(targetStorage, targetState);
         }
-      };
+      }, "listener");
       control.on("valueChanged", listener);
       this.serializeListeners[name] = listener;
     }
   }
   serializeValues(storage, values) {
     if (storage && values) {
-      const write = async () => await storage.insert(values);
-      const clear = async () => await storage.clear();
+      const write = /* @__PURE__ */ __name(async () => await storage.insert(values), "write");
+      const clear = /* @__PURE__ */ __name(async () => await storage.clear(), "clear");
       (0, import_forget3.forget)(clear());
       (0, import_forget3.forget)(write());
     }
   }
   setStateValueFromStorage(name, control) {
-    const read = async () => {
+    const read = /* @__PURE__ */ __name(async () => {
       const savedValue = await this.getSerializedValue(name, control.serializeSettings.sensitive);
       if (savedValue) {
         const targetState = control.serializeSettings.sensitive ? this.serializedSensitiveState : this.serializedState;
         targetState[name] = savedValue;
-        control.setValue(savedValue, { disableEmit: true });
+        control.setValue(savedValue, {
+          disableEmit: true
+        });
       }
-    };
+    }, "read");
     (0, import_forget3.forget)(read());
   }
 };
+__name(_FormGroup, "FormGroup");
+var FormGroup = _FormGroup;
 
 // src/context/Provider.tsx
-var import_jsx_runtime = require("react/jsx-runtime");
-var FormGroupPayloadProvider = ({ children, params, ...props }) => {
+var FormGroupPayloadProvider = /* @__PURE__ */ __name(({ children, params, ...props }) => {
   const formGroup = (0, import_react.useMemo)(() => {
     const formGroup2 = new FormGroup(params);
     return formGroup2;
-  }, [params]);
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FormGroupBaseContext.Provider, { value: { formGroup, provided: true }, ...props, children });
-};
+  }, [
+    params
+  ]);
+  return (
+    // eslint-disable-next-line @eslint-react/no-unstable-context-value
+    /* @__PURE__ */ import_react.default.createElement(FormGroupBaseContext.Provider, {
+      value: {
+        formGroup,
+        provided: true
+      },
+      ...props
+    }, children)
+  );
+}, "FormGroupPayloadProvider");
 
-// src/context/use.tsx
+// src/context/use.ts
 var import_react_shared2 = require("@xyo-network/react-shared");
-var useFormGroup = (required = false) => (0, import_react_shared2.useContextEx)(FormGroupBaseContext, "FormGroup", required);
+var useFormGroup = /* @__PURE__ */ __name((required = false) => (0, import_react_shared2.useContextEx)(FormGroupBaseContext, "FormGroup", required), "useFormGroup");
 
 // src/storage/ArchivistFormGroupStorage.ts
-var ArchivistFormGroupStorage = class {
+var _ArchivistFormGroupStorage = class _ArchivistFormGroupStorage {
+  archivist;
   constructor(archivist) {
     this.archivist = archivist;
   }
@@ -520,9 +572,13 @@ var ArchivistFormGroupStorage = class {
   }
   async insert(value) {
     var _a, _b;
-    await ((_b = (_a = this.archivist).insert) == null ? void 0 : _b.call(_a, [value]));
+    await ((_b = (_a = this.archivist).insert) == null ? void 0 : _b.call(_a, [
+      value
+    ]));
   }
 };
+__name(_ArchivistFormGroupStorage, "ArchivistFormGroupStorage");
+var ArchivistFormGroupStorage = _ArchivistFormGroupStorage;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbstractControl,