@heartlandone/vega 2.75.1 → 2.77.0

package/dist/collection/components/vega-rich-text-editor/extensions/tokens/token-toolbar-button-renderer.js

@@ -9,17 +9,8 @@ export class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer
   constructor(tokenList) {
     super();
     this.tokenList = [];
-    this.extensionContext = null;
     this.tokenList = tokenList;
   }
-  /**
-   * Sets the RTE extension context.
-   *
-   * @param {RTEExtensionContext} context - The context of the RTE extension.
-   */
-  injectExtensionContext(context) {
-    this.extensionContext = context;
-  }
   /**
    * Renders the token toolbar button.
    *
@@ -36,11 +27,13 @@ export class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer
   /**
    * Checks if the token toolbar button is disabled.
    *
+   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
    * @returns {boolean} True if the button is disabled, false otherwise.
    */
-  isDisabled() {
-    if (this.extensionContext) {
-      const { host, getSelectedNodes } = this.extensionContext;
+  isDisabled(editorContext) {
+    const context = this.getExtensionContext(editorContext.host);
+    if (context) {
+      const { host, getSelectedNodes } = context;
       const [startNode] = getSelectedNodes();
       return startNode
         ? host.disabled ||
@@ -72,16 +65,19 @@ export class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer
       const action = new InsertTokenNodeAction(rteRange, token);
       startNode.parent.apply(action);
       if (action.actionHandleResult) {
-        this.flushEditorUI();
+        this.flushEditorUI(editorContext);
       }
     }
   }
   /**
    * Refreshes the editor UI.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
    */
-  flushEditorUI() {
-    if (this.extensionContext) {
-      const { host, flushValue } = this.extensionContext;
+  flushEditorUI(editorContext) {
+    const context = this.getExtensionContext(editorContext.host);
+    if (context) {
+      const { host, flushValue } = context;
       flushValue(host.value);
     }
   }

package/dist/collection/components/vega-rich-text-editor/helpers/extension-context-manager.js

@@ -0,0 +1,31 @@
+/**
+ * Manager for storing and retrieving the extension context associated with each rich text editor host element.
+ *
+ * @todo Currently, there are three types of contexts in RTE: toolbar render context, extension context, and DTO render context. The second and third types are bound to the extension context via host props. We are considering optimizing these three types of contexts to make the program more flexible and easier to maintain.
+ */
+class RTEExtensionContextManager {
+  constructor() {
+    this.extensionContextMap = new WeakMap();
+  }
+  /**
+   * Store the extension context for the given rich text editor host element.
+   *
+   * @param {RTEExtensionContext} context - The extension context to store.
+   */
+  setExtensionContext(context) {
+    if (context && context.host) {
+      this.extensionContextMap.set(context.host, context);
+    }
+  }
+  /**
+   * Get the extension context for the given rich text editor host element.
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The type definition for the rich text editor host element.
+   * @param {Nullable<HTMLVegaRichTextEditorElement>} el - The host rich text editor element.
+   * @returns {Nullable<RTEExtensionContext>} - The extension context associated with the host.
+   */
+  getExtensionContext(el) {
+    return el ? this.extensionContextMap.get(el) : null;
+  }
+}
+export default new RTEExtensionContextManager();

package/dist/collection/components/vega-rich-text-editor/helpers/extension-context-manager.test.js

@@ -0,0 +1,19 @@
+import extensionContextManager from './extension-context-manager';
+describe('extension context manager', () => {
+  it('should store and retrieve context by host element', () => {
+    const host = document.createElement('vega-rich-text-editor');
+    const context = {
+      host,
+      isSourceEditMode: jest.fn().mockReturnValue(false),
+      getSelectedNodes: jest.fn().mockReturnValue([]),
+      flushValue: jest.fn(),
+    };
+    extensionContextManager.setExtensionContext(context);
+    expect(extensionContextManager.getExtensionContext(host)).toBe(context);
+    expect(extensionContextManager.getExtensionContext(null)).toBeNull();
+  });
+  it('should return null when no context registered for host', () => {
+    const host = document.createElement('vega-rich-text-editor');
+    expect(extensionContextManager.getExtensionContext(host)).toBeUndefined();
+  });
+});

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/value-controller.js

@@ -13,7 +13,7 @@ import { VegaInternalRichTextEditorFlushChanges } from '../../../../helpers/even
 import { Observer } from '../../../../helpers/change-manager/observer/observer';
 import { debounce } from '../../../../utils/timer';
 import { VegaRTEContent } from '../../dto/content-state';
-import { waitForComponentDidRender } from '../../../../helpers/common';
+import { waitForComponentDidRender } from '../../../../helpers/common/wait-for-component-did-render';
 import { RTEEditorState } from '../../dto/editor-state';
 import { RTESelectionState } from '../../dto/selection-state';
 import stateEntityRenderingRegistry from './state-entity-rendering-registry';

package/dist/collection/components/vega-rich-text-editor/slimmers/renderers/tools/link-toolbar-button-slimmer.js

@@ -14,7 +14,7 @@ import { LinkAnnotationAction } from '../../../dto/actions/link-annotation-actio
 import { NodeAnnotationTypeEnum } from '../../../dto/annotations/node-annotation.abstract';
 import { SelectionChangeAction } from '../../../dto/actions/selection-change-action';
 import { generateUUID } from '../../../../../utils/misc';
-import { waitForComponentDidRender } from '../../../../../helpers/common';
+import { waitForComponentDidRender } from '../../../../../helpers/common/wait-for-component-did-render';
 import { VisualModeToolbarButtonSlimmer } from './visual-mode-toolbar-button-slimmer.abstract';
 export class LinkToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
   constructor() {

package/dist/collection/components/vega-rich-text-editor/test/extensions/extension-test-utils.js

@@ -0,0 +1,41 @@
+import extensionContextManager from '../../helpers/extension-context-manager';
+import { tryGetDocument } from '../../../../utils/try-get-document';
+import { RTERange } from '../../dto/range';
+/**
+ * Gets a mock rich text editor element for testing purposes.
+ *
+ * @returns {HTMLElement} A mock rich text editor element.
+ */
+export function getMockRichTextEditor() {
+  var _a;
+  return (_a = tryGetDocument()) === null || _a === void 0 ? void 0 : _a.createElement('vega-rich-text-editor');
+}
+/**
+ * Mocks the extension context for testing purposes.
+ *
+ * @param {Partial<RTEExtensionContext>} context - Partial context to override default mock values.
+ * @returns {RTEExtensionContext} The mocked extension context.
+ */
+export function mockExtensionContext(context = {}) {
+  const extensionContext = {
+    host: context.host || getMockRichTextEditor(),
+    isSourceEditMode: context.isSourceEditMode || jest.fn().mockReturnValue(false),
+    getSelectedNodes: context.getSelectedNodes || jest.fn().mockReturnValue([]),
+    flushValue: context.flushValue || jest.fn(),
+  };
+  extensionContextManager.setExtensionContext(extensionContext);
+  return extensionContext;
+}
+/**
+ * Mocks the toolbar render context for testing purposes.
+ *
+ * @param {Partial<VegaRTEToolbarRenderContext>} context - Partial context to override default mock values.
+ * @returns {VegaRTEToolbarRenderContext} The mocked toolbar render context.
+ */
+export function mockToolbarRenderContext(context = {}) {
+  return {
+    host: context.host || getMockRichTextEditor(),
+    rteRange: context.rteRange || new RTERange(),
+    sourceEditMode: context.sourceEditMode || false,
+  };
+}

package/dist/collection/components/vega-signature-capture/slimmers/written-mode/controllers/written-mode-svg-controller.js

@@ -8,6 +8,7 @@ import { MapToComponentField, MapToComponentMethod, VegaSlimmer } from 'vega-sli
 import { FORM_ELEMENT_VALUE_CHANGE } from '../../../../../helpers/change-manager/subject/static-subject/static-subject-title';
 import ChangeManager from '../../../../../helpers/change-manager/change-manager';
 import { deepEqual } from '../../../../../utils/object';
+import { emptySanitizeStrategy, htmlSanitizer } from '../../../../../utils/sanitize';
 /**
  * Signature written mode controller
  */
@@ -19,7 +20,7 @@ export class WrittenModeSvgController extends VegaSlimmer {
      * Clear the signature
      */
     this.clear = () => {
-      this.signatureContainerRef.innerHTML = '';
+      this.signatureContainerRef.innerHTML = htmlSanitizer.sanitize('', emptySanitizeStrategy);
       this.value = null;
     };
     /*

package/dist/collection/components/vega-table/interface.js

@@ -1,3 +1,6 @@
+/**
+ * List of supported form field types for editable table cells.
+ */
 export const VegaTableEditableFieldTypes = [
   'input',
   'input-select',

package/dist/collection/components/vega-table/vega-table-foot-cell/slimmers/renderers/vega-table-foot-cell-renderer.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { MapToComponentField, VegaSlimmer } from 'vega-slimmer/core';
 import { h } from '@stencil/core';
-import { FeatureFlag } from '../../../../../helpers/public-api';
+import { FeatureFlag } from '../../../../../helpers/feature-control/feature-flag-controller';
 import { generateResponsiveClass } from '../../../utils';
 import { arrayToClassString } from '../../../../../utils/ui';
 export class VegaTableFootCellRenderer extends VegaSlimmer {

package/dist/collection/global/scripts/before-vega-load.js

@@ -8,13 +8,14 @@ import { GlobalSlimmersRegistry } from 'vega-slimmer/core';
 import { VegaWatchMethodCancelSlimmer } from '../../helpers/slimmers/global/vega-watch-method-cancel-slimmer';
 import VegaEventManager from '../../helpers/event-manager/vega-event-manager';
 import { TypographyUrls } from '../../constants/tokens/typography';
-import { VegaIconManager, VegaTranslationResourceEN } from '../../helpers/public-api';
+import { VegaIconManager } from '../../helpers/icon/icon-manager';
+import { default as VegaTranslationResourceEN } from '../../helpers/translation/locales/en';
 import VegaZIndexManager from '../../helpers/zindex/vega-z-index-manager';
 import { ValidCreditCardNumberRule } from '../../helpers/validator/rules/valid-credit-card-number-rule';
 import vegaEnvManager from '../../helpers/vega-telemetry-helper/vega-env-manager';
-import { waitForVega } from '../../helpers/common';
+import { waitForVega } from '../../helpers/common/wait-for-vega-handler';
 import { VegaSkeletonLoader } from '../../helpers/skeleton-loader/vega-skeleton-loader-controller';
-import { VegaTranslation } from '../../helpers/translation';
+import { VegaTranslation } from '../../helpers/translation/translation';
 import { VegaTranslateObserverSlimmer } from '../../helpers/slimmers/global/vega-translate-observer-slimmer';
 import { VegaRTEContent } from '../../components/vega-rich-text-editor/dto/content-state';
 import { setVegaNonce, vegaNonceManager } from '../../helpers/csp/vega-nonce-manager';

package/dist/collection/helpers/calendar/calendar-date.js

@@ -1,4 +1,4 @@
-import { VegaInternalTranslation } from '../translation';
+import { VegaInternalTranslation } from '../translation/internal-translation-controller';
 import { CalendarDateTime } from './calendar-date-time';
 import { getSystemTimezone } from './utils';
 import { DateFormatParserRegex } from '../../constants/regex';

package/dist/collection/helpers/calendar/calendar-event.js

@@ -1,6 +1,6 @@
 import calendarEventRepeatPatternFactory from '../../components/vega-calendar/slimmers/common/helpers/repeat-pattern/calendar-event-repeat-pattern-factory';
 import { generateUUID } from '../../utils/misc';
-import { VegaInternalTranslation } from '../translation';
+import { VegaInternalTranslation } from '../translation/internal-translation-controller';
 import { CalendarDate } from './calendar-date';
 import { CalendarTime } from './calendar-time';
 import { CalendarDateTime } from './calendar-date-time';

package/dist/collection/helpers/calendar/calendar-time.js

@@ -1,4 +1,4 @@
-import { VegaInternalTranslation } from '../translation';
+import { VegaInternalTranslation } from '../translation/internal-translation-controller';
 /**
  * CalendarTime represents hours/minutes in 24-hour format and centralizes parsing/formatting logic.
  */

package/dist/collection/helpers/chart/input-processors/format-time-positions-input-processor.js

@@ -1,5 +1,5 @@
 import { convertArrayToNestedArray, flatNestedArray } from '../../../utils/array';
-import { map as d3Map, timeParse as d3TimeParse } from 'd3';
+import { map as d3Map, timeParse as d3TimeParse } from '../../../polyfill/d3';
 /** The FormatTimePositionsInputProcessor class processes input data for a line chart by formatting time positions if the x-axis type is 'time'. */
 export class FormatTimePositionsInputProcessor {
   /**
@@ -30,7 +30,7 @@ export class FormatTimePositionsInputProcessor {
     let lengthArray = [];
     const flatArray = flatNestedArray(data);
     const flatArray_date = d3Map(flatArray, (d) => {
-      return { x: typeof d.x === 'string' ? d3TimeParse('%Y-%m-%d')(d.x) : d.x, y: d.y };
+      return { x: (typeof d.x === 'string' ? d3TimeParse('%Y-%m-%d')(d.x) : d.x), y: d.y };
     });
     if (data && Array.isArray(data[0])) {
       lengthArray = data.map((item) => item.length);

package/dist/collection/helpers/chart/input-processors/pie-chart-arc-path-input-processor.js

@@ -1,4 +1,4 @@
-import { pie as d3Pie } from 'd3';
+import { pie as d3Pie } from '../../../polyfill/d3';
 /** The PieChartArchPathInputProcessor class processes input data to generate options for rendering a pie or donut chart with D3.js. */
 export class PieChartArchPathInputProcessor {
   /**

package/dist/collection/helpers/chart/input-processors/x-axis-input-processor.js

@@ -1,5 +1,5 @@
 import { flatNestedArray } from '../../../utils/array';
-import { scaleTime, scaleLinear, scaleBand, extent as d3Extent } from 'd3';
+import { scaleTime, scaleLinear, scaleBand, extent as d3Extent } from '../../../polyfill/d3';
 /** The XAxisInputProcessor class generates X-axis options for a line chart based on input data and previous layout results. */
 export class XAxisInputProcessor {
   /**
@@ -43,16 +43,18 @@ export class XAxisInputProcessor {
     const xData = flatData.map((item) => item.x);
     let xScale;
     if (xAxisType === 'time') {
+      const ext = d3Extent(xData);
       xScale = scaleTime()
-        .domain(d3Extent(xData))
+        .domain(ext[0] !== undefined ? ext : [new Date(), new Date()])
         .range([0, width]);
     }
     else if (xAxisType === 'category') {
       xScale = scaleBand(typeof sorter === 'function' ? xData.sort(sorter) : xData, [0, width]).padding(padding);
     }
     else {
+      const ext = d3Extent(xData);
       xScale = scaleLinear()
-        .domain(d3Extent(xData))
+        .domain(ext[0] !== undefined ? ext : [0, 0])
         .range([0, width]);
     }
     return xScale;

package/dist/collection/helpers/chart/input-processors/x-axis-label-formatter-input-processor.js

@@ -1,4 +1,5 @@
-import { timeFormat, timeSecond, timeMinute, timeHour, timeDay, timeMonth, timeWeek, timeYear } from 'd3';
+import { timeFormat } from '../../../polyfill/d3/d3-time-format-polyfill';
+import { timeSecond, timeMinute, timeHour, timeDay, timeMonth, timeWeek, timeYear, } from '../../../polyfill/d3/d3-time-polyfill';
 /** The XAxisInputProcessor class generates X-axis options for a line chart based on input data and previous layout results. */
 export class XAxisLabelFormatterInputProcessor {
   constructor() {

package/dist/collection/helpers/chart/input-processors/y-axis-input-processor.js

@@ -1,5 +1,5 @@
 import { flatNestedArray } from '../../../utils/array';
-import { min as d3Min, max as d3Max, extent as d3Extent, scaleLinear } from 'd3';
+import { min as d3Min, max as d3Max, extent as d3Extent, scaleLinear } from '../../../polyfill/d3';
 /** The YAxisInputProcessor class generates Y-axis options for a line chart based on input data and previous layout results. */
 export class YAxisInputProcessor {
   /**
@@ -37,14 +37,16 @@ export class YAxisInputProcessor {
    * @returns {ScaleType}y scale
    */
   getScale(data, range, ticks) {
+    var _a, _b;
     const flatData = flatNestedArray(data);
     const yData = flatData.map((item) => item.y).concat(0);
-    let maxYData = d3Max(yData);
-    let minYData = d3Min(yData);
+    let maxYData = (_a = d3Max(yData)) !== null && _a !== void 0 ? _a : 0;
+    let minYData = (_b = d3Min(yData)) !== null && _b !== void 0 ? _b : 0;
     let yScale = scaleLinear().domain([minYData, maxYData]);
-    const ticksValue = yScale.ticks(ticks);
+    const ticksValue = (yScale.ticks ? yScale.ticks(ticks) : []);
     const step = Math.abs(ticksValue[ticksValue.length - 1] - ticksValue[ticksValue.length - 2]);
-    const [minTickValue, maxTickValue] = d3Extent(ticksValue);
+    const ext = d3Extent(ticksValue);
+    const [minTickValue, maxTickValue] = ext[0] !== undefined ? ext : [0, 0];
     if (minYData < minTickValue) {
       minYData = minTickValue - step;
       ticks += 1;

package/dist/collection/helpers/chart/interacting-entry-generator/arc-path-hover-generator.js

@@ -1,5 +1,5 @@
 import { InteractingEntryGenerator } from './interacting-entry-generator';
-import { select as d3Select } from 'd3';
+import { select as d3Select } from '../../../polyfill/d3';
 /** The `ArcPathHoverGenerator` class is a TypeScript function that handles mouseover events on SVG elements with a specific class and modifies their appearance. */
 export class ArcPathHoverGenerator extends InteractingEntryGenerator {
   constructor() {

package/dist/collection/helpers/chart/interacting-entry-generator/pie-legend-hover-generator.js

@@ -1,5 +1,5 @@
 import { InteractingEntryGenerator } from './interacting-entry-generator';
-import { select as d3Select } from 'd3';
+import { select as d3Select } from '../../../polyfill/d3';
 /** The PieLegendHoverGenerator class generates an InteractingEntry object that handles mouseover events on a legend of a D3 pie chart and triggers a mouseover event on the corresponding path element. */
 export class PieLegendHoverGenerator extends InteractingEntryGenerator {
   constructor() {

package/dist/collection/helpers/chart/renderers/canvas-renderer.js

@@ -1,5 +1,5 @@
 import { BaseRenderer } from './base-renderer';
-import { line as d3Line, create as d3Create } from 'd3';
+import { line as d3Line, create as d3Create } from '../../../polyfill/d3';
 /**
  * The CanvasRenderer class is a TypeScript class that extends the BaseRenderer class and provides
  * methods for drawing various shapes and elements on a canvas.

package/dist/collection/helpers/chart/renderers/svg-renderer.js

@@ -1,5 +1,5 @@
 import { BaseRenderer } from './base-renderer';
-import { select as d3Select, create as d3Create, line as d3Line, axisBottom, axisLeft, arc as d3Arc, } from 'd3';
+import { select as d3Select, create as d3Create, line as d3Line, axisBottom, axisLeft, arc as d3Arc, } from '../../../polyfill/d3';
 /**  This class is used to render charts using SVG elements. */
 export class SVGRenderer extends BaseRenderer {
   /**

package/dist/collection/helpers/chart/test/drawers/arc-path-drawer.test.js

@@ -1,6 +1,6 @@
 import { SVGRenderer } from '../../renderers/svg-renderer';
 import { ArcPathDrawer } from '../../drawers/arc-path-drawer';
-import { pie as d3Pie } from 'd3';
+import { pie as d3Pie } from '../../../../polyfill/d3';
 import { SVGInteractor } from '../../interactors/svg-interactor';
 describe('path drawer', () => {
   it('should call renderer function when run the execute function', () => {

package/dist/collection/helpers/chart/test/input-processors/format-time-positions-input-processor.test.js

@@ -1,5 +1,5 @@
 import { FormatTimePositionsInputProcessor } from '../../input-processors/format-time-positions-input-processor';
-import { timeParse as d3TimeParse } from 'd3';
+import { timeParse as d3TimeParse } from '../../../../polyfill/d3';
 describe('formatTimePositionsInputProcessor', () => {
   const formatTimePositionsInputProcessor = new FormatTimePositionsInputProcessor();
   it('should return expect result when call the process function ', () => {

package/dist/collection/helpers/chart/test/input-processors/sort-positions-input-processor.test.js

@@ -1,5 +1,5 @@
 import { SortPositionsInputProcessor } from '../../input-processors/sort-positions-input-processor';
-import { timeParse as d3TimeParse } from 'd3';
+import { timeParse as d3TimeParse } from '../../../../polyfill/d3';
 describe('sortPositionsInputProcessor', () => {
   const sortPositionsInputProcessor = new SortPositionsInputProcessor();
   it('should return expect result when call the process function ', () => {

package/dist/collection/helpers/chart/test/input-processors/x-axis-input-processor.test.js

@@ -36,4 +36,43 @@ describe('scaleGenerator', () => {
     expect(xAxisInputProcessor['getScale'](stringData, width, 'category').domain()).toEqual(stringData.map((item) => item.x));
     expect(xAxisInputProcessor['getScale'](stringDataNeedSort, width, 'category', 1, (item, nextItem) => 'ABCD'.indexOf(item) - 'ABCD'.indexOf(nextItem)).domain()).toEqual(['A', 'B', 'C', 'D']);
   });
+  it('should fall back to default domains when input data is empty', () => {
+    const width = 200;
+    expect(xAxisInputProcessor['getScale']([], width, 'value').domain()).toEqual([0, 0]);
+    const timeDomain = xAxisInputProcessor['getScale']([], width, 'time', 1).domain();
+    expect(timeDomain[0]).toBeInstanceOf(Date);
+    expect(timeDomain[1]).toBeInstanceOf(Date);
+    expect(Math.abs(timeDomain[1].getTime() - timeDomain[0].getTime())).toBeLessThan(10);
+  });
+  it('should pass correct padding to getScale based on container tagName', () => {
+    const getScaleSpy = jest
+      .spyOn(xAxisInputProcessor, 'getScale')
+      .mockReturnValue({});
+    const previousOutput = {
+      width: 200,
+      height: 100,
+      innerWidth: 200,
+      innerHeight: 100,
+      top: 0,
+      left: 0,
+      right: 0,
+      bottom: 0,
+    };
+    const dataSource = [];
+    const lineChartInput = {
+      dataSource,
+      container: document.createElement('vega-line-chart'),
+      xAxis: { type: 'value' },
+    };
+    xAxisInputProcessor.process(lineChartInput, previousOutput);
+    expect(getScaleSpy).toHaveBeenLastCalledWith(dataSource, 200, 'value', 1, undefined);
+    const divChartInput = {
+      dataSource,
+      container: document.createElement('div'),
+      xAxis: { type: 'value' },
+    };
+    xAxisInputProcessor.process(divChartInput, previousOutput);
+    expect(getScaleSpy).toHaveBeenLastCalledWith(dataSource, 200, 'value', 0.1, undefined);
+    getScaleSpy.mockRestore();
+  });
 });

package/dist/collection/helpers/chart/test/input-processors/x-axis-label-formatter-input-processor.test.js

@@ -1,5 +1,5 @@
 import { XAxisLabelFormatterInputProcessor } from '../../input-processors/x-axis-label-formatter-input-processor';
-import { scaleTime } from 'd3';
+import { scaleTime } from '../../../../polyfill/d3';
 describe('xAxisLabelFormatterInputProcessor', () => {
   const xAxisLabelFormatterInputProcessor = new XAxisLabelFormatterInputProcessor();
   it('should not override the default scale formatter function when the type is not time or labelFormatter is not empty', () => {
@@ -41,22 +41,69 @@ describe('xAxisLabelFormatterInputProcessor', () => {
   });
   it('should call the expect function when call the time formatter function', () => {
     const mockXAxisLabelFormatterInputProcessor = new XAxisLabelFormatterInputProcessor();
-    const mockSecond = jest.fn();
-    const mockMinute = jest.fn();
-    const mockHour = jest.fn();
-    const mockDay = jest.fn();
-    mockXAxisLabelFormatterInputProcessor['formatMillisecond'] = mockSecond;
-    mockXAxisLabelFormatterInputProcessor['formatSecond'] = mockMinute;
-    mockXAxisLabelFormatterInputProcessor['formatMinute'] = mockHour;
-    mockXAxisLabelFormatterInputProcessor['formatHour'] = mockDay;
-    const testDate = new Date('2023-03-02');
-    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date(testDate.valueOf() - 100));
+    const mockMillisecond = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockSecond = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockMinute = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockHour = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockDay = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockWeek = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockMonth = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    const mockYear = jest.fn((_date) => {
+      void _date;
+      return '';
+    });
+    mockXAxisLabelFormatterInputProcessor['formatMillisecond'] = mockMillisecond;
+    mockXAxisLabelFormatterInputProcessor['formatSecond'] = mockSecond;
+    mockXAxisLabelFormatterInputProcessor['formatMinute'] = mockMinute;
+    mockXAxisLabelFormatterInputProcessor['formatHour'] = mockHour;
+    mockXAxisLabelFormatterInputProcessor['formatDay'] = mockDay;
+    mockXAxisLabelFormatterInputProcessor['formatWeek'] = mockWeek;
+    mockXAxisLabelFormatterInputProcessor['formatMonth'] = mockMonth;
+    mockXAxisLabelFormatterInputProcessor['formatYear'] = mockYear;
+    // millisecond: has ms
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-03-02T00:00:00.100Z'));
+    expect(mockMillisecond).toBeCalledTimes(1);
+    // second: at second boundary but within a minute
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-03-02T00:00:01.000Z'));
     expect(mockSecond).toBeCalledTimes(1);
-    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date(testDate.valueOf() + 59 * 1000));
+    // minute: at minute boundary but within an hour
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-03-02T00:01:00.000Z'));
     expect(mockMinute).toBeCalledTimes(1);
-    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date(testDate.valueOf() + 2 * 60 * 1000));
+    // hour: at hour boundary but within a day
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-03-02T01:00:00.000Z'));
     expect(mockHour).toBeCalledTimes(1);
-    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date(testDate.valueOf() + 60 * 60 * 1000));
+    // day: at day boundary but not week boundary (Thu)
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-03-02T00:00:00.000Z'));
     expect(mockDay).toBeCalledTimes(1);
+    // week: at week boundary (Sun) but not month boundary
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-03-05T00:00:00.000Z'));
+    expect(mockWeek).toBeCalledTimes(1);
+    // month: at month boundary but not year boundary
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-02-01T00:00:00.000Z'));
+    expect(mockMonth).toBeCalledTimes(1);
+    // year: at year boundary
+    mockXAxisLabelFormatterInputProcessor['timeFormatter'](new Date('2023-01-01T00:00:00.000Z'));
+    expect(mockYear).toBeCalledTimes(1);
   });
 });

package/dist/collection/helpers/chart/test/input-processors/y-axis-input-processor.coverage.test.js

@@ -0,0 +1,39 @@
+describe('YAxisInputProcessor - coverage-only branches', () => {
+  it('should fall back when polyfill returns undefined/empty', () => {
+    jest.isolateModules(() => {
+      const createdScales = [];
+      jest.doMock('../../../../polyfill/d3', () => {
+        const scaleLinear = jest.fn(() => {
+          const scale = {
+            domain: jest.fn(function () {
+              return this;
+            }),
+            range: jest.fn(function () {
+              return this;
+            }),
+            // intentionally no ticks()
+          };
+          createdScales.push(scale);
+          return scale;
+        });
+        return {
+          scaleLinear,
+          max: jest.fn(() => undefined),
+          min: jest.fn(() => undefined),
+          extent: jest.fn(() => [undefined, undefined]),
+        };
+      });
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const requiredModule = require('../../input-processors/y-axis-input-processor');
+      const processor = new requiredModule.YAxisInputProcessor();
+      const data = [{ x: 1, y: 0 }];
+      const result = processor['getScale'](data, [200, 0], 4);
+      expect(result.ticks).toBe(4);
+      expect(createdScales.length).toBe(2);
+      expect(createdScales[0].domain).toHaveBeenCalledWith([0, 0]);
+      expect(createdScales[1].domain).toHaveBeenCalledWith([0, 0]);
+      expect(createdScales[1].range).toHaveBeenCalledWith([200, 0]);
+    });
+  });
+});
+export {};

package/dist/collection/helpers/chart/test/input-processors/y-axis-input-processor.test.js

@@ -14,6 +14,20 @@ describe('scaleGenerator', () => {
     ]);
     expect(yAxisInputProcessor['getScale'](numberData, [height, 0], 4).scale.domain()[0]).toEqual(0);
   });
+  it('should expand domain/ticks when tick rounding excludes min/max', () => {
+    // Use values where the generated tick start/stop (based on a rounded step)
+    // does not include the data min/max, forcing both min and max adjustments.
+    const numberData = [
+      { x: 1, y: -125 },
+      { x: 2, y: 210 },
+    ];
+    const height = 200;
+    const result = yAxisInputProcessor['getScale'](numberData, [height, 0], 4);
+    const domain = result.scale.domain();
+    expect(domain[0]).toBeLessThanOrEqual(-125);
+    expect(domain[1]).toBeGreaterThanOrEqual(210);
+    expect(result.ticks).toBeGreaterThan(4);
+  });
   // VD-992
   it('should return the correct min data when call the getScale function', () => {
     const numberData = [

package/dist/collection/helpers/chart/test/renderers/svg-renderer.test.js

@@ -1,5 +1,5 @@
 import { SVGRenderer } from '../../renderers/svg-renderer';
-import { scaleLinear } from 'd3';
+import { scaleLinear } from '../../../../polyfill/d3';
 describe('svg renderer', () => {
   it('should set context layout when run the set layout function', () => {
     const context = document.createElementNS('http://www.w3.org/2000/svg', 'svg');

package/dist/collection/helpers/code-format/test/code-formatter.test.js

@@ -1,5 +1,5 @@
 import CodeFormatter from '../code-formatter';
-import { VegaRTEContent } from '../../public-api';
+import { VegaRTEContent } from '../../../components/vega-rich-text-editor/dto/content-state';
 describe('Code formatter', () => {
   it('should format simple HTML with option useTabs', () => {
     const input = `<p><span>Text</span></p>`;