@mathstack/viz 0.0.1-beta.0

package/lib/data-dimensions/ordinal/ordinal-visual-value/ordinal-visual-value-builder.d.ts

@@ -0,0 +1,45 @@
+import { DataValue, VisualValue } from '../../../core/types/values';
+import { DataDimensionBuilder } from '../../dimension-builder';
+import { OrdinalVisualValueDimension } from './ordinal-visual-value';
+export declare class OrdinalVisualValueDimensionBuilder<Datum, Domain extends DataValue, Range extends VisualValue> extends DataDimensionBuilder<Datum, Domain> {
+    private _domain;
+    private _range;
+    private _scale;
+    constructor();
+    /**
+     * OPTIONAL. Sets an array of categorical values that will be used to define the domain of the scale.
+     *
+     * If not provided, the domain will be determined by the data.
+     */
+    domain(domain: null): this;
+    domain(domain: Domain[]): this;
+    /**
+     * OPTIONAL. Sets an array of visual values that will be the output from D3 scale ordinal.
+     *
+     * For example, this could be an array of colors or sizes.
+     *
+     * To have all marks use the same visual value, use an array with a single element.
+     *
+     * Will not be used if `scale` is set by the user.
+     *
+     * @default d3.schemeTableau10
+     */
+    range(range: null): this;
+    range(range: Range[]): this;
+    /**
+     * OPTIONAL. Sets a user-defined function that transforms a categorical value into a visual value.
+     *
+     * User must also provide their own implementation of `valueAccessor`.
+     *
+     * If a custom valueAccessor function is not provided, this function will not be used even if provided (due to default value of `valueAccessor`).
+     */
+    scale(scale: null): this;
+    scale(scale: (category: Domain) => Range): this;
+    /**
+     * @internal This method is not intended to be used by consumers of this library.
+     *
+     * @param dimensionName A user-intelligible name for the dimension being built. Used for error messages. Should be title cased.
+     */
+    _build(dimensionName: string): OrdinalVisualValueDimension<Datum, Domain, Range>;
+    private validateDimension;
+}

package/lib/data-dimensions/ordinal/ordinal-visual-value/ordinal-visual-value-options.d.ts

@@ -0,0 +1,7 @@
+import { DataValue, VisualValue } from '../../../core/types/values';
+import { DataDimensionOptions } from '../../dimension-options';
+export interface OrdinalVisualValueDimensionOptions<Datum, Domain extends DataValue, Range extends VisualValue> extends DataDimensionOptions<Datum, Domain> {
+    domain: Domain[];
+    range: Range[];
+    scale: (category: Domain) => Range;
+}

package/lib/data-dimensions/ordinal/ordinal-visual-value/ordinal-visual-value.d.ts

@@ -0,0 +1,38 @@
+import { DataValue, VisualValue } from '../../../core/types/values';
+import { DataDimension } from '../../dimension';
+import { OrdinalVisualValueDimensionOptions } from './ordinal-visual-value-options';
+/**
+ * A dimension that transforms string / number / Date values into a value of type number or string.
+ *
+ * This dimension is intended to be used to set a visual property of an element in a chart.
+ *
+ * The first generic is the type of the data that will be passed to the dimension. The second generic is the type of the value that will be used to set the visual property. The third generic is the type of the range of the scale / the output value.
+ *
+ * TESTABLE FUNCTIONALITY
+ *
+ * - It extracts values for the dimension from data.
+ *   - tested in: ordinal-visual-value.cy.ts
+ * - It sets the domain of the dimension.
+ *   - tested in: ordinal-visual-value.cy.ts
+ * - It checks if a value is in the domain.
+ * - The domain can be set by the user passing in an array of values.
+ *   - tested in: ordinal-chart-position.spec.ts
+ * - The domain will be unique values from the data if no custom domain is given by the user.
+ *   - tested in: ordinal-chart-position.spec.ts
+ * - The domain will always contain only unique values.
+ *   - tested in: ordinal-chart-position.spec.ts
+ */
+export declare class OrdinalVisualValueDimension<Datum, Domain extends DataValue, Range extends VisualValue> extends DataDimension<Datum, Domain> {
+    private _calculatedDomain;
+    private readonly domain;
+    private internSetDomain;
+    readonly range: Range[];
+    private scale;
+    constructor(options: OrdinalVisualValueDimensionOptions<Datum, Domain, Range>);
+    get calculatedDomain(): Domain[];
+    getScale(): (category: Domain) => Range;
+    setPropertiesFromData(data: Datum[]): void;
+    protected setDomain(): void;
+    private setScale;
+    domainIncludes(value: Domain): boolean;
+}

package/lib/data-export/data-export-config.d.ts

@@ -0,0 +1,50 @@
+export declare class VicColumnConfig {
+    title: string;
+    valueAccessor: (x: any) => any;
+    constructor(options?: Partial<VicColumnConfig>);
+}
+export declare class VicDataExportConfig {
+    data: unknown[];
+    /**
+     * If true, the data will be flipped.
+     * Data: {a: 1, b: 2}, {a: 3, b: 4}
+     * Output CSV:
+     * a | 1 | 3
+     * b | 2 | 4
+     */
+    flipped: boolean;
+    /**
+     * If provided, the flipped data's header will be set.
+     * Data: {a: 1, b: 2, category: shrimp}, {a: 3, b: 4, category: lobster}
+     * Output CSV:
+     *     shrimp | lobster
+     * a | 1      | 3
+     * b | 2      | 4
+     */
+    flippedHeaderKey: string;
+    /**
+     * Specifies the keys on each object to include in the csv,
+     * using default titles (converts thisIsAKey to This Is A Key) and values (object.thisIsAKey).
+     * Data: {myKey: 1, otherKey: 2}, {myKey: 3, otherKey: 4}
+     * defaultColumnList: [myKey]
+     * Output CSV:
+     * My Key
+     * 1
+     * 3
+     */
+    defaultColumnList: string[];
+    /**
+     * If true, all keys from the first object in the data array
+     * are used to populate defaultColumnList
+     */
+    includeAllKeysAsDefault: boolean;
+    /**
+     * A ColumnConfig needs to be provided for any column that can't use defaults
+     * e.g. if there's a special title, the data needs to be formatted in some way,
+     * sometimes certain fields are suppressed, etc.
+     */
+    columns: VicColumnConfig[];
+    marginBottom: number;
+    constructor(config?: Partial<VicDataExportConfig>);
+    convertToTitle(key: string): string;
+}

package/lib/data-export/data-export.d.ts

@@ -0,0 +1,7 @@
+import { VicDataExportConfig } from './data-export-config';
+import * as i0 from "@angular/core";
+export declare class VicDataExport {
+    saveCSV(name: string, dataConfigs: VicDataExportConfig[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VicDataExport, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VicDataExport>;
+}

package/lib/data-export/index.d.ts

@@ -0,0 +1,2 @@
+export * from './data-export';
+export * from './data-export-config';

package/lib/dots/config/dots-builder.d.ts

@@ -0,0 +1,110 @@
+import { DataValue } from '../../core';
+import { DateChartPositionDimensionBuilder } from '../../data-dimensions/continuous-quantitative/date-chart-position/date-chart-position-builder';
+import { NumberChartPositionDimensionBuilder } from '../../data-dimensions/continuous-quantitative/number-chart-position/number-chart-position-builder';
+import { NumberVisualValueDimensionBuilder } from '../../data-dimensions/continuous-quantitative/number-visual-value/number-visual-value-builder';
+import { OrdinalChartPositionDimensionBuilder } from '../../data-dimensions/ordinal/ordinal-chart-position/ordinal-chart-position-builder';
+import { OrdinalVisualValueDimensionBuilder } from '../../data-dimensions/ordinal/ordinal-visual-value/ordinal-visual-value-builder';
+import { PrimaryMarksBuilder } from '../../marks/primary-marks/config/primary-marks-builder';
+import { StrokeBuilder } from '../../stroke/stroke-builder';
+import { DotsConfig } from './dots-config';
+import * as i0 from "@angular/core";
+export declare class VicDotsConfigBuilder<Datum, XOrdinalDomain extends DataValue = string, YOrdinalDomain extends DataValue = string> extends PrimaryMarksBuilder<Datum> {
+    private _opacity;
+    private _pointerDetectionRadius;
+    private fillBuilderCategorical;
+    private fillBuilderNumber;
+    private fillBuilderConst;
+    private radiusBuilderCategorical;
+    private radiusBuilderNumber;
+    private radiusBuilderConst;
+    private strokeBuilder;
+    private xBuilderNumeric;
+    private xBuilderDate;
+    private xBuilderOrdinal;
+    private yBuilderNumeric;
+    private yBuilderDate;
+    private yBuilderOrdinal;
+    constructor();
+    /**
+     * OPTIONAL. Sets the appearance of the fill for the dots using a color string.
+     *
+     * If a string is passed, it will be used as the color for all dots.
+     *
+     * @default 'schemeTableau10[0]'
+     */
+    fill(fill: null): this;
+    fill(fill: string): this;
+    /**
+     * OPTIONAL. Sets the appearance of the fill for the dots using a categorical dimension.
+     *
+     */
+    fillCategorical(fill: null): this;
+    fillCategorical(fill: (fill: OrdinalVisualValueDimensionBuilder<Datum, string, string>) => void): this;
+    fillNumeric(fill: null): this;
+    fillNumeric(fill: (fill: NumberVisualValueDimensionBuilder<Datum, string>) => void): this;
+    private initFillBuilderNumber;
+    /**
+     * OPTIONAL. Sets the opacity of the dots.
+     *
+     * @default 1
+     */
+    opacity(opacity: number): this;
+    /**
+     * OPTIONAL. The size of the radius of the dots
+     *
+     * This is temporarily a constant.
+     *
+     * @default 2
+     */
+    radius(radius: null): this;
+    radius(radius: number): this;
+    radiusCategorical(radius: null): this;
+    radiusCategorical(radius: (radius: OrdinalVisualValueDimensionBuilder<Datum, string, number>) => void): this;
+    radiusNumeric(radius: null): this;
+    radiusNumeric(radius: (radius: NumberVisualValueDimensionBuilder<Datum, number>) => void): this;
+    /**
+     * OPTIONAL. Sets the appearance of the stroke for the dots.
+     */
+    stroke(stroke: null): this;
+    stroke(stroke: (stroke: StrokeBuilder) => void): this;
+    private initStrokeBuilder;
+    /**
+     * REQUIRED. A config for the behavior of the chart's x dimension when using numeric data.
+     */
+    xDate(x: null): this;
+    xDate(x: (x: DateChartPositionDimensionBuilder<Datum>) => void): this;
+    /**
+     * REQUIRED. A config for the behavior of the chart's x dimension when using numeric data.
+     */
+    xNumeric(x: null): this;
+    xNumeric(x: (x: NumberChartPositionDimensionBuilder<Datum>) => void): this;
+    /**
+     * REQUIRED. A config for the behavior of the chart's x dimension when using numeric data.
+     */
+    xOrdinal(x: null): this;
+    xOrdinal(x: (x: OrdinalChartPositionDimensionBuilder<Datum, XOrdinalDomain>) => void): this;
+    /**
+     * REQUIRED. A config for the behavior of the chart's x dimension when using numeric data.
+     */
+    yDate(y: null): this;
+    yDate(y: (y: DateChartPositionDimensionBuilder<Datum>) => void): this;
+    /**
+     * REQUIRED. A config for the behavior of the chart's x dimension when using numeric data.
+     */
+    yNumeric(y: null): this;
+    yNumeric(y: (y: NumberChartPositionDimensionBuilder<Datum>) => void): this;
+    /**
+     * REQUIRED. A config for the behavior of the chart's x dimension when using numeric data.
+     */
+    yOrdinal(y: null): this;
+    yOrdinal(y: (y: OrdinalChartPositionDimensionBuilder<Datum, YOrdinalDomain>) => void): this;
+    /**
+     * REQUIRED. Validates and builds the configuration object for the bars that can be passed to BarsComponent.
+     *
+     * The user must call this at the end of the chain of methods to build the configuration object.
+     */
+    getConfig(): DotsConfig<Datum, XOrdinalDomain, YOrdinalDomain>;
+    protected validateBuilder(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VicDotsConfigBuilder<any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VicDotsConfigBuilder<any, any, any>>;
+}

package/lib/dots/config/dots-config.d.ts

@@ -0,0 +1,26 @@
+import { DataValue } from '../../core';
+import { DateChartPositionDimension } from '../../data-dimensions/continuous-quantitative/date-chart-position/date-chart-position';
+import { NumberChartPositionDimension } from '../../data-dimensions/continuous-quantitative/number-chart-position/number-chart-position';
+import { NumberDimension } from '../../data-dimensions/continuous-quantitative/number-dimension/number-dimension';
+import { NumberVisualValueDimension } from '../../data-dimensions/continuous-quantitative/number-visual-value/number-visual-value';
+import { DataDimension } from '../../data-dimensions/dimension';
+import { OrdinalChartPositionDimension } from '../../data-dimensions/ordinal/ordinal-chart-position/ordinal-chart-position';
+import { OrdinalVisualValueDimension } from '../../data-dimensions/ordinal/ordinal-visual-value/ordinal-visual-value';
+import { XyPrimaryMarksConfig } from '../../marks/xy-marks/xy-primary-marks/xy-primary-marks-config';
+import { Stroke } from '../../stroke/stroke';
+import { DotsOptions } from './dots-options';
+export declare class DotsConfig<Datum, XOrdinalDomain extends DataValue = string, YOrdinalDomain extends DataValue = string> extends XyPrimaryMarksConfig<Datum> implements DotsOptions<Datum, XOrdinalDomain, YOrdinalDomain> {
+    fill: OrdinalVisualValueDimension<Datum, string, string> | NumberVisualValueDimension<Datum, string>;
+    opacity: number;
+    pointerDetectionRadius: number;
+    radius: OrdinalVisualValueDimension<Datum, string, number> | NumberVisualValueDimension<Datum, number>;
+    stroke: Stroke;
+    x: NumberChartPositionDimension<Datum> | DateChartPositionDimension<Datum> | OrdinalChartPositionDimension<Datum, XOrdinalDomain>;
+    y: NumberChartPositionDimension<Datum> | DateChartPositionDimension<Datum> | OrdinalChartPositionDimension<Datum, YOrdinalDomain>;
+    constructor(options: DotsOptions<Datum, XOrdinalDomain, YOrdinalDomain>);
+    protected initPropertiesFromData(): void;
+    protected setDimensionPropertiesFromData(): void;
+    protected setValueIndices(): void;
+    private isValidValue;
+    isContinuousQuantitativeDimension(dimension: DataDimension<Datum, DataValue>): dimension is NumberDimension<Datum>;
+}

package/lib/dots/config/dots-options.d.ts

@@ -0,0 +1,17 @@
+import { DataValue } from '../../core';
+import { DateChartPositionDimension } from '../../data-dimensions/continuous-quantitative/date-chart-position/date-chart-position';
+import { NumberChartPositionDimension } from '../../data-dimensions/continuous-quantitative/number-chart-position/number-chart-position';
+import { NumberVisualValueDimension } from '../../data-dimensions/continuous-quantitative/number-visual-value/number-visual-value';
+import { OrdinalChartPositionDimension } from '../../data-dimensions/ordinal/ordinal-chart-position/ordinal-chart-position';
+import { OrdinalVisualValueDimension } from '../../data-dimensions/ordinal/ordinal-visual-value/ordinal-visual-value';
+import { DataMarksOptions } from '../../marks/config/marks-options';
+import { Stroke } from '../../stroke/stroke';
+export interface DotsOptions<Datum, XOrdinalDomain extends DataValue = string, YOrdinalDomain extends DataValue = string> extends DataMarksOptions<Datum> {
+    fill: OrdinalVisualValueDimension<Datum, string, string> | NumberVisualValueDimension<Datum, string>;
+    opacity: number;
+    pointerDetectionRadius: number;
+    radius: OrdinalVisualValueDimension<Datum, string, number> | NumberVisualValueDimension<Datum, number>;
+    stroke: Stroke;
+    x: NumberChartPositionDimension<Datum> | DateChartPositionDimension<Datum> | OrdinalChartPositionDimension<Datum, XOrdinalDomain>;
+    y: NumberChartPositionDimension<Datum> | DateChartPositionDimension<Datum> | OrdinalChartPositionDimension<Datum, YOrdinalDomain>;
+}

package/lib/dots/dots.component.d.ts

@@ -0,0 +1,55 @@
+import { InjectionToken } from '@angular/core';
+import { Selection } from 'd3-selection';
+import { BehaviorSubject } from 'rxjs';
+import { XyChartScales } from '../charts/xy-chart/xy-chart.component';
+import { DataValue, GenericScale } from '../core';
+import { NumberDimension } from '../data-dimensions/continuous-quantitative/number-dimension/number-dimension';
+import { DataDimension } from '../data-dimensions/dimension';
+import { VicXyPrimaryMarks } from '../marks/xy-marks/xy-primary-marks/xy-primary-marks';
+import { DotsConfig } from './config/dots-config';
+import * as i0 from "@angular/core";
+export declare const DOTS: InjectionToken<DotsComponent<unknown>>;
+export type DotGroupSelection = Selection<SVGGElement, DotDatum, SVGGElement, unknown>;
+export type DotSelection = Selection<SVGCircleElement, DotDatum, SVGGElement, DotDatum>;
+export type DotLabelSelection = Selection<SVGTextElement, DotDatum, SVGGElement, DotDatum>;
+export type DotDatum = {
+    index: number;
+    x: DataValue;
+    y: DataValue;
+    fill: string | number;
+    radius: string | number;
+};
+export interface DotsTooltipDatum<Datum> {
+    datum: Datum;
+    values: {
+        x: string;
+        y: string;
+        fill: string | number;
+        radius: string | number;
+    };
+    color: string;
+}
+type DotsSvgElement = 'g' | 'dot';
+export declare class DotsComponent<Datum> extends VicXyPrimaryMarks<Datum, DotsConfig<Datum>> {
+    dotGroups: DotGroupSelection;
+    dots: BehaviorSubject<DotSelection>;
+    dots$: import("rxjs").Observable<DotSelection>;
+    scales: {
+        fill: GenericScale<any, any>;
+        radius: GenericScale<any, any>;
+    } & XyChartScales;
+    private elRef;
+    private zone;
+    get class(): Record<DotsSvgElement, string>;
+    setChartScalesFromRanges(useTransition: boolean): void;
+    drawMarks(): void;
+    drawDots(transitionDuration: number): void;
+    getDotDatumFromIndex(index: number): DotDatum;
+    updateDotElements(): void;
+    getTooltipData(dotDatum: DotDatum): DotsTooltipDatum<Datum>;
+    getFormattedValue(dimension: 'x' | 'y', datum: Datum): string;
+    isContinuousNumericDimension(dimension: DataDimension<Datum, DataValue>): dimension is NumberDimension<Datum>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DotsComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DotsComponent<any>, "[vic-primary-marks-dots]", never, {}, {}, never, never, true, never>;
+}
+export {};

package/lib/dots/dots.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./dots.component";
+import * as i2 from "./events/dots-events.directive";
+export declare class VicDotsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VicDotsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VicDotsModule, never, [typeof i1.DotsComponent, typeof i2.DotsEventsDirective], [typeof i1.DotsComponent, typeof i2.DotsEventsDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VicDotsModule>;
+}

package/lib/dots/events/actions/dots-hover-actions.d.ts

@@ -0,0 +1,6 @@
+import { EventAction } from '../../../events';
+import { DotsHost } from '../dots-events.directive';
+export declare class DotsHoverDefaultStyles<Datum> implements EventAction<DotsHost<Datum>> {
+    onStart(host: DotsHost<Datum>): void;
+    onEnd(host: DotsHost<Datum>): void;
+}

package/lib/dots/events/actions/dots-hover-move-actions.d.ts

@@ -0,0 +1,10 @@
+import { HoverMoveAction } from '../../../events';
+import { DotsHost } from '../dots-events.directive';
+export declare class DotsHoverMoveDefaultStyles<Datum> implements HoverMoveAction<DotsHost<Datum>> {
+    onStart(host: DotsHost<Datum>): void;
+    onEnd(host: DotsHost<Datum>): void;
+}
+export declare class DotsHoverMoveEmitTooltipData<Datum> implements HoverMoveAction<DotsHost<Datum>> {
+    onStart(host: DotsHost<Datum>): void;
+    onEnd(host: DotsHost<Datum>): void;
+}

package/lib/dots/events/dots-events.directive.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from '@angular/core';
+import { Observable } from 'rxjs';
+import { EventAction, EventsDirective, EventType, HoverMoveAction, InputEventAction, MarksHost, UnlistenFunction } from '../../events';
+import { DotDatum, DotsComponent } from '../dots.component';
+import { DotsInteractionOutput } from './dots-interaction-output';
+import * as i0 from "@angular/core";
+export interface DotsHost<Datum, TDotsComponent extends DotsComponent<Datum> = DotsComponent<Datum>> extends MarksHost<DotsInteractionOutput<Datum>, TDotsComponent> {
+    getDotDatum(): DotDatum | null;
+}
+export declare class DotsEventsDirective<Datum, TDotsComponent extends DotsComponent<Datum> = DotsComponent<Datum>> extends EventsDirective<DotsHost<Datum>> {
+    dots: TDotsComponent;
+    hoverActions: EventAction<DotsHost<Datum>, DotsInteractionOutput<Datum>>[] | null;
+    hoverMoveActions: HoverMoveAction<DotsHost<Datum>, DotsInteractionOutput<Datum>>[] | null;
+    clickActions: EventAction<DotsHost<Datum>, DotsInteractionOutput<Datum>>[] | null;
+    inputEventActions: InputEventAction<DotsHost<Datum>, DotsInteractionOutput<Datum>>[];
+    interactionOutput: EventEmitter<DotsInteractionOutput<Datum>>;
+    dotDatum: DotDatum;
+    origin: SVGCircleElement;
+    constructor(dots: TDotsComponent);
+    get marks(): DotsComponent<Datum>;
+    getElements(): Observable<Element[]>;
+    getDotDatum(): DotDatum | null;
+    setupListeners(elements: Element[]): UnlistenFunction[];
+    onEnter(_: PointerEvent, el: Element): void;
+    onMove(event: PointerEvent, _: Element): void;
+    onLeave(_: PointerEvent, __: Element): void;
+    onClick(event: PointerEvent, el: Element): void;
+    onClickRemove(): void;
+    onInputEvent(inputValue: unknown): void;
+    initFromElement(el: Element): void;
+    setPositionsFromElement(): void;
+    getInteractionOutput(type: EventType): DotsInteractionOutput<Datum>;
+    emitInteractionOutput(output: DotsInteractionOutput<Datum>): void;
+    private resetDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DotsEventsDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DotsEventsDirective<any, any>, "[vicDotsEvents]", never, { "hoverActions": { "alias": "hoverActions"; "required": false; }; "hoverMoveActions": { "alias": "hoverMoveActions"; "required": false; }; "clickActions": { "alias": "clickActions"; "required": false; }; "inputEventActions": { "alias": "inputEventActions"; "required": false; }; }, { "interactionOutput": "interactionOutput"; }, never, never, true, never>;
+}

package/lib/dots/events/dots-interaction-output.d.ts

@@ -0,0 +1,14 @@
+import { InteractionOutput } from '../../events/interaction-output';
+import { HtmlTooltipCdkManagedPosition } from '../../tooltips';
+import { DotsTooltipDatum } from '../dots.component';
+export interface DotsInteractionOutput<Datum> extends DotsTooltipDatum<Datum>, InteractionOutput {
+    /**
+     * A method that returns a position for the tooltip above the pointer for HoverMove or Click actions or above the center of the dot for Hover actions.
+     *
+     * @param yOffset - Optional offset from the pointer's y position.
+     */
+    fromAnchor: (offset?: Partial<{
+        x: number;
+        y: number;
+    }>) => HtmlTooltipCdkManagedPosition;
+}

package/lib/dots/events/dots-tooltip-positioner.d.ts

@@ -0,0 +1,13 @@
+import { TooltipPositioner } from '../../events/tooltip-positioner';
+import { HtmlTooltipCdkManagedPosition } from '../../tooltips';
+export declare class DotsTooltipPositioner extends TooltipPositioner {
+    private anchor;
+    constructor(anchor: {
+        x: number;
+        y: number;
+    });
+    fromAnchor(offset: {
+        x: number;
+        y: number;
+    }): HtmlTooltipCdkManagedPosition;
+}

package/lib/dots/index.d.ts

@@ -0,0 +1,9 @@
+export * from './config/dots-builder';
+export * from './config/dots-config';
+export * from './config/dots-options';
+export * from './dots.component';
+export * from './dots.module';
+export * from './events/actions/dots-hover-actions';
+export * from './events/actions/dots-hover-move-actions';
+export * from './events/dots-events.directive';
+export * from './events/dots-interaction-output';

package/lib/events/events.directive.d.ts

@@ -0,0 +1,43 @@
+import { AfterViewInit, DestroyRef, OnDestroy, Renderer2 } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ActionHost, EventAction, EventType, UnlistenFunction } from './events.types';
+import * as i0 from "@angular/core";
+export declare abstract class EventsDirective<Host extends ActionHost<unknown> = any> implements AfterViewInit, OnDestroy {
+    clickRemoveEvent$: Observable<void>;
+    inputEvent$: Observable<unknown>;
+    protected destroyRef: DestroyRef;
+    protected renderer: Renderer2;
+    protected abstract getElements(): Observable<Element[]>;
+    protected abstract onClickRemove(): void;
+    protected abstract onInputEvent(inputValue: unknown): void;
+    protected abstract setPositionsFromElement(): void;
+    protected abstract setupListeners(elements: Element[]): UnlistenFunction[];
+    protected unlistenFns: UnlistenFunction[];
+    protected events: EventType[];
+    preventAction: Record<EventType, boolean>;
+    positionX: number;
+    positionY: number;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected buildInteractionListeners(handlers: Partial<Record<EventType, Partial<{
+        pointerenter: (e: PointerEvent, el: Element) => void;
+        pointermove: (e: PointerEvent, el: Element) => void;
+        pointerleave: (e: PointerEvent, el: Element) => void;
+        click: (e: PointerEvent, el: Element) => void;
+    }>>>): Record<string, (e: PointerEvent, el: Element) => void>;
+    protected bindEventListeners(elements: Element[], handlers: Partial<{
+        pointerenter: (event: PointerEvent, el: Element) => void;
+        pointermove: (event: PointerEvent, el: Element) => void;
+        pointerleave: (event: PointerEvent, el: Element) => void;
+        click: (event: PointerEvent, el: Element) => void;
+    }>): UnlistenFunction[];
+    disableOtherActions(eventType: EventType): void;
+    resumeOtherActions(eventType: EventType, cancelCurrentActions?: boolean): void;
+    setPositionsFromPointer(event: PointerEvent): void;
+    protected runActions<T extends EventAction<Host>>(actions: T[] | null | undefined, fn: (action: T) => void): void;
+    protected hasEvent(event: EventType): boolean;
+    protected isEventAllowed(event: EventType): boolean;
+    protected asHost(): Host;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventsDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EventsDirective<any>, never, never, { "clickRemoveEvent$": { "alias": "clickRemoveEvent$"; "required": false; }; "inputEvent$": { "alias": "inputEvent$"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/events/events.types.d.ts

@@ -0,0 +1,34 @@
+import { Renderer2 } from '@angular/core';
+export type UnlistenFunction = () => void;
+export type ListenElement = HTMLElement | SVGElement;
+export declare enum EventType {
+    Click = "click",
+    Hover = "hover",
+    HoverMove = "hoverMove",
+    Input = "input"
+}
+export interface EventAction<Host extends ActionHost<Output>, Output = unknown> {
+    onStart: (host: Host) => void;
+    onEnd: (host: Host) => void;
+}
+export interface HoverMoveAction<Host extends ActionHost<Output>, Output = unknown> extends EventAction<Host> {
+    initialize?: (host: Host) => void;
+}
+export interface InputEventAction<Host extends ActionHost<Output>, Output = unknown> {
+    onStart: (host: Host, ...args: any[]) => void;
+    onEnd: (host: Host, ...args: any[]) => void;
+}
+export interface ActionHost<Output> {
+    getInteractionOutput(type: EventType): Output;
+    setPositionsFromElement(): void;
+    setPositionsFromPointer(event: PointerEvent): void;
+    disableOtherActions(eventType: EventType): void;
+    resumeOtherActions(eventType: EventType, cancelCurrentActions?: boolean): void;
+    emitInteractionOutput(output: Output): void;
+}
+export interface MarksHost<Output, MarksComponent = unknown> extends ActionHost<Output> {
+    marks: MarksComponent;
+}
+export interface EventStrategy {
+    bindTo(elements: Element[], renderer: Renderer2): UnlistenFunction[];
+}

package/lib/events/index.d.ts

@@ -0,0 +1,4 @@
+export * from './events.directive';
+export * from './events.types';
+export * from './interaction-output';
+export * from './tooltip-positioner';

package/lib/events/interaction-output.d.ts

@@ -0,0 +1,33 @@
+import { EventType } from '../events';
+import { HtmlTooltipCdkManagedPosition, TooltipPosition } from '../tooltips';
+export interface InteractionOutput<Anchor = {
+    x: number;
+    y: number;
+}> {
+    /**
+     * If used with Hover actions, the coordinates of the center of the origin element relative to the top left corner of the origin.
+     *
+     * If used with HoverMove actions, the position of the pointer relative to the top left corner of the origin element.
+     */
+    anchor: Anchor;
+    /**
+     * The origin element of the tooltip.
+     */
+    origin: SVGGraphicsElement;
+    /**
+     * The type of the event that triggered the interaction.
+     */
+    type: EventType;
+    /**
+     * The default position of the tooltip.
+     */
+    defaultPosition: HtmlTooltipCdkManagedPosition;
+    /**
+     * A method that positions the tooltip with a user specified offset from the tooltip's anchor point.
+     */
+    fromAnchor: (...args: any[]) => HtmlTooltipCdkManagedPosition;
+    /**
+     * A method that allows a user to provide custom positions for the tooltip.
+     */
+    customPosition: (positions: TooltipPosition[]) => HtmlTooltipCdkManagedPosition;
+}

package/lib/events/tooltip-positioner.d.ts

@@ -0,0 +1,6 @@
+import { HtmlTooltipCdkManagedPosition, TooltipPosition } from '../tooltips/html-tooltip/config/position/tooltip-position';
+export declare const DEFAULT_TOOLTIP_Y_OFFSET = 2;
+export declare abstract class TooltipPositioner {
+    abstract fromAnchor(...args: any): HtmlTooltipCdkManagedPosition;
+    customPosition(positions: TooltipPosition[]): HtmlTooltipCdkManagedPosition;
+}

package/lib/fill-definitions/fill-definitions.d.ts

@@ -0,0 +1,4 @@
+export interface FillDefinition<Datum> {
+    defId: string;
+    shouldApply: (d: Datum) => boolean;
+}

package/lib/fill-definitions/index.d.ts

@@ -0,0 +1 @@
+export * from './fill-definitions';