@mathstack/viz 0.0.1-beta.0

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

@@ -0,0 +1,48 @@
+import { BarsLabels } from './bars-labels';
+export declare class BarsLabelsBuilder<Datum> {
+    private _color;
+    private _display;
+    private _noValueFunction;
+    private _offset;
+    constructor();
+    /**
+     *
+     * Sets colors for the labels.
+     *
+     * The default label color is used for a label positioned outside of a bar. Additionally, if its contrast ratio with the bar color is higher than that of the withinBarAlternative color, it is used for a label positioned within a bar. Otherwise the withinBarAlternative color is used.
+     *
+     * @default { default: '#000000', withinBarAlternative: '#ffffff' }
+     */
+    color(color: {
+        default: string;
+        withinBarAlternative: string;
+    }): this;
+    /**
+     * Sets whether labels are displayed or not. Labels will be created but not displayed if this is set to false.
+     *
+     * A user may want to set this to false if they want labels to display on hover, for example.
+     *
+     * @default true
+     */
+    display(display: boolean): this;
+    /**
+     * Sets the function to set the text of the label when the value of the bar is null or undefined.
+     *
+     * If called with null, the default function is used.
+     *
+     * @default (d: Datum) => 'N/A'
+     */
+    noValueFunction(noValueFunction: null): this;
+    noValueFunction(noValueFunction: (d: Datum) => string): this;
+    /**
+     * Sets the distance between the label and the end of the bar.
+     *
+     * @default 4
+     */
+    offset(offset: number): this;
+    /**
+     * @internal
+     * This function is for internal use only and should never be called by the user.
+     */
+    _build(): BarsLabels<Datum>;
+}

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

@@ -0,0 +1,9 @@
+export interface BarsLabelsOptions<Datum> {
+    color: {
+        default: string;
+        withinBarAlternative: string;
+    };
+    display: boolean;
+    noValueFunction: (d: Datum) => string;
+    offset: number;
+}

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

@@ -0,0 +1,11 @@
+import { BarsLabelsOptions } from './bars-labels-options';
+export declare class BarsLabels<Datum> implements BarsLabelsOptions<Datum> {
+    color: {
+        default: string;
+        withinBarAlternative: string;
+    };
+    display: boolean;
+    noValueFunction: (d: Datum) => string;
+    offset: number;
+    constructor(options: BarsLabels<Datum>);
+}

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

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

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

@@ -0,0 +1,12 @@
+import { DataValue } from '../../../core/types/values';
+import { EventAction } from '../../../events';
+import { BarsHost } from '../bars-events.directive';
+import { BarsInteractionOutput } from '../bars-interaction-output';
+export declare class BarsHoverShowLabels<Datum, TOrdinalValue extends DataValue> implements EventAction<BarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>> {
+    onStart(host: BarsHost<Datum, TOrdinalValue>): void;
+    onEnd(host: BarsHost<Datum, TOrdinalValue>): void;
+}
+export declare class BarsHoverEmitTooltipData<Datum, TOrdinalValue extends DataValue> implements EventAction<BarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>> {
+    onStart(host: BarsHost<Datum, TOrdinalValue>): void;
+    onEnd(host: BarsHost<Datum, TOrdinalValue>): void;
+}

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

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

package/lib/bars/events/bars-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, EventsDirective, EventType, HoverMoveAction, InputEventAction, MarksHost, UnlistenFunction } from '../../events';
+import { BarDatum, BarsComponent } from '../bars.component';
+import { BarsInteractionOutput } from './bars-interaction-output';
+import * as i0 from "@angular/core";
+export interface BarsHost<Datum, TOrdinalValue extends DataValue, TBarsComponent extends BarsComponent<Datum, TOrdinalValue> = BarsComponent<Datum, TOrdinalValue>> extends MarksHost<BarsInteractionOutput<Datum>, TBarsComponent> {
+    getBarDatum(): BarDatum<TOrdinalValue> | null;
+}
+export declare class BarsEventsDirective<Datum, TOrdinalValue extends DataValue, TBarsComponent extends BarsComponent<Datum, TOrdinalValue> = BarsComponent<Datum, TOrdinalValue>> extends EventsDirective<BarsHost<Datum, TOrdinalValue>> implements BarsHost<Datum, TOrdinalValue, TBarsComponent> {
+    bars: TBarsComponent;
+    hoverActions: EventAction<BarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>>[] | null;
+    hoverMoveActions: HoverMoveAction<BarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>>[] | null;
+    clickActions: EventAction<BarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>>[] | null;
+    inputEventActions: InputEventAction<BarsHost<Datum, TOrdinalValue>, BarsInteractionOutput<Datum>>[];
+    interactionOutput: EventEmitter<BarsInteractionOutput<Datum>>;
+    barDatum: BarDatum<TOrdinalValue>;
+    origin: SVGRectElement;
+    constructor(bars: TBarsComponent);
+    get marks(): TBarsComponent;
+    getElements(): Observable<Element[]>;
+    getBarDatum(): BarDatum<TOrdinalValue> | 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): BarsInteractionOutput<Datum>;
+    emitInteractionOutput(output: BarsInteractionOutput<Datum> | null): void;
+    private resetDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BarsEventsDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BarsEventsDirective<any, any, any>, "[vicBarsEvents]", 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/bars/events/bars-interaction-output.d.ts

@@ -0,0 +1,16 @@
+import { InteractionOutput } from '../../events/interaction-output';
+import { HtmlTooltipCdkManagedPosition } from '../../tooltips';
+import { BarsTooltipDatum } from '../bars.component';
+export interface BarsInteractionOutput<Datum> extends BarsTooltipDatum<Datum>, InteractionOutput {
+    /**
+     * 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: (offset?: Partial<{
+        x: number;
+        y: number;
+    }>) => HtmlTooltipCdkManagedPosition;
+}

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

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

package/lib/bars/index.d.ts

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

package/lib/charts/chart/chart.component.d.ts

@@ -0,0 +1,73 @@
+import { DestroyRef, ElementRef, NgZone, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ElementSpacing } from '../../core/types/layout';
+import { Chart } from './chart';
+import { ScalingStrategy } from './config/chart-builder';
+import { ChartConfig } from './config/chart-config';
+import * as i0 from "@angular/core";
+export interface Ranges {
+    x: [number, number];
+    y: [number, number];
+}
+export interface ChartResizing {
+    width: boolean;
+    height: boolean;
+    useViewbox: boolean;
+}
+export interface ReactiveConfig {
+    margin: ElementSpacing;
+    height: number;
+    width: number;
+    scalingStrategy: ScalingStrategy;
+}
+/**
+ * A base component that can be extended to create specific types of `Chart` components,
+ *  each of which can serve as a wrapper component for one `PrimaryMarks` component and any
+ *  other content that is projected into its content projection slots.
+ *
+ * <p class="comment-slots">Content projection slots</p>
+ *
+ * `html-elements-before`: Elements that will be projected before the chart's scaled div
+ *  and scaled svg element in the DOM. USeful for adding elements that require access to chart scales.
+ *
+ * `svg-defs`: Used to create any required defs for the chart's svg element. For example, patterns or gradients.
+ *
+ * `svg-elements`: Used for all elements that should be children of the chart's scaled svg element.
+ *
+ * `html-elements-after`: Elements that will be projected after the chart's scaled div
+ *  and scaled svg element in the DOM. USeful for adding elements that require access to chart scales.
+ */
+export declare class ChartComponent implements Chart, OnInit, OnChanges {
+    private ngZone;
+    config: ChartConfig;
+    divRef: ElementRef<HTMLDivElement>;
+    svgRef: ElementRef<SVGSVGElement>;
+    private _config;
+    config$: Observable<ChartConfig>;
+    protected readonly strategy$: Observable<ScalingStrategy>;
+    protected readonly widthCfg$: Observable<number>;
+    protected readonly minWidthCfg$: Observable<number>;
+    protected readonly heightCfg$: Observable<number>;
+    private readonly aspectRatioCfg$;
+    private readonly isFixedHeight$;
+    protected readonly marginCfg$: Observable<ElementSpacing>;
+    private readonly width$;
+    private readonly height$;
+    protected readonly svgDimensions$: Observable<{
+        width: number;
+        height: number;
+    }>;
+    readonly ranges$: Observable<Ranges>;
+    protected destroyRef: DestroyRef;
+    constructor(ngZone: NgZone);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    private observeElementWidth;
+    private getRangesFromSvgDimensions;
+    getViewBoxScale(): {
+        x: number;
+        y: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChartComponent, "vic-chart", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, ["[html-elements-before]", "[svg-defs]", "[svg-elements]", "[html-elements-after]"], true, never>;
+}

package/lib/charts/chart/chart.d.ts

@@ -0,0 +1,4 @@
+import { ElementRef } from '@angular/core';
+export declare class Chart {
+    svgRef: ElementRef<SVGSVGElement>;
+}

package/lib/charts/chart/chart.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { Chart } from './chart';
+export declare const CHART: InjectionToken<Chart>;

package/lib/charts/chart/config/chart-builder.d.ts

@@ -0,0 +1,94 @@
+import { ChartConfig } from './chart-config';
+import * as i0 from "@angular/core";
+export type ScalingStrategy = 'fixed' | 'responsive-width' | 'viewbox';
+export declare const CHART_SIZE: {
+    scaledWidth: number;
+    viewBoxWidth: number;
+    minWidth: number;
+    aspectRatio: number;
+};
+/**
+ * Builds a configuration object for a ChartComponent.
+ *
+ * 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: [VicChartConfigBuilder]` in the component decorator)
+ *
+ */
+export declare class VicChartConfigBuilder {
+    private _aspectRatio?;
+    private _fixedHeight;
+    private _height;
+    private _margin;
+    private _minWidth;
+    private _scalingStrategy;
+    private _transitionDuration;
+    private _width;
+    constructor();
+    /**
+     * OPTIONAL. Explicitly sets the aspect ratio to use when scalingStrategy is 'responsive-width' and fixedHeight is false, or when scalingStrategy is 'viewbox'.
+     *
+     * @param value - The aspect ratio (width / height) to use. If not called or called with null, a default value of 16/9 will be used. If maxWidth and maxHeight are set, aspect ratio will be derived from those values.
+     */
+    aspectRatio(value: number): this;
+    /**
+     * OPTIONAL. If set to true and used with 'responsive-width' scaling strategy, height will be fixed and not derived from aspect ratio.
+     *
+     * Has no effect if scaling strategy is 'fixed' or 'viewbox'.
+     */
+    fixedHeight(value: boolean): this;
+    /**
+     * OPTIONAL. Determines the margin that will be established between the edges of the svg and the svg's contents, in px.
+     *
+     * @param value - The margin that will be established between the edges of the svg and the svg's contents, in px. If called with null, a default value of `{ top: 36, right: 36, bottom: 36, left: 36 }` will be used.
+     */
+    margin(value: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    } | null): this;
+    /**
+     * OPTIONAL. If scaling strategy is 'responsive-width' or 'viewbox', determines the maximum height of the chart. This will override any provided aspect ratio.
+     *
+     * If scaling strategy is 'fixed', sets the fixed height of the chart.
+     *
+     * @param value - The maximum height of the chart, in px. If chart size is static, the fixed height of the chart. If not called or called with `null`, chart height will be set via aspect ratio.
+     */
+    maxHeight(value: number | null): this;
+    /**
+     * OPTIONAL. If scaling strategy is responsive-width or viewbox, sets the maximum width of the chart. In this case, this value is also used to determine the aspect ratio of the chart which will be maintained on resizing.
+     *
+     * If scaling strategy is fixed, sets the fixed width of the chart.
+     *
+     * @param value - The maximum width of the chart, in px. If chart size is static, the fixed width of the chart.
+     *
+     * If not called or called with `null`, a default value of 800 will be used.
+     */
+    maxWidth(value: number | null): this;
+    /**
+     * OPTIONAL. If scaling strategy is responsive-width or viewbox, sets the minimum width of the chart. Has no effect if scaling strategy is fixed.
+     *
+     * @param value - The minimum width of the chart, in px. If not called or called with `null`, a default value of 320 will be used.
+     */
+    minWidth(value: number | null): this;
+    /**
+     * OPTIONAL. Determines how the chart scales in response to container or window size changes.
+     *
+     * Default value, if not called, is 'responsive-width'.
+     *
+     * @param value - One of:
+     * - 'fixed': Chart dimensions remain constant. Width and height are fixed. Dimensions can be set with maxWidth and maxHeight.
+     * - 'responsive-width': Chart width responds to container; height is derived via aspect ratio, unless fixedHeight is true.
+     * - 'viewbox': Chart is scaled entirely via SVG viewBox. All resizing behavior is controlled through CSS.
+     */
+    scalingStrategy(value: ScalingStrategy): this;
+    /**
+     * OPTIONAL. A time duration for all transitions in the chart, in ms.
+     *
+     * @@param value - The time duration for all transitions in the chart, in ms. If not called or called with null, a default value of 250 will be used.
+     */
+    transitionDuration(value: number | null): this;
+    getConfig(): ChartConfig;
+    private validateBuilder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VicChartConfigBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VicChartConfigBuilder>;
+}

package/lib/charts/chart/config/chart-config.d.ts

@@ -0,0 +1,16 @@
+import { ElementSpacing } from '../../../core/types/layout';
+import { ScalingStrategy } from './chart-builder';
+import { ChartOptions } from './chart-options';
+export declare class ChartConfig implements ChartOptions {
+    aspectRatio?: number;
+    height: number | null;
+    isFixedHeight: boolean;
+    margin: ElementSpacing;
+    minWidth: number | null;
+    scalingStrategy: ScalingStrategy;
+    transitionDuration: number;
+    width: number | null;
+    viewBoxX: number;
+    viewBoxY: number;
+    constructor(config: ChartConfig);
+}

package/lib/charts/chart/config/chart-options.d.ts

@@ -0,0 +1,10 @@
+import { ElementSpacing } from '../../../core/types/layout';
+import { ScalingStrategy } from './chart-builder';
+export interface ChartOptions {
+    aspectRatio?: number;
+    height: number;
+    margin: ElementSpacing;
+    scalingStrategy: ScalingStrategy;
+    transitionDuration: number;
+    width: number;
+}

package/lib/charts/chart.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./chart/chart.component";
+import * as i2 from "./xy-chart/xy-chart.component";
+import * as i3 from "./map-chart/map-chart.component";
+export declare class VicChartModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VicChartModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VicChartModule, never, [typeof i1.ChartComponent, typeof i2.XyChartComponent, typeof i3.MapChartComponent], [typeof i1.ChartComponent, typeof i2.XyChartComponent, typeof i3.MapChartComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VicChartModule>;
+}

package/lib/charts/index.d.ts

@@ -0,0 +1,8 @@
+export * from './chart.module';
+export * from './chart/chart';
+export * from './chart/chart.component';
+export * from './chart/chart.token';
+export * from './chart/config/chart-builder';
+export * from './chart/config/chart-config';
+export * from './map-chart/map-chart.component';
+export * from './xy-chart/xy-chart.component';

package/lib/charts/map-chart/map-chart.component.d.ts

@@ -0,0 +1,40 @@
+import { NgZone } from '@angular/core';
+import { VicAttributeDataDimensionConfig } from '../../geographies/config/layers/attribute-data-layer/dimensions/attribute-data-bin-types';
+import { Chart } from '../chart/chart';
+import { ChartComponent } from '../chart/chart.component';
+import * as i0 from "@angular/core";
+/**
+ * A `Chart` component to be used with a `Geographies` `PrimaryMarks` component.
+ *
+ * This component adds an attribute data scale and config to the base `ChartComponent` that can
+ *  be used by any components projected into the chart.
+ *
+ * Components that may use these scales include the `Geographies` component
+ *  and the `MapLegend` component.
+ *
+ * <p class="comment-slots">Content projection slots</p>
+ *
+ * `html-elements-before`: Elements that will be projected before the chart's scaled div
+ *  and scaled svg element in the DOM. USeful for adding elements that require access to chart scales.
+ *
+ * `svg-defs`: Used to create any required defs for the chart's svg element. For example, patterns or gradients.
+ *
+ * `svg-elements`: Used for all elements that should be children of the chart's scaled svg element.
+ *
+ * `html-elements-after`: Elements that will be projected after the chart's scaled div
+ *  and scaled svg element in the DOM. USeful for adding elements that require access to chart scales.
+ */
+export declare class MapChartComponent<Datum> extends ChartComponent implements Chart {
+    private attributeProperties;
+    attributeProperties$: import("rxjs").Observable<{
+        config: VicAttributeDataDimensionConfig<Datum>;
+        scale: any;
+    }>;
+    protected zone: NgZone;
+    updateAttributeProperties(properties: {
+        config: VicAttributeDataDimensionConfig<Datum>;
+        scale: any;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapChartComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapChartComponent<any>, "vic-map-chart", never, {}, {}, never, ["[html-elements-before]", "[svg-defs]", "[svg-elements]", "[html-elements-after]"], true, never>;
+}

package/lib/charts/xy-chart/xy-chart.component.d.ts

@@ -0,0 +1,40 @@
+import { NgZone, OnInit } from '@angular/core';
+import { GenericScale } from '../../core';
+import { Chart } from '../chart/chart';
+import { ChartComponent } from '../chart/chart.component';
+import * as i0 from "@angular/core";
+export declare enum XyContentScale {
+    x = "x",
+    y = "y"
+}
+export interface XyChartScales {
+    [XyContentScale.x]: GenericScale<any, any>;
+    [XyContentScale.y]: GenericScale<any, any>;
+    useTransition: boolean;
+}
+/**
+ * A `Chart` component to be used with `PrimaryMarks` components that have X and Y axes, such as `Bars` and `Lines`.
+ *
+ * This component adds x, y, and categorical scales to the base `ChartComponent` that can
+ *  be used by any components projected into the chart.
+ *
+ * <p class="comment-slots">Content projection slots</p>
+ *
+ * `html-elements-before`: Elements that will be projected before the chart's scaled div
+ *  and scaled svg element in the DOM. USeful for adding elements that require access to chart scales.
+ *
+ * `svg-defs`: Used to create any required defs for the chart's svg element. For example, patterns or gradients.
+ *
+ * `svg-elements`: Used for all elements that should be children of the chart's scaled svg element.
+ *
+ * `html-elements-after`: Elements that will be projected after the chart's scaled div
+ *  and scaled svg element in the DOM. USeful for adding elements that require access to chart scales.
+ */
+export declare class XyChartComponent extends ChartComponent implements Chart, OnInit {
+    private scales;
+    scales$: import("rxjs").Observable<XyChartScales>;
+    protected zone: NgZone;
+    updateScales(scales: Partial<XyChartScales>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<XyChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<XyChartComponent, "vic-xy-chart", never, {}, {}, never, ["[html-elements-before]", "[svg-defs]", "[svg-elements]", "[html-elements-after]"], true, never>;
+}

package/lib/core/common-behaviors/constructor.d.ts

@@ -0,0 +1,2 @@
+export type Constructor<T = object> = new (...args: any[]) => T;
+export type AbstractConstructor<T = object> = abstract new (...args: any[]) => T;

package/lib/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types/layout';
+export * from './types/scale';
+export * from './types/values';
+export * from './utilities/colors';
+export * from './utilities/value-format';

package/lib/core/types/layout.d.ts

@@ -0,0 +1,24 @@
+export declare enum Orientation {
+    horizontal = "horizontal",
+    vertical = "vertical"
+}
+export declare enum Side {
+    top = "top",
+    right = "right",
+    bottom = "bottom",
+    left = "left"
+}
+export interface ElementSpacing {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface Dimensions {
+    width: number;
+    height: number;
+}
+export interface Position {
+    x: number;
+    y: number;
+}

package/lib/core/types/scale.d.ts

@@ -0,0 +1,5 @@
+export interface GenericScale<Domain, Range> {
+    (...args: any): Range;
+    domain?(): [Domain, Domain];
+    range?(): [Range, Range];
+}

package/lib/core/types/values.d.ts

@@ -0,0 +1,7 @@
+export declare enum ValueExtent {
+    max = "max",
+    min = "min"
+}
+export type ContinuousValue = number | Date;
+export type DataValue = number | string | Date;
+export type VisualValue = number | string;

package/lib/core/utilities/colors.d.ts

@@ -0,0 +1,13 @@
+import * as CSSType from 'csstype';
+export declare class ColorUtilities {
+    static getContrastRatio(foreground: string, background: string): number;
+    static getLuminance(color: string): number;
+    static sRGBToLinear(value: number): number;
+    /**
+     * @param backgroundColor string, provided by getFill
+     * @param darkColor
+     * @param lightColor
+     * @returns label fill color (either dark or light color)
+     */
+    static getHigherContrastColorForBackground(backgroundColor: string, darkColor: CSSType.Property.Fill, lightColor: CSSType.Property.Fill): CSSType.Property.Fill;
+}

package/lib/core/utilities/fill-utilities.d.ts

@@ -0,0 +1,7 @@
+import { FillDefinition } from '../../fill-definitions/fill-definitions';
+/**
+ * @internal
+ */
+export declare class FillUtilities {
+    static getFill<Datum>(datum: Datum, defaultColor: string, patterns: FillDefinition<Datum>[]): string;
+}

package/lib/core/utilities/type-guards.d.ts

@@ -0,0 +1,6 @@
+export declare function isNumber(x: unknown): x is number;
+export declare function isNumberArray(x: unknown[]): x is number[];
+export declare function isDate(x: unknown): x is Date;
+export declare function isFunction<T, U = unknown>(x: unknown): x is (...args: U[]) => T;
+export declare function isPrimitiveType<T>(x: unknown): x is T;
+export declare function isObject<T>(x: unknown): x is T;

package/lib/core/utilities/value-format.d.ts

@@ -0,0 +1,11 @@
+export interface VicValueFormats {
+    integer: string;
+    integerNoComma: string;
+    percent: (digits: number) => string;
+    decimal: (digits: number) => string;
+    decimalNoComma: (digits: number) => string;
+    fullYear: string;
+    monthYear: string;
+    monthFullYear: string;
+}
+export declare const valueFormat: VicValueFormats;

package/lib/core/utilities/values.d.ts

@@ -0,0 +1,16 @@
+import { ValueExtent } from '../types/values';
+export type VicFormatSpecifier<Datum> = string | ((x: Datum) => string);
+/**
+ * @internal
+ */
+export declare class ValueUtilities {
+    static getValueRoundedToNSignificantFigures(value: number, sigFigures: number, valueExtent: keyof typeof ValueExtent): number;
+    private static validateSigFigures;
+    private static getRoundedDecimalLessThanOne;
+    private static getNewValueForNine;
+    private static getRoundingOffset;
+    static getValueRoundedToInterval(value: number, interval: number, valueExtent: keyof typeof ValueExtent): number;
+    static d3Format(value: Date | number, formatter: string): string;
+    static customFormat<Datum>(value: Datum, formatter: (x: Datum) => string): string;
+    static formatForHtmlAttribute(value: string): string;
+}