@elliemae/loan-field-renderers 26.2.2

package/dist/cjs/renderer/base/hooks/fieldDescription.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fieldDescription_exports = {};
+__export(fieldDescription_exports, {
+  FieldDescription: () => FieldDescription
+});
+module.exports = __toCommonJS(fieldDescription_exports);
+var import_hookBase = require("./hookBase");
+class FieldDescription extends import_hookBase.HookBase {
+  getFieldAriaDescProps(label, description) {
+    if (description) {
+      if (this.BLL.Core.CoreUtils.Validate.isNullOrUndefined(label) || label === "") {
+        return {
+          "aria-label": description
+        };
+      }
+      return {
+        "aria-description": description
+      };
+    }
+    return {};
+  }
+}

package/dist/cjs/renderer/base/hooks/fieldDisabled.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fieldDisabled_exports = {};
+__export(fieldDisabled_exports, {
+  FieldDisabled: () => FieldDisabled
+});
+module.exports = __toCommonJS(fieldDisabled_exports);
+var import_react = require("react");
+var import_hookBase = require("./hookBase");
+class FieldDisabled extends import_hookBase.HookBase {
+  async isLoanReadonly() {
+    try {
+      const readonlyStatus = await this.BLL.SSF.isReadOnlyLoan();
+      return readonlyStatus;
+    } catch (error) {
+      this.BLL.Core.Log("error", `error fetching loan readonly status`, {
+        error
+      });
+      return false;
+    }
+  }
+  useFieldDisabled({
+    fieldId,
+    metadata,
+    isLockedState
+  }) {
+    const { isLockField = false, isReadOnly = false } = metadata || {};
+    const [isReadonlyLoan, setIsReadonlyLoan] = (0, import_react.useState)(false);
+    (0, import_react.useEffect)(() => {
+      (async () => {
+        const readonlyStatus = await this.isLoanReadonly();
+        setIsReadonlyLoan(readonlyStatus);
+      })();
+    }, [fieldId]);
+    return isReadonlyLoan || isLockField && !isLockedState || isReadOnly;
+  }
+}

package/dist/cjs/renderer/base/hooks/fieldGoTo.js

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fieldGoTo_exports = {};
+__export(fieldGoTo_exports, {
+  FieldGoTo: () => FieldGoTo
+});
+module.exports = __toCommonJS(fieldGoTo_exports);
+var import_hookBase = require("./hookBase");
+class FieldGoTo extends import_hookBase.HookBase {
+  async isGoToField(fieldId) {
+    const formDetails = this.BLL.SSF.getCachedGTFFormDetails();
+    if (formDetails) {
+      return formDetails.fieldId === fieldId;
+    }
+    try {
+      const fetchedDetails = await this.BLL.SSF.getGTFSelectedFormDetails();
+      if (fetchedDetails) {
+        this.BLL.SSF.setCachedGTFFormDetails(fetchedDetails);
+        return fetchedDetails.fieldId === fieldId;
+      }
+      return false;
+    } catch (error) {
+      this.BLL.Core.Log(
+        "error",
+        `Error fetching GTF selected form details in fetchGTFFormDetails for fieldId ${fieldId}`,
+        {
+          fieldId,
+          error
+        }
+      );
+      return false;
+    }
+  }
+}

package/dist/cjs/renderer/base/hooks/fieldLocked.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fieldLocked_exports = {};
+__export(fieldLocked_exports, {
+  FieldLocked: () => FieldLocked
+});
+module.exports = __toCommonJS(fieldLocked_exports);
+var import_hookBase = require("./hookBase");
+class FieldLocked extends import_hookBase.HookBase {
+  async getFieldLockStatus(fieldId) {
+    try {
+      const lockedStatus = await this.BLL.SSF.getLockStatus(fieldId);
+      return lockedStatus;
+    } catch (error) {
+      this.BLL.Core.Log(
+        "error",
+        `error fetching field lock status for ${fieldId}`,
+        {
+          fieldId,
+          error
+        }
+      );
+      return false;
+    }
+  }
+}

package/dist/cjs/renderer/base/hooks/fieldMeta.js

@@ -0,0 +1,150 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators2, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators2.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators2[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var fieldMeta_exports = {};
+__export(fieldMeta_exports, {
+  FieldMeta: () => FieldMeta
+});
+module.exports = __toCommonJS(fieldMeta_exports);
+var import_pui_app_sdk = require("@elliemae/pui-app-sdk");
+var import_hookBase = require("./hookBase");
+class FieldMeta extends import_hookBase.HookBase {
+  async getMetadata(fieldId) {
+    try {
+      const fieldPaths = await this.BLL.SSF.getFieldContractPaths();
+      const { fieldData, isCollection } = await this.lookupFieldData(
+        fieldId,
+        fieldPaths
+      );
+      const [
+        contractPath,
+        isNullable,
+        fieldFormat,
+        description,
+        isReadOnly,
+        maxLength,
+        options,
+        isLockField
+      ] = fieldData;
+      const finalContractPath = await this.transformContractPath(
+        contractPath,
+        fieldId,
+        isCollection
+      );
+      return await this.buildFieldMetadata({
+        contractPath: finalContractPath,
+        isNullable,
+        fieldFormat,
+        description,
+        isReadOnly,
+        maxLength,
+        options,
+        isLockField
+      });
+    } catch (error) {
+      return this.handleMetadataError(fieldId, error);
+    }
+  }
+  async lookupFieldData(fieldId, fieldPaths) {
+    let fieldData = fieldPaths[fieldId];
+    let isCollection = false;
+    let lookupFieldId = fieldId;
+    if (!fieldData) {
+      lookupFieldId = await this.BLL.SSF.resolveBaseCollectionId(fieldId);
+      isCollection = lookupFieldId !== fieldId;
+      fieldData = fieldPaths[lookupFieldId];
+    }
+    if (!fieldData) {
+      throw new Error(
+        `Field metadata not found for ${fieldId}${isCollection ? ` (base: ${lookupFieldId})` : ""}`
+      );
+    }
+    return { fieldData, isCollection };
+  }
+  async transformContractPath(contractPath, fieldId, isCollection) {
+    if (!isCollection) {
+      return contractPath;
+    }
+    const rowIndex = await this.BLL.SSF.getCollectionRowIndex(fieldId);
+    const collectionIndex = rowIndex - 1;
+    return contractPath.replace(/\[%\]/g, `[${collectionIndex}]`);
+  }
+  async buildFieldMetadata(params) {
+    const {
+      contractPath,
+      isNullable,
+      fieldFormat,
+      description,
+      isReadOnly,
+      maxLength,
+      options,
+      isLockField
+    } = params;
+    const fieldMetadata = {
+      contractPath,
+      isNullable: Boolean(isNullable),
+      fieldFormat,
+      description: description || "",
+      isReadOnly: Boolean(isReadOnly),
+      maxLength,
+      isLockField: Boolean(isLockField),
+      fieldOptions: options && options.length > 0 ? options.map((option, currentIdx) => ({
+        dsId: `${currentIdx}`,
+        type: "option",
+        label: option[0],
+        value: option[1]
+      })) : []
+    };
+    if (fieldMetadata.fieldFormat === "ST") {
+      fieldMetadata.fieldOptions = await this.fetchStateOptions();
+    }
+    return fieldMetadata;
+  }
+  handleMetadataError(fieldId, error) {
+    this.BLL.Core.Log("error", `error fetching field metadata for ${fieldId}`, {
+      fieldId,
+      error
+    });
+    throw this.BLL.Core.ExceptionUtils.runtimeException(
+      error.message || "Unknown error",
+      {
+        context: `field metadata for fieldId: ${fieldId} not found`
+      }
+    );
+  }
+  async fetchStateOptions() {
+    const stateOptions = await this.BLL.SSF.getStateDropDownList();
+    return stateOptions?.map((state, idx) => ({
+      dsId: `${idx}`,
+      type: "option",
+      label: state.name,
+      value: state.value
+    }));
+  }
+}
+__decorateClass([
+  import_pui_app_sdk.decorators.function.MemoizeAsync
+], FieldMeta.prototype, "fetchStateOptions", 1);

package/dist/cjs/renderer/base/hooks/fieldSubscribers.js

@@ -0,0 +1,66 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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);
+var fieldSubscribers_exports = {};
+__export(fieldSubscribers_exports, {
+  FieldSubscribers: () => FieldSubscribers
+});
+module.exports = __toCommonJS(fieldSubscribers_exports);
+var elli = __toESM(require("@elliemae/em-ssf-guest"));
+var import_react = require("react");
+var import_hookBase = require("./hookBase");
+class FieldSubscribers extends import_hookBase.HookBase {
+  useSubscribeEffect({
+    objectId = "loan",
+    eventName = "loanUpdated",
+    callback
+  }) {
+    (0, import_react.useEffect)(() => {
+      const token = elli.subscribe(objectId, eventName, callback);
+      return () => {
+        if (token) {
+          elli.unsubscribe(objectId, eventName, token);
+        }
+      };
+    }, []);
+  }
+  useLoanUpdatedCB(callback) {
+    this.useSubscribeEffect({
+      objectId: "loan",
+      eventName: "loanUpdated",
+      callback
+    });
+  }
+  useLoanChangeCB(callback) {
+    this.useSubscribeEffect({
+      objectId: "loan",
+      eventName: "change",
+      callback
+    });
+  }
+}

package/dist/cjs/renderer/base/hooks/fieldValidation.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fieldValidation_exports = {};
+__export(fieldValidation_exports, {
+  FieldValidation: () => FieldValidation
+});
+module.exports = __toCommonJS(fieldValidation_exports);
+var import_react = require("react");
+var import_hookBase = require("./hookBase");
+class FieldValidation extends import_hookBase.HookBase {
+  runValidationsOnValue(value, validationRules, customValidation) {
+    const result = { isValid: true, message: "" };
+    if (customValidation) {
+      customValidation(value);
+      return result;
+    }
+    if (validationRules.length > 0) {
+      return this.BLL.Validator.runValidators(validationRules, value);
+    }
+    return result;
+  }
+  useFieldValidation() {
+    const [validationResult, setValidationResult] = (0, import_react.useState)(null);
+    return {
+      validationResult,
+      setValidationResult
+    };
+  }
+}

package/dist/cjs/renderer/base/hooks/fieldValue.js

@@ -0,0 +1,215 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fieldValue_exports = {};
+__export(fieldValue_exports, {
+  FieldValue: () => FieldValue
+});
+module.exports = __toCommonJS(fieldValue_exports);
+var import_react = require("react");
+var import_hookBase = require("./hookBase");
+class FieldValue extends import_hookBase.HookBase {
+  async getFieldValue(fieldId) {
+    try {
+      const value = await this.BLL.SSF.getFieldValue(fieldId);
+      return value;
+    } catch (error) {
+      this.BLL.Core.Log("error", `error fetching field value for ${fieldId}`, {
+        fieldId,
+        error
+      });
+      return void 0;
+    }
+  }
+  formatValue(params) {
+    const { fieldValue, fieldFormat, options } = params;
+    if (fieldValue === null || fieldValue === void 0 || fieldValue === "") {
+      return fieldValue;
+    }
+    return this.formatByRendererType(fieldValue, fieldFormat, options);
+  }
+  formatByRendererType(fieldValue, fieldFormat, options) {
+    const { rendererType, maskType, numberMaskOptions } = options;
+    switch (rendererType) {
+      case "text":
+      case "email":
+      case "radiogroup":
+      case "radio":
+        return this.formatTextValue({
+          value: fieldValue,
+          fieldFormat,
+          maskType,
+          rendererType
+        });
+      case "number":
+        return this.formatNumberValue(
+          fieldValue,
+          fieldFormat,
+          numberMaskOptions
+        );
+      case "checkbox":
+        return this.formatBooleanValue(fieldValue);
+      case "date":
+        return this.formatDateValue(fieldValue, options.dateFormat);
+      case "dropdown":
+        return this.formatDropdownValue(fieldValue);
+      case "zipcode":
+        return this.formatZipValue(String(fieldValue));
+      default:
+        return fieldValue;
+    }
+  }
+  formatTextValue({
+    value,
+    fieldFormat,
+    maskType,
+    rendererType
+  }) {
+    if ((rendererType === "radio" || rendererType === "radiogroup") && fieldFormat === "Y") {
+      return this.formatBooleanValue(value);
+    }
+    if (maskType === "SSN" || fieldFormat === "SS") {
+      return this.BLL.Formatter.createFormatter("SS").format(value);
+    }
+    if (maskType === "Phone" || fieldFormat === "P") {
+      return this.BLL.Formatter.createFormatter("P").format(value, {
+        isInternational: false
+      });
+    }
+    return String(value);
+  }
+  formatNumberValue(value, fieldFormat, numberMaskOptions) {
+    return this.BLL.Formatter.createFormatter("D2").format(value, {
+      fieldFormat,
+      numberOptions: {
+        includeThousandsSeparator: true,
+        ...numberMaskOptions
+      }
+    });
+  }
+  formatBooleanValue(value) {
+    return this.BLL.Formatter.createFormatter("Y").format(value);
+  }
+  formatDateValue(value, dateFormat) {
+    return this.BLL.Formatter.createFormatter("DT").format(value, {
+      dateFormat
+    });
+  }
+  formatDropdownValue(value) {
+    const formatter = this.BLL.Formatter.createFormatter("DD");
+    return formatter.format(value);
+  }
+  formatZipValue(value) {
+    const formatter = this.BLL.Formatter.createFormatter("Z");
+    return formatter.format(value);
+  }
+  useFieldValue(params) {
+    const { fieldId, fieldFormat, options } = params;
+    const [fieldValue, setFieldValue] = (0, import_react.useState)(void 0);
+    (0, import_react.useEffect)(() => {
+      (async () => {
+        if (fieldFormat) {
+          const value = await this.getFieldValue(fieldId);
+          setFieldValue(
+            this.formatValue({
+              fieldValue: value,
+              fieldFormat,
+              options
+            })
+          );
+        }
+      })();
+    }, [fieldId, fieldFormat]);
+    return {
+      fieldValue,
+      setFieldValue
+    };
+  }
+  // eslint-disable-next-line complexity
+  parseValue(params) {
+    const { fieldValue, fieldFormat, options } = params;
+    if (fieldValue === null || fieldValue === void 0 || fieldValue === "") {
+      return fieldValue;
+    }
+    const { rendererType, maskType, unmaskPattern } = options;
+    switch (rendererType) {
+      case "text":
+      case "email":
+      case "radio":
+      case "radiogroup":
+        return this.parseTextValue({
+          rendererType,
+          value: fieldValue,
+          fieldFormat,
+          maskType,
+          unmaskPattern
+        });
+      case "number":
+        return this.parseNumberValue({
+          value: fieldValue,
+          fieldFormat,
+          unmaskPattern
+        });
+      case "checkbox":
+        return this.parseBooleanValue(fieldValue);
+      case "date":
+        return this.parseDateValue({
+          value: fieldValue,
+          dateFormat: options.dateFormat
+        });
+      case "zipcode":
+        return this.parseZipValue(String(fieldValue));
+      default:
+        return fieldValue;
+    }
+  }
+  parseTextValue(params) {
+    const { rendererType, value, fieldFormat, maskType, unmaskPattern } = params;
+    if ((rendererType === "radio" || rendererType === "radiogroup") && fieldFormat === "Y") {
+      return this.parseBooleanValue(value);
+    }
+    if (maskType === "SSN" || fieldFormat === "SS") {
+      return this.BLL.Formatter.createFormatter("SS").parse(String(value));
+    }
+    if (maskType === "Phone" || fieldFormat === "P") {
+      return this.BLL.Formatter.createFormatter("P").parse(String(value), {
+        unmaskPattern
+      });
+    }
+    return value;
+  }
+  parseNumberValue(params) {
+    const { value, fieldFormat, unmaskPattern } = params;
+    return this.BLL.Formatter.createFormatter("D2").parse(String(value), {
+      fieldFormat,
+      unmaskPattern
+    });
+  }
+  parseBooleanValue(value) {
+    return this.BLL.Formatter.createFormatter("Y").parse(Boolean(value));
+  }
+  parseDateValue(params) {
+    const { value, dateFormat } = params;
+    return this.BLL.Formatter.createFormatter("DT").parse(String(value), {
+      dateFormat
+    });
+  }
+  parseZipValue(value) {
+    return this.BLL.Formatter.createFormatter("Z").parse(value);
+  }
+}

package/dist/cjs/renderer/base/hooks/hookBase.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hookBase_exports = {};
+__export(hookBase_exports, {
+  HookBase: () => HookBase
+});
+module.exports = __toCommonJS(hookBase_exports);
+class HookBase {
+  BLL;
+  constructor(bll) {
+    this.BLL = bll;
+  }
+}