@mathstack/viz 1.1.5 → 2.0.3

package/src/lib/geographies/config/geographies-builder.ts

@@ -0,0 +1,224 @@
+import { Injectable } from '@angular/core';
+import { safeAssign } from '@mathstack/app-kit';
+import {
+  ExtendedFeature,
+  ExtendedFeatureCollection,
+  ExtendedGeometryCollection,
+  geoAlbersUsa,
+  GeoGeometryObjects,
+  GeoProjection,
+} from 'd3';
+import { GeoJsonProperties, Geometry, MultiPolygon, Polygon } from 'geojson';
+import { GeographiesFeature } from '../geographies-feature';
+import { GeographiesConfig } from './geographies-config';
+import { GeographiesAttributeDataLayerBuilder } from './layers/attribute-data-layer/attribute-data-layer-builder';
+import { GeographiesGeojsonPropertiesLayerBuilder } from './layers/geojson-properties-layer/geojson-properties-layer-builder';
+
+const DEFAULT = {
+  _class: () => '',
+  _projection: geoAlbersUsa(),
+  _mixBlendMode: 'normal',
+};
+
+/** Builds a configuration object for a GeographiesComponent.
+ *
+ * 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: [VicGeographiesBuilder]` in the component decorator)
+ *
+ * The first generic parameter, Datum, is the type of the attribute data that will be used to shade the map areas.
+ *
+ * The second generic parameter, TProperties, is the type of the properties object that is associated with the GeoJson.
+ *
+ * The optional third generic parameter, TGeometry, is the type of the geometry object that is associated with the GeoJson. It defaults to MultiPolygon | Polygon if not provided.
+ */
+@Injectable()
+export class VicGeographiesConfigBuilder<
+  Datum,
+  TProperties extends GeoJsonProperties,
+  TGeometry extends Geometry = MultiPolygon | Polygon,
+> {
+  private _boundary:
+    | ExtendedFeature
+    | ExtendedFeatureCollection
+    | GeoGeometryObjects
+    | ExtendedGeometryCollection;
+  protected _class: (d: Datum) => string;
+  private _featureIndexAccessor: (
+    d: GeographiesFeature<TProperties, TGeometry>
+  ) => string;
+  private _mixBlendMode: string;
+  private _projection: GeoProjection;
+  private attributeDataBuilder: GeographiesAttributeDataLayerBuilder<
+    Datum,
+    TProperties,
+    TGeometry
+  >;
+  public geojsonBuilders: GeographiesGeojsonPropertiesLayerBuilder<
+    TProperties,
+    TGeometry
+  >[] = [];
+
+  constructor() {
+    safeAssign(this, DEFAULT);
+  }
+
+  /**
+   * REQUIRED. Sets a feature or geometry object or collection that defines the extents of the map to be drawn.
+   *
+   * Used for scaling the map.
+   */
+  boundary(
+    boundary:
+      | ExtendedFeature
+      | ExtendedFeatureCollection
+      | GeoGeometryObjects
+      | ExtendedGeometryCollection
+  ): this {
+    this._boundary = boundary;
+    return this;
+  }
+
+  /**
+   * REQUIRED. Sets a function that derives an identifying string from the GeoJson feature.
+   */
+  featureIndexAccessor(
+    accessor: (d: GeographiesFeature<TProperties, TGeometry>) => string
+  ): this {
+    this._featureIndexAccessor = accessor;
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Creates a configuration object for a layer that will be drawn and styled using solely the properties on a geojson feature.
+   *
+   * This might be used for to draw the outline of a country, for example. It could also shade the area of a country based on a property of the geojson feature.
+   *
+   * If events are enabled, the geojson properties will be used to populate the tooltip.
+   *
+   * This method can be called multiple times to create multiple layers. If this method is called with null, all layers will be removed. (Though subsequent calls can be made to add new layers.)
+   *
+   * The order in which layers are created will determine the order in which they are drawn.
+   *
+   * Multiple layers can be used to draw different parts of the map with different styles.
+   */
+  geojsonPropertiesLayer(geojson: null): this;
+  geojsonPropertiesLayer(
+    geojson: (
+      geojson: GeographiesGeojsonPropertiesLayerBuilder<TProperties, TGeometry>
+    ) => void
+  ): this;
+  geojsonPropertiesLayer(
+    geojson:
+      | ((
+          geojson: GeographiesGeojsonPropertiesLayerBuilder<
+            TProperties,
+            TGeometry
+          >
+        ) => void)
+      | null
+  ): this {
+    if (geojson === null) {
+      this.geojsonBuilders = [];
+      return this;
+    }
+    const builder = new GeographiesGeojsonPropertiesLayerBuilder<
+      TProperties,
+      TGeometry
+    >();
+    geojson(builder);
+    this.geojsonBuilders.push(builder);
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Creates a configuration object for a layer that will be drawn from geojson and styled using attribute data.
+   *
+   * This object provides various methods for transforming data values into colors / color bins.
+   *
+   * This method can be called only once.
+   */
+  attributeDataLayer(attributeData: null): this;
+  attributeDataLayer(
+    attributeData: (
+      attributeData: GeographiesAttributeDataLayerBuilder<
+        Datum,
+        TProperties,
+        TGeometry
+      >
+    ) => void
+  ): this;
+  attributeDataLayer(
+    attributeData:
+      | ((
+          attributeData: GeographiesAttributeDataLayerBuilder<
+            Datum,
+            TProperties,
+            TGeometry
+          >
+        ) => void)
+      | null
+  ): this {
+    if (attributeData === null) {
+      this.attributeDataBuilder = undefined;
+      return this;
+    }
+    this.attributeDataBuilder = new GeographiesAttributeDataLayerBuilder<
+      Datum,
+      TProperties,
+      TGeometry
+    >();
+    attributeData(this.attributeDataBuilder);
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Sets the mix-blend-mode of the marks.
+   *
+   * @default 'normal'
+   */
+  mixBlendMode(mixBlendMode: string): this {
+    this._mixBlendMode = mixBlendMode;
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Sets a projection function that maps a point in the map's coordinate space to a point in the SVG's coordinate space.
+   *
+   * @default d3.geoAlbersUsa()
+   */
+  projection(projection: GeoProjection): this {
+    this._projection = projection;
+    return this;
+  }
+
+  /**
+   * REQUIRED. Builds the GeographiesConfig object.
+   */
+  getConfig(): GeographiesConfig<Datum, TProperties, TGeometry> {
+    this.validateBuilder();
+    const config = new GeographiesConfig<Datum, TProperties, TGeometry>({
+      marksClass: 'vic-geographies',
+      attributeDataLayer: this.attributeDataBuilder?._build(),
+      boundary: this._boundary,
+      mixBlendMode: this._mixBlendMode,
+      featureIndexAccessor: this._featureIndexAccessor,
+      geojsonPropertiesLayers: this.geojsonBuilders.length
+        ? this.geojsonBuilders.map((builder) => builder._build())
+        : undefined,
+      projection: this._projection,
+    });
+    this.geojsonBuilders = [];
+    return config;
+  }
+
+  private validateBuilder(): void {
+    if (!this._boundary) {
+      throw new Error('Boundary is required');
+    }
+    if (!this._featureIndexAccessor) {
+      throw new Error('Feature index accessor is required');
+    }
+    if (!this.attributeDataBuilder && !this.geojsonBuilders.length) {
+      throw new Error('At least one layer is required');
+    }
+  }
+}

package/src/lib/geographies/config/geographies-config.spec.ts

@@ -0,0 +1,100 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { VicGeographiesConfigBuilder } from './geographies-builder';
+import { GeographiesConfig } from './geographies-config';
+import { GeographiesAttributeDataLayer } from './layers/attribute-data-layer/attribute-data-layer';
+import { GeographiesLayer } from './layers/geographies-layer/geographies-layer';
+
+type Datum = { value: number; state: string };
+const data = [
+  { value: 1, state: 'AL' },
+  { value: 2, state: 'AK' },
+  { value: 3, state: 'AZ' },
+  { value: 4, state: 'CA' },
+  { value: 5, state: 'CO' },
+  { value: 6, state: 'CO' },
+];
+const features = [
+  { name: 'Alabama' },
+  { name: 'Alaska' },
+  { name: 'Arizona' },
+  { name: 'California' },
+  { name: 'Colorado' },
+];
+function createConfig(): GeographiesConfig<Datum, { name: string }, any> {
+  return new VicGeographiesConfigBuilder<Datum, { name: string }>()
+    .boundary('boundary' as any)
+    .featureIndexAccessor((d) => d.properties.name)
+    .attributeDataLayer((layer) =>
+      layer
+        .equalValueRangesBins((dimension) =>
+          dimension.valueAccessor((d) => d.value).numBins(5)
+        )
+        .geographyIndexAccessor((d) => d.state)
+        .data(data)
+    )
+    .geojsonPropertiesLayer((layer) =>
+      layer
+        .geographies(features as any)
+        .fill((dimension) => dimension.range(['lime']))
+    )
+    .getConfig();
+}
+
+describe('GeographiesConfig', () => {
+  let config: GeographiesConfig<Datum, { name: string }, any>;
+
+  beforeEach(() => {
+    config = undefined;
+  });
+
+  describe('init()', () => {
+    beforeEach(() => {
+      spyOn(
+        GeographiesAttributeDataLayer.prototype as any,
+        'initPropertiesFromData'
+      );
+      spyOn(GeographiesConfig.prototype as any, 'setLayers');
+      spyOn(
+        GeographiesConfig.prototype as any,
+        'setLayerFeatureIndexAccessors'
+      );
+      config = createConfig();
+    });
+    it('calls initPropertiesFromData once', () => {
+      expect(
+        (config as any).attributeDataLayer.initPropertiesFromData
+      ).toHaveBeenCalledTimes(1);
+    });
+    it('calls setLayers once', () => {
+      expect((config as any).setLayers).toHaveBeenCalledTimes(1);
+    });
+    it('calls setLayerFeatureIndexAccessors once', () => {
+      expect(
+        (config as any).setLayerFeatureIndexAccessors
+      ).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('setLayers()', () => {
+    beforeEach(() => {
+      config = createConfig();
+    });
+    it('sets layers to an array with attributeDataLayer and geojsonPropertiesLayers', () => {
+      expect(config.layers.length).toBe(2);
+    });
+  });
+
+  describe('setLayerFeatureIndexAccessors()', () => {
+    let featureAccessorSpy: jasmine.Spy;
+    beforeEach(() => {
+      featureAccessorSpy = spyOn(
+        GeographiesLayer.prototype as any,
+        'setFeatureIndexAccessor'
+      );
+      config = createConfig();
+    });
+    it('calls setFeatureValueAccessor once per layer', () => {
+      expect(featureAccessorSpy).toHaveBeenCalledTimes(2);
+    });
+  });
+});

package/src/lib/geographies/config/geographies-config.ts

@@ -0,0 +1,81 @@
+import { safeAssign } from '@mathstack/app-kit';
+import {
+  ExtendedFeature,
+  ExtendedFeatureCollection,
+  ExtendedGeometryCollection,
+  GeoGeometryObjects,
+  GeoProjection,
+} from 'd3';
+import {
+  GeoJsonProperties,
+  GeometryObject as Geometry,
+  MultiPolygon,
+  Polygon,
+} from 'geojson';
+import { MarksConfig } from '../../marks';
+import { GeographiesFeature } from '../geographies-feature';
+import { GeographiesOptions } from './geographies-options';
+import { GeographiesAttributeDataLayer } from './layers/attribute-data-layer/attribute-data-layer';
+import { GeographiesGeojsonPropertiesLayer } from './layers/geojson-properties-layer/geojson-properties-layer';
+
+export class GeographiesConfig<
+  Datum,
+  TProperties extends GeoJsonProperties,
+  TGeometry extends Geometry = MultiPolygon | Polygon,
+>
+  extends MarksConfig
+  implements GeographiesOptions<Datum, TProperties, TGeometry>
+{
+  readonly boundary:
+    | ExtendedFeature
+    | ExtendedFeatureCollection
+    | GeoGeometryObjects
+    | ExtendedGeometryCollection;
+  readonly attributeDataLayer: GeographiesAttributeDataLayer<
+    Datum,
+    TProperties,
+    TGeometry
+  >;
+  featureIndexAccessor: (
+    d: GeographiesFeature<TProperties, TGeometry>
+  ) => string;
+  layers: (
+    | GeographiesAttributeDataLayer<Datum, TProperties, TGeometry>
+    | GeographiesGeojsonPropertiesLayer<TProperties, TGeometry>
+  )[];
+  readonly geojsonPropertiesLayers: GeographiesGeojsonPropertiesLayer<
+    TProperties,
+    TGeometry
+  >[];
+  readonly projection: GeoProjection;
+
+  constructor(options: GeographiesOptions<Datum, TProperties, TGeometry>) {
+    super();
+    safeAssign(this, options);
+    this.initPropertiesFromData();
+  }
+
+  protected initPropertiesFromData(): void {
+    this.setLayers();
+    this.setLayerFeatureIndexAccessors();
+  }
+
+  private setLayers(): void {
+    this.layers = [];
+    if (this.attributeDataLayer) {
+      this.layers.push(this.attributeDataLayer);
+    }
+    if (this.geojsonPropertiesLayers) {
+      this.layers.push(...this.geojsonPropertiesLayers);
+    }
+    this.layers.forEach((layer, i) => {
+      layer.id = i;
+    });
+  }
+
+  private setLayerFeatureIndexAccessors(): void {
+    this.layers.forEach((layer) =>
+      layer.setFeatureIndexAccessor(this.featureIndexAccessor)
+    );
+  }
+}

package/src/lib/geographies/config/geographies-options.ts

@@ -0,0 +1,37 @@
+import {
+  ExtendedFeature,
+  ExtendedFeatureCollection,
+  ExtendedGeometryCollection,
+  GeoGeometryObjects,
+  GeoProjection,
+} from 'd3';
+import { GeoJsonProperties, Geometry, MultiPolygon, Polygon } from 'geojson';
+import { MarksOptions } from '../../marks/config/marks-options';
+import { GeographiesFeature } from '../geographies-feature';
+import { GeographiesAttributeDataLayer } from './layers/attribute-data-layer/attribute-data-layer';
+import { GeographiesGeojsonPropertiesLayer } from './layers/geojson-properties-layer/geojson-properties-layer';
+
+export interface GeographiesOptions<
+  Datum,
+  TProperties extends GeoJsonProperties,
+  TGeometry extends Geometry = MultiPolygon | Polygon,
+> extends MarksOptions {
+  boundary:
+    | ExtendedFeature
+    | ExtendedFeatureCollection
+    | GeoGeometryObjects
+    | ExtendedGeometryCollection;
+  attributeDataLayer: GeographiesAttributeDataLayer<
+    Datum,
+    TProperties,
+    TGeometry
+  >;
+  featureIndexAccessor: (
+    d: GeographiesFeature<TProperties, TGeometry>
+  ) => string;
+  geojsonPropertiesLayers: GeographiesGeojsonPropertiesLayer<
+    TProperties,
+    TGeometry
+  >[];
+  projection: GeoProjection;
+}

package/src/lib/geographies/config/layers/attribute-data-layer/attribute-data-layer-builder.ts

@@ -0,0 +1,212 @@
+import { safeAssign } from '@mathstack/app-kit';
+import { Geometry, MultiPolygon, Polygon } from 'geojson';
+import { FillDefinition } from '../../../../fill-definitions/fill-definitions';
+import { GeographiesLayerBuilder } from '../geographies-layer/geographies-layer-builder';
+import { GeographiesAttributeDataLayer } from './attribute-data-layer';
+import { CategoricalBinsBuilder } from './dimensions/categorical-bins/categorical-bins-builder';
+import { CustomBreaksBinsAttributeDataDimensionBuilder } from './dimensions/custom-breaks/custom-breaks-bins-builder';
+import { EqualFrequenciesAttributeDataDimensionBuilder } from './dimensions/equal-frequencies-bins/equal-frequencies-bins-builder';
+import { EqualValueRangesBinsBuilder } from './dimensions/equal-value-ranges-bins/equal-value-ranges-bins-builder';
+import { NoBinsAttributeDataDimensionBuilder } from './dimensions/no-bins/no-bins-builder';
+
+const DEFAULT = {
+  _class: () => '',
+  _enableEventActions: true,
+};
+
+export class GeographiesAttributeDataLayerBuilder<
+  Datum,
+  TProperties,
+  TGeometry extends Geometry = MultiPolygon | Polygon,
+> extends GeographiesLayerBuilder<TProperties, TGeometry> {
+  private _customFills: FillDefinition<Datum>[];
+  private _data: Datum[];
+  private _geographyIndexAccessor: (d: Datum) => string;
+
+  private binsBuilder:
+    | CategoricalBinsBuilder<Datum>
+    | CustomBreaksBinsAttributeDataDimensionBuilder<Datum>
+    | EqualFrequenciesAttributeDataDimensionBuilder<Datum>
+    | EqualValueRangesBinsBuilder<Datum>
+    | NoBinsAttributeDataDimensionBuilder<Datum>;
+
+  private categoricalBinsBuilder: CategoricalBinsBuilder<Datum>;
+  private customBreaksBinsBuilder: CustomBreaksBinsAttributeDataDimensionBuilder<Datum>;
+  private equalFrequenciesBinsBuilder: EqualFrequenciesAttributeDataDimensionBuilder<Datum>;
+  private equalValueRangesBinsBuilder: EqualValueRangesBinsBuilder<Datum>;
+  private noBinsBuilder: NoBinsAttributeDataDimensionBuilder<Datum>;
+
+  constructor() {
+    super();
+    safeAssign(this, DEFAULT);
+  }
+
+  /**
+   * OPTIONAL. Creates a configuration object that maps data to colors by categorical values.
+   *
+   * For example, if the data for a set of U.S. states had a string property, 'region', this could be used to color the states by region.
+   */
+  categoricalBins(bins: null): this;
+  categoricalBins(bins: (bins: CategoricalBinsBuilder<Datum>) => void): this;
+  categoricalBins(
+    bins: ((bins: CategoricalBinsBuilder<Datum>) => void) | null
+  ): this {
+    if (bins === null) {
+      this.categoricalBinsBuilder = undefined;
+      return this;
+    }
+    this.categoricalBinsBuilder = new CategoricalBinsBuilder<Datum, string>();
+    bins(this.categoricalBinsBuilder);
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Creates a configuration object that maps data to colors by custom breaks values for bins.
+   */
+  customBreaksBins(bins: null): this;
+  customBreaksBins(
+    bins: (bins: CustomBreaksBinsAttributeDataDimensionBuilder<Datum>) => void
+  ): this;
+  customBreaksBins(
+    bins:
+      | ((bins: CustomBreaksBinsAttributeDataDimensionBuilder<Datum>) => void)
+      | null
+  ): this {
+    if (bins === null) {
+      this.customBreaksBinsBuilder = undefined;
+      return this;
+    }
+    this.customBreaksBinsBuilder =
+      new CustomBreaksBinsAttributeDataDimensionBuilder();
+    bins(this.customBreaksBinsBuilder);
+    return this;
+  }
+
+  /**
+   * REQUIRED. The data that will be used to color the geographies.
+   */
+  data(data: Datum[]): this {
+    this._data = data;
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Creates a configuration object that for creating a map without binning values.
+   */
+  noBins(bins: null): this;
+  noBins(
+    bins: (bins: NoBinsAttributeDataDimensionBuilder<Datum>) => void
+  ): this;
+  noBins(
+    bins: ((bins: NoBinsAttributeDataDimensionBuilder<Datum>) => void) | null
+  ): this {
+    if (bins === null) {
+      this.noBinsBuilder = undefined;
+      return this;
+    }
+    this.noBinsBuilder = new NoBinsAttributeDataDimensionBuilder();
+    bins(this.noBinsBuilder);
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Creates a configuration object that maps data to bins that each have the same size range.
+   *
+   * For example, bins may be, 0-10, 10-20, 20-30, etc.
+   */
+  equalValueRangesBins(bins: null): this;
+  equalValueRangesBins(
+    bins: (bins: EqualValueRangesBinsBuilder<Datum>) => void
+  ): this;
+  equalValueRangesBins(
+    bins: ((bins: EqualValueRangesBinsBuilder<Datum>) => void) | null
+  ): this {
+    if (bins === null) {
+      this.equalValueRangesBinsBuilder = undefined;
+      return this;
+    }
+    this.equalValueRangesBinsBuilder = new EqualValueRangesBinsBuilder();
+    bins(this.equalValueRangesBinsBuilder);
+    return this;
+  }
+
+  /**
+   * OPTIONAL. Creates a configuration object that maps data to bins that contain an equal number of data observations.
+   *
+   * This is useful for creating quartiles, deciles, etc.
+   */
+  equalFrequenciesBins(bins: null): this;
+  equalFrequenciesBins(
+    bins: (bins: EqualFrequenciesAttributeDataDimensionBuilder<Datum>) => void
+  ): this;
+  equalFrequenciesBins(
+    bins:
+      | ((bins: EqualFrequenciesAttributeDataDimensionBuilder<Datum>) => void)
+      | null
+  ): this {
+    if (bins === null) {
+      this.equalFrequenciesBinsBuilder = undefined;
+      return this;
+    }
+    this.equalFrequenciesBinsBuilder =
+      new EqualFrequenciesAttributeDataDimensionBuilder();
+    bins(this.equalFrequenciesBinsBuilder);
+    return this;
+  }
+
+  customFills(customFills: FillDefinition<Datum>[]): this {
+    this._customFills = customFills;
+    return this;
+  }
+
+  /**
+   * REQUIRED. The accessor function that returns a value from a Datum that must match the value returned by featureIndexAccessor.
+   */
+  geographyIndexAccessor(accessor: (d: Datum) => string): this {
+    this._geographyIndexAccessor = accessor;
+    return this;
+  }
+
+  _build(): GeographiesAttributeDataLayer<Datum, TProperties, TGeometry> {
+    this.validateBuilder();
+    return new GeographiesAttributeDataLayer({
+      marksClass: 'vic-geographies-attribute-data-layer',
+      attributeDimension: this.binsBuilder._build(),
+      customFills: this._customFills,
+      data: this._data,
+      featureClass: this._class,
+      enableEventActions: this._enableEventActions,
+      geographies: this._geographies,
+      geographyIndexAccessor: this._geographyIndexAccessor,
+      labels: this.labelsBuilder?._build(),
+      mixBlendMode: this._mixBlendMode,
+      stroke: this.strokeBuilder?._build(),
+    });
+  }
+
+  private validateBuilder(): void {
+    const binsBuilders = [
+      this.categoricalBinsBuilder,
+      this.customBreaksBinsBuilder,
+      this.equalFrequenciesBinsBuilder,
+      this.equalValueRangesBinsBuilder,
+      this.noBinsBuilder,
+    ];
+    if (!this._data) {
+      throw new Error('Data must be provided');
+    }
+    if (!this._geographyIndexAccessor) {
+      throw new Error('Geography index accessor must be provided');
+    }
+    const numBinsBuilders = binsBuilders.filter((builder) => builder).length;
+    if (numBinsBuilders !== 1) {
+      throw new Error(
+        `Exactly one bin strategy must be provided. Currently, ${numBinsBuilders} are provided.`
+      );
+    }
+    this.binsBuilder = binsBuilders.find((builder) => builder);
+    if (!this.strokeBuilder) {
+      this.initStrokeBuilder();
+    }
+  }
+}

package/{lib/geographies/config/layers/attribute-data-layer/attribute-data-layer-options.d.ts → src/lib/geographies/config/layers/attribute-data-layer/attribute-data-layer-options.ts}

@@ -1,16 +1,26 @@
-import { Geometry, MultiPolygon, Polygon } from 'geojson';
-import { FillDefinition } from '../../../../fill-definitions/fill-definitions';
-import { GeographiesLayerOptions } from '../geographies-layer/geographies-layer-options';
-import { CategoricalBinsAttributeDataDimension } from './dimensions/categorical-bins/categorical-bins';
-import { CustomBreaksBinsAttributeDataDimension } from './dimensions/custom-breaks/custom-breaks-bins';
-import { EqualFrequenciesAttributeDataDimension } from './dimensions/equal-frequencies-bins/equal-frequencies-bins';
-import { EqualValueRangesAttributeDataDimension } from './dimensions/equal-value-ranges-bins/equal-value-ranges-bins';
-import { NoBinsAttributeDataDimension } from './dimensions/no-bins/no-bins';
-export interface GeographiesAttributeDataLayerOptions<Datum, TProperties, TGeometry extends Geometry = MultiPolygon | Polygon> extends GeographiesLayerOptions<TProperties, TGeometry> {
-    attributeDimension: CategoricalBinsAttributeDataDimension<Datum> | NoBinsAttributeDataDimension<Datum> | EqualValueRangesAttributeDataDimension<Datum> | EqualFrequenciesAttributeDataDimension<Datum> | CustomBreaksBinsAttributeDataDimension<Datum>;
-    customFills: FillDefinition<Datum>[];
-    data: Datum[];
-    geographyIndexAccessor: (d: Datum) => string;
-    marksClass: string;
-    mixBlendMode: string;
-}
+import { Geometry, MultiPolygon, Polygon } from 'geojson';
+import { FillDefinition } from '../../../../fill-definitions/fill-definitions';
+import { GeographiesLayerOptions } from '../geographies-layer/geographies-layer-options';
+import { CategoricalBinsAttributeDataDimension } from './dimensions/categorical-bins/categorical-bins';
+import { CustomBreaksBinsAttributeDataDimension } from './dimensions/custom-breaks/custom-breaks-bins';
+import { EqualFrequenciesAttributeDataDimension } from './dimensions/equal-frequencies-bins/equal-frequencies-bins';
+import { EqualValueRangesAttributeDataDimension } from './dimensions/equal-value-ranges-bins/equal-value-ranges-bins';
+import { NoBinsAttributeDataDimension } from './dimensions/no-bins/no-bins';
+
+export interface GeographiesAttributeDataLayerOptions<
+  Datum,
+  TProperties,
+  TGeometry extends Geometry = MultiPolygon | Polygon,
+> extends GeographiesLayerOptions<TProperties, TGeometry> {
+  attributeDimension:
+    | CategoricalBinsAttributeDataDimension<Datum>
+    | NoBinsAttributeDataDimension<Datum>
+    | EqualValueRangesAttributeDataDimension<Datum>
+    | EqualFrequenciesAttributeDataDimension<Datum>
+    | CustomBreaksBinsAttributeDataDimension<Datum>;
+  customFills: FillDefinition<Datum>[];
+  data: Datum[];
+  geographyIndexAccessor: (d: Datum) => string;
+  marksClass: string;
+  mixBlendMode: string;
+}