@heartlandone/vega 1.51.0 → 2.0.0-preview-2

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-8d1cad8a.js → app-globals-73828fff.js}

@@ -1,14 +1,14 @@
 'use strict';
 
-const featureFlagController = require('./featureFlagController-9b9e651a.js');
-const themeManager = require('./themeManager-c7d4b002.js');
-const vegaEnvManager = require('./vegaEnvManager-7ce70a9e.js');
+const vegaEventManager = require('./vegaEventManager-bfe0bf67.js');
 const log = require('./log-5d8066e0.js');
-const vegaDialogController = require('./vegaDialogController-d2ae40fb.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('./ui-97068bc7.js');
+require('./internalVegaEventManager-78a14dbf.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;
@@ -37,8 +37,7 @@ class VegaWatchMethodCancelSlimmer extends vegaSlimmer.VegaSlimmer {
      * 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.isEnabled = vegaEventManager.FeatureFlag.isEnabled('VEGA_REACT.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD');
     this.component = option.component;
   }
   /**
@@ -120,13 +119,15 @@ function appGlobalScript () {
   injectVegaLogLevelIntoGlobal();
   injectVegaDialogIntoGlobal();
   registerGlobalVegaSlimmers();
+  injectSetEventSemanticsIntoGlobal();
+  injectVegaTypography();
 }
 /**
  * Disable feature flags from the client global defined lists.
  */
 function disableFeatureFlagFromClientGlobal() {
   if (globalThis['VegaDisabledFeatureKeys']) {
-    featureFlagController.FeatureFlag.disable(...globalThis['VegaDisabledFeatureKeys']);
+    vegaEventManager.FeatureFlag.disable(...globalThis['VegaDisabledFeatureKeys']);
   }
 }
 /**
@@ -134,26 +135,26 @@ function disableFeatureFlagFromClientGlobal() {
  */
 function enableFeatureFlagFromClientGlobal() {
   if (globalThis['VegaEnabledFeatureKeys']) {
-    featureFlagController.FeatureFlag.enable(...globalThis['VegaEnabledFeatureKeys']);
+    vegaEventManager.FeatureFlag.enable(...globalThis['VegaEnabledFeatureKeys']);
   }
 }
 /**
  * Inject VegaLoader to global as a public api
  */
 function injectVegaLoaderIntoGlobal() {
-  globalThis['VegaLoader'] = themeManager.VegaLoader;
+  globalThis['VegaLoader'] = vegaEventManager.VegaLoader;
 }
 /**
  * Inject VegaNotify to global as a public api
  */
 function injectVegaNotifyIntoGlobal() {
-  globalThis.VegaNotify = vegaEnvManager.VegaNotify;
+  globalThis.VegaNotify = vegaEventManager.VegaNotify;
 }
 /**
  * Inject VegaThemeManager to global as a public api
  */
 function injectVegaThemeManagerIntoGlobal() {
-  globalThis.VegaThemeManager = themeManager.VegaThemeManager;
+  globalThis.VegaThemeManager = vegaEventManager.VegaThemeManager;
 }
 /**
  * Inject VegaLogLevel to global as a public api
@@ -173,6 +174,28 @@ function injectVegaDialogIntoGlobal() {
 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;
 

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-e610ef7c.js}

@@ -1,6 +1,17 @@
 'use strict';
 
-const breakpoints = require('./breakpoints-b5eab9c2.js');
+const ui = require('./ui-04f8a3e7.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-c7a6f4e1.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const vegaSlimmer = require('./vega-slimmer-f026897e.js');
+const mapToComponentMethod = require('./map-to-component-method-bdf875d3.js');
+require('./global-slimmer-registry-58eee093.js');
+const internalVegaEventManager = require('./internalVegaEventManager-78a14dbf.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([
+  mapToComponentMethod.MapToComponentMethod('connectedCallback')
+], ChildNodesEventPreventSlimmer.prototype, "setup", null);
+__decorate([
+  mapToComponentMethod.MapToComponentMethod('componentDidLoad')
+], ChildNodesEventPreventSlimmer.prototype, "checkEventListenerStatus", null);
+__decorate([
+  mapToComponentMethod.MapToComponentMethod('disconnectedCallback')
+], ChildNodesEventPreventSlimmer.prototype, "destroy", null);
+
+exports.ChildNodesEventPreventSlimmer = ChildNodesEventPreventSlimmer;

package/dist/cjs/childNodesNotifyObserverSlimmer-88c492da.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const vegaSlimmer = require('./vega-slimmer-f026897e.js');
+const mapToComponentMethod = require('./map-to-component-method-bdf875d3.js');
+require('./global-slimmer-registry-58eee093.js');
+const observer = require('./observer-f49483e8.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 observer.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([
+  mapToComponentMethod.MapToComponentMethod('connectedCallback')
+], ChildNodesNotifyObserverSlimmer.prototype, "connectedCallback", null);
+__decorate([
+  mapToComponentMethod.MapToComponentMethod('disconnectedCallback')
+], ChildNodesNotifyObserverSlimmer.prototype, "disconnectedCallback", null);
+
+exports.ChildNodesNotifyObserverSlimmer = ChildNodesNotifyObserverSlimmer;

package/dist/cjs/{component-e6612ec4.js → component-b50f0483.js}

@@ -1,6 +1,5 @@
 'use strict';
 
-const featureFlagController = require('./featureFlagController-9b9e651a.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;

package/dist/cjs/{designToken-45078c17.js → designToken-57de7f2b.js}

@@ -1,10 +1,10 @@
 'use strict';
 
-const typeGuard = require('./typeGuard-447fb5bd.js');
-const breakpoints = require('./breakpoints-b5eab9c2.js');
+const typeGuard = require('./typeGuard-a4b5297f.js');
+const breakpoints = require('./breakpoints-e610ef7c.js');
 const log = require('./log-5d8066e0.js');
-const responsiveFormatFacade = require('./responsiveFormatFacade-6cc0b6b2.js');
-const typography = require('./typography-358013af.js');
+const responsiveFormatFacade = require('./responsiveFormatFacade-36a8860a.js');
+const typography = require('./typography-3d2ba97d.js');
 
 /**
  * It logs a warning message to the console.
@@ -70,7 +70,7 @@ function formatAndValidBorderColor(token) {
     return `v-${token}`;
   }
   else {
-    logInvalidValueMessage('border-color', token, typeGuard.Colors.filter(() => /^border-.+$/.test));
+    logInvalidValueMessage('border-color', token, typeGuard.Colors.filter(() => /^border-color-.+$/.test));
   }
 }
 /**
@@ -85,7 +85,7 @@ function formatAndValidBackgroundColor(token, withModes = []) {
     return `v-${token}` + formatTokenWithModes(token, withModes);
   }
   else {
-    logInvalidValueMessage('background-color', token, typeGuard.Colors.filter(() => /^border-.+$/.test));
+    logInvalidValueMessage('background-color', token, typeGuard.Colors.filter(() => /^bg-.+$/.test));
   }
 }
 /**
@@ -101,21 +101,7 @@ function formatAndValidTextColor(token, withModes = []) {
     return `v-${token}` + formatTokenWithModes(token, withModes);
   }
   else {
-    logInvalidValueMessage('text-color', token, typeGuard.Colors.filter(() => /^border-.+$/.test));
-  }
-}
-/**
- * If the token is a valid breakpoint, return CSS class string for the flex breakpoint. Otherwise, log an error
- *
- * @param {unknown} token - The value of the breakpoint.
- * @returns {string} CSS class string for the flex breakpoint.
- */
-function formatAndValidFlexBreakpoint(token) {
-  if (typeGuard.isBreakpointsTokenType(token)) {
-    return `vega-flex-${token}`;
-  }
-  else {
-    logInvalidValueMessage('breakpoint', token, Object.keys(breakpoints.Breakpoints));
+    logInvalidValueMessage('text-color', token, typeGuard.Colors.filter(() => /^text-.+$/.test));
   }
 }
 /**
@@ -194,7 +180,6 @@ exports.formatAndValidBackgroundColor = formatAndValidBackgroundColor;
 exports.formatAndValidBorderColor = formatAndValidBorderColor;
 exports.formatAndValidBorderRadius = formatAndValidBorderRadius;
 exports.formatAndValidBreakpointSize = formatAndValidBreakpointSize;
-exports.formatAndValidFlexBreakpoint = formatAndValidFlexBreakpoint;
 exports.formatAndValidGap = formatAndValidGap;
 exports.formatAndValidPadding = formatAndValidPadding;
 exports.formatAndValidResponsiveToken = formatAndValidResponsiveToken;