@heartlandone/vega-sandbox-pr-1520-691bff7087c621eb9bbbfe1797636727b1277984 2.27.0

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-1520-691bff7087c621eb9bbbfe1797636727b1277984-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-1520-691bff7087c621eb9bbbfe1797636727b1277984-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();
+    });
+  });
+});

package/dist/collection/helpers/slimmers/string-input-formatter-slimmer.js

@@ -0,0 +1,198 @@
+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, VegaSlimmer } from 'vega-slimmer/core';
+import { isNonNullable } from '../../types/type-guard';
+/** The `StringInputFormatterSlimmer` class in TypeScript is used to format input values based on specified strategies and handle events like keydown, blur, and focus. */
+export class StringInputFormatterSlimmer extends VegaSlimmer {
+  constructor() {
+    super(...arguments);
+    this.inputFlag = true;
+    this.blurFlag = true;
+    /**
+     * restore input value
+     *
+     * @param {InputEvent} e - focus event
+     */
+    this.onFocus = (e) => {
+      if (this.host && this.host['value']) {
+        const target = e.target;
+        const rawValue = target.value;
+        const componentValue = this.host['value'];
+        if (rawValue !== componentValue) {
+          this.inputElement.value = componentValue;
+        }
+      }
+    };
+    /**
+     * A function update the value of the input element by inputFormatStrategy output.
+     *
+     * @param {InputEvent} e - blur event
+     */
+    this.onBlur = (e) => {
+      this.blurFlag = false;
+      if (this.blurFormatStrategy) {
+        const target = e.target;
+        const rawValue = target.value;
+        const maskedValue = this.blurFormatStrategy.format(rawValue);
+        this.updateInputValue(rawValue, maskedValue);
+        if (this.host &&
+          this.blurFormatStrategy.shouldOverrideComponentValueAfterBlur &&
+          this.blurFormatStrategy.shouldOverrideComponentValueAfterBlur()) {
+          this.host['value'] = maskedValue;
+        }
+      }
+    };
+    /**
+     * A function update the value of the input element by inputFormatStrategy output.
+     *
+     * @param {InputEvent} e - input event
+     */
+    this.onKeyDown = (e) => {
+      this.inputFlag = false;
+      const target = e.target;
+      const rawValue = target.value;
+      const caretPosition = target.selectionStart; // selectionStart is nullable, link https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#dom-textarea/input-selectionstart
+      if (this.inputFormatStrategy) {
+        const maskedValue = this.inputFormatStrategy.format(rawValue, caretPosition);
+        this.updateInputValue(rawValue, maskedValue);
+        this.updateInputCaretPosition(rawValue, caretPosition);
+      }
+    };
+    /**
+     * A function to update the value of the input element by inputFormatStrategy output when paste is applied.
+     *
+     * @param {ClipboardEvent} e - paste event
+     */
+    this.onPaste = (e) => {
+      var _a;
+      e.preventDefault();
+      const rawValue = ((_a = e.clipboardData) === null || _a === void 0 ? void 0 : _a.getData('text')) || '';
+      if (this.inputFormatStrategy) {
+        const maskedValue = this.inputFormatStrategy.format(rawValue);
+        this.updateInputValue(rawValue, maskedValue);
+      }
+    };
+  }
+  /**
+   * The setup function initializes input element event listeners based on input and blur format strategies.
+   */
+  setup() {
+    this.destroy();
+    const inputElement = this.getInputElementRef();
+    if (inputElement) {
+      this.inputElement = inputElement;
+      this.inputFormatStrategy = this.getInputModeStrategy();
+      this.blurFormatStrategy = this.getBlurModeStrategy();
+      this.onInit();
+      if (this.inputFormatStrategy) {
+        this.inputElement.addEventListener('input', this.onKeyDown, { capture: true });
+        if (!this.disableCopyPaste) {
+          this.inputElement.addEventListener('paste', this.onPaste, { capture: true });
+        }
+      }
+      if (this.blurFormatStrategy) {
+        this.inputElement.addEventListener('blur', this.onBlur, { capture: true });
+        this.inputElement.addEventListener('focus', this.onFocus, { capture: true });
+      }
+    }
+  }
+  /**
+   * It removes the event listener from the input element.
+   */
+  destroy() {
+    if (this.inputElement) {
+      if (this.inputFormatStrategy) {
+        this.inputElement.removeEventListener('input', this.onKeyDown, { capture: true });
+        if (!this.disableCopyPaste) {
+          this.inputElement.removeEventListener('paste', this.onPaste, { capture: true });
+        }
+      }
+      if (this.blurFormatStrategy) {
+        this.inputElement.removeEventListener('blur', this.onBlur, { capture: true });
+        this.inputElement.removeEventListener('focus', this.onFocus, { capture: true });
+      }
+    }
+  }
+  /**
+   * The `onInit` function checks for specific feature flags and conditions to format input values
+   * accordingly.
+   */
+  onInit() {
+    var _a, _b, _c, _d;
+    if (((_b = (_a = this.inputFormatStrategy) === null || _a === void 0 ? void 0 : _a.shouldTriggerAtInit) === null || _b === void 0 ? void 0 : _b.call(_a)) && !this.isOnFocus() && this.inputFlag) {
+      this.inputFlag = false;
+      this.updateInputValueOnInit('input');
+    }
+    if (((_d = (_c = this.blurFormatStrategy) === null || _c === void 0 ? void 0 : _c.shouldTriggerAtInit) === null || _d === void 0 ? void 0 : _d.call(_c)) && !this.isOnFocus() && this.blurFlag) {
+      this.blurFlag = false;
+      this.updateInputValueOnInit('blur');
+    }
+  }
+  /*
+   * The below method is e2e-test covered in
+   * @see{module:vega-input-credit-card-dynamic-mask-e2e}
+   */
+  /* istanbul ignore next */
+  /**
+   * The function `isOnFocus` checks if the input element is currently focused.
+   *
+   * @returns {boolean} The method `isOnFocus()` is returning a `Nullable<boolean>`, which means it can return
+   * either a boolean value or null. The method checks if the `inputElement` is currently focused and
+   * returns true if it is focused, false if it is not focused, or null if the `inputElement` is not
+   * found.
+   */
+  isOnFocus() {
+    return this.inputElement.matches(':focus');
+  }
+  /**
+   * Update input value
+   *
+   * @param {string} rawValue - the original value
+   * @param {string} maskedValue - masked value
+   */
+  updateInputValue(rawValue, maskedValue) {
+    // link: https://stackoverflow.com/questions/52003841/why-doesnt-event-target-value-include-and-e-for-number-inputs
+    // If the input value is '123.', '123' will be got from `target.value` when the input element type is number
+    // '123.' will be formatted to '123', then `this.inputElement.value = 123`, '.' will never be filled in
+    if (maskedValue !== rawValue) {
+      this.inputElement.value = maskedValue;
+    }
+  }
+  /**
+   * Updated the input caret position after the mask format
+   *
+   * @param {string} rawValue - The original input value
+   * @param {Nullable<number>} caretPosition - The current input caret position
+   */
+  updateInputCaretPosition(rawValue, caretPosition) {
+    var _a, _b, _c;
+    const newCaretPosition = (_c = (_b = (_a = this.inputFormatStrategy).calculateCaretPosition) === null || _b === void 0 ? void 0 : _b.call(_a, rawValue, caretPosition)) !== null && _c !== void 0 ? _c : caretPosition;
+    if (isNonNullable(newCaretPosition)) {
+      this.inputElement.setSelectionRange(newCaretPosition, newCaretPosition);
+    }
+  }
+  /**
+   * The function `updateInputValueOnInit` updates the input value based on a specified strategy.
+   *
+   * @param {string} strategy - The `strategy` parameter is a string that determines which formatting
+   * strategy to use when updating the input value. It can have two possible values: 'input' or any other
+   * value.
+   */
+  updateInputValueOnInit(strategy) {
+    const rawValue = this.inputElement.value;
+    const maskedValue = strategy === 'input'
+      ? // eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
+        this.inputFormatStrategy.format(rawValue)
+      : // eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
+        this.blurFormatStrategy.format(rawValue);
+    this.updateInputValue(rawValue, maskedValue);
+    strategy === 'input' && (this.host['value'] = maskedValue);
+  }
+}
+__decorate([
+  MapToComponentField()
+], StringInputFormatterSlimmer.prototype, "host", void 0);

package/dist/collection/helpers/slimmers/sub-state/sub-state-notify-slimmer-base.js

@@ -0,0 +1,49 @@
+import { VegaSlimmer } from 'vega-slimmer/core';
+import ChangeManager from '../../change-manager/change-manager';
+import { Observer } from '../../change-manager/observer/observer';
+import { VegaInternalSubStatePull, VegaInternalSubStatePush, } from '../../event-manager/event-id/vega-internal-event-id';
+import DomNodeSubjectFactory from '../../change-manager/subject/dom-node-subject/dom-node-subject-factory';
+/**
+ * Sub state notify slimmer
+ */
+export class SubStateNotifySlimmerBase extends VegaSlimmer {
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  constructor({ propName }) {
+    super();
+    /**
+     * Checks if the input `host` matches the current `host` and `stateName` matches the current `propName`.
+     *
+     * @param {unknown} input - The `input` parameter is of type `unknown`, which means it can be any type.
+     * @returns {boolean} a boolean value indicating whether the input is an acceptable table observer.
+     */
+    this.isAcceptableObserverPayload = (input) => {
+      return input.host === this.host && input.stateName === this.propName;
+    };
+    this.propName = propName;
+  }
+  /**
+   * Register the observer in connectedCallback
+   */
+  connectedCallback() {
+    this.subStateObserver = new Observer(this.isAcceptableObserverPayload.bind(this), (payload) => {
+      payload.callback(this.propValue);
+    });
+    ChangeManager.register(DomNodeSubjectFactory.getSubject(this.host, VegaInternalSubStatePull), this.subStateObserver);
+  }
+  /**
+   * unregister the observer in disconnectedCallback
+   */
+  disconnectedCallback() {
+    ChangeManager.unregister(DomNodeSubjectFactory.getSubject(this.host, VegaInternalSubStatePull), this.subStateObserver);
+  }
+  /**
+   * Notify the children component which prop has been changed in the parent component
+   */
+  subStateNotify() {
+    ChangeManager.notify(DomNodeSubjectFactory.getSubject(this.host, VegaInternalSubStatePush), {
+      host: this.host,
+      stateName: this.propName,
+      value: this.propValue,
+    });
+  }
+}

package/dist/collection/helpers/slimmers/sub-state/sub-state-notify-slimmer.js

@@ -0,0 +1,24 @@
+import { createDynamicSlimmer } from 'vega-slimmer/core';
+import { SubStateNotifySlimmerBase } from './sub-state-notify-slimmer-base';
+/**
+ * Create dynamic subState notify slimmer
+ *
+ * @param {ClassPrototype} mapFromClass - It represents the class that you want to map from.
+ * @param {string} propName - The parent component prop name
+ * @param {string} watchMethodName - The watch method name of prop change
+ * @returns {SubStateNotifySlimmerBase} - SubState notify slimmer
+ */
+export function createSubStateNotifySlimmer(mapFromClass, propName, watchMethodName) {
+  return createDynamicSlimmer(mapFromClass, SubStateNotifySlimmerBase, [
+    { mapFrom: 'host', mapTo: 'host' },
+    { mapFrom: propName, mapTo: 'propValue' },
+  ], [
+    { mapFrom: watchMethodName, mapTo: 'subStateNotify' },
+    { mapFrom: 'connectedCallback', mapTo: 'connectedCallback' },
+    { mapFrom: 'disconnectedCallback', mapTo: 'disconnectedCallback' },
+  ], [
+    {
+      propName: propName,
+    },
+  ]);
+}

package/dist/collection/helpers/slimmers/sub-state/sub-state-observer-slimmer.js

@@ -0,0 +1,129 @@
+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';
+import { Observer } from '../../change-manager/observer/observer';
+import ChangeManager from '../../change-manager/change-manager';
+import { findParent } from '../../../utils/ui';
+import DomNodeSubjectFactory from '../../change-manager/subject/dom-node-subject/dom-node-subject-factory';
+import { VegaInternalSubStatePull, VegaInternalSubStatePush, } from '../../event-manager/event-id/vega-internal-event-id';
+/**
+ * The subState observer that to sync up the parent state to the children components.
+ */
+export class SubStateObserverSlimmer extends VegaSlimmer {
+  /**
+   * @param {SubStateObserverEntry} observerEntry - observerEntry is the object that contains the parent state and the state name.
+   */
+  constructor(observerEntry) {
+    super();
+    /**
+     * The function checks if the input object has a 'host' property that matches the parent host and a 'stateName' property.
+     *
+     * @param {unknown} input - The `input` parameter is of type `unknown`, which means it can be any type.
+     * @returns {boolean} a boolean value indicating whether the input is an acceptable observer payload.
+     */
+    this.isAcceptableObserverPayload = (input) => {
+      return input['host'] === this.parent;
+    };
+    this.observerEntry = observerEntry;
+  }
+  /**
+   * Initialize the subState observer.
+   */
+  connectedCallback() {
+    this.parent = this.getParent();
+    if (!this.parent)
+      return;
+    const { subStates } = this.observerEntry;
+    this.subStateObserver = new Observer(this.isAcceptableObserverPayload, (payload) => {
+      const subState = subStates.find((subState) => subState.parentStateName === payload.stateName);
+      if (subState) {
+        this.updateState(subState, payload.value);
+      }
+    });
+    ChangeManager.register(DomNodeSubjectFactory.getSubject(this.parent, VegaInternalSubStatePush), this.subStateObserver);
+    if (this.observerEntry.pullStatesWhenReattached && this.host.classList.contains('hydrated')) {
+      this.parent = this.getParent();
+      this.pullStates();
+    }
+  }
+  /**
+   * Unregister the observer when disconnectedCallback
+   */
+  disconnectedCallback() {
+    if (!this.parent)
+      return;
+    ChangeManager.unregister(DomNodeSubjectFactory.getSubject(this.parent, VegaInternalSubStatePush), this.subStateObserver);
+  }
+  /**
+   * Fetch the parent props when componentWillLoad
+   */
+  componentWillLoad() {
+    this.pullStates();
+  }
+  /**
+   * The function `getParent` returns the parent element of a given host element, based on the observer
+   * entry and appender element.
+   *
+   * @returns {HTMLElement} the parent HTMLElement.
+   */
+  getParent() {
+    if (typeof this.observerEntry.parent === 'string') {
+      return findParent(this.host, this.observerEntry.parent);
+    }
+    else {
+      return this.observerEntry.parent();
+    }
+  }
+  /**
+   * Update the state with new value
+   *
+   * @param {SubStateEntry} subState - current state entry
+   * @param {unknown} value - new value
+   */
+  updateState(subState, value) {
+    if (subState.callback) {
+      subState.callback(value);
+    }
+    else {
+      this[subState.subStateName] = value;
+    }
+  }
+  /**
+   * The `pullStates` function iterates through subStates and notifies the ChangeManager to update the
+   * state based on the callback function provided.
+   *
+   * @returns {void} If the `this.parent` property is falsy, the `pullStates` method will return early and not
+   * execute the rest of the code inside the method.
+   */
+  pullStates() {
+    if (!this.parent)
+      return;
+    const { subStates } = this.observerEntry;
+    subStates.forEach((subState) => {
+      ChangeManager.notify(DomNodeSubjectFactory.getSubject(this.parent, VegaInternalSubStatePull), {
+        host: this.parent,
+        stateName: subState.parentStateName,
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        callback: (value) => {
+          this.updateState(subState, value);
+        },
+      });
+    });
+  }
+}
+__decorate([
+  MapToComponentField()
+], SubStateObserverSlimmer.prototype, "host", void 0);
+__decorate([
+  MapToComponentMethod('connectedCallback')
+], SubStateObserverSlimmer.prototype, "connectedCallback", null);
+__decorate([
+  MapToComponentMethod('disconnectedCallback')
+], SubStateObserverSlimmer.prototype, "disconnectedCallback", null);
+__decorate([
+  MapToComponentMethod('componentWillLoad')
+], SubStateObserverSlimmer.prototype, "componentWillLoad", null);