@heartlandone/vega 2.75.1 → 2.77.0

package/dist/types/components.d.ts

@@ -25,7 +25,7 @@ import { FormFieldValidationRule } from "./helpers/validator/rules/form-field-va
 import { VegaChipIconAlign, VegaChipSize, VegaChipType, VegaChipVariant } from "./components/vega-chip/types";
 import { VegaCodeBlockValue } from "./components/vega-code-block/types";
 import { VegaComboBoxSize, VegaDropdownPropsForComboBox } from "./components/vega-combo-box/types";
-import { DatePickerCalendarRepickType, DatePickerCalendarSizeType, DatePickerModeType, DatePickerMonthYearTypes, DatePickerValueType, DropdownConfigForDatePicker, VegaDropdownPropsForDatePickerCalendar } from "./components/vega-date-picker/types";
+import { DatePickerCalendarIndicator, DatePickerCalendarRepickType, DatePickerCalendarSizeType, DatePickerModeType, DatePickerMonthYearTypes, DatePickerValueType, DropdownConfigForDatePicker, VegaDropdownPropsForDatePickerCalendar } from "./components/vega-date-picker/types";
 import { VegaDialogAction, VegaDialogActionButtonProps } from "./components/vega-dialog/types";
 import { VegaDividerDirectionType, VegaDividerVariantType } from "./components/vega-divider/interface";
 import { VegaDropdownItemClickEvent } from "./components/vega-dropdown/vega-dropdown-item/types";
@@ -48,7 +48,7 @@ import { VegaModalBackdrop, VegaModalBackdropColor } from "./components/vega-mod
 import { VegaPageNotificationActionButtonConfig, VegaPageNotificationTypes } from "./components/vega-page-notification/types";
 import { DropdownPropsForPagination, VegaPaginationItemType, VegaPaginationLayoutType } from "./components/vega-pagination/types";
 import { PieChartOptions } from "./helpers/chart/pie-chart";
-import { VegaProgressTrackerDirectionType } from "./components/vega-progress-tracker/type";
+import { VegaProgressTrackerDirectionType, VegaProgressTrackerStepItem } from "./components/vega-progress-tracker/type";
 import { VegaRTEContent } from "./components/vega-rich-text-editor/dto/content-state";
 import { VegaRTEExtension } from "./components/vega-rich-text-editor/extensions/extension.abstract";
 import { VegaRichTextEditorImage, VegaRTESourceEditConfig, VegaRTEToolbarItem } from "./components/vega-rich-text-editor/interface";
@@ -1266,6 +1266,11 @@ export namespace Components {
           * @vegaVersion 2.72.0
          */
         "clearButton": boolean;
+        /**
+          * Specifies a function that returns the properties for the date indicator tooltip for a given date in the date picker.  The function is called for each date cell before rendering.
+          * @vegaVersion 2.77.0
+         */
+        "dateIndicator": DatePickerCalendarIndicator;
         /**
           * Specifies the desired date format.
           * @vegaVersion 2.72.0
@@ -3173,9 +3178,14 @@ export namespace Components {
           * Specifies an array of step subtitles for    the Progress Tracker component.  Each subtitle corresponds to a step in the    progression of the workflow or process.
           * @vegaVersion 1.3.0
          */
-        "steps": string[];
+        "steps": string[] | VegaProgressTrackerStepItem[];
     }
     interface VegaProgressTrackerStep {
+        /**
+          * If step is clickable.
+          * @vegaVersion 2.76.0
+         */
+        "clickable": boolean;
         /**
           * The unique key for the step.
           * @vegaVersion 2.73.0
@@ -7062,6 +7072,11 @@ declare namespace LocalJSX {
           * @vegaVersion 2.72.0
          */
         "clearButton"?: boolean;
+        /**
+          * Specifies a function that returns the properties for the date indicator tooltip for a given date in the date picker.  The function is called for each date cell before rendering.
+          * @vegaVersion 2.77.0
+         */
+        "dateIndicator"?: DatePickerCalendarIndicator;
         /**
           * Specifies the desired date format.
           * @vegaVersion 2.72.0
@@ -9418,9 +9433,14 @@ declare namespace LocalJSX {
           * Specifies an array of step subtitles for    the Progress Tracker component.  Each subtitle corresponds to a step in the    progression of the workflow or process.
           * @vegaVersion 1.3.0
          */
-        "steps"?: string[];
+        "steps"?: string[] | VegaProgressTrackerStepItem[];
     }
     interface VegaProgressTrackerStep {
+        /**
+          * If step is clickable.
+          * @vegaVersion 2.76.0
+         */
+        "clickable"?: boolean;
         /**
           * The unique key for the step.
           * @vegaVersion 2.73.0

package/dist/types/helpers/chart/test/input-processors/y-axis-input-processor.coverage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/helpers/common/index.d.ts

@@ -1,15 +1,2 @@
-import { HTMLVegaElementType } from './wait-for-vega-handler';
-import { HTMLStencilElement } from '../../stencil-public-runtime';
-/**
- * Wait for all vega elements to be ready.
- *
- * The below method is e2e-test covered in @see{module:wait-for-vega-should-work-as-expected}
- */
-export declare const waitForVega: () => Promise<Awaited<HTMLVegaElementType>[]>;
-/**
- * Wait for the component has been rendered.
- *
- * @param {HTMLStencilElement} componentRef - The reference to the component that needs to be rendered.
- * @returns {Promise<unknown>} A promise that resolves when the component has been rendered.
- */
-export declare const waitForComponentDidRender: (componentRef: HTMLStencilElement) => Promise<unknown>;
+export { waitForVega } from './wait-for-vega-handler';
+export { waitForComponentDidRender } from './wait-for-component-did-render';

package/dist/types/helpers/common/test/wait-for-component-did-render.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/helpers/common/wait-for-component-did-render.d.ts

@@ -0,0 +1,8 @@
+import { HTMLStencilElement } from '../../stencil-public-runtime';
+/**
+ * Wait for the component has been rendered.
+ *
+ * @param {HTMLStencilElement} componentRef - The reference to the component that needs to be rendered.
+ * @returns {Promise<unknown>} A promise that resolves when the component has been rendered.
+ */
+export declare const waitForComponentDidRender: (componentRef: HTMLStencilElement) => Promise<unknown>;

package/dist/types/helpers/common/wait-for-vega-handler.d.ts

@@ -1,19 +1,10 @@
 import { VegaComponentInterface } from '../../types/ui.type';
-import { VegaPublicAPIRuntimeMetricsSlimmerBase } from '../slimmers/runtime-metrics/public-api-runtime-metrics-slimmer-base';
 export declare type HTMLVegaElementType = VegaComponentInterface<any>;
 /**
- * WaitForVegaHandler to check whether the vega component has been loaded.
+ * Wait for all vega elements to be ready.
+ *
+ * The below method is e2e-test covered in @see{module:wait-for-vega-should-work-as-expected}
+ *
+ * @returns {Promise} A promise that resolves when all vega elements are ready.
  */
-declare class WaitForVegaHandler {
-  protected vegaPublicAPIRuntimeMetricsSlimmer: VegaPublicAPIRuntimeMetricsSlimmerBase;
-  /**
-   * Wait for all vega elements to be ready.
-   *
-   * The below method is e2e-test covered in @see{module:wait-for-vega-should-work-as-expected}
-   *
-   * @vegaVersion 2.8.0
-   */
-  handle(): Promise<Awaited<HTMLVegaElementType>[]>;
-}
-export declare const WaitForVega: WaitForVegaHandler;
-export {};
+export declare const waitForVega: () => Promise<Awaited<HTMLVegaElementType>[]>;

package/dist/types/helpers/feature-control/feature-flag.d.ts

@@ -59,4 +59,5 @@ export type FeatureFlagKey =
 	| 'VEGA_TABLE.REVERSE_SORT_ORDER'
 	| 'VEGA_PAGINATION.ENABLE_EXTENSIONS_RESPONSIVE_DEFAULT_VALUE'
 	| 'VEGA_COMPONENT.CORNERS_USE_OLD_BEHAVIOR'
-	| 'VEGA_INPUT_PHONE_NUMBER.ENABLE_CALCULATION_POSITION_BY_SCREEN';
+	| 'VEGA_INPUT_PHONE_NUMBER.ENABLE_CALCULATION_POSITION_BY_SCREEN'
+	| 'VEGA_ELEMENT_APPENDER.AUTO_PLACEMENT';

package/dist/types/helpers/public-api.d.ts

@@ -15,6 +15,4 @@ export { waitForVega } from './common';
 export { IconPayload } from './icon/interface';
 export { VegaSkeletonLoader } from './skeleton-loader/vega-skeleton-loader-controller';
 export { VegaTranslation, en as VegaTranslationResourceEN } from './translation';
-export { VegaRTEContent } from '../components/vega-rich-text-editor/dto/content-state';
 export { setVegaNonce } from './csp/vega-nonce-manager';
-export * from '../components/vega-rich-text-editor/public-api';

package/dist/types/helpers/slimmers/mutation-observer/aria-attributes-value-mapper.d.ts

@@ -0,0 +1,44 @@
+import { MutationObserverSlimmer } from './mutation-observer-slimmer';
+export declare type AriaAttrDependency = {
+  dependency: string[];
+  defaultValue?: string;
+};
+export declare type AriaAttributesMap = Record<string, AriaAttrDependency>;
+/**
+ * Maps component attributes/properties to aria-XXX attributes on an inner native element.
+ * Observes attribute changes on host and updates the target element accordingly.
+ */
+export declare class AriaAttributesValueMapper extends MutationObserverSlimmer {
+  private readonly targetGetter;
+  private readonly ariaMap;
+  /**
+   * Component lifecycle - [componentDidLoad]
+   */
+  componentDidLoad(): void;
+  /**
+   * Run mapping after each component render to ensure refs assigned and
+   * attributes/properties are up-to-date. This guarantees the mapper runs
+   * even when attribute changes are observed before the inner target ref
+   * is available.
+   */
+  componentDidRender(): void;
+  /**
+   * The constructor initializes a class instance with a targetGetter function and an ariaMap.
+   *
+   * @param {() => HTMLElement} targetGetter - a function that returns the target element to set aria attributes on
+   * @param {AriaAttributesMap} ariaMap - a map where the key is the aria attribute to set on the target element, and the value is an object that defines the dependencies (attributes/properties on host to check for value) and an optional default value
+   */
+  constructor(targetGetter: () => HTMLElement, ariaMap: AriaAttributesMap);
+  /**
+   * The `handleMutations` function processes an array of `MutationRecord` objects to determine which attributes have changed and then calls the `performMapping` function to update the corresponding aria attributes on the target element. It collects the names of the changed attributes into a set and passes it to the `performMapping` function, which uses this information to decide which aria attributes need to be updated based on their defined dependencies.
+   *
+   * @param {MutationRecord[]} mutations - an array of MutationRecord objects that represent the changes observed by the MutationObserver. Each MutationRecord contains information about the type of mutation, the target element that was mutated, and any relevant attribute names if the mutation was an attribute change.
+   */
+  private handleMutations;
+  /**
+   * The `performMapping` function updates the aria attributes on the target element based on the defined dependencies in the `ariaMap`. It checks which attributes have changed (if provided) and only updates the aria attributes that depend on those changed attributes. For each aria attribute defined in the `ariaMap`, it looks for the first non-empty value among its dependencies (checking both attributes and properties on the host element) and sets that as the value of the aria attribute on the target element. If all dependencies are empty or undefined, it uses the default value specified in the `ariaMap`. The function also includes error handling when setting attributes on the target element.
+   *
+   * @param {Set<string>} changedAttrs - a set of attribute names that have changed on the host element
+   */
+  private performMapping;
+}

package/dist/types/helpers/slimmers/mutation-observer/test/aria-attributes-value-mapper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/helpers/slimmers/position-calculation/base-position-calculation-strategy.d.ts

@@ -6,6 +6,15 @@ import { ElementAppenderShowConfig } from '../../ui/element-appender';
  */
 export declare abstract class BasePositionCalculationStrategy extends VegaSlimmer {
   abstract showConfig: ElementAppenderShowConfig;
+  /**
+   * Whether the controller should adjust/recompute position at this time.
+   *
+   * This hook allows strategies to avoid unnecessary work (for example, on scroll) by deciding
+   * whether a re-position is required.
+   *
+   * @returns {boolean} True when the controller should proceed with width/height/position adjustments.
+   */
+  shouldAdjustPosition(): boolean;
   /**
    * Get the position box.
    *
@@ -15,6 +24,54 @@ export declare abstract class BasePositionCalculationStrategy extends VegaSlimme
    * returns an ElementPositionBox.
    */
   protected getPositionBox(placement?: PlacementType[], alignment?: PositionAlignmentType[]): ElementPositionBox;
+  /**
+   * Whether the alignment space is enough
+   *
+   * @param {ElementScrollDimension} containerBox - The bounding box of the container element.
+   * @param {ElementBoundBox} targetBox - The position of the target element.
+   * @param {ElementBoundBox} elementBox - The box of the element that we're trying to position.
+   * @param {PlacementType} placement - The placement of the element relative to the target.
+   * @param {PlacementType} alignment - The alignment of the element relative to the target.
+   * @returns {boolean} return true if it has enough space, otherwise false
+   */
+  protected hasEnoughAlignmentSpace(containerBox: ElementScrollDimension, targetBox: ElementBoundBox, elementBox: ElementBoundBox, placement: PlacementType, alignment: PositionAlignmentType): boolean;
+  /**
+   * Calculate the left position of the element
+   *
+   * @param {ElementBoundBox} elementBox - The position box of the element.
+   * @param {ElementBoundBox} targetBox - The position box of the target element that is attached to.
+   * @param {PlacementType} placement - The placement of the element.
+   * @param {PositionAlignmentType} alignment - The alignment of the element
+   * @returns {number} The left position of the element.
+   */
+  protected calculateLeft(elementBox: ElementBoundBox, targetBox: ElementBoundBox, placement: PlacementType, alignment: PositionAlignmentType): number;
+  /**
+   * Calculate the top position of the element
+   *
+   * @param {ElementBoundBox} elementBox - The position box of the element.
+   * @param {ElementBoundBox} targetBox - The position box of the target element that is attached to.
+   * @param {PlacementType} placement - The placement of the element.
+   * @param {PositionAlignmentType} alignment - The alignment of the element
+   * @returns {number} the top position of the element.
+   */
+  protected calculateTop(elementBox: ElementBoundBox, targetBox: ElementBoundBox, placement: PlacementType, alignment: PositionAlignmentType): number;
+  /**
+   * It returns acceptable alignments.
+   *
+   * @returns {PositionAlignmentType[]} acceptable alignments
+   */
+  protected getAlignments(): PositionAlignmentType[];
+  /**
+   * It takes a list of placements and returns the first placement that has enough space to place the
+   * element
+   *
+   * @param {ElementScrollDimension} containerBox - The box of the container element.
+   * @param {ElementBoundBox} elementBox - The box of the element to be placed.
+   * @param {ElementBoundBox} targetBox - The box of the target element.
+   * @param {PlacementType[]} placements - The placements that we want to try.
+   * @returns {PlacementType} A function that takes in a containerBox, elementBox, targetBox, placements, and element.
+   */
+  protected getSuitablePlacement(containerBox: ElementScrollDimension, elementBox: ElementBoundBox, targetBox: ElementBoundBox, placements: PlacementType[]): PlacementType;
   /**
    * "Get the width, height, and top position of an element."
    *
@@ -37,12 +94,6 @@ export declare abstract class BasePositionCalculationStrategy extends VegaSlimme
    * @returns {PlacementType[]} ordered placements.
    */
   private getPlacements;
-  /**
-   * It returns acceptable alignments.
-   *
-   * @returns {PositionAlignmentType[]} acceptable alignments
-   */
-  private getAlignments;
   /**
    * It takes a placement, a target box, and a element box, and returns an element box
    *
@@ -60,37 +111,6 @@ export declare abstract class BasePositionCalculationStrategy extends VegaSlimme
    * @returns {TranslocationType} A translocation object with X and Y properties.
    */
   private getTranslocationBox;
-  /**
-   * Calculate the left position of the element
-   *
-   * @param {ElementBoundBox} elementBox - The position box of the element.
-   * @param {ElementBoundBox} targetBox - The position box of the target element that is attached to.
-   * @param {PlacementType} placement - The placement of the element.
-   * @param {PositionAlignmentType} alignment - The alignment of the element
-   * @returns {number} The left position of the element.
-   */
-  private calculateLeft;
-  /**
-   * Calculate the top position of the element
-   *
-   * @param {ElementBoundBox} elementBox - The position box of the element.
-   * @param {ElementBoundBox} targetBox - The position box of the target element that is attached to.
-   * @param {PlacementType} placement - The placement of the element.
-   * @param {PositionAlignmentType} alignment - The alignment of the element
-   * @returns {number} the top position of the element.
-   */
-  private calculateTop;
-  /**
-   * It takes a list of placements and returns the first placement that has enough space to place the
-   * element
-   *
-   * @param {ElementScrollDimension} containerBox - The box of the container element.
-   * @param {ElementBoundBox} elementBox - The box of the element to be placed.
-   * @param {ElementBoundBox} targetBox - The box of the target element.
-   * @param {PlacementType[]} placements - The placements that we want to try.
-   * @returns {PlacementType} A function that takes in a containerBox, elementBox, targetBox, placements, and element.
-   */
-  private getSuitablePlacement;
   /**
    * It takes a list of alignments and returns the suitable one that has enough space to fit the element
    *
@@ -102,17 +122,6 @@ export declare abstract class BasePositionCalculationStrategy extends VegaSlimme
    * @returns {PositionAlignmentType} the alignment that is suitable for the element.
    */
   private getSuitableAlignment;
-  /**
-   * Whether the alignment space is enough
-   *
-   * @param {ElementScrollDimension} containerBox - The bounding box of the container element.
-   * @param {ElementBoundBox} targetBox - The position of the target element.
-   * @param {ElementBoundBox} elementBox - The box of the element that we're trying to position.
-   * @param {PlacementType} placement - The placement of the element relative to the target.
-   * @param {PlacementType} alignment - The alignment of the element relative to the target.
-   * @returns {boolean} return true if it has enough space, otherwise false
-   */
-  private hasEnoughAlignmentSpace;
   /**
    * If the placement is top or left, then the target's top or left position must be greater than or
    * equal to the element's height or width. If the placement is bottom or right, then the container's

package/dist/types/helpers/slimmers/position-calculation/position-calculation-controller.d.ts

@@ -11,6 +11,11 @@ export declare class PositionCalculationController extends VegaSlimmer {
   protected readonly bodyPositionStrategy: BodyPositionCalculationStrategy;
   protected readonly screenPositionStrategy: ScreenPositionCalculationStrategy;
   private positionStrategy;
+  /**
+   * Clears any pending screen-position scroll animation frame callback.
+   * Call this when the appendable is hidden/destroyed.
+   */
+  clearScreenPositionScrollFrame(): void;
   /**
    * Sets the calculate postion strategy.
    */

package/dist/types/helpers/slimmers/position-calculation/screen-position-calculation-strategy.d.ts

@@ -1,5 +1,5 @@
 import { ElementAppenderShowConfig } from '../../ui/element-appender';
-import { ElementBoundBox, ElementPositionBox, ElementScrollDimension } from '../../../types/ui.type';
+import { ElementBoundBox, ElementPositionBox, ElementScrollDimension, PlacementType, PositionAlignmentType } from '../../../types/ui.type';
 import { BasePositionCalculationStrategy } from './base-position-calculation-strategy';
 /**
  * calculate position by screen container
@@ -7,6 +7,23 @@ import { BasePositionCalculationStrategy } from './base-position-calculation-str
 export declare class ScreenPositionCalculationStrategy extends BasePositionCalculationStrategy {
   showConfig: ElementAppenderShowConfig;
   private previousPositionBox;
+  private previousTargetRect;
+  private scrollFrameRequestId;
+  private usePreviousPlacement;
+  private readonly scrollPositionUpdateStrategy;
+  /**
+   * For screen-positioned appendable we may get a lot of scroll events.
+   * This hook throttles the check with requestAnimationFrame and only allows an adjust when
+   * the strategy determines we should update.
+   *
+   * @returns {boolean} True when controller should perform a position adjustment.
+   */
+  shouldAdjustPosition(): boolean;
+  /**
+   * Clears any pending scroll animation frame callback.
+   * Call this when popover is hidden/destroyed to avoid leaks and stale callbacks.
+   */
+  clearScrollFrame(): void;
   /**
    * Get the position of the element in the container according to the target element and the placement
    * If give a translocation, it will apply the translocation to the result.
@@ -31,4 +48,27 @@ export declare class ScreenPositionCalculationStrategy extends BasePositionCalcu
    * @returns {ElementScrollDimension} An object with two properties: width and height.
    */
   protected getElementScrollDimension(): ElementScrollDimension;
+  /**
+   * Whether the alignment space is enough
+   *
+   * @param {ElementScrollDimension} containerBox - The bounding box of the container element.
+   * @param {ElementBoundBox} targetBox - The position of the target element.
+   * @param {ElementBoundBox} elementBox - The box of the element that we're trying to position.
+   * @param {PlacementType} placement - The placement of the element relative to the target.
+   * @param {PlacementType} alignment - The alignment of the element relative to the target.
+   * @returns {boolean} return true if it has enough space, otherwise false
+   */
+  protected hasEnoughAlignmentSpace(containerBox: ElementScrollDimension, targetBox: ElementBoundBox, elementBox: ElementBoundBox, placement: PlacementType, alignment: PositionAlignmentType): boolean;
+  /**
+   * Screen-specific suitable placement selection.
+   * Tries to find a placement that has enough alignment space within the viewport first,
+   * otherwise falls back to the base strategy.
+   *
+   * @param {ElementScrollDimension} containerBox - The bounding box of the container.
+   * @param {ElementBoundBox} elementBox - The box of the element to place.
+   * @param {ElementBoundBox} targetBox - The box of the target element.
+   * @param {PlacementType[]} placements - Ordered list of placements to try.
+   * @returns {PlacementType} The chosen placement.
+   */
+  protected getSuitablePlacement(containerBox: ElementScrollDimension, elementBox: ElementBoundBox, targetBox: ElementBoundBox, placements: PlacementType[]): PlacementType;
 }

package/dist/types/helpers/slimmers/position-calculation/screen-scroll-position-update.d.ts

@@ -0,0 +1,39 @@
+export declare type ScrollPositionUpdateDecision = {
+  shouldUpdate: boolean;
+};
+export declare type ScrollPositionUpdateStrategyContext = {
+  currentTargetRect: DOMRect;
+  appendableRect: DOMRect;
+  previousTargetRect: DOMRect;
+  viewportWidth: number;
+  viewportHeight: number;
+};
+/**
+ * Updates position on scroll When the target rect changes, we recompute placement/alignment.
+ */
+export declare class ScreenScrollPositionUpdate {
+  private viewportWidth;
+  private viewportHeight;
+  /**
+   * Determines whether the appendable element's position should update on scroll.
+   *
+   * @param {ScrollPositionUpdateStrategyContext} context - Current/previous rectangles plus viewport size.
+   * @returns {ScrollPositionUpdateDecision} Decision that indicates whether to recompute position.
+   */
+  shouldUpdatePosition(context: ScrollPositionUpdateStrategyContext): ScrollPositionUpdateDecision;
+  /**
+   * Whether the rect is fully within the viewport bounds.
+   *
+   * @param {DOMRect} rect - The DOMRect to check.
+   * @returns {boolean} True when rect is fully within the viewport.
+   */
+  private isRectEntirelyWithinViewport;
+  /**
+   * Whether the element is fully outside the viewport.
+   * If true, the rect has "disappeared" from the viewport.
+   *
+   * @param {DOMRect} rect - The DOMRect to check.
+   * @returns {boolean} True when rect is completely outside viewport bounds.
+   */
+  private isRectOutsideViewport;
+}

package/dist/types/helpers/ui/element-appender.d.ts

@@ -41,7 +41,6 @@ export declare class ElementAppender {
   private showConfigCallbackTarget;
   private showConfig;
   private container;
-  private previousTargetRect;
   /**
    * The `constructor` function is used to initialize the `showConfigCallback` and
    * `showConfigCallbackTarget` properties of the class.

package/dist/types/index.d.ts

@@ -4,3 +4,5 @@ export * from './constants/public-api';
 export * from './helpers/public-api';
 export * from './types/public-api';
 export * from './helpers/validator/public-rules';
+export { VegaRTEContent } from './components/vega-rich-text-editor/dto/content-state';
+export * from './components/vega-rich-text-editor/public-api';

package/dist/types/polyfill/d3/d3-array-polyfill.d.ts

@@ -0,0 +1,48 @@
+/**
+ * D3 Array Polyfill - Lightweight array utility functions.
+ *
+ * This is a drop-in replacement for d3-array, implementing only the methods
+ * used in the Vega chart rendering system: min, max, extent, and map.
+ *
+ * @see VD-5022 - [Zero Dependencies] remove d3 dependency
+ */
+/**
+ * Returns the minimum value in the array.
+ * Mimics d3.min().
+ *
+ * @template T
+ * @param {T[]} array - Array of values.
+ * @param {Function} [accessor] - Optional accessor function.
+ * @returns {number | undefined} The minimum value, or undefined for empty arrays.
+ */
+export declare function min<T>(array: T[], accessor?: (d: T, i: number) => number): number | undefined;
+/**
+ * Returns the maximum value in the array.
+ * Mimics d3.max().
+ *
+ * @template T
+ * @param {T[]} array - Array of values.
+ * @param {Function} [accessor] - Optional accessor function.
+ * @returns {number | undefined} The maximum value, or undefined for empty arrays.
+ */
+export declare function max<T>(array: T[], accessor?: (d: T, i: number) => number): number | undefined;
+/**
+ * Returns the [min, max] of the array.
+ * Mimics d3.extent().
+ *
+ * @template T
+ * @param {T[]} array - Array of values.
+ * @returns {[T, T] | [undefined, undefined]} Tuple of [min, max], or [undefined, undefined] for empty arrays.
+ */
+export declare function extent<T>(array: T[]): [T, T] | [undefined, undefined];
+/**
+ * Maps each element of the array through a transform function.
+ * Mimics d3.map() (the array mapping function from d3-array, not the Map collection).
+ *
+ * @template T
+ * @template U
+ * @param {T[]} array - Input array.
+ * @param {Function} mapper - Transform function called with (element, index).
+ * @returns {U[]} New array of transformed values.
+ */
+export declare function map<T, U>(array: T[], mapper: (d: T, i: number) => U): U[];

package/dist/types/polyfill/d3/d3-axis-polyfill.d.ts

@@ -0,0 +1,53 @@
+/**
+ * D3 Axis Polyfill - Lightweight SVG axis generators.
+ *
+ * This is a drop-in replacement for d3-axis, implementing only the methods
+ * used in the Vega chart rendering system: axisBottom and axisLeft.
+ *
+ * @see VD-5022 - [Zero Dependencies] remove d3 dependency
+ */
+/**
+ * The domain type for axis scales.
+ */
+export declare type AxisDomain = string | number | Date | {
+  valueOf(): number;
+};
+/**
+ * The scale interface required by axis generators.
+ */
+export interface AxisScale<Domain> {
+  (value: Domain): number | undefined;
+  domain(): Domain[];
+  domain(domain: Domain[]): this;
+  range(): number[];
+  range(range: number[]): this;
+  ticks?(count?: number): Domain[];
+  tickFormat?(...args: unknown[]): (d: Domain) => string;
+  bandwidth?(): number;
+  copy?(): AxisScale<Domain>;
+}
+/**
+ * An axis generator that renders tick marks, labels, and a domain line into an SVG <g> element.
+ * Mimics d3's Axis interface with .ticks(), .tickFormat(), and callable behavior.
+ */
+export interface Axis<Domain extends AxisDomain> {
+  (selection: any): void;
+  ticks(count: number): Axis<Domain>;
+  tickFormat(formatter: (d: Domain) => string): Axis<Domain>;
+}
+/**
+ * Creates a bottom-oriented axis generator. Mimics d3.axisBottom().
+ *
+ * @template Domain
+ * @param {AxisScale} scale - The scale to use.
+ * @returns {Axis<Domain>} An Axis callable that renders into a <g> element.
+ */
+export declare function axisBottom<Domain extends AxisDomain = AxisDomain>(scale: AxisScale<Domain>): Axis<Domain>;
+/**
+ * Creates a left-oriented axis generator. Mimics d3.axisLeft().
+ *
+ * @template Domain
+ * @param {AxisScale} scale - The scale to use.
+ * @returns {Axis<Domain>} An Axis callable that renders into a <g> element.
+ */
+export declare function axisLeft<Domain extends AxisDomain = AxisDomain>(scale: AxisScale<Domain>): Axis<Domain>;

package/dist/types/polyfill/d3/d3-scale-polyfill.d.ts

@@ -0,0 +1,42 @@
+/**
+ * D3 Scale Polyfill - Lightweight scale generators for chart axes.
+ *
+ * This is a drop-in replacement for d3-scale, implementing only the methods
+ * used in the Vega chart rendering system: scaleLinear, scaleTime, and scaleBand.
+ *
+ * @see VD-5022 - [Zero Dependencies] remove d3 dependency
+ */
+import { AxisDomain, AxisScale } from './d3-axis-polyfill';
+/**
+ * Common scale interface extending AxisScale<AxisDomain> for direct
+ * compatibility with chart type declarations.
+ */
+export interface ScaleInterface extends AxisScale<AxisDomain> {
+  ticks(count?: number): AxisDomain[];
+  tickFormat(...args: unknown[]): (d: AxisDomain) => string;
+  copy(): ScaleInterface;
+  bandwidth(): number;
+}
+/**
+ * Creates a linear scale. Mimics d3.scaleLinear().
+ *
+ * @returns A callable linear scale function with chaining methods.
+ */
+export declare function scaleLinear(): ScaleInterface;
+/**
+ * Creates a time scale. Mimics d3.scaleTime().
+ *
+ * @returns A callable time scale function with chaining methods.
+ */
+export declare function scaleTime(): ScaleInterface;
+/**
+ * Creates a band scale. Mimics d3.scaleBand().
+ *
+ * @param domain - Optional initial domain values.
+ * @param range - Optional initial range [min, max].
+ * @returns A callable band scale function with chaining methods.
+ */
+export declare function scaleBand(domain?: AxisDomain[], range?: number[]): ScaleInterface & {
+  padding(p: number): ScaleInterface;
+  bandwidth(): number;
+};