@heartlandone/vega 2.19.0 → 2.20.0

package/dist/cjs/app-globals-c199ea5e.js

@@ -0,0 +1,272 @@
+'use strict';
+
+const featureFlagController = require('./feature-flag-controller-dd0aaf67.js');
+const vegaSkeletonLoaderController = require('./vega-skeleton-loader-controller-38ab6039.js');
+const globalSlimmerRegistry = require('./global-slimmer-registry-fdb2a041.js');
+const vegaDialogController = require('./vega-dialog-controller-2d7b1f1c.js');
+const vegaEnvManager = require('./vega-env-manager-23b8b23c.js');
+require('./internal-vega-event-manager-908ef630.js');
+require('./ui-fa68545a.js');
+const typography = require('./typography-4560e7f1.js');
+const iconManager = require('./icon-manager-a973bf0f.js');
+const validCreditCardNumberRule = require('./valid-credit-card-number-rule-8d8f04f1.js');
+const zIndexManager = require('./z-index-manager-792e5b7f.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 `VegaWatchMethodCancelSlimmer` class is a TypeScript class that removes
+ * the body of watch methods when a component is not fully instantiated and
+ * applies the original method body when the component is fully instantiated.
+ */
+class VegaWatchMethodCancelSlimmer extends globalSlimmerRegistry.VegaSlimmer {
+  /**
+   * The constructor function takes a component object as a parameter and assigns it to the "component"
+   * property of the class.
+   *
+   * @param {GlobalSlimmerConfig} option - The `option` parameter is of type `GlobalSlimmerConfig`.
+   * It is an object that represents a component in a software system.
+   */
+  constructor(option) {
+    super();
+    this.originalWatchers = new Map();
+    /**
+     * while component reattached, the component will call `connectedCallback` but not call `componentDidLoad`,
+     * so we add this flag to skip empty the watch function in this case.
+     */
+    this.hasDisconnected = false;
+    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;
+  }
+  /**
+   * The connectedCallback function removes the body of watch methods when the component is not fully
+   * instantiated.
+   */
+  connectedCallback() {
+    if (!this.isEnabled)
+      return;
+    if (this.hasDisconnected)
+      return;
+    const watchers = this.component.constructor['watchers'];
+    for (const propName in watchers) {
+      const watchMethodNames = watchers[propName];
+      watchMethodNames.forEach((methodName) => {
+        // while watch method listen by multiple property, we should skip make originalMethod as empty.
+        if (!this.originalWatchers.has(methodName)) {
+          const originalMethod = this.component[methodName];
+          this.originalWatchers.set(methodName, originalMethod);
+          /**
+           * Remove the watch method body when the component not fully instantiated.
+           */
+          // eslint-disable-next-line @typescript-eslint/no-empty-function
+          this.component[methodName] = function () { };
+        }
+      });
+    }
+  }
+  /**
+   * The `@MapToComponentMethod('disconnectedCallback')` decorator is used to map the `disconnectedCallback` method
+   * to the corresponding method in the Stencil component.
+   */
+  disconnectedCallback() {
+    if (!this.isEnabled)
+      return;
+    this.hasDisconnected = true;
+  }
+  /**
+   * The `componentDidLoad` function applies the original method body to the component's watchers when
+   * the component is fully instantiated.
+   */
+  componentDidLoad() {
+    if (!this.isEnabled)
+      return;
+    this.originalWatchers.forEach((method, methodName) => {
+      const originalMethodBody = method;
+      /**
+       * Apply the watch original method body when the component fully instantiated.
+       *
+       * @param {...any} args - watch method args
+       * @returns {unknown} method results
+       */
+      this.component[methodName] = function (...args) {
+        return originalMethodBody.apply(this, args);
+      };
+    });
+  }
+}
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('connectedCallback')
+], VegaWatchMethodCancelSlimmer.prototype, "connectedCallback", null);
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('disconnectedCallback')
+], VegaWatchMethodCancelSlimmer.prototype, "disconnectedCallback", null);
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('componentDidLoad')
+], VegaWatchMethodCancelSlimmer.prototype, "componentDidLoad", null);
+
+/**
+ * The VegaZIndexManager class calls a method in the ZIndexManager class to
+ * change z-index values based on the input.
+ */
+class VegaZIndexManager {
+  /**
+   * The function "overrideZIndexBasicValues" calls a method in the "ZIndexManager" class to change the
+   * z-index values based on the input.
+   *
+   * @param {ZIndexBasicValues} input - The input parameter is of type ZIndexBasicValues.
+   */
+  overrideZIndexBasicValues(input) {
+    zIndexManager.ZIndexManager.overrideZIndexBasicValues(input);
+  }
+}
+const VegaZIndexManager$1 = new VegaZIndexManager();
+
+/**
+ * Default export function that will be used by stencil global script,
+ * which will be invoked before library loaded.
+ */
+function appGlobalScript () {
+  disableFeatureFlagFromClientGlobal();
+  enableFeatureFlagFromClientGlobal();
+  injectVegaLoaderIntoGlobal();
+  injectVegaNotifyIntoGlobal();
+  injectVegaThemeManagerIntoGlobal();
+  injectVegaLogLevelIntoGlobal();
+  injectVegaDialogIntoGlobal();
+  registerGlobalVegaSlimmers();
+  injectSetEventSemanticsIntoGlobal();
+  injectVegaTypography();
+  injectVegaIconManager();
+  injectVegaZIndexManagerIntoGlobal();
+  injectValidCreditCardNumberRuleIntoGlobal();
+  initRuntimeMetricsTelemetryCollection();
+  injectWaitForVegaIntoGlobal();
+  injectVegaSkeletonLoaderIntoGlobal();
+}
+/**
+ * Disable feature flags from the client global defined lists.
+ */
+function disableFeatureFlagFromClientGlobal() {
+  if (globalThis['VegaDisabledFeatureKeys']) {
+    featureFlagController.FeatureFlag.disable(...globalThis['VegaDisabledFeatureKeys']);
+  }
+}
+/**
+ * This function enables feature flags based on a global variable in TypeScript.
+ */
+function enableFeatureFlagFromClientGlobal() {
+  if (globalThis['VegaEnabledFeatureKeys']) {
+    featureFlagController.FeatureFlag.enable(...globalThis['VegaEnabledFeatureKeys']);
+  }
+}
+/**
+ * Inject VegaLoader to global as a public api
+ */
+function injectVegaLoaderIntoGlobal() {
+  globalThis['VegaLoader'] = vegaSkeletonLoaderController.VegaLoader;
+}
+/**
+ * Inject VegaNotify to global as a public api
+ */
+function injectVegaNotifyIntoGlobal() {
+  globalThis.VegaNotify = vegaSkeletonLoaderController.VegaNotify;
+}
+/**
+ * Inject VegaThemeManager to global as a public api
+ */
+function injectVegaThemeManagerIntoGlobal() {
+  globalThis.VegaThemeManager = vegaSkeletonLoaderController.VegaThemeManager;
+}
+/**
+ * Inject VegaLogLevel to global as a public api
+ */
+function injectVegaLogLevelIntoGlobal() {
+  globalThis.setVegaLogLevel = globalSlimmerRegistry.setVegaLogLevel;
+}
+/**
+ * Inject VegaDialog to global as a public api
+ */
+function injectVegaDialogIntoGlobal() {
+  globalThis.VegaDialog = vegaDialogController.VegaDialog;
+}
+/**
+ * register global vega slimmers
+ */
+function registerGlobalVegaSlimmers() {
+  globalSlimmerRegistry.GlobalSlimmersRegistry.register([VegaWatchMethodCancelSlimmer]);
+}
+/**
+ * Inject setEventSemantics to global as a public api
+ */
+function injectSetEventSemanticsIntoGlobal() {
+  globalThis.VegaEventManager = vegaSkeletonLoaderController.VegaEventManager;
+}
+/**
+ * Inject Vega typography stylesheet
+ */
+function injectVegaTypography() {
+  Object.keys(typography.TypographyUrls).forEach((key) => {
+    const { url } = typography.TypographyUrls[key];
+    const typographyLinkId = `vega-typography-${key}`;
+    if (!document.querySelector(`#${typographyLinkId}`)) {
+      const typographyLink = document.createElement('link');
+      typographyLink.id = typographyLinkId;
+      typographyLink.href = url;
+      typographyLink.rel = 'stylesheet';
+      document.head.append(typographyLink);
+    }
+  });
+}
+/**
+ * Inject VegaIconManager to global as a public api
+ */
+function injectVegaIconManager() {
+  globalThis.VegaIconManager = iconManager.VegaIconManager;
+}
+/**
+ * Inject VegaZIndexManager to global as a public api
+ */
+function injectVegaZIndexManagerIntoGlobal() {
+  globalThis.VegaZIndexManager = VegaZIndexManager$1;
+}
+/**
+ * Inject ValidCreditCardNumberRule to global as a public api.
+ */
+function injectValidCreditCardNumberRuleIntoGlobal() {
+  globalThis.ValidCreditCardNumberRule = validCreditCardNumberRule.ValidCreditCardNumberRule;
+}
+/**
+ * init telemetry runtime metrics.
+ * 1. Inject VegaEnvInfo to global
+ * 2. Register runtime metrics add page hide listener method
+ */
+function initRuntimeMetricsTelemetryCollection() {
+  globalThis.VegaEnvInfo = vegaEnvManager.vegaEnvManager.getVegaEnv();
+  // eslint-disable-next-line spellcheck/spell-checker
+  void Promise.resolve().then(function () { return require('./index-bf98b054.js'); }).then(function (n) { return n.index; }).then((
+  // eslint-disable-next-line spellcheck/spell-checker
+  module) => {
+    module['default']['init'](featureFlagController.FeatureFlag);
+  });
+}
+/**
+ * Inject waitForVega to global as a public api
+ */
+function injectWaitForVegaIntoGlobal() {
+  globalThis['waitForVega'] = vegaSkeletonLoaderController.waitForVega;
+}
+/**
+ * Inject VegaSkeletonLoader to global as a public api
+ */
+function injectVegaSkeletonLoaderIntoGlobal() {
+  globalThis.VegaSkeletonLoader = vegaSkeletonLoaderController.VegaSkeletonLoader;
+}
+
+const globalScripts = appGlobalScript;
+
+exports.globalScripts = globalScripts;

package/dist/cjs/child-nodes-event-prevent-slimmer-1a9ac556.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const globalSlimmerRegistry = require('./global-slimmer-registry-fdb2a041.js');
+const internalVegaEventManager = require('./internal-vega-event-manager-908ef630.js');
+const vegaEnvManager = require('./vega-env-manager-23b8b23c.js');
+const featureFlagController = require('./feature-flag-controller-dd0aaf67.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 ChildNodesEventPreventSlimmer class prevents specified events from propagating to parent elements. */
+class ChildNodesEventPreventSlimmer extends globalSlimmerRegistry.VegaSlimmer {
+  /**
+   * The constructor function takes in an array of event names and a function to get the parent element, and assigns them to the corresponding properties of the class.
+   *
+   * @param {VegaEventID[]} eventIds - The eventNames parameter is an array of VegaEventID that represents the names of the events that will be handled by the constructor.
+   * @param {HTMLElement} getHostElement - The `getHostElement` parameter is a function that returns an `HTMLElement`. It is used to get the parent element where the events will be attached.
+   * @param {boolean | EventPreventOptions} options - add event listener in capture or bubbles.
+   * @param {boolean | EventPreventOptions} needSkipByDefault - should skip event prevent by default
+   */
+  constructor(eventIds, getHostElement, options, needSkipByDefault) {
+    super();
+    // the event names need prevent from child nodes
+    this.eventIds = [];
+    this.useCapture = false;
+    this.isEventListenerAdded = false;
+    this.disabled = false;
+    /**
+     * prevent the child event
+     *
+     * @param {CustomEvent} event event object
+     */
+    this.preventChildEvent = (event) => {
+      const hostElement = this.getHostElement();
+      if (this.shouldSkipEventPrevent()) {
+        return;
+      }
+      if (typeof this.customPreventHandle === 'function') {
+        this.customPreventHandle(event);
+      }
+      else {
+        const composed = event.composedPath();
+        if (hostElement !== event.target || hostElement !== composed[0]) {
+          event.stopImmediatePropagation();
+        }
+      }
+    };
+    this.eventIds = eventIds;
+    this.getHostElement = getHostElement;
+    if (options === true) {
+      this.useCapture = true;
+    }
+    else if (options) {
+      const { useCapture = false, customPreventHandle } = options;
+      this.useCapture = useCapture;
+      this.customPreventHandle = customPreventHandle;
+    }
+    this.disabled = needSkipByDefault === true ? true : false;
+  }
+  /**
+   * add event listener when component connected, we can call the method manually if the host element not ready when connectedCallback
+   */
+  setup() {
+    this.addOrRemoveEventListener('add');
+  }
+  /**
+   * if the host element ready after component did load, then add the event listener again.
+   */
+  checkEventListenerStatus() {
+    if (!this.isEventListenerAdded) {
+      this.setup();
+    }
+    this.setSkipEventPreventFlag();
+  }
+  /**
+   * remove the event listener when component disconnect
+   */
+  destroy() {
+    this.addOrRemoveEventListener('remove');
+  }
+  /**
+   * The function `setSkipEventPreventFlag` sets a flag on a host element to skip event prevention under certain conditions.
+   */
+  setSkipEventPreventFlag() {
+    if (featureFlagController.FeatureFlag.isEnabled('VEGA_REACT.SKIP_NATIVE_EVENT_PREVENT_BY_DEFAULT') &&
+      this.disabled &&
+      this.host &&
+      vegaEnvManager.vegaEnvManager.getVegaEnv().framework === 'react' &&
+      internalVegaEventManager.internalVegaEventManager.getSemantics(this.host).namespace === 'native') {
+      const el = this.getHostElement();
+      el.setAttribute('data-vega-no-event-prevent', 'true');
+    }
+  }
+  /**
+   * add or remove the event from the parent element
+   *
+   * @param {'add'|'remove'} actionType add or remove
+   */
+  addOrRemoveEventListener(actionType) {
+    const hostElement = this.getHostElement();
+    if (this.eventIds && this.eventIds.length && hostElement) {
+      this.eventIds
+        .filter((eventID) => this.shouldPrevent(eventID))
+        .forEach((eventID) => {
+        hostElement[actionType === 'add' ? 'addEventListener' : 'removeEventListener'](this.getCurrentEventName(eventID), this.preventChildEvent, this.useCapture);
+      });
+      this.isEventListenerAdded = actionType === 'add' ? true : false;
+    }
+  }
+  /**
+   * get the current event name
+   *
+   * @param {VegaEventID} eventId event id class
+   * @returns {string} native or vega event name string
+   */
+  getCurrentEventName(eventId) {
+    return eventId.getCurrentName(internalVegaEventManager.internalVegaEventManager.getSemantics(this.host));
+  }
+  /**
+   * The function shouldPrevent checks if a given event ID should be prevented based on whether it is a
+   * native event and if it is enabled for the host.
+   *
+   * @param {VegaEventID} eventId - The `eventId` parameter is of type `VegaEventID`. It represents the ID of an event.
+   * @returns {boolean} a boolean value.
+   */
+  shouldPrevent(eventId) {
+    const { namespace, jqueryDelegatedEvent } = internalVegaEventManager.internalVegaEventManager.getSemantics(this.host);
+    return !(namespace === 'native' &&
+      !!jqueryDelegatedEvent &&
+      internalVegaEventManager.jqueryDelegatedStrategyController.isSupportDelegated(this.host, eventId));
+  }
+  /**
+   * The function `shouldSkipEventPrevent` checks if a host element has a specific dataset value to determine whether event prevention should be skipped.
+   *
+   * @returns {boolean} If the `hostElement` exists and has a `dataset.vegaNoEventPrevent` attribute with a value of `'true'`, then the function returns `true`. Otherwise, it returns `false`.
+   */
+  shouldSkipEventPrevent() {
+    const hostElement = this.getHostElement();
+    return hostElement && hostElement.dataset.vegaNoEventPrevent === 'true';
+  }
+}
+__decorate([
+  globalSlimmerRegistry.MapToComponentField()
+], ChildNodesEventPreventSlimmer.prototype, "host", void 0);
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('connectedCallback')
+], ChildNodesEventPreventSlimmer.prototype, "setup", null);
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('componentDidLoad')
+], ChildNodesEventPreventSlimmer.prototype, "checkEventListenerStatus", null);
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('disconnectedCallback')
+], ChildNodesEventPreventSlimmer.prototype, "destroy", null);
+
+exports.ChildNodesEventPreventSlimmer = ChildNodesEventPreventSlimmer;

package/dist/cjs/child-nodes-notify-observer-slimmer-2f21e0a1.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const globalSlimmerRegistry = require('./global-slimmer-registry-fdb2a041.js');
+const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-465e5483.js');
+const changeManager = require('./change-manager-ed04784c.js');
+const ui = require('./ui-fa68545a.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 globalSlimmerRegistry.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 domNodeSubjectObserverFactory.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([
+  globalSlimmerRegistry.MapToComponentField()
+], ChildNodesNotifyObserverSlimmer.prototype, "host", void 0);
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('connectedCallback')
+], ChildNodesNotifyObserverSlimmer.prototype, "connectedCallback", null);
+__decorate([
+  globalSlimmerRegistry.MapToComponentMethod('disconnectedCallback')
+], ChildNodesNotifyObserverSlimmer.prototype, "disconnectedCallback", null);
+
+exports.ChildNodesNotifyObserverSlimmer = ChildNodesNotifyObserverSlimmer;