@heartlandone/vega 2.0.0-temp-test-0.2 → 2.0.0

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-54d42962.js

@@ -0,0 +1,203 @@
+'use strict';
+
+const featureFlagController = require('./featureFlagController-e3dc9be9.js');
+const vegaEventManager = require('./vegaEventManager-2da0ff37.js');
+const log = require('./log-5d8066e0.js');
+const vegaDialogController = require('./vegaDialogController-01bddb6a.js');
+const globalSlimmerRegistry = require('./global-slimmer-registry-58eee093.js');
+const vegaSlimmer = require('./vega-slimmer-af488dc3.js');
+require('./internalVegaEventManager-cfb1df83.js');
+require('./ui-23cd9abb.js');
+const typography = require('./typography-3d2ba97d.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 vegaSlimmer.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([
+  vegaSlimmer.MapToComponentMethod('connectedCallback')
+], VegaWatchMethodCancelSlimmer.prototype, "connectedCallback", null);
+__decorate([
+  vegaSlimmer.MapToComponentMethod('disconnectedCallback')
+], VegaWatchMethodCancelSlimmer.prototype, "disconnectedCallback", null);
+__decorate([
+  vegaSlimmer.MapToComponentMethod('componentDidLoad')
+], VegaWatchMethodCancelSlimmer.prototype, "componentDidLoad", null);
+
+/**
+ * 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();
+}
+/**
+ * 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'] = vegaEventManager.VegaLoader;
+}
+/**
+ * Inject VegaNotify to global as a public api
+ */
+function injectVegaNotifyIntoGlobal() {
+  globalThis.VegaNotify = vegaEventManager.VegaNotify;
+}
+/**
+ * Inject VegaThemeManager to global as a public api
+ */
+function injectVegaThemeManagerIntoGlobal() {
+  globalThis.VegaThemeManager = vegaEventManager.VegaThemeManager;
+}
+/**
+ * Inject VegaLogLevel to global as a public api
+ */
+function injectVegaLogLevelIntoGlobal() {
+  globalThis.setVegaLogLevel = log.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 = vegaEventManager.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);
+    }
+  });
+}
+
+const globalScripts = appGlobalScript;
+
+exports.globalScripts = globalScripts;

package/dist/cjs/{array-e1e5ed1d.js → array-5f977aa2.js}

@@ -2,17 +2,6 @@
 
 const number = require('./number-7e7d9981.js');
 
-/**
- * It flattens an array of objects
- *
- * @typedef T generic type  parameter
- * @param {T[]} arr - The array to be flattened.
- * @param {string} [children=children] - The name of the key that contains the children.
- * @returns {T[]}An array of all the children of the array of items.
- */
-const flattenChildren = (arr, children = 'children') => {
-  return arr.reduce((result, item) => result.concat(item[children] ? flattenChildren(item[children], children) : item), []);
-};
 /**
  * The function checks if two arrays are equal, either in order or ignoring order.
  *
@@ -176,7 +165,6 @@ function sortAsExistArray(needSortArray, accessor, existArraySorter, existArray)
 exports.convertArrayToNestedArray = convertArrayToNestedArray;
 exports.deleteItemsFromArray = deleteItemsFromArray;
 exports.flatNestedArray = flatNestedArray;
-exports.flattenChildren = flattenChildren;
 exports.getLongestTextLengthFromArray = getLongestTextLengthFromArray;
 exports.isArrayEqual = isArrayEqual;
 exports.isObjectArrayLike = isObjectArrayLike;

package/dist/cjs/{breakpoints-89055ccc.js → breakpoints-97c1f5c8.js}

@@ -1,6 +1,17 @@
 'use strict';
 
-const breakpoints = require('./breakpoints-b5eab9c2.js');
+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
@@ -8,13 +19,13 @@ const breakpoints = require('./breakpoints-b5eab9c2.js');
  * @returns {BreakpointsTokenType} - current breakpoint
  */
 const getCurrentBreakpoint = () => {
-  let index = breakpoints.BreakpointKeys.length - 1;
+  let index = ui.BreakpointKeys.length - 1;
   const windowWidth = window.innerWidth;
   for (index; index >= 0; index--) {
-    const breakpointKey = breakpoints.BreakpointKeys[index];
+    const breakpointKey = ui.BreakpointKeys[index];
     if (breakpointKey === 'default')
       break;
-    if (windowWidth >= breakpoints.Breakpoints[breakpointKey])
+    if (windowWidth >= Breakpoints[breakpointKey])
       return breakpointKey;
   }
   return 'default';
@@ -37,18 +48,19 @@ const getCurrentBreakpoint = () => {
  * @param {ResponsiveType<ResponsiveScope>} breakpoints - responsive token
  * @returns {ResponsiveType<ResponsiveScope>} - completed breakpointss
  */
-const createCompleteResponsiveMap = (breakpoints$1) => {
+const createCompleteResponsiveMap = (breakpoints) => {
   let responsiveScope;
-  breakpoints.BreakpointKeys.forEach((breakpoint) => {
-    if (Object.prototype.hasOwnProperty.call(breakpoints$1, breakpoint)) {
-      responsiveScope = breakpoints$1[breakpoint];
+  ui.BreakpointKeys.forEach((breakpoint) => {
+    if (Object.prototype.hasOwnProperty.call(breakpoints, breakpoint)) {
+      responsiveScope = breakpoints[breakpoint];
     }
     else {
-      breakpoints$1[breakpoint] = responsiveScope;
+      breakpoints[breakpoint] = responsiveScope;
     }
   });
-  return breakpoints$1;
+  return breakpoints;
 };
 
+exports.Breakpoints = Breakpoints;
 exports.createCompleteResponsiveMap = createCompleteResponsiveMap;
 exports.getCurrentBreakpoint = getCurrentBreakpoint;

package/dist/cjs/changeManager-1dd5ac2a.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const log = require('./log-5d8066e0.js');
+
+/**
+ * The ChangeManager is a class that allows observers to register themselves to a subject
+ * and notify the observer if signaled by subject
+ *
+ * @requires Subject
+ * @requires Observer
+ * @property {Map<Subject, Observer<unknown>[]>} pubSubMap - the map of subject to observers
+ */
+class ChangeManager {
+  constructor() {
+    this.pubSubMap = new Map();
+  }
+  /**
+   * If the subject is already in the map, add the observer to the list of observers for that subject. If the subject is not
+   * in the map, add the subject to the map and add the observer to the list of observers for that subject
+   *
+   * @param {Subject} subject - The subject of the event.
+   * @param {Observer<unknown>} observer - The observer that will be registered.
+   */
+  register(subject, observer) {
+    if (this.pubSubMap.has(subject)) {
+      const observers = this.pubSubMap.get(subject);
+      if (observers && !observers.includes(observer)) {
+        observers.push(observer);
+      }
+    }
+    else {
+      this.pubSubMap.set(subject, [observer]);
+    }
+  }
+  /**
+   * If the subject is in the map, remove the observer from the list of observers for that subject
+   *
+   * @param {Subject} subject - The subject of the event.
+   * @param {Observer<unknown>} observer - The observer to be unregistered.
+   */
+  unregister(subject, observer) {
+    if (this.pubSubMap.has(subject)) {
+      const observers = this.pubSubMap.get(subject);
+      if (observers && observers.includes(observer)) {
+        observers.splice(observers.indexOf(observer), 1);
+      }
+    }
+  }
+  /**
+   * The function clears the observers for a given subject in a pub-sub map.
+   *
+   * @param {Subject} subject - The subject parameter is an object that represents the subject of the observer pattern. It is used as a key to identify the observers that are subscribed to it.
+   */
+  clearObserversBySubject(subject) {
+    this.pubSubMap.delete(subject);
+  }
+  /**
+   * If the subject is in the map, then notify all observers of the subject
+   *
+   * @param {Subject} subject - Subject
+   * @param {unknown} payload - The payload to be sent to the observer.
+   */
+  notify(subject, payload) {
+    if (this.pubSubMap.has(subject)) {
+      this.pubSubMap.get(subject).forEach((observer) => {
+        try {
+          observer.notify(payload);
+        }
+        catch (e) {
+          log.LogUtility.warn(`Encountered error while notifying observer for subject ${subject.getDescription()}`, e);
+        }
+      });
+    }
+  }
+}
+const ChangeManager$1 = new ChangeManager();
+
+exports.ChangeManager = ChangeManager$1;

package/dist/cjs/childNodesEventPreventSlimmer-4b96b18b.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const vegaSlimmer = require('./vega-slimmer-af488dc3.js');
+require('./global-slimmer-registry-58eee093.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;
+  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 vegaSlimmer.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.
+   */
+  constructor(eventIds, getHostElement, options) {
+    super();
+    // the event names need prevent from child nodes
+    this.eventIds = [];
+    this.useCapture = false;
+    this.isEventListenerAdded = false;
+    /**
+     * prevent the child event
+     *
+     * @param {CustomEvent} event event object
+     */
+    this.preventChildEvent = (event) => {
+      const hostElement = this.getHostElement();
+      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;
+    }
+  }
+  /**
+   * 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();
+    }
+  }
+  /**
+   * remove the event listener when component disconnect
+   */
+  destroy() {
+    this.addOrRemoveEventListener('remove');
+  }
+  /**
+   * 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));
+  }
+}
+__decorate([
+  vegaSlimmer.MapToComponentField()
+], ChildNodesEventPreventSlimmer.prototype, "host", void 0);
+__decorate([
+  vegaSlimmer.MapToComponentMethod('connectedCallback')
+], ChildNodesEventPreventSlimmer.prototype, "setup", null);
+__decorate([
+  vegaSlimmer.MapToComponentMethod('componentDidLoad')
+], ChildNodesEventPreventSlimmer.prototype, "checkEventListenerStatus", null);
+__decorate([
+  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/{component-a411c045.js → component-b50f0483.js}

@@ -1,6 +1,5 @@
 'use strict';
 
-const featureFlagController = require('./featureFlagController-3b23a9cb.js');
 const log = require('./log-5d8066e0.js');
 
 const exemptionClasses = [
@@ -15,7 +14,6 @@ const exemptionClasses = [
   'v-text-black',
   'v-text-white',
   'v-hidden',
-  'vega-loader-container-relative',
   'vega-page-notification-fade-out',
   'v-h-full',
   'v-h-screen',
@@ -33,10 +31,8 @@ const exemptionClasses = [
  * @returns {T} processed vega component
  */
 function sanitizeVegaComponent(renderedOutput, hostElement) {
-  if (featureFlagController.FeatureFlag.isEnabled('VEGA_COMPONENT.SANITIZE_VEGA_COMPONENT')) {
-    checkIfInAllowedClassList(renderedOutput, hostElement);
-    checkIfUseDataShrink(hostElement);
-  }
+  checkIfInAllowedClassList(renderedOutput, hostElement);
+  checkIfUseDataShrink(hostElement);
   return renderedOutput;
 }
 /**
@@ -92,5 +88,30 @@ function checkIfUseDataShrink(hostElement) {
     });
   }
 }
+/* istanbul ignore next */
+/**
+ * The function `getActiveElement` returns the active element within a shadow root or the
+ * document.
+ *
+ * @param {Document | ShadowRoot} root - The `root` parameter is the root element from which to start
+ * searching for the active element. It can be either a `Document` or a `ShadowRoot`. If no `root` is
+ * provided, it defaults to the `document` object.
+ * @returns {Nullable<Element>} The function `getActiveElementInShadow` returns an `Element` if there is an active element
+ * in the given `root` (either a `Document` or a `ShadowRoot`). If there is no active element, it
+ * returns `null`.
+ */
+const getActiveElement = (root = document) => {
+  const activeEl = root.activeElement;
+  if (activeEl === null || activeEl === void 0 ? void 0 : activeEl.shadowRoot) {
+    return getActiveElement(activeEl.shadowRoot);
+  }
+  else if (activeEl) {
+    return activeEl;
+  }
+  else {
+    return null;
+  }
+};
 
+exports.getActiveElement = getActiveElement;
 exports.sanitizeVegaComponent = sanitizeVegaComponent;