@mathstack/viz 0.0.1-beta.0

package/lib/geographies/config/layers/geographies-layer/geographies-layer-builder.d.ts

@@ -0,0 +1,52 @@
+import { Geometry } from 'geojson';
+import { StrokeBuilder } from '../../../../stroke/stroke-builder';
+import { GeographiesFeature } from '../../../geographies-feature';
+import { GeographiesLabelsBuilder } from '../labels/geographies-labels-builder';
+export declare abstract class GeographiesLayerBuilder<TProperties, TGeometry extends Geometry> {
+    protected _class: (d: TProperties) => string;
+    protected _enableEventActions: boolean;
+    protected _geographies: Array<GeographiesFeature<TProperties, TGeometry>>;
+    protected labelsBuilder: GeographiesLabelsBuilder<TProperties, TGeometry>;
+    protected _mixBlendMode: string;
+    protected strokeBuilder: StrokeBuilder;
+    constructor();
+    /**
+     * OPTIONAL. Provides a class on the SVG element that correspends to a single datum. If a datum creates multiple SVG elements -- for example, a rect and a label, the class will be applied on the parent SVGGElement.
+     *
+     * IF the chart does not have SVG elements that correspond to a single datum, this class will be placed on the SVG element that represents a collection of data, for example, a area in a stacked area chart, or a line in a line chart. In this case the datum passed to the callback function will be the first datum in the collection.
+     *
+     * Note that if the resultant string has spaces in the name, multiple classes will be applied. For example, if the class is 'North Carolina', the element will have the classes 'North' and 'Carolina'.
+     */
+    class(value: null): this;
+    class(value: string): this;
+    class(value: (d: TProperties) => string): this;
+    /**
+     * OPTIONAL. Determines whether the layer can use viz event actions.
+     *
+     * If true, the event listener that corresponds to the provided directive will be placed on that layer's paths.
+     *
+     * @default true for Attribute Data layer
+     * @default false for Geojson Properties layers
+     */
+    enableEventActions(value: boolean): this;
+    /**
+     * REQUIRED. GeoJSON features that define the geographies to be drawn.
+     */
+    geographies(value: Array<GeographiesFeature<TProperties, TGeometry>>): this;
+    /**
+     * OPTIONAL. Creates a configuration object for labels that will be drawn on the geographies.
+     */
+    labels(labels: null): this;
+    labels(labels: (labels: GeographiesLabelsBuilder<TProperties, TGeometry>) => void): this;
+    /**
+     * Sets the mix-blend-mode of the marks.
+     *
+     * @default 'normal'
+     */
+    mixBlendMode(mixBlendMode: string): this;
+    /**
+     * OPTIONAL. Sets the appearance of the stroke for the geographies in the layer.
+     */
+    stroke(setProperties?: (stroke: StrokeBuilder) => void): this;
+    protected initStrokeBuilder(): void;
+}

package/lib/geographies/config/layers/geographies-layer/geographies-layer-options.d.ts

@@ -0,0 +1,16 @@
+import { Geometry } from 'geojson';
+import { Stroke } from '../../../../stroke/stroke';
+import { GeographiesFeature } from '../../../geographies-feature';
+import { GeographiesLabels } from '../labels/geographies-labels';
+/**
+ * Base configuration object for geographies that can be used with or without attribute data.
+ *
+ * The generic parameters are the same as those in VicGeographiesConfig.
+ */
+export interface GeographiesLayerOptions<TProperties, TGeometry extends Geometry> {
+    enableEventActions: boolean;
+    featureClass: (d: TProperties) => string;
+    labels: GeographiesLabels<TProperties, TGeometry>;
+    geographies: Array<GeographiesFeature<TProperties, TGeometry>>;
+    stroke: Stroke;
+}

package/lib/geographies/config/layers/geographies-layer/geographies-layer.d.ts

@@ -0,0 +1,29 @@
+import * as CSSType from 'csstype';
+import { Geometry } from 'geojson';
+import { Stroke } from '../../../../stroke/stroke';
+import { GeographiesFeature } from '../../../geographies-feature';
+import { GeographiesLabels } from '../labels/geographies-labels';
+import { GeographiesLabelsColorOptions, GeographiesLabelsFontWeightOptions } from '../labels/geographies-labels-options';
+import { GeographiesLayerOptions } from './geographies-layer-options';
+export interface GeographiesTooltipDatum<Datum> {
+    attributeValue?: string;
+    color: string;
+    datum?: Datum;
+    geography: string;
+}
+export declare abstract class GeographiesLayer<Datum, TProperties, TGeometry extends Geometry> implements GeographiesLayerOptions<TProperties, TGeometry> {
+    enableEventActions: boolean;
+    featureClass: (d: TProperties) => string;
+    featureIndexAccessor: (d: GeographiesFeature<TProperties, TGeometry>) => string;
+    geographies: Array<GeographiesFeature<TProperties, TGeometry>>;
+    id: number;
+    labels: GeographiesLabels<TProperties, TGeometry>;
+    stroke: Stroke;
+    setFeatureIndexAccessor(accessor: (d: GeographiesFeature<TProperties, TGeometry>) => string): void;
+    abstract getFill(feature: GeographiesFeature<TProperties, TGeometry>): string;
+    abstract getTooltipData(path: SVGPathElement): GeographiesTooltipDatum<Datum | undefined>;
+    getLabelColor(feature: GeographiesFeature<TProperties, TGeometry>): CSSType.Property.Fill;
+    getLabelFontWeight(feature: GeographiesFeature<TProperties, TGeometry>): CSSType.Property.FontWeight;
+    isContrastColorOptions(options: GeographiesLabelsColorOptions | CSSType.Property.Fill): options is GeographiesLabelsColorOptions;
+    isContrastFontWeightOptions(options: GeographiesLabelsFontWeightOptions | CSSType.Property.FontWeight): options is GeographiesLabelsFontWeightOptions;
+}

package/lib/geographies/config/layers/geojson-properties-layer/geojson-properties-layer-builder.d.ts

@@ -0,0 +1,25 @@
+import { Geometry, MultiPolygon, Polygon } from 'geojson';
+import { OrdinalVisualValueDimensionBuilder } from '../../../../data-dimensions/ordinal/ordinal-visual-value/ordinal-visual-value-builder';
+import { FillDefinition } from '../../../../fill-definitions/fill-definitions';
+import { GeographiesFeature } from '../../../geographies-feature';
+import { GeographiesLayerBuilder } from '../geographies-layer/geographies-layer-builder';
+import { GeographiesGeojsonPropertiesLayer } from './geojson-properties-layer';
+export declare class GeographiesGeojsonPropertiesLayerBuilder<TProperties, TGeometry extends Geometry = MultiPolygon | Polygon> extends GeographiesLayerBuilder<TProperties, TGeometry> {
+    private fillBuilder;
+    private _customFills;
+    constructor();
+    /**
+     * OPTIONAL: Set a fill color or function that yields a color for all geographies in the layer.
+     *
+     * If a string is provided, all geographies will be filled with that color.
+     *
+     * Otherwise, you can use this method to specify how each geography should be filled based on the properties of the geojson feature.
+     */
+    fill(fill: null): this;
+    fill(fill: string): this;
+    fill(fill: (fill: OrdinalVisualValueDimensionBuilder<GeographiesFeature<TProperties, TGeometry>, string, string>) => void): this;
+    customFills(customFills: FillDefinition<GeographiesFeature<TProperties, TGeometry>>[]): this;
+    private initFillBuilder;
+    _build(): GeographiesGeojsonPropertiesLayer<TProperties, TGeometry>;
+    validateBuilder(): void;
+}

package/lib/geographies/config/layers/geojson-properties-layer/geojson-properties-layer-options.d.ts

@@ -0,0 +1,11 @@
+import { Geometry, MultiPolygon, Polygon } from 'geojson';
+import { OrdinalVisualValueDimension } from '../../../../data-dimensions/ordinal/ordinal-visual-value/ordinal-visual-value';
+import { FillDefinition } from '../../../../fill-definitions/fill-definitions';
+import { GeographiesFeature } from '../../../geographies-feature';
+import { GeographiesLayerOptions } from '../geographies-layer/geographies-layer-options';
+export interface GeographiesGeojsonPropertiesLayerOptions<TProperties, TGeometry extends Geometry = MultiPolygon | Polygon> extends GeographiesLayerOptions<TProperties, TGeometry> {
+    customFills: FillDefinition<GeographiesFeature<TProperties, TGeometry>>[];
+    fill: OrdinalVisualValueDimension<GeographiesFeature<TProperties, TGeometry>, string, string>;
+    marksClass: string;
+    mixBlendMode: string;
+}

package/lib/geographies/config/layers/geojson-properties-layer/geojson-properties-layer.d.ts

@@ -0,0 +1,16 @@
+import { Geometry, MultiPolygon, Polygon } from 'geojson';
+import { OrdinalVisualValueDimension } from '../../../../data-dimensions/ordinal/ordinal-visual-value/ordinal-visual-value';
+import { FillDefinition } from '../../../../fill-definitions/fill-definitions';
+import { GeographiesFeature } from '../../../geographies-feature';
+import { GeographiesLayer, GeographiesTooltipDatum } from '../geographies-layer/geographies-layer';
+import { GeographiesGeojsonPropertiesLayerOptions } from './geojson-properties-layer-options';
+export declare class GeographiesGeojsonPropertiesLayer<TProperties, TGeometry extends Geometry = MultiPolygon | Polygon> extends GeographiesLayer<string, TProperties, TGeometry> implements GeographiesGeojsonPropertiesLayerOptions<TProperties, TGeometry> {
+    readonly customFills: FillDefinition<GeographiesFeature<TProperties, TGeometry>>[];
+    readonly fill: OrdinalVisualValueDimension<GeographiesFeature<TProperties, TGeometry>, string, string>;
+    readonly marksClass: string;
+    readonly mixBlendMode: string;
+    constructor(options: GeographiesGeojsonPropertiesLayerOptions<TProperties, TGeometry>);
+    private initPropertiesFromGeographies;
+    getFill(feature: GeographiesFeature<TProperties, TGeometry>): string;
+    getTooltipData(path: SVGPathElement): GeographiesTooltipDatum<undefined>;
+}

package/lib/geographies/config/layers/labels/geographies-labels-builder.d.ts

@@ -0,0 +1,97 @@
+import type * as CSSType from 'csstype';
+import { GeoPath, GeoProjection, ScaleLinear } from 'd3';
+import { Geometry, MultiPolygon, Polygon } from 'geojson';
+import { Position } from '../../../../core/types/layout';
+import { GeographiesFeature } from '../../../geographies-feature';
+import { GeographiesLabels } from './geographies-labels';
+import { GeographiesLabelsColorOptions, GeographiesLabelsFontWeightOptions } from './geographies-labels-options';
+export declare class GeographiesLabelsBuilder<TProperties, TGeometry extends Geometry = MultiPolygon | Polygon> {
+    private _alignmentBaseline;
+    private _color;
+    private _cursor;
+    private _display;
+    private _dominantBaseline;
+    private _fontWeight;
+    private _fontScale;
+    private _pointerEvents;
+    private _position;
+    private _textAnchor;
+    private _valueAccessor;
+    constructor();
+    /**
+     * OPTIONAL. The alignment of the baseline of the text relative to the text's font.
+     *
+     * @default 'middle'
+     */
+    alignmentBaseline(alignmentBaseline: CSSType.Property.AlignmentBaseline): this;
+    /**
+     * OPTIONAL. The color of the text. If a string value is provided, that value will be used for all geographies on the layer.
+     *
+     * If an object is provided, the color between default and contrastAlternative that has the highest contrast ratio with the geography's background color will be used.
+     *
+     * If a value for `pattern` is provided, that value will be used for geographies with a fill pattern. If it is not provided, the default option will be used for geographies with a fill pattern.
+     *
+     * @default '#000'
+     */
+    color(color: GeographiesLabelsColorOptions | CSSType.Property.Fill): this;
+    /**
+     * OPTIONAL. The cursor to display when hovering over the text
+     *
+     * @default 'default'
+     */
+    cursor(cursor: CSSType.Property.Cursor): this;
+    /**
+     * OPTIONAL, A function that determines whether to display the label for a given feature.
+     *
+     * @default () => true
+     */
+    display(display: boolean): this;
+    display(display: (featureIndex: string) => boolean): this;
+    /**
+     * OPTIONAL. The dominant baseline of the text.
+     *
+     * @default 'middle'
+     */
+    dominantBaseline(dominantBaseline: CSSType.Property.DominantBaseline): this;
+    /**
+     * OPTIONAL. The font weight of the text.
+     *
+     * If an object is provided, the font weight for each property on the object will be used when the corresponding color is used.
+     *
+     * @default 400
+     */
+    fontWeight(fontWeight: GeographiesLabelsFontWeightOptions | CSSType.Property.FontWeight): this;
+    /**
+     * The scale used to determine the font size of the label.
+     */
+    fontScale(fontScale: ScaleLinear<number, number, never>): this;
+    /**
+     * The pointer events of the text.
+     */
+    pointerEvents(pointerEvents: CSSType.Property.PointerEvents): this;
+    /**
+     * The position of the label relative to the feature
+     */
+    position(position: (d: GeographiesFeature<TProperties, TGeometry>, path: GeoPath, projection: GeoProjection) => Position): this;
+    /**
+     * The text anchor of the text.
+     */
+    textAnchor(textAnchor: CSSType.Property.TextAnchor): this;
+    /**
+     * A function that determines the value of the label for a given feature
+     */
+    valueAccessor(valueAccessor: (featureIndex: GeographiesFeature<TProperties, TGeometry>) => string): this;
+    _build(): GeographiesLabels<TProperties, TGeometry>;
+    /**
+     * A function to position something at the centroid of a feature.
+     */
+    positionAtCentroid<TProperties, TGeometry extends Geometry>(feature: GeographiesFeature<TProperties, TGeometry>, path: GeoPath): Position;
+    /**
+     * A function to position a label for Hawaii on a GeoAlbersUsa projection.
+     */
+    positionHawaiiOnGeoAlbersUsa<TProperties>(feature: GeographiesFeature<TProperties, MultiPolygon>, projection: GeoProjection): Position;
+    /**
+     * A function to position a label with Polylabel lib
+     */
+    positionWithPolylabel<TProperties, TGeometry extends MultiPolygon | Polygon = MultiPolygon | Polygon>(feature: GeographiesFeature<TProperties, TGeometry>, projection: GeoProjection): Position;
+}

package/lib/geographies/config/layers/labels/geographies-labels-options.d.ts

@@ -0,0 +1,33 @@
+import type * as CSSType from 'csstype';
+import { GeoPath, GeoProjection, ScaleLinear } from 'd3';
+import { Geometry, MultiPolygon, Polygon } from 'geojson';
+import { Position } from '../../../../core/types/layout';
+import { GeographiesFeature } from '../../../geographies-feature';
+/**
+ * Configuration object for displaying labels on map.
+ *
+ * The generic parameters are the same as those in VicGeographiesConfig.
+ */
+export interface GeographiesLabelsOptions<TProperties, TGeometry extends Geometry = MultiPolygon | Polygon> {
+    alignmentBaseline: CSSType.Property.AlignmentBaseline;
+    color: GeographiesLabelsColorOptions | CSSType.Property.Fill;
+    cursor: CSSType.Property.Cursor;
+    display: (featureIndex: string) => boolean;
+    dominantBaseline: CSSType.Property.DominantBaseline;
+    fontScale: ScaleLinear<number, number, never>;
+    fontWeight: GeographiesLabelsFontWeightOptions | CSSType.Property.FontWeight;
+    pointerEvents: CSSType.Property.PointerEvents;
+    position: (d: GeographiesFeature<TProperties, TGeometry>, path: GeoPath, projection: GeoProjection) => Position;
+    textAnchor: CSSType.Property.TextAnchor;
+    valueAccessor: (feature: GeographiesFeature<TProperties, TGeometry>) => string;
+}
+export interface GeographiesLabelsColorOptions {
+    default: CSSType.Property.Fill;
+    contrastAlternative: CSSType.Property.Fill;
+    pattern?: CSSType.Property.Fill;
+}
+export interface GeographiesLabelsFontWeightOptions {
+    default: CSSType.Property.FontWeight;
+    contrastAlternative: CSSType.Property.FontWeight;
+    pattern?: CSSType.Property.FontWeight;
+}

package/lib/geographies/config/layers/labels/geographies-labels.d.ts

@@ -0,0 +1,20 @@
+import type * as CSSType from 'csstype';
+import { GeoPath, GeoProjection, ScaleLinear } from 'd3';
+import { Geometry, MultiPolygon, Polygon } from 'geojson';
+import { Position } from '../../../../core/types/layout';
+import { GeographiesFeature } from '../../../geographies-feature';
+import { GeographiesLabelsColorOptions, GeographiesLabelsFontWeightOptions, GeographiesLabelsOptions } from './geographies-labels-options';
+export declare class GeographiesLabels<TProperties, TGeometry extends Geometry = MultiPolygon | Polygon> implements GeographiesLabelsOptions<TProperties, TGeometry> {
+    alignmentBaseline: CSSType.Property.AlignmentBaseline;
+    color: GeographiesLabelsColorOptions | CSSType.Property.Fill;
+    cursor: CSSType.Property.Cursor;
+    display: (featureIndex: string) => boolean;
+    dominantBaseline: CSSType.Property.DominantBaseline;
+    fontScale: ScaleLinear<number, number, never>;
+    fontWeight: GeographiesLabelsFontWeightOptions | CSSType.Property.FontWeight;
+    pointerEvents: CSSType.Property.PointerEvents;
+    position: (d: GeographiesFeature<TProperties, TGeometry>, path: GeoPath, projection?: GeoProjection) => Position;
+    textAnchor: CSSType.Property.TextAnchor;
+    valueAccessor: (feature: GeographiesFeature<TProperties, TGeometry>) => string;
+    constructor(options: GeographiesLabelsOptions<TProperties, TGeometry>);
+}

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

@@ -0,0 +1,7 @@
+import { EventAction } from '../../../events';
+import { GeographiesHost } from '../geographies-events.directive';
+import { GeographiesInteractionOutput } from '../geographies-interaction-output';
+export declare class GeographiesClickEmitTooltipDataPauseOtherActions<Datum> implements EventAction<GeographiesHost<Datum>, GeographiesInteractionOutput<Datum>> {
+    onStart(host: GeographiesHost<Datum>): void;
+    onEnd(host: GeographiesHost<Datum>): void;
+}

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

@@ -0,0 +1,7 @@
+import { EventAction } from '../../../events';
+import { GeographiesHost } from '../geographies-events.directive';
+import { GeographiesInteractionOutput } from '../geographies-interaction-output';
+export declare class GeographiesHoverEmitTooltipData<Datum> implements EventAction<GeographiesHost<Datum>, GeographiesInteractionOutput<Datum>> {
+    onStart(host: GeographiesHost<Datum>): void;
+    onEnd(host: GeographiesHost<Datum>): void;
+}

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

@@ -0,0 +1,7 @@
+import { HoverMoveAction } from '../../../events';
+import { GeographiesHost } from '../geographies-events.directive';
+import { GeographiesInteractionOutput } from '../geographies-interaction-output';
+export declare class GeographiesHoverMoveEmitTooltipData<Datum> implements HoverMoveAction<GeographiesHost<Datum>, GeographiesInteractionOutput<Datum>> {
+    onStart(host: GeographiesHost<Datum>): void;
+    onEnd(host: GeographiesHost<Datum>): void;
+}

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

@@ -0,0 +1,38 @@
+import { EventEmitter } from '@angular/core';
+import { Geometry, MultiPolygon, Polygon } from 'geojson';
+import { Observable } from 'rxjs';
+import { EventAction, EventsDirective, EventType, HoverMoveAction, InputEventAction, MarksHost, UnlistenFunction } from '../../events';
+import { GeographiesAttributeDataLayer } from '../config/layers/attribute-data-layer/attribute-data-layer';
+import { GeographiesGeojsonPropertiesLayer } from '../config/layers/geojson-properties-layer/geojson-properties-layer';
+import { GeographiesComponent } from '../geographies.component';
+import { GeographiesInteractionOutput } from './geographies-interaction-output';
+import * as i0 from "@angular/core";
+export type GeographiesHost<Datum, TGeographiesComponent extends GeographiesComponent<Datum> = GeographiesComponent<Datum>> = MarksHost<GeographiesInteractionOutput<Datum>, TGeographiesComponent>;
+export declare class GeographiesEventsDirective<Datum, TProperties, TGeometry extends Geometry = MultiPolygon | Polygon, TComponent extends GeographiesComponent<Datum, TProperties, TGeometry> = GeographiesComponent<Datum, TProperties, TGeometry>> extends EventsDirective<GeographiesHost<Datum>> {
+    geographies: TComponent;
+    hoverActions: EventAction<GeographiesHost<Datum>, GeographiesInteractionOutput<Datum>>[] | null;
+    hoverMoveActions: HoverMoveAction<GeographiesHost<Datum>, GeographiesInteractionOutput<Datum>>[] | null;
+    clickActions: EventAction<GeographiesHost<Datum>, GeographiesInteractionOutput<Datum>>[] | null;
+    inputEventActions: InputEventAction<GeographiesHost<Datum>, GeographiesInteractionOutput<Datum>>[];
+    interactionOutput: EventEmitter<GeographiesInteractionOutput<Datum>>;
+    bounds: [[number, number], [number, number]];
+    layer: GeographiesAttributeDataLayer<Datum, TProperties, TGeometry> | GeographiesGeojsonPropertiesLayer<TProperties, TGeometry>;
+    path: SVGPathElement;
+    constructor(geographies: TComponent);
+    get marks(): GeographiesComponent<Datum, TProperties, TGeometry>;
+    getElements(): Observable<Element[]>;
+    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): GeographiesInteractionOutput<Datum>;
+    emitInteractionOutput(output: GeographiesInteractionOutput<Datum> | null): void;
+    private resetDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GeographiesEventsDirective<any, any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GeographiesEventsDirective<any, any, any, any>, "[vicGeographiesEvents]", 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/geographies/events/geographies-interaction-output.d.ts

@@ -0,0 +1,16 @@
+import { InteractionOutput } from '../../events/interaction-output';
+import { HtmlTooltipCdkManagedPosition } from '../../tooltips';
+import { GeographiesTooltipDatum } from '../config/layers/geographies-layer/geographies-layer';
+export interface GeographiesInteractionOutput<Datum> extends InteractionOutput, GeographiesTooltipDatum<Datum> {
+    /**
+     * 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/geographies/events/geographies-tooltip-positioner.d.ts

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

package/lib/geographies/geographies-feature.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A utility type that represents a GeoJson feature with a properties object of type TProperties and a geometry object of type TGeometry.
+ */
+import { Feature, GeoJsonProperties, Geometry, MultiPolygon, Polygon } from 'geojson';
+export type GeographiesFeature<TProperties extends GeoJsonProperties = GeoJsonProperties, TGeometry extends Geometry = MultiPolygon | Polygon> = Feature<TGeometry, TProperties>;

package/lib/geographies/geographies.component.d.ts

@@ -0,0 +1,36 @@
+import { ElementRef, InjectionToken } from '@angular/core';
+import { GeoPath, GeoProjection } from 'd3';
+import { Selection } from 'd3-selection';
+import { GeoJsonProperties, Geometry, MultiPolygon, Polygon } from 'geojson';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { MapPrimaryMarks } from '../marks/map-marks/map-primary-marks/map-primary-marks';
+import { GeographiesConfig } from './config/geographies-config';
+import { GeographiesLabels } from './config/layers/labels/geographies-labels';
+import { GeographiesFeature } from './geographies-feature';
+import * as i0 from "@angular/core";
+export type LayersGroup = Selection<SVGGElement, unknown, null, undefined>;
+export declare const GEOGRAPHIES: InjectionToken<GeographiesComponent<unknown, unknown, Polygon | MultiPolygon>>;
+export type GeographiesSvgElement = 'layer' | 'g' | 'feature' | 'label';
+export declare class GeographiesComponent<Datum, TProperties extends GeoJsonProperties = GeoJsonProperties, TGeometry extends Geometry = MultiPolygon | Polygon> extends MapPrimaryMarks<Datum, GeographiesConfig<Datum, TProperties, TGeometry>> {
+    projection: GeoProjection;
+    path: GeoPath;
+    pathsByLayer: BehaviorSubject<Selection<SVGPathElement, GeographiesFeature<TProperties, TGeometry>, SVGGElement, GeographiesFeature<TProperties, TGeometry>>[]>;
+    pathsByLayer$: Observable<Selection<SVGPathElement, GeographiesFeature<TProperties, TGeometry>, SVGGElement, GeographiesFeature<TProperties, TGeometry>>[]>;
+    elRef: ElementRef<SVGGElement>;
+    get class(): Record<GeographiesSvgElement, string>;
+    initFromConfig(): void;
+    setChartScalesFromRanges(): void;
+    setProjection(): void;
+    setPath(): void;
+    updateChartAttributeProperties(): void;
+    drawMarks(): void;
+    drawMap(transitionDuration: any): void;
+    drawLayers(t: any): void;
+    getLabelPosition(d: GeographiesFeature<TProperties, TGeometry>, labels: GeographiesLabels<TProperties, TGeometry>): {
+        x: number;
+        y: number;
+    };
+    updateGeographyElements(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GeographiesComponent<any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GeographiesComponent<any, any, any>, "[vic-primary-marks-geographies]", never, {}, {}, never, ["*"], true, never>;
+}

package/lib/geographies/geographies.module.d.ts

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

package/lib/geographies/index.d.ts

@@ -0,0 +1,32 @@
+export * from './config/geographies-builder';
+export * from './config/geographies-config';
+export * from './config/geographies-options';
+export * from './config/layers/attribute-data-layer/attribute-data-layer';
+export * from './config/layers/attribute-data-layer/attribute-data-layer-builder';
+export * from './config/layers/attribute-data-layer/attribute-data-layer-options';
+export * from './config/layers/attribute-data-layer/dimensions/attribute-data-bin-enums';
+export * from './config/layers/attribute-data-layer/dimensions/attribute-data-bin-types';
+export * from './config/layers/attribute-data-layer/dimensions/categorical-bins/categorical-bins';
+export * from './config/layers/attribute-data-layer/dimensions/categorical-bins/categorical-bins-options';
+export * from './config/layers/attribute-data-layer/dimensions/custom-breaks/custom-breaks-bins';
+export * from './config/layers/attribute-data-layer/dimensions/custom-breaks/custom-breaks-bins-options';
+export * from './config/layers/attribute-data-layer/dimensions/equal-frequencies-bins/equal-frequencies-bins';
+export * from './config/layers/attribute-data-layer/dimensions/equal-frequencies-bins/equal-frequencies-bins-options';
+export * from './config/layers/attribute-data-layer/dimensions/equal-value-ranges-bins/equal-value-ranges-bins';
+export * from './config/layers/attribute-data-layer/dimensions/equal-value-ranges-bins/equal-value-ranges-bins-options';
+export * from './config/layers/attribute-data-layer/dimensions/no-bins/no-bins';
+export * from './config/layers/attribute-data-layer/dimensions/no-bins/no-bins-options';
+export * from './config/layers/geojson-properties-layer/geojson-properties-layer';
+export * from './config/layers/geojson-properties-layer/geojson-properties-layer-builder';
+export * from './config/layers/geojson-properties-layer/geojson-properties-layer-options';
+export * from './config/layers/labels/geographies-labels';
+export * from './config/layers/labels/geographies-labels-builder';
+export * from './config/layers/labels/geographies-labels-options';
+export * from './events/actions/geographies-click-actions';
+export * from './events/actions/geographies-hover-actions';
+export * from './events/actions/geographies-hover-move-actions';
+export * from './events/geographies-events.directive';
+export * from './events/geographies-interaction-output';
+export * from './geographies-feature';
+export * from './geographies.component';
+export * from './geographies.module';

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

@@ -0,0 +1,29 @@
+import { VicBarsConfigBuilder } from '../../bars/config/bars-builder';
+import { DataValue } from '../../core/types/values';
+import { GroupedBarsConfig } from './grouped-bars-config';
+import * as i0 from "@angular/core";
+/**
+ * Builds a configuration object for a GroupedBarsComponent.
+ *
+ * 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: [VicGroupedBarsBuilder]` in the component decorator)
+ *
+ * The first generic parameter, Datum, is the type of the data that will be used to create the bars.
+ *
+ * The second generic parameter, TOrdinalValue, is the type of the ordinal data that will be used to position the bars.
+ */
+export declare class VicGroupedBarsConfigBuilder<Datum, TOrdinalValue extends DataValue> extends VicBarsConfigBuilder<Datum, TOrdinalValue> {
+    private _intraGroupPadding;
+    constructor();
+    /**
+     * OPTIONAL. Set the padding between groups of bars. Passed to d3.scaleBand.padding.
+     *
+     * @default 0.05
+     */
+    intraGroupPadding(padding: number): this;
+    /**
+     * REQUIRED. Builds the configuration object for a GroupedBarsComponent.
+     */
+    getConfig(): GroupedBarsConfig<Datum, TOrdinalValue>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VicGroupedBarsConfigBuilder<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VicGroupedBarsConfigBuilder<any, any>>;
+}

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

@@ -0,0 +1,10 @@
+import { BarsConfig } from '../../bars/config/bars-config';
+import { BarsDimensions } from '../../bars/config/bars-dimensions';
+import { DataValue } from '../../core/types/values';
+import { GroupedBarsOptions } from './grouped-bars-options';
+export declare class GroupedBarsConfig<Datum, TOrdinalValue extends DataValue> extends BarsConfig<Datum, TOrdinalValue> implements GroupedBarsOptions<Datum, TOrdinalValue> {
+    intraGroupPadding: number;
+    constructor(dimensions: BarsDimensions, options: GroupedBarsOptions<Datum, TOrdinalValue>);
+    setValueIndices(): void;
+    setBarsKeyFunction(): void;
+}

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

@@ -0,0 +1,5 @@
+import { BarsOptions } from '../../bars/config/bars-options';
+import { DataValue } from '../../core/types/values';
+export interface GroupedBarsOptions<Datum, TOrdinalValue extends DataValue> extends BarsOptions<Datum, TOrdinalValue> {
+    intraGroupPadding: number;
+}

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

@@ -0,0 +1,35 @@
+import { EventEmitter } from '@angular/core';
+import { Observable } from 'rxjs';
+import { BarDatum, BarsHost, BarsInteractionOutput } from '../../bars';
+import { DataValue } from '../../core';
+import { EventAction, EventsDirective, EventType, HoverMoveAction, InputEventAction, UnlistenFunction } from '../../events';
+import { GroupedBarsComponent } from '../grouped-bars.component';
+import * as i0 from "@angular/core";
+export declare class GroupedBarsEventsDirective<Datum, TOrdinalValue extends DataValue, TGroupedBarsComponent extends GroupedBarsComponent<Datum, TOrdinalValue> = GroupedBarsComponent<Datum, TOrdinalValue>> extends EventsDirective<BarsHost<Datum, TOrdinalValue>> implements BarsHost<Datum, TOrdinalValue> {
+    bars: TGroupedBarsComponent;
+    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: TGroupedBarsComponent);
+    get marks(): GroupedBarsComponent<Datum, TOrdinalValue>;
+    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<GroupedBarsEventsDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GroupedBarsEventsDirective<any, any, any>, "[vicGroupedBarsEvents]", 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/grouped-bars/grouped-bars.component.d.ts

@@ -0,0 +1,19 @@
+import { BarDatum, BarsComponent } from '../bars/bars.component';
+import { DataValue } from '../core/types/values';
+import { GroupedBarsConfig } from './config/grouped-bars-config';
+import * as i0 from "@angular/core";
+export declare class GroupedBarsComponent<Datum, TOrdinalValue extends DataValue> extends BarsComponent<Datum, TOrdinalValue> {
+    config: GroupedBarsConfig<Datum, TOrdinalValue>;
+    groupScale: any;
+    drawMarks(): void;
+    setGroupScale(): void;
+    getBarColor(d: BarDatum<TOrdinalValue>): string;
+    getBarXOrdinal(d: BarDatum<TOrdinalValue>): number;
+    getBarY(d: BarDatum<TOrdinalValue>): number;
+    getBarYOrdinal(d: BarDatum<TOrdinalValue>): number;
+    getBarYQuantitative(d: BarDatum<TOrdinalValue>): number;
+    getBarWidthOrdinal(): number;
+    getBarHeightOrdinal(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupedBarsComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GroupedBarsComponent<any, any>, "[vic-primary-grouped-bars]", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}

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

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

package/lib/grouped-bars/index.d.ts

@@ -0,0 +1,7 @@
+export type { BarsHost as GroupedBarsHost, BarsInteractionOutput as GroupedBarsInteractionOutput, } from '../bars';
+export * from './config/grouped-bars-builder';
+export * from './config/grouped-bars-config';
+export * from './config/grouped-bars-options';
+export * from './events/grouped-bars-events.directive';
+export * from './grouped-bars.component';
+export * from './grouped-bars.module';