@heartlandone/vega-sandbox-pr-1474-a64385b416d2e92ec0fb6cf2ef83219880562cb4 2.26.0

package/dist/collection/helpers/slimmers/mutation-observer/mutation-observer-slimmer.js

@@ -0,0 +1,80 @@
+var __decorate = (this && this.__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;
+};
+import { MapToComponentField, MapToComponentMethod, VegaSlimmer } from 'vega-slimmer/core';
+/**
+ * The `MutationObserverSlimmer` class in TypeScript extends `VegaSlimmer` and implements a
+ * simplified version of `MutationObserver` functionality for observing DOM mutations.
+ */
+export class MutationObserverSlimmer extends VegaSlimmer {
+  /**
+   * The constructor initializes a class instance with a MutationObserverEntry parameter.
+   *
+   * @param {MutationObserverEntry} observerEntry - The `observerEntry` parameter in the constructor is
+   * of type `MutationObserverEntry`. This parameter likely contains information about a single change
+   * that was observed by a `MutationObserver` instance. It could include details such as the type of
+   * mutation, the target element that was mutated, and any additional relevant information
+   */
+  constructor(observerEntry) {
+    super();
+    this.observerEntry = observerEntry;
+  }
+  /**
+   * Component lifecycle - [connectedCallback]
+   */
+  connectedCallback() {
+    if (this.mutationObserver) {
+      this.observeMutationObserver();
+    }
+  }
+  /**
+   * Component lifecycle - [disconnectedCallback]
+   */
+  disconnectedCallback() {
+    this.mutationObserver.disconnect();
+  }
+  /**
+   * Component lifecycle - [componentDidLoad]
+   */
+  componentDidLoad() {
+    this.initMutationObserver();
+    this.observeMutationObserver();
+  }
+  /**
+   * The function `initMutationObserver` creates a new MutationObserver that triggers a callback based on
+   * specified mutation filters.
+   */
+  initMutationObserver() {
+    this.mutationObserver = new MutationObserver(async (mutations) => {
+      if (!this.observerEntry.mutationFilter ||
+        this.observerEntry.mutationFilter(mutations, this.host)) {
+        this.observerEntry.callback(mutations);
+      }
+    });
+  }
+  /**
+   * The function observeMutationObserver() observes mutations on a target element using a
+   * MutationObserver.
+   */
+  observeMutationObserver() {
+    const target = this.observerEntry.target ? this.observerEntry.target() : this.host;
+    if (target) {
+      this.mutationObserver.observe(target, this.observerEntry.options);
+    }
+  }
+}
+__decorate([
+  MapToComponentField()
+], MutationObserverSlimmer.prototype, "host", void 0);
+__decorate([
+  MapToComponentMethod('connectedCallback')
+], MutationObserverSlimmer.prototype, "connectedCallback", null);
+__decorate([
+  MapToComponentMethod('disconnectedCallback')
+], MutationObserverSlimmer.prototype, "disconnectedCallback", null);
+__decorate([
+  MapToComponentMethod('componentDidLoad')
+], MutationObserverSlimmer.prototype, "componentDidLoad", null);

package/dist/collection/helpers/slimmers/mutation-observer/test/mutation-observer-slimmer.test.js

@@ -0,0 +1,168 @@
+var __decorate = (this && this.__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;
+};
+import { MockHTMLElement } from '@stencil/core/mock-doc';
+import { InjectVegaSlimmer } from 'vega-slimmer/core';
+import { MutationObserverSlimmer } from '../mutation-observer-slimmer';
+import { MockedMutationObserver } from '../../../../utils/spec-utils';
+import { AttributeOldValueMutationFilter, TagNameAndAttributeMutationFilter, TagNameMutationFilter, } from '../mutation-observer-filters';
+describe('mutationObserverSlimmer', () => {
+  const mockedConnectedCallback = jest.fn();
+  const mockedDisconnectedCallback = jest.fn();
+  const mockedComponentDidLoad = jest.fn();
+  const mockedMutationCallback = jest.fn();
+  class MockedComponent {
+    constructor() {
+      this.host = new MockHTMLElement('body', 'mocked-component');
+    }
+    connectedCallback() {
+      mockedConnectedCallback();
+    }
+    disconnectedCallback() {
+      mockedDisconnectedCallback();
+    }
+    componentDidLoad() {
+      mockedComponentDidLoad();
+    }
+    setMutationObserverSlimmer(slimmer) {
+      this.mutationObserverSlimmer = slimmer;
+    }
+  }
+  __decorate([
+    InjectVegaSlimmer()
+  ], MockedComponent.prototype, "mutationObserverSlimmer", void 0);
+  beforeEach(() => {
+    global.MutationObserver = MockedMutationObserver;
+    mockedConnectedCallback.mockClear();
+    mockedDisconnectedCallback.mockClear();
+    mockedComponentDidLoad.mockClear();
+    mockedMutationCallback.mockClear();
+  });
+  it('slimmer callback should be called when observer child list', () => {
+    const mockedComponent = new MockedComponent();
+    mockedComponent.setMutationObserverSlimmer(new MutationObserverSlimmer({
+      options: { childList: true },
+      mutationFilter: TagNameMutationFilter('MOCKED-NODE'),
+      callback: () => {
+        mockedMutationCallback();
+      },
+    }));
+    mockedComponent.connectedCallback();
+    mockedComponent.componentDidLoad();
+    const node = document.createElement('mocked-node');
+    MockedMutationObserver.mock.instances[0].trigger([
+      {
+        addedNodes: [node],
+        removedNodes: [],
+      },
+    ]);
+    expect(mockedMutationCallback).toBeCalledTimes(1);
+    mockedComponent.disconnectedCallback();
+    MockedMutationObserver.mock.instances[0].trigger([
+      {
+        addedNodes: [],
+        removedNodes: [node],
+      },
+    ]);
+    expect(mockedMutationCallback).toBeCalledTimes(2);
+  });
+  it('slimmer callback should be called when observer attributes', () => {
+    const mockedComponent = new MockedComponent();
+    mockedComponent.setMutationObserverSlimmer(new MutationObserverSlimmer({
+      target: () => mockedComponent.host,
+      options: { attributes: true, attributeOldValue: true },
+      mutationFilter: AttributeOldValueMutationFilter(),
+      callback: () => {
+        mockedMutationCallback();
+      },
+    }));
+    mockedComponent.connectedCallback();
+    mockedComponent.componentDidLoad();
+    mockedComponent.host.setAttribute('disabled', true);
+    MockedMutationObserver.mock.instances[0].trigger([
+      {
+        attributeName: 'disabled',
+        oldValue: 'false',
+      },
+    ]);
+    expect(mockedMutationCallback).toBeCalledTimes(1);
+    mockedComponent.disconnectedCallback();
+  });
+  it('slimmer callback should be called when observer attributes and child list', () => {
+    const mockedComponent = new MockedComponent();
+    mockedComponent.setMutationObserverSlimmer(new MutationObserverSlimmer({
+      target: () => mockedComponent.host,
+      options: { attributes: true, attributeFilter: ['disabled'], childList: true, subtree: true },
+      mutationFilter: TagNameAndAttributeMutationFilter('MOCKED-NODE'),
+      callback: () => {
+        mockedMutationCallback();
+      },
+    }));
+    mockedComponent.connectedCallback();
+    mockedComponent.componentDidLoad();
+    const node = document.createElement('mocked-node');
+    MockedMutationObserver.mock.instances[0].trigger([
+      {
+        addedNodes: [node],
+        removedNodes: [],
+      },
+    ]);
+    expect(mockedMutationCallback).toBeCalledTimes(1);
+    node.setAttribute('disabled', 'true');
+    MockedMutationObserver.mock.instances[0].trigger([
+      {
+        attributeName: 'disabled',
+        oldValue: 'false',
+        addedNodes: [],
+        removedNodes: [],
+        target: node,
+      },
+    ]);
+    expect(mockedMutationCallback).toBeCalledTimes(2);
+    mockedComponent.disconnectedCallback();
+    const noListenNode = document.createElement('no-listen-node');
+    MockedMutationObserver.mock.instances[0].trigger([
+      {
+        addedNodes: [noListenNode],
+        removedNodes: [],
+      },
+    ]);
+    expect(mockedMutationCallback).toBeCalledTimes(2);
+    noListenNode.setAttribute('disabled', 'true');
+    MockedMutationObserver.mock.instances[0].trigger([
+      {
+        attributeName: 'disabled',
+        oldValue: 'false',
+        addedNodes: [],
+        removedNodes: [],
+        target: noListenNode,
+      },
+    ]);
+    expect(mockedMutationCallback).toBeCalledTimes(2);
+  });
+  it('should work proper while component disconnected', () => {
+    const mockedComponent = new MockedComponent();
+    mockedComponent.setMutationObserverSlimmer(new MutationObserverSlimmer({
+      options: { childList: true },
+      mutationFilter: TagNameMutationFilter('MOCKED-NODE'),
+      callback: () => {
+        mockedMutationCallback();
+      },
+    }));
+    mockedComponent.connectedCallback();
+    mockedComponent.componentDidLoad();
+    mockedComponent.disconnectedCallback();
+    mockedComponent.connectedCallback();
+    const node = document.createElement('mocked-node');
+    MockedMutationObserver.mock.instances[0].trigger([
+      {
+        addedNodes: [node],
+        removedNodes: [],
+      },
+    ]);
+    expect(mockedMutationCallback).toBeCalledTimes(1);
+  });
+});

package/dist/collection/helpers/slimmers/page-resize-observer-slimmer.js

@@ -0,0 +1,117 @@
+var __decorate = (this && this.__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;
+};
+import { MapToComponentMethod, MapToComponentField, VegaSlimmer } from 'vega-slimmer/core';
+import { getCurrentBreakpoint } from '../../utils/breakpoints';
+/**
+ * The `PageResizeObserverSlimmer` class is a TypeScript class that extends `VegaSlimmer` and provides functionality for observing page resize events.
+ *
+ * Note: The slimmer which will extends the `PageResizeObserverSlimmer` should not have same name method `connectedCallbackByResizeSlimmer` , `disconnectedCallbackByResizeSlimmer` and `componentDidLoadByResizeSlimmer`
+ */
+export class PageResizeObserverSlimmer extends VegaSlimmer {
+  /**
+   * The constructor function takes a PageResizeObserverEntry object as a parameter.
+   *
+   * @param {PageResizeObserverEntry} observerEntry - The `observerEntry` parameter is an instance of
+   * the `PageResizeObserverEntry` class. It represents an entry in the `PageResizeObserver`'s list of
+   * observed elements. It contains information about the observed element's size and position.
+   */
+  constructor(observerEntry) {
+    super();
+    this.observerEntry = observerEntry;
+  }
+  /**
+   * create resize observer when connectedCallback
+   */
+  reconnectResizeObserver() {
+    if (this.resizeObserver === null) {
+      this.createResizeObserver();
+    }
+  }
+  /**
+   * cancel resize observer when disconnectedCallback
+   */
+  disconnectResizeObserver() {
+    var _a;
+    (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+    this.resizeObserver = null;
+  }
+  /**
+   * create resize observer when componentDidLoad
+   */
+  connectResizeObserver() {
+    this.createResizeObserver();
+  }
+  /**
+   * The function creates a resize observer that calls a callback function with the current breakpoint whenever the page resize.
+   */
+  createResizeObserver() {
+    var _a;
+    const observerEntry = this.observerEntry;
+    (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+    const VegaResizeObserver = window['VegaResizeObserver'] || window.ResizeObserver;
+    if (VegaResizeObserver) {
+      this.resizeObserver = new VegaResizeObserver((entries, observer) => {
+        if (observerEntry &&
+          typeof observerEntry.shouldTrigger === 'function' &&
+          !observerEntry.shouldTrigger()) {
+          return;
+        }
+        if (observerEntry && typeof observerEntry.callback === 'function') {
+          /**
+           * The function "handle" calls the callback function of an observer entry with the specified
+           * arguments.
+           */
+          const handle = () => {
+            observerEntry.callback(entries, observer);
+          };
+          observerEntry.isDeferred ? setTimeout(handle) : handle();
+        }
+        else {
+          this.currentBreakpoint = getCurrentBreakpoint();
+        }
+      });
+    }
+    this.observerResizeObserver();
+  }
+  /**
+   * The function `observerResizeObserver` observes the resize of one or multiple HTML elements using the
+   * ResizeObserver API.
+   */
+  observerResizeObserver() {
+    var _a;
+    if (this.resizeObserver) {
+      const resizeObserver = this.resizeObserver;
+      let observers = null;
+      if ((_a = this.observerEntry) === null || _a === void 0 ? void 0 : _a.target) {
+        observers = this.observerEntry.target();
+      }
+      if (Array.isArray(observers)) {
+        observers.forEach((observer) => {
+          resizeObserver.observe(observer);
+        });
+      }
+      else if (observers) {
+        resizeObserver.observe(observers);
+      }
+      else {
+        resizeObserver.observe(document.body);
+      }
+    }
+  }
+}
+__decorate([
+  MapToComponentField({ writable: true, isOptional: true })
+], PageResizeObserverSlimmer.prototype, "currentBreakpoint", void 0);
+__decorate([
+  MapToComponentMethod('connectedCallback')
+], PageResizeObserverSlimmer.prototype, "reconnectResizeObserver", null);
+__decorate([
+  MapToComponentMethod('disconnectedCallback')
+], PageResizeObserverSlimmer.prototype, "disconnectResizeObserver", null);
+__decorate([
+  MapToComponentMethod('componentDidLoad')
+], PageResizeObserverSlimmer.prototype, "connectResizeObserver", null);

package/dist/collection/helpers/slimmers/runtime-metrics/create-public-api-runtime-metrics-slimmer.js

@@ -0,0 +1,23 @@
+import { createDynamicSlimmer } from 'vega-slimmer/core';
+import { VegaPublicAPIRuntimeMetricsSlimmerBase } from './public-api-runtime-metrics-slimmer-base';
+/**
+ * The function `createComponentUsageRuntimeMetricsSlimmer` creates a slimmer version of a component
+ * usage runtime metrics object based on a given class prototype and optional method names to watch.
+ *
+ * @param {ClassPrototype} mapFromClass - The `mapFromClass` parameter is a ClassPrototype that represents the class
+ * from which the dynamic map will be created.
+ * @param {MethodKeysOf[]} [watchMethodNames] - The `watchMethodNames` parameter
+ * is an optional array of method names that you want to watch for in the component.
+ * @param {unknown[]} [initData] - The `initData` parameter allows you to
+ * pass an array of initial data to be used during the initialization of the component usage runtime
+ * metrics slimmer.
+ * @returns {VegaPublicAPIRuntimeMetricsSlimmerBase} The function creates a dynamic public api runtime metrics slimmer.
+ */
+export function createPublicAPIRuntimeMetricsSlimmer(mapFromClass, watchMethodNames, initData) {
+  const methodsMap = [];
+  watchMethodNames.map((watchMethodName) => methodsMap.push({
+    mapFrom: watchMethodName,
+    mapTo: 'sendPublicAPIPayloadToTelemetry',
+  }));
+  return createDynamicSlimmer(mapFromClass, VegaPublicAPIRuntimeMetricsSlimmerBase, [], methodsMap, [mapFromClass.name, initData]);
+}

package/dist/collection/helpers/slimmers/runtime-metrics/public-api-runtime-metrics-slimmer-base.js

@@ -0,0 +1,74 @@
+import { CurrentlyInvokedMethodName, VegaSlimmer } from 'vega-slimmer/core';
+import { LogUtility } from '../../../utils/log';
+import { isObjectEmpty } from '../../../utils/misc';
+/**
+ * The `VegaPublicAPIRuntimeMetricsSlimmerBase` class is used for sending
+ * telemetry data to a telemetry service based on defined usage metrics for a public api.
+ */
+export class VegaPublicAPIRuntimeMetricsSlimmerBase extends VegaSlimmer {
+  /**
+   * The constructor initializes a private readonly property with an optional array of
+   * PublicAPIRuntimeMetricsDefinition.
+   *
+   * @param {string} [className] - The parameter show the class name of public api.
+   * @param {PublicAPIRuntimeMetricsDefinition[]} [usageDefinitions] - The `usageDefinitions`
+   * parameter in the constructor is of type `PublicAPIRuntimeMetricsDefinition<T>[]`, which is an
+   * array of `ComponentUsageRuntimeMetricsDefinition` objects. This parameter is optional as it is
+   * marked with a question mark `?`, meaning it can be omitted when creating an instance of
+   */
+  constructor(className, usageDefinitions) {
+    super();
+    this.className = className;
+    this.usageDefinitions = usageDefinitions;
+  }
+  /**
+   * register the observer when the slimmer method called
+   *
+   * @param {unknown[]} [args] - The `args` parameter passed in when the slimmer method is executed
+   */
+  sendPublicAPIPayloadToTelemetry(args) {
+    try {
+      const publicAPIMetricsPayload = this.getPublicAPIMetricsPayload(args);
+      if (publicAPIMetricsPayload) {
+        // eslint-disable-next-line spellcheck/spell-checker
+        void import('@heartlandone/vega-sandbox-pr-1474-a64385b416d2e92ec0fb6cf2ef83219880562cb4-telemetry-runtime-metrics/runtime-metrics/src/index.js').then((
+        // eslint-disable-next-line spellcheck/spell-checker
+        module) => {
+          module['default']['emit']('publicAPIMetrics', publicAPIMetricsPayload);
+        });
+      }
+    }
+    catch (error) {
+      LogUtility.log('Public API payload failed to emit telemetry:', error);
+    }
+  }
+  /**
+   * The function `getPublicAPIMetricsPayload` generates a payload containing public api
+   * metrics data.
+   * The `CurrentlyInvokedMethodName` is a public API method name, it comes from the `InjectVegaTelemetrySlimmer` definition and assignment
+   *
+   * @param {unknown[]} [args] - The `args` parameter passed in when the slimmer method is executed
+   * @returns {Record<string, unknown>} The `getPublicAPIMetricsPayload` method returns an object with the following
+   * structure:
+   * {
+   * 	publicAPIName: string, // The public api name
+   * 	data: { // An object containing payload data with keys and boolean values
+   * 		'waitForVegaRenderFinished': true,
+   * }
+   */
+  getPublicAPIMetricsPayload(args) {
+    const payloadData = {};
+    this.usageDefinitions
+      .filter((definitions) => definitions.canAccept(this.className, this[CurrentlyInvokedMethodName], args))
+      .forEach((definitions) => {
+      payloadData[definitions.payloadKey] = definitions.payloadValue(args);
+    });
+    if (isObjectEmpty(payloadData)) {
+      return null;
+    }
+    return {
+      publicAPIName: this.className,
+      data: payloadData,
+    };
+  }
+}

package/dist/collection/helpers/slimmers/runtime-metrics/test/public-api-runtime-metrics-slimmer-base.test.js

@@ -0,0 +1,96 @@
+var __decorate = (this && this.__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;
+};
+import { InjectVegaSlimmer } from '../../../../../../vega-slimmer/src/decorators/inject-vega-slimmer';
+import { createPublicAPIRuntimeMetricsSlimmer } from '../create-public-api-runtime-metrics-slimmer';
+import VegaTelemetryRuntimeMetricsManager from '@heartlandone/vega-sandbox-pr-1474-a64385b416d2e92ec0fb6cf2ef83219880562cb4-telemetry-runtime-metrics/runtime-metrics/src/index';
+import { sleep } from '../../../../utils/test-utils';
+describe('VegaPublicAPIRuntimeMetricsSlimmerBase', () => {
+  it('should console error log when usageDefinitions is empty ', () => {
+    class MockPublicAPI {
+      constructor() {
+        this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(MockPublicAPI, ['test'], 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        '');
+      }
+      test(parameter) {
+        console.log('parameter', parameter);
+      }
+    }
+    __decorate([
+      InjectVegaSlimmer()
+    ], MockPublicAPI.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
+    const mockPublicAPI = new MockPublicAPI();
+    jest.spyOn(console, 'log');
+    mockPublicAPI.test('test');
+    expect(console.log).toBeCalledTimes(1);
+  });
+  it('should call the emit method of VegaTelemetryRuntimeMetricsManager ', () => {
+    const MockPublicAPIRuntimeMetricsPayloadDefinition = [
+      {
+        payloadKey: 'IS_TEST_METHOD_CALLED',
+        payloadDescription: 'Indicate if the method test of public API MockPublicAPI is called',
+        canAccept: (scope, methodName) => scope === 'MockPublicAPI' && methodName === 'test',
+        payloadValue: () => {
+          return true;
+        },
+      },
+    ];
+    class MockPublicAPI {
+      constructor() {
+        this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(MockPublicAPI, ['test'], MockPublicAPIRuntimeMetricsPayloadDefinition);
+      }
+      test(parameter) {
+        console.log('parameter', parameter);
+      }
+    }
+    __decorate([
+      InjectVegaSlimmer()
+    ], MockPublicAPI.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
+    const mockPublicAPI = new MockPublicAPI();
+    jest.spyOn(VegaTelemetryRuntimeMetricsManager, 'emit');
+    mockPublicAPI.test('test');
+    void Promise.resolve(sleep(100)).then(async () => {
+      expect(VegaTelemetryRuntimeMetricsManager.emit).toHaveBeenCalledWith('publicAPIMetrics', {
+        publicAPIName: 'MockPublicAPI',
+        data: {
+          IS_TEST_METHOD_CALLED: true,
+        },
+      });
+    });
+  });
+  it('should not send runtime metrics to telemetry when the public api payload is empty', () => {
+    const MockPublicAPIRuntimeMetricsPayloadDefinition = [
+      {
+        payloadKey: 'IS_TEST_METHOD_CALLED',
+        payloadDescription: 'Indicate if the method test of public API MockPublicAPI is called',
+        canAccept: (scope, methodName) => scope === 'MockPublicAPI' && methodName === 'test',
+        payloadValue: () => {
+          return true;
+        },
+      },
+    ];
+    class MockPublicAPI {
+      constructor() {
+        this.vegaPublicAPIRuntimeMetricsSlimmer = createPublicAPIRuntimeMetricsSlimmer(MockPublicAPI, ['test'], 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        MockPublicAPIRuntimeMetricsPayloadDefinition);
+      }
+      test(parameter) {
+        console.log('parameter', parameter);
+      }
+    }
+    __decorate([
+      InjectVegaSlimmer()
+    ], MockPublicAPI.prototype, "vegaPublicAPIRuntimeMetricsSlimmer", void 0);
+    const mockPublicAPI = new MockPublicAPI();
+    jest.spyOn(VegaTelemetryRuntimeMetricsManager, 'emit');
+    mockPublicAPI.test('test');
+    void Promise.resolve(sleep(100)).then(async () => {
+      expect(VegaTelemetryRuntimeMetricsManager.emit).not.toBeCalled();
+    });
+  });
+});