@heartlandone/vega 2.0.0-preview-3 → 2.0.0-preview-4

package/dist/cjs/_commonjsHelpers-537d719a.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function createCommonjsModule(fn, basedir, module) {
+	return module = {
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire();
+		}
+	}, fn(module, module.exports), module.exports;
+}
+
+function commonjsRequire () {
+	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+}
+
+exports.commonjsGlobal = commonjsGlobal;
+exports.createCommonjsModule = createCommonjsModule;

package/dist/cjs/{app-globals-9f849d87.js → app-globals-5379f0ea.js}

@@ -1,12 +1,12 @@
 'use strict';
 
-const vegaEventManager = require('./vegaEventManager-bc2b4a40.js');
+const featureFlagController = require('./featureFlagController-e3dc9be9.js');
+const vegaEventManager = require('./vegaEventManager-14c9a361.js');
 const log = require('./log-5d8066e0.js');
-const vegaDialogController = require('./vegaDialogController-7323f3be.js');
+const vegaDialogController = require('./vegaDialogController-01bddb6a.js');
 const globalSlimmerRegistry = require('./global-slimmer-registry-58eee093.js');
-const mapToComponentMethod = require('./map-to-component-method-bdf875d3.js');
-const vegaSlimmer = require('./vega-slimmer-f026897e.js');
-require('./internalVegaEventManager-78a14dbf.js');
+const vegaSlimmer = require('./vega-slimmer-af488dc3.js');
+require('./internalVegaEventManager-cfb1df83.js');
 require('./ui-23cd9abb.js');
 const typography = require('./typography-3d2ba97d.js');
 
@@ -37,8 +37,8 @@ class VegaWatchMethodCancelSlimmer extends vegaSlimmer.VegaSlimmer {
      * so we add this flag to skip empty the watch function in this case.
      */
     this.hasDisconnected = false;
-    this.isEnabled = vegaEventManager.FeatureFlag.isEnabled('VEGA_REACT.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD') &&
-      vegaEventManager.FeatureFlag.isEnabled('VEGA_FRAMEWORK.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD');
+    this.isEnabled = featureFlagController.FeatureFlag.isEnabled('VEGA_REACT.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD') &&
+      featureFlagController.FeatureFlag.isEnabled('VEGA_FRAMEWORK.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD');
     this.component = option.component;
   }
   /**
@@ -98,13 +98,13 @@ class VegaWatchMethodCancelSlimmer extends vegaSlimmer.VegaSlimmer {
   }
 }
 __decorate([
-  mapToComponentMethod.MapToComponentMethod('connectedCallback')
+  vegaSlimmer.MapToComponentMethod('connectedCallback')
 ], VegaWatchMethodCancelSlimmer.prototype, "connectedCallback", null);
 __decorate([
-  mapToComponentMethod.MapToComponentMethod('disconnectedCallback')
+  vegaSlimmer.MapToComponentMethod('disconnectedCallback')
 ], VegaWatchMethodCancelSlimmer.prototype, "disconnectedCallback", null);
 __decorate([
-  mapToComponentMethod.MapToComponentMethod('componentDidLoad')
+  vegaSlimmer.MapToComponentMethod('componentDidLoad')
 ], VegaWatchMethodCancelSlimmer.prototype, "componentDidLoad", null);
 
 /**
@@ -128,7 +128,7 @@ function appGlobalScript () {
  */
 function disableFeatureFlagFromClientGlobal() {
   if (globalThis['VegaDisabledFeatureKeys']) {
-    vegaEventManager.FeatureFlag.disable(...globalThis['VegaDisabledFeatureKeys']);
+    featureFlagController.FeatureFlag.disable(...globalThis['VegaDisabledFeatureKeys']);
   }
 }
 /**
@@ -136,7 +136,7 @@ function disableFeatureFlagFromClientGlobal() {
  */
 function enableFeatureFlagFromClientGlobal() {
   if (globalThis['VegaEnabledFeatureKeys']) {
-    vegaEventManager.FeatureFlag.enable(...globalThis['VegaEnabledFeatureKeys']);
+    featureFlagController.FeatureFlag.enable(...globalThis['VegaEnabledFeatureKeys']);
   }
 }
 /**

package/dist/cjs/array-5f977aa2.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const number = require('./number-7e7d9981.js');
+
+/**
+ * The function checks if two arrays are equal, either in order or ignoring order.
+ *
+ * @param {T[]} first - An array of type T, which is the first array to compare.
+ * @param {T[]} second - `second` is the second array that is being compared for equality with the
+ * first array (`first`).
+ * @param {boolean} [ignoreOrder=false] - The `ignoreOrder` parameter is a boolean flag that determines
+ * whether the order of elements in the arrays should be taken into account when comparing them. If
+ * `ignoreOrder` is set to `true`, the function will return `true` if the two arrays contain the same
+ * elements, regardless of their order
+ * @returns {boolean} The function `isArrayEqual` returns a boolean value indicating whether the two input arrays
+ * are equal or not. If the arrays are equal, it returns `true`, otherwise it returns `false`. The
+ * equality of the arrays can be determined either by comparing the elements in the same order or by
+ * ignoring the order of the elements.
+ */
+const isArrayEqual = (first, second, ignoreOrder = false) => {
+  if (!Array.isArray(first) || !Array.isArray(second) || first.length != second.length)
+    return false;
+  if (ignoreOrder) {
+    const firstSet = new Set(first);
+    const secondSet = new Set(second);
+    return first.every((item) => secondSet.has(item)) && second.every((item) => firstSet.has(item));
+  }
+  else {
+    for (let i = 0; i < first.length; i++) {
+      if (first[i] !== second[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+/**
+ * Return true if all the keys of the object are numbers since it's an array-like object, false otherwise.
+ *
+ * @param {Record<string, unknown>} obj - The object to check.
+ * @returns {boolean} boolean indicating if the object is array-like
+ */
+const isObjectArrayLike = (obj) => {
+  return Object.keys(obj).every((key) => !isNaN(number.convertToNumber(key)));
+};
+/**
+ * It takes an array and to be deleted items, and returns a new array with those items removed at the first occurrence.
+ *
+ * @param {T[]} arr - T[] - The array to remove the item from
+ * @param {T[]} items - The items to be deleted from the array.
+ * @returns {T[]} A function that takes two arguments, arr and item, and returns an array.
+ */
+const deleteItemsFromArray = (arr, items) => {
+  items.forEach((item) => {
+    const index = arr.indexOf(item);
+    if (index > -1) {
+      arr.splice(index, 1);
+    }
+  });
+  return arr;
+};
+/**
+ * Return the longest text length In a string array
+ *
+ * @param {string[]} textArray string array
+ * @returns {number} text length
+ */
+function getLongestTextLengthFromArray(textArray) {
+  let length = 0;
+  textArray.forEach((text) => {
+    length = text && text.length > length ? text.length : length;
+  });
+  return length;
+}
+/**
+ * Convert the single array to nested array base on the lengths of sub-arrays provided, will return the self array if length array not provided
+ *
+ * @example
+ * // return [[1,2],[3,4,5,6]]
+ * revertArrayFromFlatArray([1,2,3,4,5,6],[2,4])
+ * @example
+ * // return [1,2,3,4,5,6]
+ * revertArrayFromFlatArray([1,2,3,4,5,6],[])
+ * @param {T[]} flatArr - an array of elements that have been flattened into a single array.
+ * @param {T[]} lengthArr - `lengthArr` is an array of numbers that specifies the length of each sub-array that the `flatArr`
+ * @returns {T[]|T[][]} The function `revertArrayFromFlatArray` returns either a single-dimensional array of type `T[]` or a two-dimensional array of type `T[][]`
+ */
+function convertArrayToNestedArray(flatArr, lengthArr) {
+  if (lengthArr.length) {
+    const result = [];
+    lengthArr.reduce((startIndex, length) => {
+      result.push(flatArr.slice(startIndex, startIndex + length));
+      return startIndex + length;
+    }, 0);
+    return result;
+  }
+  return flatArr;
+}
+/**
+ * Convert nested array to simple array. the array only handle the directly children array
+ *
+ * @param {T[] | T[][]} arr the array data source
+ * @returns {T[]} result simple array
+ */
+function flatNestedArray(arr) {
+  if (arr && Array.isArray(arr[0])) {
+    return arr.reduce((result, item) => {
+      return result.concat(item);
+    }, []);
+  }
+  return arr;
+}
+/**
+ * sort number object array by given property, and the given property must be a number
+ *
+ * @param {T[] | T[][]} data data source
+ * @param {(data: T) => number} sortBy the object item used to sort by
+ * @returns {T[] | T[][]} result array
+ */
+function sortArrayOrNestedArray(data, sortBy) {
+  let result = data;
+  if (Array.isArray(data[0])) {
+    result = data.map((item) => {
+      item.sort((d1, d2) => sortBy(d1) - sortBy(d2));
+      return item;
+    });
+  }
+  else {
+    result.sort((d1, d2) => sortBy(d1) - sortBy(d2));
+  }
+  return result;
+}
+/**
+ * This function sorts an array or nested array based on a provided accessor function and an existing array of strings.
+ *
+ * @param {unknown[] | unknown[][]} needSortArray - The array or nested array that needs to be sorted.
+ * @param {(item: T) => string} [accessor] - The accessor parameter is an optional function that takes an item from the
+ * needSortArray and returns a string value that will be used for sorting. If not provided, the
+ * function assumes that the items in the array are already strings.
+ * @param {(item:string,nextItem:string)=>number} [existArraySorter] - the sort function for the exist array
+ * @param {string[]} [existArray] - The `existArray` parameter is an optional array of strings that
+ * represents the desired order of the elements in the `needSortArray`. If provided, the function will
+ * sort the elements in `needSortArray` based on their position in `existArray`. If not provided, the default exist array will use the default order of the array
+ * @returns {unknown[] | unknown[][]} The function `sortAsExistArray` returns a sorted array or nested array of type `T[] |
+ * T[][]`. The sorting is based on the order of elements in the `existArray` parameter, or if
+ * `existArray` is not provided, it is based on the order of appearance of elements in the input array
+ * or nested array. The sorting is done using the `sortArrayOrNested
+ */
+function sortAsExistArray(needSortArray, accessor, existArraySorter, existArray) {
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  const newAccessor = (item) => typeof accessor === 'function' ? accessor(item) : item;
+  existArray = existArray
+    ? existArray
+    : Array.from(new Set(flatNestedArray(needSortArray).map(newAccessor)));
+  const sorterArray = typeof existArraySorter === 'function' ? existArray.sort(existArraySorter) : existArray;
+  const orderMap = sorterArray.reduce((result, text, index) => {
+    result[text] = index;
+    return result;
+  }, {});
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  const orderBy = (item) => orderMap[newAccessor(item)];
+  return sortArrayOrNestedArray(needSortArray, orderBy);
+}
+
+exports.convertArrayToNestedArray = convertArrayToNestedArray;
+exports.deleteItemsFromArray = deleteItemsFromArray;
+exports.flatNestedArray = flatNestedArray;
+exports.getLongestTextLengthFromArray = getLongestTextLengthFromArray;
+exports.isArrayEqual = isArrayEqual;
+exports.isObjectArrayLike = isObjectArrayLike;
+exports.sortArrayOrNestedArray = sortArrayOrNestedArray;
+exports.sortAsExistArray = sortAsExistArray;

package/dist/cjs/breakpoints-97c1f5c8.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const ui = require('./ui-ef822fe1.js');
+
+/* This file is generated by vega-design 2.0.71 */
+/* eslint-disable */
+/* tslint:disable */
+// prettier-ignore
+const Breakpoints = {
+  "S": 320,
+  "M": 768,
+  "L": 1024,
+  "XL": 1440
+};
+
+/**
+ * Get current breakpoint according current window size
+ *
+ * @returns {BreakpointsTokenType} - current breakpoint
+ */
+const getCurrentBreakpoint = () => {
+  let index = ui.BreakpointKeys.length - 1;
+  const windowWidth = window.innerWidth;
+  for (index; index >= 0; index--) {
+    const breakpointKey = ui.BreakpointKeys[index];
+    if (breakpointKey === 'default')
+      break;
+    if (windowWidth >= Breakpoints[breakpointKey])
+      return breakpointKey;
+  }
+  return 'default';
+};
+/**
+ * Completion breakponts, eg:
+ * {
+ *   default: 'size-12',
+ *   M: 'size-24'
+ * }
+ * it will convert to
+ * {
+ *   default: 'size-12',
+ *   S: 'size-12',
+ *   M: 'size-24',
+ *   L: 'size-24',
+ *   XL: 'size-24',
+ * }
+ *
+ * @param {ResponsiveType<ResponsiveScope>} breakpoints - responsive token
+ * @returns {ResponsiveType<ResponsiveScope>} - completed breakpointss
+ */
+const createCompleteResponsiveMap = (breakpoints) => {
+  let responsiveScope;
+  ui.BreakpointKeys.forEach((breakpoint) => {
+    if (Object.prototype.hasOwnProperty.call(breakpoints, breakpoint)) {
+      responsiveScope = breakpoints[breakpoint];
+    }
+    else {
+      breakpoints[breakpoint] = responsiveScope;
+    }
+  });
+  return breakpoints;
+};
+
+exports.Breakpoints = Breakpoints;
+exports.createCompleteResponsiveMap = createCompleteResponsiveMap;
+exports.getCurrentBreakpoint = getCurrentBreakpoint;

package/dist/cjs/{childNodesEventPreventSlimmer-c7a6f4e1.js → childNodesEventPreventSlimmer-4b96b18b.js}

@@ -1,9 +1,8 @@
 'use strict';
 
-const vegaSlimmer = require('./vega-slimmer-f026897e.js');
-const mapToComponentMethod = require('./map-to-component-method-bdf875d3.js');
+const vegaSlimmer = require('./vega-slimmer-af488dc3.js');
 require('./global-slimmer-registry-58eee093.js');
-const internalVegaEventManager = require('./internalVegaEventManager-78a14dbf.js');
+const internalVegaEventManager = require('./internalVegaEventManager-cfb1df83.js');
 
 var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -117,13 +116,13 @@ __decorate([
   vegaSlimmer.MapToComponentField()
 ], ChildNodesEventPreventSlimmer.prototype, "host", void 0);
 __decorate([
-  mapToComponentMethod.MapToComponentMethod('connectedCallback')
+  vegaSlimmer.MapToComponentMethod('connectedCallback')
 ], ChildNodesEventPreventSlimmer.prototype, "setup", null);
 __decorate([
-  mapToComponentMethod.MapToComponentMethod('componentDidLoad')
+  vegaSlimmer.MapToComponentMethod('componentDidLoad')
 ], ChildNodesEventPreventSlimmer.prototype, "checkEventListenerStatus", null);
 __decorate([
-  mapToComponentMethod.MapToComponentMethod('disconnectedCallback')
+  vegaSlimmer.MapToComponentMethod('disconnectedCallback')
 ], ChildNodesEventPreventSlimmer.prototype, "destroy", null);
 
 exports.ChildNodesEventPreventSlimmer = ChildNodesEventPreventSlimmer;

package/dist/cjs/childNodesNotifyObserverSlimmer-77d939be.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const vegaSlimmer = require('./vega-slimmer-af488dc3.js');
+require('./global-slimmer-registry-58eee093.js');
+const eventEmitSlimmer = require('./eventEmitSlimmer-f0546f9d.js');
+const changeManager = require('./changeManager-1dd5ac2a.js');
+const ui = require('./ui-23cd9abb.js');
+
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/** The `ChildNodesNotifyObserverSlimmer` class is a TypeScript class that acts as a slimmed-down version of a notify observer for child nodes, allowing for add and remove of observers and handling of observer payloads. */
+class ChildNodesNotifyObserverSlimmer extends vegaSlimmer.VegaSlimmer {
+  /**
+   * The constructor function initializes the subject and notifyObserverEntry properties of the class.
+   *
+   * @param {Subject} subject - The `subject` parameter is an instance of the `Subject` class. It represents the subject that the observer will be observing.
+   * @param {NotifyObserverCallback} callback - It is typically called by the subject when it undergoes a change and needs to notify its observers.
+   * @param {CustomAcceptableType} [customAcceptableHandle] - It is typically called by the subject when it undergoes a change and needs to notify its observers.
+   */
+  constructor(subject, callback, customAcceptableHandle) {
+    super();
+    this.acceptableResultMap = new WeakMap();
+    /**
+     * It is used to determine whether a given observer payload is acceptable for the observer.
+     *
+     * @param {NotifyObserverPayload<unknown>} input input payload
+     * @returns {boolean} true or false
+     */
+    this.isAcceptableObserverPayload = (input) => {
+      let result = false;
+      if (typeof this.customAcceptableHandle === 'function') {
+        result = this.customAcceptableHandle(input);
+      }
+      else if (this.host && input.host) {
+        if (this.acceptableResultMap.has(input.host)) {
+          result = !!this.acceptableResultMap.get(input.host);
+        }
+        else {
+          result = this.host === input.host ? false : ui.isParent(input.host, this.host);
+          this.acceptableResultMap.set(input.host, result);
+        }
+      }
+      return result;
+    };
+    /**
+     * trigger the callback function
+     *
+     * @param {NotifyObserverPayload<unknown>} input input payload
+     */
+    this.handleObserver = (input) => {
+      if (typeof this.callback === 'function') {
+        this.callback(input);
+      }
+    };
+    this.subject = subject;
+    this.callback = callback;
+    this.customAcceptableHandle = customAcceptableHandle;
+  }
+  /**
+   * Initialize the notify observer.
+   */
+  connectedCallback() {
+    if (this.subject) {
+      this.notifyObserver = new eventEmitSlimmer.Observer(this.isAcceptableObserverPayload.bind(this), this.handleObserver);
+      changeManager.ChangeManager.register(this.subject, this.notifyObserver);
+    }
+  }
+  /**
+   * Unregister the observer when disconnectedCallback
+   */
+  disconnectedCallback() {
+    if (this.subject) {
+      changeManager.ChangeManager.unregister(this.subject, this.notifyObserver);
+    }
+  }
+}
+__decorate([
+  vegaSlimmer.MapToComponentField()
+], ChildNodesNotifyObserverSlimmer.prototype, "host", void 0);
+__decorate([
+  vegaSlimmer.MapToComponentMethod('connectedCallback')
+], ChildNodesNotifyObserverSlimmer.prototype, "connectedCallback", null);
+__decorate([
+  vegaSlimmer.MapToComponentMethod('disconnectedCallback')
+], ChildNodesNotifyObserverSlimmer.prototype, "disconnectedCallback", null);
+
+exports.ChildNodesNotifyObserverSlimmer = ChildNodesNotifyObserverSlimmer;

package/dist/cjs/componentGlobalStyleSlimmer-d988c66b.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const vegaSlimmer = require('./vega-slimmer-af488dc3.js');
+require('./global-slimmer-registry-58eee093.js');
+
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/**
+ * Component global style slimmer
+ */
+class ComponentGlobalStyleSlimmer extends vegaSlimmer.VegaSlimmer {
+  /**
+   * The constructor of the slimmer
+   *
+   * @param {string} styles - The style string that will be appended to the document head.
+   */
+  constructor(styles) {
+    super();
+    this.style = styles;
+  }
+  /**
+   * Component lifecycle - [connectedCallback]
+   */
+  connectedCallback() {
+    const componentName = this.host.tagName;
+    const connectedComponents = ComponentGlobalStyleSlimmer.connectedComponents.get(componentName);
+    if (connectedComponents) {
+      connectedComponents.add(this.host);
+    }
+    else {
+      ComponentGlobalStyleSlimmer.connectedComponents.set(componentName, new Set([this.host]));
+    }
+  }
+  /**
+   * Component lifecycle - [disconnectedCallback]
+   */
+  disconnectedCallback() {
+    const componentName = this.host.tagName;
+    const connectedComponents = ComponentGlobalStyleSlimmer.connectedComponents.get(componentName);
+    if (connectedComponents) {
+      connectedComponents.delete(this.host);
+      if (connectedComponents.size === 0) {
+        const styleElement = this.getStyleElement();
+        if (styleElement) {
+          styleElement.remove();
+        }
+      }
+    }
+  }
+  /**
+   * Component lifecycle - [componentWillLoad]
+   */
+  componentWillLoad() {
+    this.id = `${this.host.tagName}-GLOBAL-STYLE`;
+    let styleElement = this.getStyleElement();
+    if (!styleElement) {
+      styleElement = document.createElement('style');
+      styleElement.id = this.id;
+      styleElement.innerHTML = this.style;
+      document.head.append(styleElement);
+    }
+  }
+  /**
+   * @returns {Nullable<HTMLStyleElement>} - The style element
+   */
+  getStyleElement() {
+    return document.head.querySelector(`style#${this.id}`);
+  }
+}
+ComponentGlobalStyleSlimmer.connectedComponents = new Map();
+__decorate([
+  vegaSlimmer.MapToComponentField()
+], ComponentGlobalStyleSlimmer.prototype, "host", void 0);
+__decorate([
+  vegaSlimmer.MapToComponentMethod('connectedCallback')
+], ComponentGlobalStyleSlimmer.prototype, "connectedCallback", null);
+__decorate([
+  vegaSlimmer.MapToComponentMethod('disconnectedCallback')
+], ComponentGlobalStyleSlimmer.prototype, "disconnectedCallback", null);
+__decorate([
+  vegaSlimmer.MapToComponentMethod('componentWillLoad')
+], ComponentGlobalStyleSlimmer.prototype, "componentWillLoad", null);
+
+exports.ComponentGlobalStyleSlimmer = ComponentGlobalStyleSlimmer;

package/dist/cjs/componentLoadRequired-bcc5c8a1.js

@@ -0,0 +1,48 @@
+'use strict';
+
+/**
+ * Wrap the method to make sure when the method is invoked, it will only be essentially running after the component is load
+ * For example in {@link VegaDatePicker},
+ * we want to make sure when {@code @Watch('value')} method is invoked, it should wait for the component is loaded before executing
+ *
+ * @returns {Function} The function decorated
+ */
+function ComponentLoadRequired() {
+  return (componentClass, _decoratedMethodName, decoratedMethod) => {
+    const renderedInstanceSet = new Set();
+    const { componentDidLoad, disconnectedCallback, connectedCallback } = componentClass;
+    /* eslint-disable jsdoc/require-jsdoc */
+    componentClass.componentDidLoad = function () {
+      renderedInstanceSet.add(this);
+      return componentDidLoad && componentDidLoad.call(this);
+    };
+    componentClass.disconnectedCallback = function () {
+      renderedInstanceSet.delete(this);
+      this.componentDidLoadedFlag = true;
+      return disconnectedCallback && disconnectedCallback.call(this);
+    };
+    componentClass.connectedCallback = function () {
+      this.componentDidLoadedFlag && renderedInstanceSet.add(this);
+      return connectedCallback && connectedCallback.call(this);
+    };
+    const originalMethodBody = decoratedMethod.value;
+    /* eslint-disable jsdoc/require-jsdoc */
+    decoratedMethod.value = function (...args) {
+      if (renderedInstanceSet.has(this)) {
+        return originalMethodBody.apply(this, args);
+      }
+      return new Promise((resolve) => {
+        const waitForComponentReady = () => {
+          if (renderedInstanceSet.has(this)) {
+            return resolve(originalMethodBody.apply(this, args));
+          }
+          setTimeout(waitForComponentReady, 30);
+        };
+        waitForComponentReady();
+      });
+    };
+    return decoratedMethod;
+  };
+}
+
+exports.ComponentLoadRequired = ComponentLoadRequired;

package/dist/cjs/date-177d34ab.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const log = require('./log-5d8066e0.js');
+
+/**
+ * It returns true if the input is a valid date string, and false otherwise
+ *
+ * @param {string} input - The string to check.
+ * @returns {boolean} is a valid date string or not
+ */
+const isDateStr = (input) => !isNaN(Date.parse(input));
+/**
+ * Compare if the firstDate is after the secondDate
+ *
+ * @param {Date} firstDate - The first date to compare.
+ * @param {Date} secondDate - The date to compare to.
+ * @returns {boolean} Return true if the firstDate is after the secondDate, otherwise it returns false.
+ */
+const compareIsAfter = (firstDate, secondDate) => {
+  return firstDate.getTime() > secondDate.getTime();
+};
+/**
+ * Compare if the firstDate is before the secondDate
+ *
+ * @param {Date} firstDate - The first date to compare.
+ * @param {Date} secondDate - The date to compare to.
+ * @returns {boolean} Return true if the firstDate is before the secondDate, otherwise it returns false.
+ */
+const compareIsBefore = (firstDate, secondDate) => {
+  return firstDate.getTime() < secondDate.getTime();
+};
+/**
+ * Compare if the first date is before or the same as the second date.
+ *
+ * @param {Date} firstDate - The first date to compare.
+ * @param {Date} secondDate - The date to compare against.
+ * @returns {boolean} Return true if the firstDate is before or the same as the secondDate, otherwise it returns false.
+ */
+const compareIsSameOrBefore = (firstDate, secondDate) => {
+  return firstDate.getTime() <= secondDate.getTime();
+};
+/**
+ * It returns true if the input string is a valid time string in the format specified by the timeFormat parameter
+ *
+ * @param {string} input - The string to be tested.
+ * @param {TimeFormat} timeFormat - '12-hour' | '24-hour'
+ * @returns {boolean} A boolean value.
+ */
+const isTimeStr = (input, timeFormat) => {
+  return timeFormat === '12-hour'
+    ? new RegExp(/^(1[012]|0[1-9]):[0-5][0-9] ([AP][M])$/).test(input)
+    : new RegExp(/^([0-1][0-9]|2[0-3]):[0-5][0-9]$/).test(input);
+};
+/**
+ * It takes a number and returns a string
+ *
+ * @param {number} number - number - The number to pad
+ * @returns {Nullable<string>} A function that takes a number as an argument and returns a nullable string.
+ */
+const pad = (number) => {
+  if (number || number === 0) {
+    return number.toString().padStart(2, '0');
+  }
+  else {
+    log.LogUtility.error(`The input should be a number`);
+  }
+};
+/**
+ * The `convert12HourTo24HourFormat` function takes a time string in 12-hour format and converts it to 24-hour format.
+ *
+ * @param {string} time the time string need to convert, the time string should be 12-hour or 24-hour format
+ * @returns {string} 24 hour format time string
+ */
+const convert12HourTo24HourFormat = (time) => {
+  if (isTimeStr(time, '12-hour')) {
+    const [hour, minute, amPm] = time.replace(' ', ':').split(':');
+    let convertedHour = parseInt(hour, 10);
+    if (amPm === 'PM' && convertedHour !== 12) {
+      convertedHour += 12;
+    }
+    else if (amPm === 'AM' && convertedHour === 12) {
+      convertedHour = 0;
+    }
+    return `${pad(convertedHour)}:${minute}`;
+  }
+  return time;
+};
+
+exports.compareIsAfter = compareIsAfter;
+exports.compareIsBefore = compareIsBefore;
+exports.compareIsSameOrBefore = compareIsSameOrBefore;
+exports.convert12HourTo24HourFormat = convert12HourTo24HourFormat;
+exports.isDateStr = isDateStr;
+exports.isTimeStr = isTimeStr;
+exports.pad = pad;