@globalpayments/vega 1.0.0 → 2.13.0-backfill-beta.0

package/dist/cjs/eventEmitSlimmer-da0b3b8b.js

@@ -0,0 +1,257 @@
+'use strict';
+
+const globalSlimmerRegistry = require('./global-slimmer-registry-fdb2a041.js');
+const dynamicSlimmer = require('./dynamic-slimmer-d5ea4204.js');
+const changeManager = require('./changeManager-7c13d64f.js');
+const domNodeSubjectObserverFactory = require('./domNodeSubjectObserverFactory-2bbdec29.js');
+const internalVegaEventManager = require('./internalVegaEventManager-a3672e0c.js');
+
+var __decorate$3 = (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 `VegaEventEmitHandlerSlimmer` class is a TypeScript class that handles the emission of Vega events based on the availability of the 'emit' function and the event semantics namespace. */
+class VegaEventEmitHandlerSlimmer extends globalSlimmerRegistry.VegaSlimmer {
+  constructor() {
+    super(...arguments);
+    /**
+     * The function determines whether a Vega event should be emitted based on the namespace and the availability of the 'emit' function.
+     *
+     * @param {EventSemantics} namespace the event semantics namespace
+     * @returns {boolean} a boolean value.
+     */
+    this.canHandle = ({ namespace }) => {
+      return namespace === 'vega' || !this.nativeEvent || typeof this.nativeEvent['emit'] !== 'function';
+    };
+    /**
+     * The function emits a Vega event with a given detail.
+     *
+     * @param {unknown} detail - The "detail" parameter is a generic type parameter that represents the data or
+     * information that you want to emit with the event. It can be any type of data, such as a string,
+     * number, object, or custom class.
+     * @returns {CustomEvent} The emitted event.
+     */
+    this.handle = (detail) => {
+      return this.vegaEvent.emit(detail);
+    };
+  }
+}
+__decorate$3([
+  globalSlimmerRegistry.MapToComponentField()
+], VegaEventEmitHandlerSlimmer.prototype, "vegaEvent", void 0);
+__decorate$3([
+  globalSlimmerRegistry.MapToComponentField()
+], VegaEventEmitHandlerSlimmer.prototype, "nativeEvent", void 0);
+
+var __decorate$2 = (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 `NativeEventEmitHandlerSlimmer` class is a TypeScript class that handles emitting native events based on event semantics. */
+class NativeEventEmitHandlerSlimmer extends globalSlimmerRegistry.VegaSlimmer {
+  constructor() {
+    super(...arguments);
+    /**
+     * The function determines whether a native event should be emitted based on the namespace of the event semantics.
+     *
+     * @param {EventSemantics} namespace the event semantics namespace
+     * @returns {boolean} a boolean value.
+     */
+    this.canHandle = ({ namespace }) => {
+      return namespace === 'native';
+    };
+    /**
+     * The function emits a native event with a given detail.
+     *
+     * @param {unknown} detail - The `detail` parameter is a generic type `T` that represents the data or
+     * information that you want to pass along with the event. It can be any type of data, such as a
+     * string, number, object, or custom type.
+     * @param {Event} [e] the event object
+     * @returns {CustomEvent} The emitted event.
+     */
+    this.handle = (detail, e) => {
+      if (e) {
+        e.stopPropagation();
+      }
+      return this.nativeEvent.emit(detail);
+    };
+  }
+}
+__decorate$2([
+  globalSlimmerRegistry.MapToComponentField()
+], NativeEventEmitHandlerSlimmer.prototype, "nativeEvent", void 0);
+
+var __decorate$1 = (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 `JqueryDelegatedEventEmitHandlerSlimmer` class is a TypeScript class that handles emitting delegated events using jQuery. */
+class JqueryDelegatedEventEmitHandlerSlimmer extends globalSlimmerRegistry.VegaSlimmer {
+  constructor() {
+    super(...arguments);
+    /**
+     * The function determines whether a jQuery delegated event should be emitted based on certain conditions.
+     *
+     * @param {EventSemantics} namespace the event semantics namespace
+     * @returns {boolean} The function shouldEmitJqueryDelegatedEvent() returns a boolean value.
+     */
+    this.canHandle = ({ namespace, jqueryDelegatedEvent }) => {
+      return (namespace === 'native' &&
+        !!jqueryDelegatedEvent &&
+        internalVegaEventManager.jqueryDelegatedStrategyController.isSupportDelegated(this.host, this.eventID));
+    };
+    /**
+     * The function emits a delegated event with a given detail using a jQuery delegated event slimmer.
+     *
+     * @param {unknown} detail - The `detail` parameter is a generic type `T` that represents additional
+     * information or data associated with the event. It can be any type of data that you want to pass
+     * along with the event when it is emitted.
+     * @param {Event} [e] the event object
+     * @returns {Nullable<Event>} The emitted event.
+     */
+    this.handle = (detail, e) => {
+      const strategy = internalVegaEventManager.jqueryDelegatedStrategyController.getStrategy(this.host, this.eventID);
+      if (strategy) {
+        if (e) {
+          e.stopPropagation();
+        }
+        return strategy.handle(this.host, detail);
+      }
+    };
+  }
+  /**
+   * The function "setEventID" sets the eventID property of the current object to the provided VegaEventID value.
+   *
+   * @param {VegaEventID} eventID - The eventID parameter is of type VegaEventID.
+   */
+  setEventID(eventID) {
+    this.eventID = eventID;
+  }
+}
+__decorate$1([
+  globalSlimmerRegistry.MapToComponentField()
+], JqueryDelegatedEventEmitHandlerSlimmer.prototype, "host", void 0);
+
+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 EventEmitSlimmerBase class is a TypeScript class that extends VegaSlimmer and provides methods for emitting events with or without notifications. */
+class EventEmitSlimmerBase extends globalSlimmerRegistry.VegaSlimmer {
+  /**
+   * The constructor function takes an object with an eventName property and assigns it to the eventName property of the class.
+   *
+   * @param {{ eventName: string }} eventName  - The constructor function takes in an object with a property called "eventName" of type
+   * string. The value of "eventName" is then assigned to the instance variable "this.eventName".
+   */
+  constructor({ eventID }) {
+    super();
+    this.vegaEventEmitHandler = new VegaEventEmitHandlerSlimmer();
+    this.nativeEventEmitHandler = new NativeEventEmitHandlerSlimmer();
+    this.jqueryDelegatedEventEmitHandler = new JqueryDelegatedEventEmitHandlerSlimmer();
+    /**
+     * emit the vega component event
+     *
+     * @param {unknown} [detail] the event detail
+     * @param {Event} [e] the event object
+     * @returns {Nullable<Event>} The emitted event.
+     */
+    this.emit = (detail, e) => {
+      changeManager.ChangeManager.notify(domNodeSubjectObserverFactory.domNodeSubjectFactory.getSubject(this.host, this.eventID), {
+        host: this.host,
+        detail: detail,
+        eventName: this.eventName,
+      });
+      const eventSemantics = internalVegaEventManager.InternalVegaEventManager.getSemantics(this.host);
+      let event;
+      for (const handler of this.eventHandlers) {
+        if (handler.canHandle(eventSemantics)) {
+          event = handler.handle(detail, e);
+          break;
+        }
+      }
+      return event;
+    };
+    /**
+     * used to clean up and remove any observers that were added to the host element during the lifecycle of the class
+     */
+    this.removeObserverFromHost = () => {
+      // add promise to fix the testPolyfill#replaceChildren
+      void Promise.resolve(true).then(() => {
+        if (this.isNodeRemovedFromDocument(this.host)) {
+          domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.removeUniqueObserverFromNode(this.host, this.eventID);
+        }
+      });
+    };
+    this.eventID = eventID;
+    this.eventName = eventID.getVegaName();
+    this.initialEventHandlers();
+  }
+  /**
+   * The function checks if a given HTML element has been removed from the document.
+   *
+   * @param {Nullable<HTMLElement>} node - The `node` parameter is of type `Nullable<HTMLElement>`, which means it can either be
+   * an `HTMLElement` or `null`. It represents the element that needs to be checked if it has been removed from the document.
+   * @returns {boolean} a boolean value.
+   */
+  isNodeRemovedFromDocument(node) {
+    // elementAppender#show will call the HTMLElement#append method, and the append method will call the component disconnectedCallback, but the component not remove from the page.
+    // see the issue in test case vega-popover.e2e.ts->should behavior normal while click app header button and time picker nested in popover
+    if (node && !document.body.contains(node) && !node.parentNode) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * The function initializes event handlers for different types of events.
+   */
+  initialEventHandlers() {
+    this.jqueryDelegatedEventEmitHandler.setEventID(this.eventID);
+    this.eventHandlers = [
+      this.vegaEventEmitHandler,
+      this.jqueryDelegatedEventEmitHandler,
+      this.nativeEventEmitHandler,
+    ];
+  }
+}
+__decorate([
+  globalSlimmerRegistry.InjectVegaSlimmer()
+], EventEmitSlimmerBase.prototype, "vegaEventEmitHandler", void 0);
+__decorate([
+  globalSlimmerRegistry.InjectVegaSlimmer()
+], EventEmitSlimmerBase.prototype, "nativeEventEmitHandler", void 0);
+__decorate([
+  globalSlimmerRegistry.InjectVegaSlimmer()
+], EventEmitSlimmerBase.prototype, "jqueryDelegatedEventEmitHandler", void 0);
+/**
+ * The function `createEventEmitSlimmer` creates a slimmer version of an event emitter class by mapping specific properties and events.
+ *
+ * @param {ClassPrototype<unknown>} mapFromClass - The class prototype from which the event emitter will be created.
+ * @param {VegaEventID} eventID - The eventName parameter is a VegaEventID that represents the name of the event.
+ * @param {string} [nativeEventPropertyName] - usually the native event name is eventID#nativeName, set a property name when the native name is used by other method or property
+ * @returns {EventEmitSlimmerBase} an instance of the `EventEmitSlimmerBase` class.
+ */
+function createEventEmitSlimmer(mapFromClass, eventID, nativeEventPropertyName) {
+  const eventName = eventID.getVegaName();
+  const nativeEventName = nativeEventPropertyName || eventID.getNativeName();
+  return dynamicSlimmer.createDynamicSlimmer(mapFromClass, EventEmitSlimmerBase, [
+    { mapFrom: 'host', mapTo: 'host' },
+    { mapFrom: eventName, mapTo: 'vegaEvent' },
+    //optional for now
+    { mapFrom: nativeEventName, mapTo: 'nativeEvent', isOptional: true },
+  ], [{ mapFrom: 'disconnectedCallback', mapTo: 'removeObserverFromHost' }], [
+    {
+      eventID,
+    },
+  ]);
+}
+
+exports.createEventEmitSlimmer = createEventEmitSlimmer;

package/dist/cjs/featureFlagController-da4c779b.js

@@ -0,0 +1,289 @@
+'use strict';
+
+const globalSlimmerRegistry = require('./global-slimmer-registry-fdb2a041.js');
+const index = require('./index-55e89877.js');
+
+/**
+ * The concrete feature flag map that we are going to use to determine if a feature is enabled or not.
+ */
+const FeatureFlagsMap = {
+  'VEGA_DATE_PICKER.COMPONENT_LOAD_REQUIRED_DECORATOR': {
+    description: `Feature flag to enable the required decorator for the date picker component. <br/> <b>Note: This feature flag is for demonstration purpose and will be persisted permanently.</b>`,
+    createdTimestamp: 1660330561422,
+    createdAtVersion: '1.2.0',
+    removedAfterVersion: '1.11.1',
+  },
+  'VEGA_COMPONENT.SANITIZE_VEGA_COMPONENT': {
+    description: `Feature flag to enable sanitize vega components.`,
+    createdTimestamp: 1664262689486,
+    createdAtVersion: '1.8.1',
+    removedAfterVersion: '2.0.0',
+  },
+  'VEGA_TEXT.LABEL_OR_CONTENT_NESTED_VEGA_TEXT_COMPONENT': {
+    description: 'Feature flag to enable the label or content of other component nested vega-text component.',
+    createdTimestamp: 1665218525140,
+    createdAtVersion: '1.8.1',
+    removedAfterVersion: '1.9.1',
+  },
+  'VEGA_FLEX.ENABLE_DIRECTION_ONLY': {
+    description: `Feature flag to make direction take effect only regardless of breakpoint for vega-flex component.`,
+    createdTimestamp: 1665639912117,
+    createdAtVersion: '1.9.0',
+  },
+  'VEGA_FIELD_LABEL.SHOW_LABEL': {
+    description: `Feature flag to enable the vega-field-label component for vega-input, vega-input-select and vega-date-picker.`,
+    createdTimestamp: 1666184962131,
+    createdAtVersion: '1.9.0',
+    removedAfterVersion: '2.0.0',
+  },
+  'VEGA_FLEX.USE_NATIVE_FLEX_BEHAVIOR': {
+    description: `Feature flag to enable the **default** use of native flex behavior for vega-flex component.`,
+    createdTimestamp: 1668059639449,
+    createdAtVersion: '1.11.1',
+    removedAfterVersion: '2.0.0',
+  },
+  'VEGA_TABLE.DEPRECATED_ROW_SELECTION_CHANGE_PROP': {
+    description: `Feature flag to deprecate the rowSelection.onSelectChange and rowSelection.onSelectAllChange`,
+    createdTimestamp: 1673321949321,
+    createdAtVersion: '1.18.0',
+    removedAfterVersion: '2.0.0',
+  },
+  'VEGA_ICON.USE_SIZE_PROP_FOR_THIRD_PARTY_ICONS': {
+    description: `Feature flag to make size prop of vega-icon to take effect for third party icons.`,
+    createdTimestamp: 1675752744795,
+    createdAtVersion: '1.20.0',
+    removedAfterVersion: '2.0.0',
+  },
+  'VEGA_INJECT_FORM_FIELD_CONTROLLER.ADD_DATA_VEGA_FORM_FILTER': {
+    description: `Feature flag to deprecate the form field should validate only have data-vega-from attribute`,
+    createdTimestamp: 1676017004107,
+    createdAtVersion: '1.19.0',
+    removedAfterVersion: '2.0.0',
+  },
+  'VEGA_FORM_FIELD.CHANGE_BLOCK_TO_INLINE_BLOCK': {
+    description: `Feature flag to deprecate the form fields like input/datePicker/timePicker should use inline block`,
+    createdTimestamp: 1676512727310,
+    createdAtVersion: '1.20.0',
+    removedAfterVersion: '2.0.0',
+  },
+  'VEGA_CHECKBOX_RADIO_GROUP.FLEX_DIRECTION_COL_DEFAULT': {
+    description: `Feature flag to make the checkbox group and radio group prop vegaFlexProp default direction to col`,
+    createdTimestamp: 1681171200000,
+    createdAtVersion: '1.27.3',
+    removedAfterVersion: '2.0.0',
+  },
+  'VEGA_REACT.PREVENT_SSR': {
+    description: `Feature flag to prevent the SSR in vega-react`,
+    createdTimestamp: 1679450185124,
+    createdAtVersion: '1.25.0',
+    disabledByDefault: true,
+  },
+  'VEGA_STEPPER.INPUT_DISABLED': {
+    description: `Feature flag to rename the prop input-editable to input-disabled `,
+    createdTimestamp: 1683252081350,
+    createdAtVersion: '1.30.0',
+    removedAfterVersion: '2.0.0',
+  },
+  'VEGA_FLEX.ALIGNITEM_JUSTIFYCONTENT_USE_PREFIX_V_INSTEAD_OF_VEGA': {
+    description: `Feature flag to render vega-flex prop alignItems and justifyContent classes by using v- instead of vega-`,
+    createdTimestamp: 1684128467390,
+    createdAtVersion: '1.32.0',
+    removedAfterVersion: '1.48.3',
+  },
+  'VEGA_ANGULAR.USE_JUGGLE_RESIZE_OBSERVER': {
+    description: `Feature flag to enable the @juggle/resizeObserver to instead window resizeObserver`,
+    createdTimestamp: 1684203399089,
+    createdAtVersion: '1.31.0',
+  },
+  'VEGA_INPUT.FOCUS_ON_INPUT_BY_CLICK_CLEAR_BUTTON': {
+    description: `Feature flag to keep the input focused whenever click the clear button`,
+    createdTimestamp: 1685513925082,
+    createdAtVersion: '1.34.0',
+    removedAfterVersion: '1.38.2',
+  },
+  'VEGA_VUE.EMIT_CAMEL_CASE_EVENT_NAME': {
+    description: `Feature flag to emit camel case event name for Vue framework`,
+    createdTimestamp: 1688971026741,
+    createdAtVersion: '1.37.0',
+  },
+  'VEGA_ITEM_TOGGLE_ISERROR_DEPRECATED': {
+    description: `Feature flag to deprecated the component vega-item-toggle property isError`,
+    createdTimestamp: 1687934508330,
+    createdAtVersion: '1.36.0',
+    removedAfterVersion: '2.0.0',
+  },
+  'VEGA_BUTTON_LINK.DEPRECATED_EVENTFUL': {
+    description: `Feature flag to deprecated eventful property`,
+    createdTimestamp: 1689313658898,
+    createdAtVersion: '1.36.1',
+    removedAfterVersion: '2.0.0',
+  },
+  'VEGA_DROPDOWN.RENAME_PREFIX_TO_PREFIX_ICON': {
+    description: `Feature flag to rename prefix to prefixIcon`,
+    createdTimestamp: 1689576347049,
+    createdAtVersion: '1.37.0',
+    removedAfterVersion: '2.0.0',
+  },
+  'VEGA_REACT.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD': {
+    description: `Feature flag to prevent call watch method before componnentDidLoad`,
+    createdTimestamp: 1706598728908,
+    createdAtVersion: '2.0.0',
+  },
+  'VEGA_FRAMEWORK.PREVENT_CALL_WATCH_METHOD_BEFORE_COMPONENT_LOAD': {
+    description: `Feature flag to prevent call watch method before componnentDidLoad in all framework`,
+    createdTimestamp: 1708495728180,
+    createdAtVersion: '2.0.0',
+  },
+  'VEGA_REACT.ENABLE_ON_CHANGE_HANDLE_UNDER_LOW_VERSION': {
+    description: `Feature flag to enable the onChange event handle under react version 19 or below`,
+    createdTimestamp: 1709603823660,
+    createdAtVersion: '2.0.0',
+  },
+  'VEGA_INPUT_CREDIT_CARD.ENABLE_HIDE_NUMBER_MASK_ON_FIRST_LOAD': {
+    description: `Feature flag to enable the hide card number mask upon initial loading of the credit card.`,
+    createdTimestamp: 1715932781059,
+    createdAtVersion: '2.9.0',
+  },
+  'VEGA_TABLE.ENABLE_NEW_CELL_BREAK_WORDS_STYLE': {
+    description: `Feature flag to enable the new cell words break style`,
+    createdTimestamp: 1719282763075,
+    createdAtVersion: '2.11.2',
+  },
+  'VEGA_TELEMETRY.ENABLE_COLLECT_COMPONENTS_USAGE': {
+    description: `Feature flag to enable the collection of component usage.`,
+    createdTimestamp: 1717468723384,
+    createdAtVersion: '2.11.3',
+  },
+  'VEGA_TELEMETRY.ENABLE_COLLECT_FEATURE_FLAG_OVERRIDDEN': {
+    description: `Feature flag to enable the feature flag overridden.`,
+    createdTimestamp: 1717468723384,
+    createdAtVersion: '2.11.3',
+  },
+  'VEGA_REACT.ENABLE_ON_CLOSE_HANDLE_UNDER_LOW_VERSION': {
+    description: `Feature flag to enable the onClose event handle under react version 19 or below`,
+    createdTimestamp: 1719910557333,
+    createdAtVersion: '2.12.0',
+  },
+};
+const FeatureFlagsMap$1 = Object.freeze(FeatureFlagsMap);
+
+/**
+ * Feature flag controller to manage feature flags.
+ *
+ * @class FeatureFlag
+ * @property {Set<FeatureFlagKey>} enabledFeatureFlagKeySet - Set of feature flags that are enabled.
+ */
+class FeatureFlagController {
+  /**
+   * During constructor, It enables all the feature flags given by {@link FeatureFlagsMap} expect default disabled flags.
+   */
+  constructor() {
+    this.enabledFeatureFlagKeySet = new Set();
+    this.init();
+  }
+  /**
+   * This function enables the feature flags with the given keys.
+   *
+   * @param {FeatureFlagKey[]} featureFlagKeys - The feature flags to enable.
+   */
+  enable(...featureFlagKeys) {
+    featureFlagKeys.forEach((featureFlagKey) => {
+      if (this.versionGuard(featureFlagKey)) {
+        this.enabledFeatureFlagKeySet.add(featureFlagKey);
+        this.sendFeatureFlagKeyToTelemetry(featureFlagKey, true);
+      }
+    });
+  }
+  /**
+   * Disable the feature flags with the given keys.
+   *
+   * @param {FeatureFlagKey[]} featureFlagKeys - The feature flags to disable.
+   */
+  disable(...featureFlagKeys) {
+    featureFlagKeys.forEach((featureFlagKey) => {
+      if (this.versionGuard(featureFlagKey)) {
+        this.enabledFeatureFlagKeySet.delete(featureFlagKey);
+        this.sendFeatureFlagKeyToTelemetry(featureFlagKey, false);
+      }
+    });
+  }
+  /**
+   * If the feature flag key is in the set of enabled feature flag keys, then return true, otherwise return false.
+   *
+   * @param {FeatureFlagKey} featureFlagKey - The feature flag key to check.
+   * @returns {boolean} - True if the feature flag key is in the set of enabled feature flag keys, otherwise false.
+   */
+  isEnabled(featureFlagKey) {
+    return this.enabledFeatureFlagKeySet.has(featureFlagKey);
+  }
+  /**
+   * The `init` function initializes a set of enabled feature flags based on a map of feature flags,
+   * excluding those disabled by default or removed.
+   */
+  init() {
+    Object.keys(FeatureFlagsMap$1).map((flagKey) => {
+      if (!FeatureFlagsMap$1[flagKey].disabledByDefault && !this.isRemoved(flagKey)) {
+        this.enabledFeatureFlagKeySet.add(flagKey);
+      }
+    });
+  }
+  /**
+   * Verify if the flag is valid
+   *
+   * @param {FeatureFlagKey} featureFlagKey - the feature flag key
+   * @returns {boolean} return false and console error if the feature flag is removedAfterVersion is not empty
+   */
+  versionGuard(featureFlagKey) {
+    if (this.isRemoved(featureFlagKey)) {
+      globalSlimmerRegistry.LogUtility.error(`The feature flag key '${featureFlagKey}' has been removed after v${FeatureFlagsMap$1[featureFlagKey].removedAfterVersion}`);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Verify if the flag is removed or not
+   *
+   * @param {FeatureFlagKey} featureFlagKey - the feature flag key
+   * @returns {boolean} return true if the feature flag removedAfterVersion is not empty
+   */
+  isRemoved(featureFlagKey) {
+    return !!FeatureFlagsMap$1[featureFlagKey].removedAfterVersion;
+  }
+  /**
+   * The function sends a feature flag key and its value to telemetry if a specific feature flag is
+   * enabled.
+   *
+   * @param {FeatureFlagKey} featureFlagName - The `featureFlagName` parameter is a key that represents
+   * a specific feature flag. It is used to identify and reference a particular feature
+   * flag when checking its status or sending telemetry data related to it.
+   * @param {boolean} featureFlagValue - The `featureFlagValue` parameter is a boolean value that
+   * represents the value of a feature flag. It indicates whether the feature flag is enabled (`true`)
+   * or disabled (`false`).
+   */
+  sendFeatureFlagKeyToTelemetry(featureFlagName, featureFlagValue) {
+    if (this.canSendFeatureFlagsToTelemetry(featureFlagName, featureFlagValue)) {
+      index['default'].emit('featureFlagOverridden', {
+        featureFlagName: featureFlagName,
+        featureFlagOverriddenValue: featureFlagValue,
+      });
+    }
+  }
+  /**
+   * The function `canSendFeatureFlagsToTelemetry` checks if a specific feature flag can be sent to
+   * telemetry based on certain conditions.
+   *
+   * @param {FeatureFlagKey} featureFlagName - The `featureFlagName` parameter represents the key or
+   * identifier of a feature flag. It is used to look up the corresponding feature flag in the
+   * `FeatureFlagsMap` object.
+   * @param {boolean} featureFlagValue - The `featureFlagValue` parameter in the
+   * `canSendFeatureFlagsToTelemetry` function represents the value of a specific feature flag. It is a
+   * boolean value that indicates whether the feature flag is enabled (`true`) or disabled (`false`).
+   * @returns {boolean} The function `canSendFeatureFlagsToTelemetry` is returning a boolean value.
+   */
+  canSendFeatureFlagsToTelemetry(featureFlagName, featureFlagValue) {
+    return !!FeatureFlagsMap$1[featureFlagName].disabledByDefault === featureFlagValue;
+  }
+}
+const FeatureFlag = new FeatureFlagController();
+
+exports.FeatureFlag = FeatureFlag;