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

package/dist/esm/{eventEmitSlimmer-da1fd54e.js → eventEmitSlimmer-d605ac81.js}

@@ -1,9 +1,153 @@
-import { I as InjectVegaSlimmer } from './global-slimmer-registry-f1dec4a2.js';
-import { M as MapToComponentField, V as VegaSlimmer } from './vega-slimmer-d63e92d9.js';
-import { c as createDynamicSlimmer } from './dynamic-slimmer-16826d2b.js';
+import { I as InjectVegaSlimmer } from './global-slimmer-registry-b91c742d.js';
+import { a as MapToComponentField, V as VegaSlimmer } from './vega-slimmer-ce2e45d1.js';
+import { c as createDynamicSlimmer } from './dynamic-slimmer-c8ad78de.js';
 import { C as ChangeManager } from './changeManager-935d420b.js';
-import { d as domNodeSubjectFactory, D as DomNodeSubjectObserverFactory } from './domNodeSubjectObserverFactory-8aeac4b6.js';
-import { j as jqueryDelegatedStrategyController, i as internalVegaEventManager } from './internalVegaEventManager-4ab886bc.js';
+import { j as jqueryDelegatedStrategyController, I as InternalVegaEventManager } from './internalVegaEventManager-efa77ebb.js';
+
+/**
+ *  An Observer is a class that has a listener method that accepts a value of type T
+ *  and calls the listener method with a value of type T
+ */
+class Observer {
+  /**
+   * It accepts a function that accepts a value and returns a boolean, and a function that accepts a value of the type that
+   * the first function accepts
+   *
+   * @typedef T generic type parameter
+   * @param {(input: unknown) => input is T} accept - A function that indicate if the input is acceptable by the observer
+   * @param {(input: T) => void} listener - A function handle the input for the observer if the input is accepted
+   */
+  constructor(accept, listener) {
+    this.accept = accept;
+    this.listener = listener;
+  }
+  /**
+   * If the input is of the type that this handler is interested in, then call the listener function
+   *
+   * @param {unknown} input - unknown
+   */
+  notify(input) {
+    if (this.accept(input)) {
+      this.listener(input);
+    }
+  }
+}
+
+/** The DomNodeSubject class represents a subject related to DOM nodes. */
+class DomNodeSubject {
+  /**
+   * The constructor function takes a SubjectTitle parameter and assigns it to the private title property.
+   *
+   * @param {SubjectTitle} title - The "title" parameter is a private property of the class that is of type "SubjectTitle".
+   * @param {HTMLElement} host - The `host` parameter is an HTMLElement that represents the container or
+   * parent element where the subject title will be displayed. It is used to specify the location where
+   * the title will be rendered on the web page.
+   */
+  constructor(title, host) {
+    this.title = title;
+    this.host = host;
+  }
+  /**
+   * The getDescription function returns the title of an object as a string.
+   *
+   * @returns {string} The title of the object.
+   */
+  getDescription() {
+    return `, this is a dom nodes subject of ${this.title}.(class name:${this.host.className}, id:${this.host.id})`;
+  }
+}
+
+/** The `DomNodesSubjectFactory` class is responsible for managing and caching `DomNodeSubject` objects associated with HTML elements. */
+class DomNodeSubjectFactory {
+  constructor() {
+    this.cache = new WeakMap();
+  }
+  /**
+   * The function `getSubject` returns the subject associated with a given node and event ID, either from the cache or by setting it if it doesn't exist.
+   *
+   * @param {HTMLElement} node - The `node` parameter is an HTMLElement, which represents an element in the HTML document.
+   * @param {VegaEventIDInterface} eventId - The `eventId` parameter is of type `VegaEventIDInterface`. It represents the ID of the event for which we want to get the subject.
+   * @returns {DomNodeSubject} a `DomNodeSubject` object.
+   */
+  getSubject(node, eventId) {
+    if (this.isExist(node, eventId)) {
+      return this.cache.get(node).get(eventId);
+    }
+    else {
+      return this.setSubject(node, eventId);
+    }
+  }
+  /**
+   * The function checks if a given node exists in the cache and if it has a specific event ID.
+   *
+   * @param {HTMLElement} node - The "node" parameter is an HTMLElement, which represents an HTML element in the DOM (Document Object Model). It could be any HTML element such as a div, span, button, etc.
+   * @param {VegaEventIDInterface} eventId - The `eventId` parameter is of type `VegaEventIDInterface`. It represents an event ID that is used to identify a specific event.
+   * @returns {boolean} a boolean value.
+   */
+  isExist(node, eventId) {
+    if (node) {
+      return (this.cache.has(node) &&
+        this.cache.get(node) !== undefined &&
+        this.cache.get(node).has(eventId));
+    }
+    return false;
+  }
+  /**
+   * The function `setSubject` creates a new `DomNodeSubject` and associates it with a given `node` and `eventId`, and then returns the created subject.
+   *
+   * @param {HTMLElement} node - The `node` parameter is an HTMLElement object representing an HTML element in the DOM (Document Object Model).
+   * @param {VegaEventIDInterface} eventId - The `eventId` parameter is of type `VegaEventIDInterface`. It represents the ID of a Vega event.
+   * @returns {DomNodeSubject} dom node subject object
+   */
+  setSubject(node, eventId) {
+    const subjectTitle = `${node.tagName}:${eventId.getName()}`;
+    const subject = new DomNodeSubject(subjectTitle, node);
+    if (!this.cache.get(node)) {
+      this.cache.set(node, new Map());
+    }
+    this.cache.get(node).set(eventId, subject);
+    return subject;
+  }
+}
+const domNodeSubjectFactory = new DomNodeSubjectFactory();
+
+/**
+ * The function `domAcceptableHandle` always returns `true`.
+ *
+ * @returns {boolean} true
+ */
+const domAcceptableHandle = () => {
+  return true;
+};
+/** The `DomNodeSubjectObserverFactory` class provides methods to add and remove observers to HTML element nodes. */
+class DomNodeSubjectObserverFactory {
+  /**
+   * add observer to a given HTML element node
+   *
+   * @param {HTMLElement} node the node ref
+   * @param {VegaEventIDInterface} eventId The `eventId` parameter is of type `VegaEventIDInterface`. It represents the ID of a Vega event.
+   * @param {(input?: unknown) => void} callback the callback handle
+   * @param {(input?: unknown) => boolean} acceptableHandle the acceptable handle
+   */
+  static addUniqueObserverToNode(node, eventId, callback, acceptableHandle) {
+    if (node) {
+      const domNodesObserver = new Observer(typeof acceptableHandle === 'function' ? acceptableHandle.bind(null) : domAcceptableHandle, callback);
+      DomNodeSubjectObserverFactory.removeUniqueObserverFromNode(node, eventId);
+      ChangeManager.register(domNodeSubjectFactory.getSubject(node, eventId), domNodesObserver);
+    }
+  }
+  /**
+   * The function removes observers from a given HTML element node.
+   *
+   * @param {HTMLElement} node - The `node` parameter is an `HTMLElement` object representing an HTML element in the DOM (Document Object Model).
+   * @param {VegaEventIDInterface} eventId The `eventId` parameter is of type `VegaEventIDInterface`. It represents the ID of a Vega event.
+   */
+  static removeUniqueObserverFromNode(node, eventId) {
+    if (domNodeSubjectFactory.isExist(node, eventId)) {
+      ChangeManager.clearObserversBySubject(domNodeSubjectFactory.getSubject(node, eventId));
+    }
+  }
+}
 
 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;
@@ -122,9 +266,9 @@ class JqueryDelegatedEventEmitHandlerSlimmer extends VegaSlimmer {
     };
   }
   /**
-   * The function "setEventID" sets the eventID property of the current object to the provided VegaEventIDInterface value.
+   * The function "setEventID" sets the eventID property of the current object to the provided VegaEventID value.
    *
-   * @param {VegaEventIDInterface} eventID - The eventID parameter is of type VegaEventIDInterface.
+   * @param {VegaEventID} eventID - The eventID parameter is of type VegaEventID.
    */
   setEventID(eventID) {
     this.eventID = eventID;
@@ -165,7 +309,7 @@ class EventEmitSlimmerBase extends VegaSlimmer {
         detail: detail,
         eventName: this.eventName,
       });
-      const eventSemantics = internalVegaEventManager.getSemantics(this.host);
+      const eventSemantics = InternalVegaEventManager.getSemantics(this.host);
       for (const handler of this.eventHandlers) {
         if (handler.canHandle(eventSemantics)) {
           handler.handle(detail, e);
@@ -180,7 +324,7 @@ class EventEmitSlimmerBase extends VegaSlimmer {
       // add promise to fix the testPolyfill#replaceChildren
       void Promise.resolve(true).then(() => {
         if (this.isNodeRemovedFromDocument(this.host)) {
-          DomNodeSubjectObserverFactory.removeObserverFromNode(this.host, this.eventID);
+          DomNodeSubjectObserverFactory.removeUniqueObserverFromNode(this.host, this.eventID);
         }
       });
     };
@@ -228,7 +372,7 @@ __decorate([
  * 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 {VegaEventIDInterface} eventID - The eventName parameter is a VegaEventID that represents the name of the event.
+ * @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.
  */
@@ -247,4 +391,4 @@ function createEventEmitSlimmer(mapFromClass, eventID, nativeEventPropertyName)
   ]);
 }
 
-export { createEventEmitSlimmer as c };
+export { DomNodeSubjectObserverFactory as D, Observer as O, createEventEmitSlimmer as c, domNodeSubjectFactory as d };

package/dist/esm/{featureFlagController-5d7e64f1.js → featureFlagController-f5c118d6.js}

@@ -8,22 +8,24 @@ const FeatureFlagsMap = {
     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',
-    removedAfterVersion: '2.0.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.`,
@@ -53,11 +55,13 @@ const FeatureFlagsMap = {
     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`,
@@ -75,9 +79,10 @@ const FeatureFlagsMap = {
     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 alignItem and justifyContent classes by using 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',
@@ -102,11 +107,13 @@ const FeatureFlagsMap = {
     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`,
@@ -119,6 +126,16 @@ const FeatureFlagsMap = {
     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',
+  },
 };
 const FeatureFlagsMap$1 = Object.freeze(FeatureFlagsMap);