@heartlandone/vega 1.51.0 → 2.0.0-preview-2

package/dist/cjs/domNodeSubjectObserverFactory-b9050559.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const changeManager = require('./changeManager-1dd5ac2a.js');
+const observer = require('./observer-f49483e8.js');
+
+/** 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 addObserverToNode(node, eventId, callback, acceptableHandle) {
+    if (node) {
+      const domNodesObserver = new observer.Observer(typeof acceptableHandle === 'function' ? acceptableHandle.bind(null) : domAcceptableHandle, callback);
+      DomNodeSubjectObserverFactory.removeObserverFromNode(node, eventId);
+      changeManager.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 removeObserverFromNode(node, eventId) {
+    if (domNodeSubjectFactory.isExist(node, eventId)) {
+      changeManager.ChangeManager.clearObserversBySubject(domNodeSubjectFactory.getSubject(node, eventId));
+    }
+  }
+}
+
+exports.DomNodeSubjectObserverFactory = DomNodeSubjectObserverFactory;
+exports.domNodeSubjectFactory = domNodeSubjectFactory;

package/dist/cjs/eventEmitSlimmer-946bc373.js

@@ -0,0 +1,252 @@
+'use strict';
+
+const globalSlimmerRegistry = require('./global-slimmer-registry-58eee093.js');
+const vegaSlimmer = require('./vega-slimmer-f026897e.js');
+const dynamicSlimmer = require('./dynamic-slimmer-028b0e61.js');
+const changeManager = require('./changeManager-1dd5ac2a.js');
+const domNodeSubjectObserverFactory = require('./domNodeSubjectObserverFactory-b9050559.js');
+const internalVegaEventManager = require('./internalVegaEventManager-78a14dbf.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 vegaSlimmer.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.
+     */
+    this.handle = (detail) => {
+      this.vegaEvent.emit(detail);
+    };
+  }
+}
+__decorate$3([
+  vegaSlimmer.MapToComponentField()
+], VegaEventEmitHandlerSlimmer.prototype, "vegaEvent", void 0);
+__decorate$3([
+  vegaSlimmer.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 vegaSlimmer.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
+     */
+    this.handle = (detail, e) => {
+      this.nativeEvent.emit(detail);
+      if (e) {
+        e.stopPropagation();
+      }
+    };
+  }
+}
+__decorate$2([
+  vegaSlimmer.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 vegaSlimmer.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
+     */
+    this.handle = (detail, e) => {
+      const strategy = internalVegaEventManager.jqueryDelegatedStrategyController.getStrategy(this.host, this.eventID);
+      if (strategy) {
+        strategy.handle(this.host, detail);
+        if (e) {
+          e.stopPropagation();
+        }
+      }
+    };
+  }
+  /**
+   * 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([
+  vegaSlimmer.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 vegaSlimmer.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
+     */
+    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);
+      for (const handler of this.eventHandlers) {
+        if (handler.canHandle(eventSemantics)) {
+          handler.handle(detail, e);
+          break;
+        }
+      }
+    };
+    /**
+     * 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.removeObserverFromNode(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;