@unovis/angular 1.0.0-beta.0

package/dist/lib/components/area/area.component.d.ts

@@ -0,0 +1,94 @@
+import { AfterViewInit, SimpleChanges } from '@angular/core';
+import { Area, AreaConfigInterface, ContainerCore, VisEventType, VisEventCallback, NumericAccessor, ColorAccessor, ContinuousScale, CurveType, StringAccessor } from '@unovis/ts';
+import * as i0 from "@angular/core";
+export declare class VisAreaComponent<Datum> implements AreaConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the values along the X axis. Default: `undefined` */
+    x: NumericAccessor<Datum>;
+    /** A single of multiple accessor functions for getting the values along the Y axis. Default: `undefined` */
+    y: NumericAccessor<Datum> | NumericAccessor<Datum>[];
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i?: number, ...rest: any[]) => string);
+    /** Component color accessor function. Default: `d => d.color` */
+    color?: ColorAccessor<Datum | Datum[]>;
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /** Curve type from the CurveType enum. Default: `CurveType.MonotoneX` */
+    curveType?: CurveType;
+    /** Baseline value or accessor function. Default: `undefined` */
+    baseline?: NumericAccessor<Datum>;
+    /** Opacity value or accessor function. Default: `1` */
+    opacity?: NumericAccessor<Datum>;
+    /** Optional area cursor. String or accessor function. Default: `null` */
+    cursor?: StringAccessor<Datum[]>;
+    /** If an area is smaller than 1px, extend it to have 1px height.
+     * This setting is useful when some of the area values are zeros or very small so visually they become
+     * practically invisible, but you want to show that the data behind them exists and they're not just empty segments.
+     * Default: `false` */
+    minHeight1Px?: boolean;
+    data: Datum[];
+    component: Area<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisAreaComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisAreaComponent<any>, "vis-area", never, { "duration": "duration"; "events": "events"; "attributes": "attributes"; "x": "x"; "y": "y"; "id": "id"; "color": "color"; "xScale": "xScale"; "yScale": "yScale"; "excludeFromDomainCalculation": "excludeFromDomainCalculation"; "curveType": "curveType"; "baseline": "baseline"; "opacity": "opacity"; "cursor": "cursor"; "minHeight1Px": "minHeight1Px"; "data": "data"; }, {}, never, never>;
+}

package/dist/lib/components/area/area.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./area.component";
+export declare class VisAreaModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisAreaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisAreaModule, [typeof i1.VisAreaComponent], never, [typeof i1.VisAreaComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisAreaModule>;
+}

package/dist/lib/components/axis/axis.component.d.ts

@@ -0,0 +1,125 @@
+import { AfterViewInit, SimpleChanges } from '@angular/core';
+import { Axis, AxisConfigInterface, ContainerCore, VisEventType, VisEventCallback, NumericAccessor, ColorAccessor, ContinuousScale, Position, AxisType, FitMode, TrimMode, TextAlign } from '@unovis/ts';
+import * as i0 from "@angular/core";
+export declare class VisAxisComponent<Datum> implements AxisConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the values along the X axis. Default: `undefined` */
+    x: NumericAccessor<Datum>;
+    /** A single of multiple accessor functions for getting the values along the Y axis. Default: `undefined` */
+    y: NumericAccessor<Datum> | NumericAccessor<Datum>[];
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i?: number, ...rest: any[]) => string);
+    /** Component color accessor function. Default: `d => d.color` */
+    color?: ColorAccessor<Datum | Datum[]>;
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /** Axis position: `Position.Top`, `Position.Bottom`, `Position.Right` or `Position.Left`. Default: `undefined` */
+    position?: Position | string;
+    /** Axis type: `AxisType.X` or `AxisType.Y` */
+    type?: AxisType | string;
+    /** Extend the axis domain line to be full width or full height. Default: `true` */
+    fullSize?: boolean;
+    /** Axis label. Default: `undefined` */
+    label?: string;
+    /** Font size of the axis label as CSS string. Default: `null` */
+    labelFontSize?: string | null;
+    /** Distance between the axis and the label in pixels. Default: `8` */
+    labelMargin?: number;
+    /** Sets whether to draw the grid lines or not. Default: `true` */
+    gridLine?: boolean;
+    /** Sets whether to draw the tick lines or not. Default: `true` */
+    tickLine?: boolean;
+    /** Sets whether to draw the domain line or not. Default: `true` */
+    domainLine?: boolean;
+    /** Draw the min and max axis ticks only. Default: `false` */
+    minMaxTicksOnly?: boolean;
+    /** Tick label formatter function. Default: `undefined` */
+    tickFormat?: (tick: number | Date, i: number, ticks: (number | Date)[]) => string;
+    /** Explicitly set tick values. Default: `undefined` */
+    tickValues?: number[];
+    /** Set the approximate number of axis ticks (will be passed to D3's axis constructor). Default: `undefined` */
+    numTicks?: number;
+    /** Tick text fit mode: `FitMode.Wrap` or `FitMode.Trim`. Default: `FitMode.Wrap`. */
+    tickTextFitMode?: FitMode | string;
+    /** Maximum number of characters for tick text wrapping. Default: `undefined` */
+    tickTextLength?: number;
+    /** Maximum width in pixels for the tick text to be wrapped or trimmed. Default: `undefined` */
+    tickTextWidth?: number;
+    /** Tick text wrapping separator. String or array of strings. Default: `' '` */
+    tickTextSeparator?: string | string[];
+    /** Force word break for ticks when they don't fit. Default: `false` */
+    tickTextForceWordBreak?: boolean;
+    /** Tick text trim mode: `TrimMode.Start`, `TrimMode.Middle` or `TrimMode.End`. Default: `TrimMode.Middle` */
+    tickTextTrimType?: TrimMode | string;
+    /** Font size of the tick text as CSS string. Default: `null` */
+    tickTextFontSize?: string | null;
+    /** Text alignment for ticks: `TextAlign.Left`, `TextAlign.Center` or `TextAlign.Right`. Default: `undefined` */
+    tickTextAlign?: TextAlign;
+    /** The spacing in pixels between the tick and it's label. Default: `8` */
+    tickPadding?: number;
+    data: Datum[];
+    component: Axis<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisAxisComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisAxisComponent<any>, "vis-axis", never, { "duration": "duration"; "events": "events"; "attributes": "attributes"; "x": "x"; "y": "y"; "id": "id"; "color": "color"; "xScale": "xScale"; "yScale": "yScale"; "excludeFromDomainCalculation": "excludeFromDomainCalculation"; "position": "position"; "type": "type"; "fullSize": "fullSize"; "label": "label"; "labelFontSize": "labelFontSize"; "labelMargin": "labelMargin"; "gridLine": "gridLine"; "tickLine": "tickLine"; "domainLine": "domainLine"; "minMaxTicksOnly": "minMaxTicksOnly"; "tickFormat": "tickFormat"; "tickValues": "tickValues"; "numTicks": "numTicks"; "tickTextFitMode": "tickTextFitMode"; "tickTextLength": "tickTextLength"; "tickTextWidth": "tickTextWidth"; "tickTextSeparator": "tickTextSeparator"; "tickTextForceWordBreak": "tickTextForceWordBreak"; "tickTextTrimType": "tickTextTrimType"; "tickTextFontSize": "tickTextFontSize"; "tickTextAlign": "tickTextAlign"; "tickPadding": "tickPadding"; "data": "data"; }, {}, never, never>;
+}

package/dist/lib/components/axis/axis.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./axis.component";
+export declare class VisAxisModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisAxisModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisAxisModule, [typeof i1.VisAxisComponent], never, [typeof i1.VisAxisComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisAxisModule>;
+}

package/dist/lib/components/brush/brush.component.d.ts

@@ -0,0 +1,104 @@
+import { AfterViewInit, SimpleChanges } from '@angular/core';
+import { Brush, BrushConfigInterface, ContainerCore, VisEventType, VisEventCallback, NumericAccessor, ColorAccessor, ContinuousScale, Arrangement } from '@unovis/ts';
+import { D3BrushEvent } from 'd3-brush';
+import * as i0 from "@angular/core";
+export declare class VisBrushComponent<Datum> implements BrushConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the values along the X axis. Default: `undefined` */
+    x: NumericAccessor<Datum>;
+    /** A single of multiple accessor functions for getting the values along the Y axis. Default: `undefined` */
+    y: NumericAccessor<Datum> | NumericAccessor<Datum>[];
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i?: number, ...rest: any[]) => string);
+    /** Component color accessor function. Default: `d => d.color` */
+    color?: ColorAccessor<Datum | Datum[]>;
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /** Callback function to be called on any Brush event.
+     * Default: `(selection: [number, number], event: D3BrushEvent<Datum>, userDriven: boolean): void => {}` */
+    onBrush?: ((selection?: [number, number], event?: D3BrushEvent<Datum>, userDriven?: boolean) => void);
+    /** Callback function to be called on the Brush start event.
+     * Default: `(selection: [number, number], event: D3BrushEvent<Datum>, userDriven: boolean): void => {}` */
+    onBrushStart?: ((selection?: [number, number], event?: D3BrushEvent<Datum>, userDriven?: boolean) => void);
+    /** Callback function to be called on the Brush move event.
+     * Default: `(selection: [number, number], event: D3BrushEvent<Datum>, userDriven: boolean): void => {}` */
+    onBrushMove?: ((selection?: [number, number], event?: D3BrushEvent<Datum>, userDriven?: boolean) => void);
+    /** Callback function to be called on the Brush end event.
+     * Default: `(selection: [number, number], event: D3BrushEvent<Datum>, userDriven: boolean): void => {}` */
+    onBrushEnd?: ((selection?: [number, number], event?: D3BrushEvent<Datum>, userDriven?: boolean) => void);
+    /** Width of the Brush handle. Default: `1` */
+    handleWidth?: number;
+    /** Brush selection in the data space coordinates, can be used to control the selection. Default: `undefined` */
+    selection?: [number, number] | null;
+    /** Allow dragging the selected area as a whole in order to change the selected range. Default: `false` */
+    draggable?: boolean;
+    /** Position of the handle: `Arrangement.Inside` or `Arrangement.Outside`. Default: `Arrangement.Inside` */
+    handlePosition?: Arrangement | string;
+    /** Constraint Brush selection to a minimal length in data units. Default: `undefined` */
+    selectionMinLength?: number;
+    data: Datum[];
+    component: Brush<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisBrushComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisBrushComponent<any>, "vis-brush", never, { "duration": "duration"; "events": "events"; "attributes": "attributes"; "x": "x"; "y": "y"; "id": "id"; "color": "color"; "xScale": "xScale"; "yScale": "yScale"; "excludeFromDomainCalculation": "excludeFromDomainCalculation"; "onBrush": "onBrush"; "onBrushStart": "onBrushStart"; "onBrushMove": "onBrushMove"; "onBrushEnd": "onBrushEnd"; "handleWidth": "handleWidth"; "selection": "selection"; "draggable": "draggable"; "handlePosition": "handlePosition"; "selectionMinLength": "selectionMinLength"; "data": "data"; }, {}, never, never>;
+}

package/dist/lib/components/brush/brush.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./brush.component";
+export declare class VisBrushModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisBrushModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisBrushModule, [typeof i1.VisBrushComponent], never, [typeof i1.VisBrushComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisBrushModule>;
+}

package/dist/lib/components/crosshair/crosshair.component.d.ts

@@ -0,0 +1,104 @@
+import { AfterViewInit, SimpleChanges } from '@angular/core';
+import { Crosshair, CrosshairConfigInterface, ContainerCore, VisEventType, VisEventCallback, NumericAccessor, ColorAccessor, ContinuousScale, Tooltip, CrosshairCircle } from '@unovis/ts';
+import * as i0 from "@angular/core";
+export declare class VisCrosshairComponent<Datum> implements CrosshairConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the values along the X axis. Default: `undefined` */
+    x: NumericAccessor<Datum>;
+    /** A single of multiple accessor functions for getting the values along the Y axis. Default: `undefined` */
+    y: NumericAccessor<Datum> | NumericAccessor<Datum>[];
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i?: number, ...rest: any[]) => string);
+    /** Component color accessor function. Default: `d => d.color` */
+    color?: ColorAccessor<Datum | Datum[]>;
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /** Separate array of accessors for stacked components (eg StackedBar, Area). Default: `undefined` */
+    yStacked?: NumericAccessor<Datum>[];
+    /** Baseline accessor function for stacked values, useful with stacked areas. Default: `null` */
+    baseline?: NumericAccessor<Datum>;
+    /** An instance of the Tooltip component to be used with Crosshair. Default: `undefined` */
+    tooltip?: Tooltip | undefined;
+    /** Tooltip template accessor. The function is supposed to return either a valid HTML string or an HTMLElement. Default: `d => ''` */
+    template?: (data: Datum, x: number | Date) => string | HTMLElement;
+    /** Hide Crosshair when the corresponding element is far from mouse pointer. Default: `true` */
+    hideWhenFarFromPointer?: boolean;
+    /** Distance in pixels to check in the hideWhenFarFromPointer condition. Default: `100` */
+    hideWhenFarFromPointerDistance?: number;
+    /** Snap to the nearest data point.
+     * If disabled, the tooltip template will receive only the horizontal position of the crosshair and you'll be responsible
+     * for getting the underlying data records and crosshair circles (see the `getCircles` configuration option).
+     * Default: `true` */
+    snapToData?: boolean;
+    /** Custom function for setting up the crosshair circles, usually needed when `snapToData` is set to `false`.
+     * The function receives the horizontal position of the crosshair (in the data space, not in pixels), the data array
+     * and the `yScale` instance to help you calculate the correct vertical position of the circles.
+     * It has to return an array of the CrosshairCircle objects: `{ y: number; color: string; opacity?: number }[]`.
+     * Default: `undefined` */
+    getCircles?: (x: number, data: Datum[], yScale: ContinuousScale) => CrosshairCircle[];
+    data: Datum[];
+    component: Crosshair<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisCrosshairComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisCrosshairComponent<any>, "vis-crosshair", never, { "duration": "duration"; "events": "events"; "attributes": "attributes"; "x": "x"; "y": "y"; "id": "id"; "color": "color"; "xScale": "xScale"; "yScale": "yScale"; "excludeFromDomainCalculation": "excludeFromDomainCalculation"; "yStacked": "yStacked"; "baseline": "baseline"; "tooltip": "tooltip"; "template": "template"; "hideWhenFarFromPointer": "hideWhenFarFromPointer"; "hideWhenFarFromPointerDistance": "hideWhenFarFromPointerDistance"; "snapToData": "snapToData"; "getCircles": "getCircles"; "data": "data"; }, {}, never, never>;
+}

package/dist/lib/components/crosshair/crosshair.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./crosshair.component";
+export declare class VisCrosshairModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisCrosshairModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisCrosshairModule, [typeof i1.VisCrosshairComponent], never, [typeof i1.VisCrosshairComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisCrosshairModule>;
+}

package/dist/lib/components/donut/donut.component.d.ts

@@ -0,0 +1,86 @@
+import { AfterViewInit, SimpleChanges } from '@angular/core';
+import { Donut, DonutConfigInterface, ContainerCore, VisEventType, VisEventCallback, NumericAccessor, ColorAccessor } from '@unovis/ts';
+import * as i0 from "@angular/core";
+export declare class VisDonutComponent<Datum> implements DonutConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i?: number, ...rest: any[]) => string | number);
+    /** Value accessor function. Default: `undefined` */
+    value: NumericAccessor<Datum>;
+    /** Diagram angle range. Default: `[0, 2 * Math.PI]` */
+    angleRange?: [number, number];
+    /** Pad angle. Default: `0` */
+    padAngle?: number;
+    /** Custom sort function. Default: `undefined` */
+    sortFunction?: (a: Datum, b: Datum) => number;
+    /** Corner Radius. Default: `0` */
+    cornerRadius?: number;
+    /** Color accessor function. Default: `undefined` */
+    color?: ColorAccessor<Datum>;
+    /** Explicitly set the donut outer radius. Default: `undefined` */
+    radius?: number;
+    /** Arc width in pixels. Set to `0` if you want to have a pie chart. Default: `20` */
+    arcWidth?: number;
+    /** Central label accessor function or text. Default: `undefined` */
+    centralLabel?: string;
+    /** Central sub-label accessor function or text. Default: `undefined` */
+    centralSubLabel?: string;
+    /** Enables wrapping for the sub-label. Default: `true` */
+    centralSubLabelWrap?: boolean;
+    /** Draw segment as a thin line when its value is 0. Default: `false` */
+    preventEmptySegments?: boolean;
+    data: Datum[];
+    component: Donut<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisDonutComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisDonutComponent<any>, "vis-donut", never, { "duration": "duration"; "events": "events"; "attributes": "attributes"; "id": "id"; "value": "value"; "angleRange": "angleRange"; "padAngle": "padAngle"; "sortFunction": "sortFunction"; "cornerRadius": "cornerRadius"; "color": "color"; "radius": "radius"; "arcWidth": "arcWidth"; "centralLabel": "centralLabel"; "centralSubLabel": "centralSubLabel"; "centralSubLabelWrap": "centralSubLabelWrap"; "preventEmptySegments": "preventEmptySegments"; "data": "data"; }, {}, never, never>;
+}

package/dist/lib/components/donut/donut.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./donut.component";
+export declare class VisDonutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisDonutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisDonutModule, [typeof i1.VisDonutComponent], never, [typeof i1.VisDonutComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisDonutModule>;
+}