@mathstack/viz 0.0.1-beta.0

package/lib/stacked-area/config/stacked-area-builder.d.ts

@@ -0,0 +1,85 @@
+import { CurveFactory, InternMap, Series } from 'd3';
+import { ContinuousValue, DataValue } from '../../core/types/values';
+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 { OrdinalVisualValueDimensionBuilder } from '../../data-dimensions/ordinal/ordinal-visual-value/ordinal-visual-value-builder';
+import { PrimaryMarksBuilder } from '../../marks/primary-marks/config/primary-marks-builder';
+import { StackedAreaConfig } from './stacked-area-config';
+import * as i0 from "@angular/core";
+/**
+ * Builds a configuration object for a StackedAreaComponent.
+ *
+ * Must be added to a providers array in or above the component that consumes it if it is injected via the constructor. (e.g. `providers: [VicStackedAreaBuilder]` in the component decorator)
+ *
+ * The first generic parameter, Datum, is the type of the data that will be used to create the stacked area chart.
+ *
+ * The second generic parameter, TCategoricalValue, is the type of the categorical data that will be used to stack the areas.
+ */
+export declare class VicStackedAreaConfigBuilder<Datum, CategoricalDomain extends DataValue> extends PrimaryMarksBuilder<Datum> {
+    private colorDimensionBuilder;
+    private _categoricalOrder;
+    private _curve;
+    private _stackOrder;
+    private _stackOffset;
+    private xDimensionBuilder;
+    private yDimensionBuilder;
+    constructor();
+    /**
+     * REQUIRED. Sets the categorical dimension for the stacked area chart.
+     */
+    color(color: (color: OrdinalVisualValueDimensionBuilder<Datum, CategoricalDomain, string>) => void): this;
+    /**
+     * OPTIONAL. Allows user to provide a custom order for the categories of data / the stack.
+     *
+     * If not provided, the order will be determined by d3.
+     */
+    categoricalOrder(value: CategoricalDomain[]): this;
+    /**
+     * OPTIONAL. Sets the curve factory for the line.
+     *
+     * @default curveLinear
+     */
+    curve(value: null): this;
+    curve(value: CurveFactory): this;
+    /**
+     * OPTIONAL: Sets the order of the stack.
+     *
+     * @default stackOrderNone
+     */
+    stackOrder(stackOrder: null): this;
+    stackOrder(stackOrder: (series: Series<[
+        ContinuousValue,
+        InternMap<CategoricalDomain, number>
+    ], CategoricalDomain>) => Iterable<number>): this;
+    /**
+     * OPTIONAL. Sets the offset of the stack.
+     *
+     * @default stackOffsetNone
+     */
+    stackOffset(stackOffset: null): this;
+    stackOffset(stackOffset: (series: Series<[
+        ContinuousValue,
+        InternMap<CategoricalDomain, number>
+    ], CategoricalDomain>, order: number[]) => void): this;
+    /**
+     * REQUIRED. Sets the x dimension for the stacked area chart when using Date data.
+     */
+    xDate(x: null): this;
+    xDate(x: (x: DateChartPositionDimensionBuilder<Datum>) => void): this;
+    /**
+     * REQUIRED. Sets the x dimension for the stacked area chart when using numeric data.
+     */
+    xNumeric(x: null): this;
+    xNumeric(x: (x: NumberChartPositionDimensionBuilder<Datum>) => void): this;
+    /**
+     * REQUIRED. Sets the y dimension for the stacked area chart.
+     */
+    y(y: (y: NumberChartPositionDimensionBuilder<Datum>) => void): this;
+    /**
+     * REQUIRED. Builds the configuration object for the stacked area chart.
+     */
+    getConfig(): StackedAreaConfig<Datum, CategoricalDomain>;
+    protected validateBuilder(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VicStackedAreaConfigBuilder<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VicStackedAreaConfigBuilder<any, any>>;
+}

package/lib/stacked-area/config/stacked-area-config.d.ts

@@ -0,0 +1,36 @@
+import { CurveFactory, InternMap, Series, SeriesPoint } from 'd3';
+import { ContinuousValue, DataValue } from '../../core/types/values';
+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 { OrdinalVisualValueDimension } from '../../data-dimensions/ordinal/ordinal-visual-value/ordinal-visual-value';
+import { DataMarksOptions } from '../../marks/config/marks-options';
+import { XyPrimaryMarksConfig } from '../../marks/xy-marks/xy-primary-marks/xy-primary-marks-config';
+import { StackedAreaOptions } from './stacked-area-options';
+export type StackedAreaDatum<CategoricalDomain> = (SeriesPoint<[
+    ContinuousValue,
+    InternMap<CategoricalDomain, number>
+]> & {
+    i: number;
+})[];
+export declare class StackedAreaConfig<Datum, CategoricalDomain extends DataValue> extends XyPrimaryMarksConfig<Datum> implements DataMarksOptions<Datum> {
+    color: OrdinalVisualValueDimension<Datum, CategoricalDomain, string>;
+    categoricalOrder: CategoricalDomain[];
+    curve: CurveFactory;
+    stackOrder: (series: Series<[
+        ContinuousValue,
+        InternMap<CategoricalDomain, number>
+    ], CategoricalDomain>) => Iterable<number>;
+    stackOffset: (series: Series<[
+        ContinuousValue,
+        InternMap<CategoricalDomain, number>
+    ], CategoricalDomain>, order: number[]) => void;
+    x: DateChartPositionDimension<Datum> | NumberChartPositionDimension<Datum>;
+    y: NumberChartPositionDimension<Datum>;
+    series: StackedAreaDatum<CategoricalDomain>[];
+    constructor(options: StackedAreaOptions<Datum, CategoricalDomain>);
+    protected initPropertiesFromData(): void;
+    private setDimensionPropertiesFromData;
+    private setValueIndicies;
+    private setSeries;
+    private initQuantitativeDomainFromStack;
+}

package/lib/stacked-area/config/stacked-area-options.d.ts

@@ -0,0 +1,21 @@
+import { CurveFactory, InternMap, Series } from 'd3';
+import { ContinuousValue, DataValue } from '../../core/types/values';
+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 { OrdinalVisualValueDimension } from '../../data-dimensions/ordinal/ordinal-visual-value/ordinal-visual-value';
+import { DataMarksOptions } from '../../marks/config/marks-options';
+export interface StackedAreaOptions<Datum, CategoricalDomain extends DataValue> extends DataMarksOptions<Datum>, DataMarksOptions<Datum> {
+    color: OrdinalVisualValueDimension<Datum, CategoricalDomain, string>;
+    categoricalOrder: CategoricalDomain[];
+    curve: CurveFactory;
+    stackOrder: (series: Series<[
+        ContinuousValue,
+        InternMap<CategoricalDomain, number>
+    ], CategoricalDomain>) => Iterable<number>;
+    stackOffset: (series: Series<[
+        ContinuousValue,
+        InternMap<CategoricalDomain, number>
+    ], CategoricalDomain>, order: number[]) => void;
+    x: DateChartPositionDimension<Datum> | NumberChartPositionDimension<Datum>;
+    y: NumberChartPositionDimension<Datum>;
+}

package/lib/stacked-area/events/actions/stacked-area-hover-move-actions.d.ts

@@ -0,0 +1,7 @@
+import { DataValue } from '../../../core/types/values';
+import { HoverMoveAction } from '../../../events';
+import { StackedAreaHost } from '../stacked-area-events.directive';
+export declare class StackedAreaHoverMoveEmitTooltipData<Datum, TCategoricalValue extends DataValue> implements HoverMoveAction<StackedAreaHost<Datum, TCategoricalValue>> {
+    onStart(host: StackedAreaHost<Datum, TCategoricalValue>): void;
+    onEnd(host: StackedAreaHost<Datum, TCategoricalValue>): void;
+}

package/lib/stacked-area/events/stacked-area-events.directive.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DataValue } from '../../core/types/values';
+import { EventAction, EventType, EventsDirective, HoverMoveAction, InputEventAction, MarksHost, UnlistenFunction } from '../../events';
+import { StackedAreaComponent } from '../stacked-area.component';
+import { StackedAreaInteractionOutput } from './stacked-area-interaction-output';
+import * as i0 from "@angular/core";
+export type StackedAreaHost<Datum, TCategoricalValue extends DataValue, TStackedAreaComponent extends StackedAreaComponent<Datum, TCategoricalValue> = StackedAreaComponent<Datum, TCategoricalValue>> = MarksHost<StackedAreaInteractionOutput<Datum, TCategoricalValue>, TStackedAreaComponent>;
+export declare class StackedAreaEventsDirective<Datum, TCategoricalValue extends DataValue, TStackedAreaComponent extends StackedAreaComponent<Datum, TCategoricalValue> = StackedAreaComponent<Datum, TCategoricalValue>> extends EventsDirective<StackedAreaHost<Datum, TCategoricalValue>> implements StackedAreaHost<Datum, TCategoricalValue> {
+    stackedArea: TStackedAreaComponent;
+    hoverMoveActions: HoverMoveAction<StackedAreaHost<Datum, TCategoricalValue>, StackedAreaInteractionOutput<Datum, TCategoricalValue>>[] | null;
+    clickActions: EventAction<StackedAreaHost<Datum, TCategoricalValue>, StackedAreaInteractionOutput<Datum, TCategoricalValue>>[] | null;
+    inputEventActions: InputEventAction<StackedAreaHost<Datum, TCategoricalValue>, StackedAreaInteractionOutput<Datum, TCategoricalValue>>[];
+    interactionOutput: EventEmitter<StackedAreaInteractionOutput<Datum, TCategoricalValue>>;
+    closestXIndicies: number[];
+    categoryYMin: number;
+    categoryYMax: number;
+    categoryIndex: number;
+    constructor(stackedArea: TStackedAreaComponent);
+    get marks(): StackedAreaComponent<Datum, TCategoricalValue>;
+    getElements(): Observable<Element[]>;
+    setupListeners(elements: Element[]): UnlistenFunction[];
+    onEnter(_: PointerEvent, __: Element): void;
+    onMove(event: PointerEvent, _: Element): void;
+    onLeave(_: PointerEvent, __: Element): void;
+    onClick(event: PointerEvent, _: Element): void;
+    onInputEvent(inputValue: unknown): void;
+    onClickRemove(): void;
+    setPositionsFromElement(): void;
+    pointerIsInChartArea(): boolean;
+    setClosestXIndicies(): void;
+    setClosestDatumPosition(): void;
+    getInteractionOutput(type: EventType): StackedAreaInteractionOutput<Datum, TCategoricalValue>;
+    emitInteractionOutput(output: StackedAreaInteractionOutput<Datum, TCategoricalValue>): void;
+    resetDirective(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StackedAreaEventsDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StackedAreaEventsDirective<any, any, any>, "[vicStackedAreaEvents]", never, { "hoverMoveActions": { "alias": "hoverMoveActions"; "required": false; }; "clickActions": { "alias": "clickActions"; "required": false; }; "inputEventActions": { "alias": "inputEventActions"; "required": false; }; }, { "interactionOutput": "interactionOutput"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,28 @@
+import { DataValue } from '../../core/types/values';
+import { InteractionOutput } from '../../events/interaction-output';
+import { HtmlTooltipCdkManagedPosition } from '../../tooltips';
+import { StackedAreaTooltipDatum } from '../stacked-area.component';
+export interface StackedAreaInteractionAnchor {
+    x: number;
+    yAreaTop: number;
+    yAreaBottom: number;
+    yChartTop: number;
+    yChartBottom: number;
+}
+export interface StackedAreaInteractionOutput<Datum, TCategoricalValue extends DataValue> extends InteractionOutput<StackedAreaInteractionAnchor> {
+    data: StackedAreaTooltipDatum<Datum, TCategoricalValue>[];
+    hoveredAreaDatum: StackedAreaTooltipDatum<Datum, TCategoricalValue>;
+    defaultPositionFromArea: HtmlTooltipCdkManagedPosition;
+    defaultPositionFromChart: HtmlTooltipCdkManagedPosition;
+    /**
+     * A method that positions the tooltip with a user specified offset from the tooltip's anchor point.
+     *
+     * @param offset - Optional offset from the anchor's x and y position.
+     * If not provided, defaults to { x: 0, y: 0 }.
+     * If provided, the x value is added to the anchor's x position (moves tooltip right) and the y value is subtracted from the anchor's y position (moves tooltip up).
+     */
+    fromAnchor: (relativeTo: 'area' | 'chart', offset?: Partial<{
+        x: number;
+        y: number;
+    }>) => HtmlTooltipCdkManagedPosition;
+}

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

@@ -0,0 +1,16 @@
+import { TooltipPositioner } from '../../events/tooltip-positioner';
+import { HtmlTooltipCdkManagedPosition } from '../../tooltips';
+export declare class StackedAreaTooltipPositioner extends TooltipPositioner {
+    private anchor;
+    constructor(anchor: {
+        x: number;
+        yAreaTop: number;
+        yAreaBottom: number;
+        yChartTop: number;
+        yChartBottom: number;
+    });
+    fromAnchor(relativeTo: 'area' | 'chart', offset: {
+        x: number;
+        y: number;
+    }): HtmlTooltipCdkManagedPosition;
+}

package/lib/stacked-area/index.d.ts

@@ -0,0 +1,7 @@
+export * from './config/stacked-area-builder';
+export * from './config/stacked-area-config';
+export * from './config/stacked-area-options';
+export * from './events/actions/stacked-area-hover-move-actions';
+export * from './events/stacked-area-events.directive';
+export * from './stacked-area.component';
+export * from './stacked-area.module';

package/lib/stacked-area/stacked-area.component.d.ts

@@ -0,0 +1,51 @@
+import { ElementRef, InjectionToken } from '@angular/core';
+import { Selection } from 'd3';
+import { BehaviorSubject } from 'rxjs';
+import { XyChartScales } from '../charts';
+import { GenericScale } from '../core';
+import { DataValue } from '../core/types/values';
+import { VicXyPrimaryMarks } from '../marks/xy-marks/xy-primary-marks/xy-primary-marks';
+import { StackedAreaConfig, StackedAreaDatum } from './config/stacked-area-config';
+import { StackedAreaInteractionAnchor } from './events/stacked-area-interaction-output';
+import * as i0 from "@angular/core";
+export declare const STACKED_AREA: InjectionToken<StackedAreaComponent<unknown, DataValue>>;
+export interface StackedAreaTooltipDatum<Datum, TCategoricalValue extends DataValue> {
+    datum: Datum;
+    color: string;
+    values: {
+        x: string;
+        y: string;
+        color: TCategoricalValue;
+    };
+}
+type StackedAreaSvgElements = 'area';
+export type StackedAreaSelection<CategoricalDomain> = Selection<SVGPathElement, StackedAreaDatum<CategoricalDomain>, SVGGElement, unknown>;
+export declare class StackedAreaComponent<Datum, TCategoricalValue extends DataValue> extends VicXyPrimaryMarks<Datum, StackedAreaConfig<Datum, TCategoricalValue>> {
+    area: any;
+    areas: any;
+    stackedAreas: BehaviorSubject<StackedAreaSelection<TCategoricalValue>>;
+    stackedAreas$: import("rxjs").Observable<StackedAreaSelection<TCategoricalValue>>;
+    scales: {
+        color: GenericScale<any, any>;
+    } & XyChartScales;
+    protected elRef: ElementRef<SVGSVGElement>;
+    private zone;
+    get class(): Record<StackedAreaSvgElements, string>;
+    setChartScalesFromRanges(useTransition: boolean): void;
+    drawMarks(): void;
+    setArea(): void;
+    drawAreas(transitionDuration: number): void;
+    getTooltipData(closestXIndicies: number[], categoryYMin: number, categoryYMax: number, categoryIndex: number): {
+        anchor: StackedAreaInteractionAnchor;
+        data: StackedAreaTooltipDatum<Datum, TCategoricalValue>[];
+        hoveredAreaDatum: StackedAreaTooltipDatum<Datum, TCategoricalValue>;
+        origin: SVGGraphicsElement;
+    };
+    private getDatumFromIndex;
+    private getXyDimensionValue;
+    private sortTooltipDataByCategoricalSortOrder;
+    updateStackedAreaElements(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StackedAreaComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StackedAreaComponent<any, any>, "[vic-primary-marks-stacked-area]", never, {}, {}, never, never, true, never>;
+}
+export {};

package/lib/stacked-area/stacked-area.module.d.ts

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

package/lib/stacked-bars/config/stacked-bars-builder.d.ts

@@ -0,0 +1,26 @@
+import { Series } from 'd3';
+import { VicBarsConfigBuilder } from '../../bars/config/bars-builder';
+import { DataValue } from '../../core/types/values';
+import { StackedBarsConfig } from './stacked-bars-config';
+import * as i0 from "@angular/core";
+/**
+ * Builds a configuration object for a StackedBarsComponent.
+ *
+ * Must be added to a providers array in or above the component that consumes it if it is injected via the constructor. (e.g. `providers: [VicStackedBarsBuilder]` in the component decorator)
+ *
+ * The first generic parameter, Datum, is the type of the data that will be used to create the stacked bars.
+ *
+ * The second generic parameter, TOrdinalValue, is the type of the ordinal data that will be used to position the bars.
+ */
+export declare class VicStackedBarsConfigBuilder<Datum, TOrdinalValue extends DataValue> extends VicBarsConfigBuilder<Datum, TOrdinalValue> {
+    private _stackOffset;
+    private _stackOrder;
+    constructor();
+    stackOffset(stackOffset: null): this;
+    stackOffset(stackOffset: (series: Series<any, any>, order: Iterable<number>) => void): this;
+    stackOrder(stackOrder: null): this;
+    stackOrder(stackOrder: ((series: Series<Datum, TOrdinalValue>) => Iterable<number>) | null): this;
+    getConfig(): StackedBarsConfig<Datum, TOrdinalValue>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VicStackedBarsConfigBuilder<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VicStackedBarsConfigBuilder<any, any>>;
+}

package/lib/stacked-bars/config/stacked-bars-config.d.ts

@@ -0,0 +1,16 @@
+import { Series } from 'd3';
+import { BarsConfig } from '../../bars/config/bars-config';
+import { BarsDimensions } from '../../bars/config/bars-dimensions';
+import { DataValue } from '../../core/types/values';
+import { StackDatum } from '../stacked-bars.component';
+import { StackedBarsOptions } from './stacked-bars-options';
+export declare class StackedBarsConfig<Datum, TOrdinalValue extends DataValue> extends BarsConfig<Datum, TOrdinalValue> implements StackedBarsOptions<Datum, TOrdinalValue> {
+    stackOffset: (series: Series<any, any>, order: Iterable<number>) => void;
+    stackOrder: (x: any) => any;
+    stackedData: StackDatum[][];
+    constructor(dimensions: BarsDimensions, options: StackedBarsOptions<Datum, TOrdinalValue>);
+    initPropertiesFromData(): void;
+    setValueIndices(): void;
+    constructStackedData(): void;
+    initQuantitativeDomainFromStack(): void;
+}

package/lib/stacked-bars/config/stacked-bars-options.d.ts

@@ -0,0 +1,7 @@
+import { Series } from 'd3';
+import { BarsOptions } from '../../bars/config/bars-options';
+import { DataValue } from '../../core/types/values';
+export interface StackedBarsOptions<Datum, TOrdinalValue extends DataValue> extends BarsOptions<Datum, TOrdinalValue> {
+    stackOffset: (series: Series<any, any>, order: Iterable<number>) => void;
+    stackOrder: (x: any) => any;
+}

package/lib/stacked-bars/events/actions/stacked-bars-click-actions.d.ts

@@ -0,0 +1,8 @@
+import { BarsInteractionOutput } from '../../../bars';
+import { DataValue } from '../../../core/types/values';
+import { EventAction } from '../../../events';
+import { StackedBarsHost } from '../stacked-bars-events.directive';
+export declare class StackedBarsClickEmitTooltipDataPauseOtherActions<Datum, TOrdinalValue extends DataValue> implements EventAction<StackedBarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>> {
+    onStart(host: StackedBarsHost<Datum, TOrdinalValue>): void;
+    onEnd(host: StackedBarsHost<Datum, TOrdinalValue>): void;
+}

package/lib/stacked-bars/events/actions/stacked-bars-hover-actions.d.ts

@@ -0,0 +1,8 @@
+import { BarsInteractionOutput } from '../../../bars';
+import { DataValue } from '../../../core/types/values';
+import { EventAction } from '../../../events';
+import { StackedBarsHost } from '../stacked-bars-events.directive';
+export declare class StackedBarsHoverEmitTooltipData<Datum, TOrdinalValue extends DataValue> implements EventAction<StackedBarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>> {
+    onStart(host: StackedBarsHost<Datum, TOrdinalValue>): void;
+    onEnd(host: StackedBarsHost<Datum, TOrdinalValue>): void;
+}

package/lib/stacked-bars/events/actions/stacked-bars-hover-move-actions.d.ts

@@ -0,0 +1,8 @@
+import { BarsInteractionOutput } from '../../../bars';
+import { DataValue } from '../../../core/types/values';
+import { HoverMoveAction } from '../../../events';
+import { StackedBarsHost } from '../stacked-bars-events.directive';
+export declare class StackedBarsHoverMoveEmitTooltipData<Datum, TOrdinalValue extends DataValue> implements HoverMoveAction<StackedBarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>> {
+    onStart(host: StackedBarsHost<Datum, TOrdinalValue>): void;
+    onEnd(host: StackedBarsHost<Datum, TOrdinalValue>): void;
+}

package/lib/stacked-bars/events/stacked-bars-events.directive.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter } from '@angular/core';
+import { Observable } from 'rxjs';
+import { BarsInteractionOutput } from '../../bars';
+import { DataValue } from '../../core/types/values';
+import { EventAction, EventsDirective, EventType, HoverMoveAction, InputEventAction, MarksHost, UnlistenFunction } from '../../events';
+import { StackDatum, StackedBarsComponent } from '../stacked-bars.component';
+import * as i0 from "@angular/core";
+export interface StackedBarsHost<Datum, TOrdinalValue extends DataValue, TStackedBarsComponent extends StackedBarsComponent<Datum, TOrdinalValue> = StackedBarsComponent<Datum, TOrdinalValue>> extends MarksHost<BarsInteractionOutput<Datum>, TStackedBarsComponent> {
+    getStackDatum(): StackDatum | null;
+}
+export declare class StackedBarsEventsDirective<Datum, TOrdinalValue extends DataValue, TStackedBarsComponent extends StackedBarsComponent<Datum, TOrdinalValue> = StackedBarsComponent<Datum, TOrdinalValue>> extends EventsDirective<StackedBarsHost<Datum, TOrdinalValue>> {
+    stackedBars: TStackedBarsComponent;
+    hoverActions: EventAction<StackedBarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>>[] | null;
+    hoverMoveActions: HoverMoveAction<StackedBarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>>[] | null;
+    clickActions: EventAction<StackedBarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>>[] | null;
+    inputEventActions: InputEventAction<StackedBarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>>[];
+    interactionOutput: EventEmitter<BarsInteractionOutput<Datum>>;
+    stackDatum: StackDatum | null;
+    origin: SVGRectElement;
+    constructor(stackedBars: TStackedBarsComponent);
+    get marks(): TStackedBarsComponent;
+    getElements(): Observable<Element[]>;
+    getStackDatum(): StackDatum | 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;
+    setPositionsFromPointer(event: PointerEvent): void;
+    getInteractionOutput(type: EventType): BarsInteractionOutput<Datum>;
+    emitInteractionOutput(output: BarsInteractionOutput<Datum> | null): void;
+    private resetDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StackedBarsEventsDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StackedBarsEventsDirective<any, any, any>, "[vicStackedBarsEvents]", 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/stacked-bars/index.d.ts

@@ -0,0 +1,10 @@
+export type { BarsInteractionOutput as StackedBarsInteractionOutput } from '../bars';
+export * from './config/stacked-bars-builder';
+export * from './config/stacked-bars-config';
+export * from './config/stacked-bars-options';
+export * from './events/actions/stacked-bars-click-actions';
+export * from './events/actions/stacked-bars-hover-actions';
+export * from './events/actions/stacked-bars-hover-move-actions';
+export * from './events/stacked-bars-events.directive';
+export * from './stacked-bars.component';
+export * from './stacked-bars.module';

package/lib/stacked-bars/stacked-bars.component.d.ts

@@ -0,0 +1,26 @@
+import { InjectionToken } from '@angular/core';
+import { BaseType, SeriesPoint } from 'd3';
+import { Selection } from 'd3-selection';
+import { BarsComponent } from '../bars/bars.component';
+import { DataValue } from '../core/types/values';
+import { StackedBarsConfig } from './config/stacked-bars-config';
+import * as i0 from "@angular/core";
+export type StackDatum = SeriesPoint<{
+    [key: string]: number;
+}> & {
+    i: number;
+};
+export type StackedBarGroupSelection = Selection<BaseType | SVGRectElement, StackDatum, SVGGElement | BaseType, StackDatum[]>;
+export declare const STACKED_BARS: InjectionToken<StackedBarsComponent<unknown, DataValue>>;
+export declare class StackedBarsComponent<Datum, TOrdinalValue extends DataValue> extends BarsComponent<Datum, TOrdinalValue> {
+    config: StackedBarsConfig<Datum, TOrdinalValue>;
+    stackedBarGroups: StackedBarGroupSelection;
+    drawBars(transitionDuration: number): void;
+    getStackElementX(datum: StackDatum): number;
+    getStackElementY(datum: StackDatum): number;
+    getStackElementWidth(datum: StackDatum): number;
+    getStackElementHeight(datum: StackDatum): number;
+    getSourceDatumFromStackedBarDatum(datum: StackDatum): Datum;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StackedBarsComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StackedBarsComponent<any, any>, "[vic-primary-marks-stacked-bars]", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/stacked-bars/stacked-bars.module.d.ts

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

package/lib/stroke/base/stroke-base-options.d.ts

@@ -0,0 +1,7 @@
+export interface StrokeBaseOptions {
+    linecap: string;
+    linejoin: string;
+    opacity: number;
+    width: number;
+    dasharray: string;
+}

package/lib/stroke/base/stroke-base.d.ts

@@ -0,0 +1,8 @@
+import { StrokeBaseOptions } from './stroke-base-options';
+export declare abstract class StrokeBase implements StrokeBaseOptions {
+    readonly linecap: string;
+    readonly linejoin: string;
+    readonly opacity: number;
+    readonly width: number;
+    readonly dasharray: string;
+}

package/lib/stroke/index.d.ts

@@ -0,0 +1,2 @@
+export * from './stroke';
+export * from './stroke-options';

package/lib/stroke/stroke-builder.d.ts

@@ -0,0 +1,56 @@
+import { Stroke } from './stroke';
+export declare class StrokeBuilder {
+    private _color;
+    private _dasharray;
+    private _linecap;
+    private _linejoin;
+    private _opacity;
+    private _width;
+    constructor();
+    /**
+     * OPTIONAL. A value for the line's [stroke]{@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke}
+     *  attribute.
+     *
+     * @default '#000'
+     */
+    color(color: string): this;
+    /**
+     * OPTIONAL. A value for the line's [stroke-dasharray]{@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray}
+     *  attribute.
+     *
+     * @default 'round'
+     */
+    dasharray(dasharray: string): this;
+    /**
+     * OPTIONAL. A value for the line's [stroke-linecap]{@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap}
+     *  attribute.
+     *
+     * @default 'round'
+     */
+    linecap(linecap: string): this;
+    /**
+     * OPTIONAL. A value for the line's [stroke-linejoin]{@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin}
+     *  attribute.
+     *
+     * @default 'round'
+     */
+    linejoin(linejoin: string): this;
+    /**
+     * OPTIONAL. A value for the line's [stroke-opacity]{@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-opacity}
+     *  attribute.
+     *
+     * @default 1
+     */
+    opacity(opacity: number): this;
+    /**
+     * OPTIONAL. A value for the line's [stroke-width]{@link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-width}
+     *  attribute, in px.
+     *
+     * @default 2
+     */
+    width(width: number): this;
+    /**
+     * @internal This function is for internal use only and should never be called by the user.
+     */
+    _build(): Stroke;
+}

package/lib/stroke/stroke-options.d.ts

@@ -0,0 +1,4 @@
+import { StrokeBaseOptions } from './base/stroke-base-options';
+export interface StrokeOptions extends StrokeBaseOptions {
+    color: string;
+}

package/lib/stroke/stroke.d.ts

@@ -0,0 +1,6 @@
+import { StrokeBase } from './base/stroke-base';
+import { StrokeOptions } from './stroke-options';
+export declare class Stroke extends StrokeBase implements StrokeOptions {
+    readonly color: string;
+    constructor(options: Partial<StrokeOptions>);
+}

package/lib/svg-text-wrap/index.d.ts

@@ -0,0 +1,2 @@
+export * from './svg-text-wrap';
+export * from './svg-text-wrap-options';