ts-maps 0.2.5 → 0.2.6

package/dist/map.d.ts

@@ -1,428 +1,81 @@
-declare const JVM_PREFIX: 'jvm-' const CONTAINER_CLASS = `${JVM_PREFIX}container` const MARKERS_GROUP_ID = `${JVM_PREFIX}markers-group` const MARKERS_LABELS_GROUP_ID = `${JVM_PREFIX}markers-labels-group` const LINES_GROUP_ID = `${JVM_PREFIX}lines-group` const SERIES_CONTAINER_CLASS = `${JVM_PREFIX}series-container` const SERIES_CONTAINER_H_CLASS = `${SERIES_CONTAINER_CLASS} ${JVM_PREFIX}series-h` const SERIES_CONTAINER_V_CLASS = `${SERIES_CONTAINER_CLASS} ${JVM_PREFIX}series-v`;
+import {  } from './util';
+import DataVisualization from './data-visualization';
+import SVGCanvasElement from './svg/canvas-element';
+import Tooltip from './components/tooltip';
+import type { FocusOnOptions, Line, LineConfig, MapData, MapInterface, MapOptions, Marker, MarkerConfig, Region,  } from './types';
+import type SVGElement from './svg/base-element';
 export declare class Map implements MapInterface {
-  static maps: { [key: string]: MapData & { [key: string]: any } } = {}
-  static defaults: MapOptions = Defaults
-
-  params: MapOptions
-  regions: Record<string, Region> = {}
-  scale: number = 1
-  transX: number = 0
-  transY: number = 0
-  container!: HTMLElement
-  canvas!: SVGCanvasElementInterface
-  dataVisualization?: DataVisualization
-  legendHorizontal?: HTMLElement
-  legendVertical?: HTMLElement
-  series: { markers: any[], regions: any[], [key: string]: any[] } = { markers: [], regions: [] }
-
-  _mapData: MapData
-  _markers: Record<string, Marker> = {}
-  _lines: Record<string, Line> = {}
-  _defaultWidth: number
-  _defaultHeight: number
-  _height: number = 0
-  _width: number = 0
-  _baseScale: number = 1
-  _baseTransX: number = 0
-  _baseTransY: number = 0
-  _tooltip?: Tooltip
-  _linesGroup?: SVGElement
-  _markersGroup?: SVGElement
-  _markerLabelsGroup?: SVGElement
-  _canvasImpl!: SVGCanvasElement
-
-  constructor(options: MapOptions = {} as MapOptions) {
-    this.params = merge(Map.defaults, options, true) as MapOptions
-
-    const mapParam = this.params.map
-    const mapName = typeof mapParam === 'string' ? mapParam : mapParam.name
-    const mapData = Map.maps[mapName]
-    if (!mapData) {
-      throw new Error(`Attempt to use map which was not loaded: ${mapName}`)
-    }
-
-    this._mapData = mapData
-    this._defaultWidth = this._mapData.width
-    this._defaultHeight = this._mapData.height
-
-    if (document.readyState !== 'loading') {
-      this._init()
-    }
-    else {
-      window.addEventListener('DOMContentLoaded', () => this._init())
-    }
-  }
-
-  _init(): void {
-    const options = this.params
-
-    const element = getElement(options.selector)
-    if (!element) {
-      throw new Error(`Element not found: ${options.selector}`)
-    }
-    this.container = element as HTMLElement
-    this.container.classList.add(CONTAINER_CLASS)
-
-    this._canvasImpl = new SVGCanvasElement(this.container)
-    this.canvas = this._canvasImpl as unknown as SVGCanvasElementInterface
-
-    this.setBackgroundColor(options.backgroundColor || '')
-
-    this._createRegions()
-
-    this.updateSize()
-
-    if (options.lines?.elements) {
-      const group = this._canvasImpl.createGroup(LINES_GROUP_ID)
-      if (!group) {
-        throw new TypeError('Failed to create lines group')
-      }
-      this._linesGroup = group
-    }
-
-    if (options.markers) {
-      const markersGroup = this._canvasImpl.createGroup(MARKERS_GROUP_ID)
-      const labelsGroup = this._canvasImpl.createGroup(MARKERS_LABELS_GROUP_ID)
-      if (!markersGroup || !labelsGroup) {
-        throw new TypeError('Failed to create markers groups')
-      }
-
-      this._markersGroup = markersGroup
-      this._markerLabelsGroup = labelsGroup
-    }
-
-    this._createMarkers(options.markers || [])
-
-    this._createLines(options.lines?.elements || [])
-
-    this._repositionLabels()
-
-    this._setupContainerEvents()
-
-    this._setupElementEvents()
-
-    if (options.zoomButtons) {
-      this._setupZoomButtons()
-    }
-
-    if (options.showTooltip) {
-      this._tooltip = new Tooltip(this)
-    }
-
-    if (options.selectedRegions) {
-      this._setSelected('regions', options.selectedRegions)
-    }
-
-    if (options.selectedMarkers) {
-      this._setSelected('_markers', options.selectedMarkers)
-    }
-
-    if (options.focusOn) {
-      this.setFocus(options.focusOn)
-    }
-
-    if (options.visualizeData) {
-      this.dataVisualization = new DataVisualization(options.visualizeData, this)
-    }
-
-    if (options.bindTouchEvents) {
-      if ('ontouchstart' in window) {
-        this._setupContainerTouchEvents()
-      }
-    }
-
-    if (options.series) {
-      this.container.appendChild(this.legendHorizontal = createElement(
-        'div',
-        SERIES_CONTAINER_H_CLASS,
-      ))
-
-      this.container.appendChild(this.legendVertical = createElement(
-        'div',
-        SERIES_CONTAINER_V_CLASS,
-      ))
-
-      this._createSeries()
-    }
-
-    this._emit(Events.onLoaded, [this])
-  }
-
-
-  setBackgroundColor(color: string): void {
-    this.container.style.backgroundColor = color
-  }
-
-
-  getSelectedRegions(): string[] {
-    return this._getSelected('regions')
-  }
-
-  clearSelectedRegions(regions?: string[]): void {
-    const regionsToProcess = this._normalizeRegions(regions) || this._getSelected('regions')
-    regionsToProcess.forEach((key) => {
-      this.regions[key].element.select(false)
-    })
-  }
-
-  setSelectedRegions(regions: string | string[]): void {
-    this.clearSelectedRegions()
-    const normalizedRegions = this._normalizeRegions(regions)
-    if (normalizedRegions) {
-      this._setSelected('regions', normalizedRegions)
-    }
-  }
-
-
-  getSelectedMarkers(): string[] {
-    return this._getSelected('_markers')
-  }
-
-  clearSelectedMarkers(): void {
-    this._clearSelected('_markers')
-  }
-
-  setSelectedMarkers(markers: string | string[]): void {
-    const normalizedMarkers = this._normalizeRegions(markers)
-    if (normalizedMarkers) {
-      this._setSelected('_markers', normalizedMarkers)
-    }
-  }
-
-  addMarkers(config: MarkerConfig | MarkerConfig[]): void {
-    const configs = Array.isArray(config) ? config : [config]
-    this._createMarkers(configs, true)
-  }
-
-  removeMarkers(markers?: string[]): void {
-    const toRemove = markers || Object.keys(this._markers)
-    toRemove.forEach((index) => {
-      const marker = this._markers[index] as any
-      if (marker) {
-        if (typeof marker.remove === 'function') {
-          marker.remove()
-        }
-        else if (marker.shape) {
-          marker.shape.remove()
-          if (marker.label) {
-            marker.label.remove()
-          }
-        }
-        delete this._markers[index]
-      }
-    })
-  }
-
-
-  addLine(from: string, to: string, style: Record<string, any> = {}): void {
-    console.warn('`addLine` method is deprecated, please use `addLines` instead.')
-    this._createLines([{ from, to, style }])
-  }
-
-  addLines(config: LineConfig | LineConfig[]): void {
-    const uids = this._getLinesAsUids()
-    const configs = Array.isArray(config) ? config : [config]
-
-    this._createLines(configs.filter((line) => {
-      return !(uids.includes(getLineUid(line.from, line.to)))
-    }))
-  }
-
-  removeLines(lines: LineConfig[] | string[]): void {
-    if (Array.isArray(lines) && typeof lines[0] !== 'string') {
-      lines = (lines as LineConfig[]).map(line => getLineUid(line.from, line.to))
-    }
-    else if (!Array.isArray(lines)) {
-      lines = this._getLinesAsUids()
-    }
-
-    (lines as string[]).forEach((uid) => {
-      this._lines[uid].dispose()
-      delete this._lines[uid]
-    })
-  }
-
-  removeLine(from: string, to: string): void {
-    console.warn('`removeLine` method is deprecated, please use `removeLines` instead.')
-    const uid = getLineUid(from, to)
-
-    if (Object.prototype.hasOwnProperty.call(this._lines, uid)) {
-      this._lines[uid].element.remove()
-      delete this._lines[uid]
-    }
-  }
-
-  reset(): void {
-    for (const key in this.series || {}) {
-      for (let i = 0; i < (this.series?.[key]?.length || 0); i++) {
-        this.series?.[key][i]?.clear()
-      }
-    }
-
-    if (this.legendHorizontal) {
-      removeElement(this.legendHorizontal)
-      this.legendHorizontal = undefined
-    }
-
-    if (this.legendVertical) {
-      removeElement(this.legendVertical)
-      this.legendVertical = undefined
-    }
-
-    this.scale = this._baseScale
-    this.transX = this._baseTransX
-    this.transY = this._baseTransY
-
-    this._applyTransform()
-    this.clearSelectedMarkers()
-    this.clearSelectedRegions()
-    this.removeMarkers()
-  }
-
-  destroy(destroyInstance = true): void {
-    EventHandler.flush()
-
-    this._tooltip?.dispose()
-
-    this._emit(Events.onDestroyed, [])
-
-    if (destroyInstance) {
-      Object.keys(this).forEach((key) => {
-        try {
-          delete (this as any)[key]
-        }
-        catch {
-        }
-      })
-    }
-  }
-
-  extend(name: string, callback: (...args: any[]) => void): void {
-    if (typeof (this as any)[name] === 'function') {
-      throw new TypeError(`The method [${name}] does already exist, please use another name.`)
-    }
-
-    (Map.prototype as any)[name] = callback
-  }
-
-  mercator = {
-    convert: (lat: number, lng: number): false | { x: number, y: number } => {
-      const centralMeridian = this._mapData.projection?.centralMeridian || 0
-      const result = Projection.merc(lat, lng, centralMeridian)
-      return result
-    },
-  }
-
-  miller = {
-    convert: (lat: number, lng: number): false | { x: number, y: number } => {
-      const centralMeridian = this._mapData.projection?.centralMeridian || 0
-      const result = Projection.mill(lat, lng, centralMeridian)
-      return result
-    },
-  }
-
-  getInsetForPoint(_x: number, _y: number): boolean {
-    return false
-  }
-
-  getMarkerPosition(_config: MarkerConfig): false | { x: number, y: number } {
-    return { x: 0, y: 0 }
-  }
-
-  coordsToPoint(_lat: number, _lng: number): false | { x: number, y: number } {
-    return { x: 0, y: 0 }
-  }
-
-  _repositionMarkers(): void {
-  }
-
-  _repositionLines(): void {
-  }
-
-  _setScale(_scale: number): void {
-  }
-
-
-  _emit(eventName: string, args: any[]): void {
-    for (const event in Events) {
-      if (Events[event as keyof typeof Events] === eventName && typeof this.params[event as keyof MapOptions] === 'function') {
-        this.params[event as keyof MapOptions]?.apply(this, args)
-      }
-    }
-  }
-
-  _getSelected(type: string): string[] {
-    const selected: string[] = []
-
-    for (const key in (this as any)[type]) {
-      if ((this as any)[type][key].element.isSelected) {
-        selected.push(key)
-      }
-    }
-
-    return selected
-  }
-
-  _setSelected(type: string, keys: string[]): void {
-    keys.forEach((key) => {
-      if ((this as any)[type][key]) {
-        (this as any)[type][key].element.select(true)
-      }
-    })
-  }
-
-  _clearSelected(type: string): void {
-    this._getSelected(type).forEach((key) => {
-      (this as any)[type][key].element.select(false)
-    })
-  }
-
-  _getLinesAsUids(): string[] {
-    return Object.keys(this._lines)
-  }
-
-  _normalizeRegions(regions: string | string[] | undefined): string[] | undefined {
-    if (!regions)
-      return undefined
-    return typeof regions === 'string' ? [regions] : regions
-  }
-
-  _createRegions(): void {
-  }
-
-
-  _createMarkers(_markers: MarkerConfig[], _isRecentlyCreated: boolean = false): void {
-  }
-
-  _createLines(_lines: LineConfig[]): void {
-  }
-
-  _createSeries(): void {
-  }
-
-  _repositionLabels(): void {
-  }
-
-  _setupContainerEvents(): void {
-  }
-
-  _setupElementEvents(): void {
-  }
-
-  _setupZoomButtons(): void {
-  }
-
-  _setupContainerTouchEvents(): void {
-  }
-
-  _applyTransform(): void {
-  }
-
-  updateSize(): void {
-  }
-
-  setFocus(_config: FocusOnOptions): void {
-  }
+  static maps: { [key: string]: MapData & { [key: string]: any } };
+  static defaults: MapOptions;
+  params: MapOptions;
+  regions: Record<string, Region>;
+  scale: number;
+  transX: number;
+  transY: number;
+  container: HTMLElement;
+  canvas: SVGCanvasElementInterface;
+  dataVisualization?: DataVisualization;
+  legendHorizontal?: HTMLElement;
+  legendVertical?: HTMLElement;
+  series: { markers: any[], regions: any[], [key: string]: any[] };
+  _mapData: MapData;
+  _markers: Record<string, Marker>;
+  _lines: Record<string, Line>;
+  _defaultWidth: number;
+  _defaultHeight: number;
+  _height: number;
+  _width: number;
+  _baseScale: number;
+  _baseTransX: number;
+  _baseTransY: number;
+  _tooltip?: Tooltip;
+  _linesGroup?: SVGElement;
+  _markersGroup?: SVGElement;
+  _markerLabelsGroup?: SVGElement;
+  _canvasImpl: SVGCanvasElement;
+  constructor(options?: MapOptions);
+  _init(): void;
+  setBackgroundColor(color: string): void;
+  getSelectedRegions(): string[];
+  clearSelectedRegions(regions?: string[]): void;
+  setSelectedRegions(regions: string | string[]): void;
+  getSelectedMarkers(): string[];
+  clearSelectedMarkers(): void;
+  setSelectedMarkers(markers: string | string[]): void;
+  addMarkers(config: MarkerConfig | MarkerConfig[]): void;
+  removeMarkers(markers?: string[]): void;
+  addLine(from: string, to: string, style?: Record<string, any>): void;
+  addLines(config: LineConfig | LineConfig[]): void;
+  removeLines(lines: LineConfig[] | string[]): void;
+  removeLine(from: string, to: string): void;
+  reset(): void;
+  destroy(destroyInstance?: any): void;
+  extend(name: string, callback: (...args: any[]) => void): void;
+  mercator: any;
+  miller: any;
+  getInsetForPoint(_x: number, _y: number): boolean;
+  getMarkerPosition(_config: MarkerConfig): false | { x: number, y: number };
+  coordsToPoint(_lat: number, _lng: number): false | { x: number, y: number };
+  _repositionMarkers(): void;
+  _repositionLines(): void;
+  _setScale(_scale: number): void;
+  _emit(eventName: string, args: any[]): void;
+  _getSelected(type: string): string[];
+  _setSelected(type: string, keys: string[]): void;
+  _clearSelected(type: string): void;
+  _getLinesAsUids(): string[];
+  _normalizeRegions(regions: string | string[] | undefined): string[] | undefined;
+  _createRegions(): void;
+  _createMarkers(_markers: MarkerConfig[], _isRecentlyCreated?: boolean): void;
+  _createLines(_lines: LineConfig[]): void;
+  _createSeries(): void;
+  _repositionLabels(): void;
+  _setupContainerEvents(): void;
+  _setupElementEvents(): void;
+  _setupZoomButtons(): void;
+  _setupContainerTouchEvents(): void;
+  _applyTransform(): void;
+  updateSize(): void;
+  setFocus(_config: FocusOnOptions): void;
 }
-
 export default Map;

package/dist/maps/brasil.d.ts

@@ -1 +1,2 @@
+export declare const brasil: MapData;
 export default brasil;

package/dist/maps/canada.d.ts

@@ -1 +1,2 @@
+export declare const canada: MapData;
 export default canada;

package/dist/maps/iraq.d.ts

@@ -1,5 +1,2 @@
-import type { MapData } from '../types';
-
 export declare const iraq: MapData;
-
 export default iraq;

package/dist/maps/italy.d.ts

@@ -1 +1,2 @@
+export declare const italy: MapData;
 export default italy;

package/dist/maps/russia.d.ts

@@ -1,5 +1,2 @@
-import type { MapData } from 'ts-maps';
-
 export declare const russia: MapData;
-
 export default russia;

package/dist/maps/spain.d.ts

@@ -1 +1,2 @@
+export declare const spain: MapData;
 export default spain;

package/dist/maps/us-aea-en.d.ts

@@ -1,5 +1,2 @@
-import type { MapData } from '../types';
-
 export declare const us_aea_en: MapData;
-
 export default us_aea_en;

package/dist/maps/us-lcc-en.d.ts

@@ -1,5 +1,2 @@
-import type { MapData } from '../types';
-
 export declare const us_lcc_en: MapData;
-
 export default us_lcc_en;

package/dist/maps/us-merc-en.d.ts

@@ -1,5 +1,2 @@
-import type { MapData } from '../types';
-
 export declare const us_merc_en: MapData;
-
 export default us_merc_en;

package/dist/maps/us-mill-en.d.ts

@@ -1,5 +1,2 @@
-import type { MapData } from '../types';
-
 export declare const us_mill_en: MapData;
-
 export default us_mill_en;

package/dist/maps/world-merc.d.ts

@@ -1 +1,2 @@
+export declare const world_merc: MapData;
 export default world_merc;

package/dist/maps/world.d.ts

@@ -1 +1,2 @@
+export declare const world: MapData;
 export default world;

package/dist/projection.d.ts

@@ -1,18 +1 @@
-declare interface Point {
-  x: number
-  y: number
-}
-declare interface Projection {
-  mill: (lat: number, lng: number, c: number) => Point
-  merc: (lat: number, lng: number, c: number) => Point
-  aea: (lat: number, lng: number, c: number) => Point
-  lcc: (lat: number, lng: number, c: number) => Point
-  degRad: number
-  radDeg: number
-  radius: number
-}
-declare const Proj: Projection;
-declare const fi0: unknown;
-declare const fi0: unknown;
-
 export default Proj;

package/dist/scales/ordinal-scale.d.ts

@@ -1,32 +1,12 @@
 import type { ScaleOptions } from '../types';
-
 declare interface Tick {
   value: string
   label: string
 }
 export declare class OrdinalScale {
-  private _scale: Record<string, string>
-
-  constructor(options: ScaleOptions) {
-    this._scale = options.scale
-  }
-
-  getValue(value: string | number): string {
-    return this._scale[String(value)]
-  }
-
-  getTicks(): Tick[] {
-    const ticks: Tick[] = []
-
-    for (const key in this._scale) {
-      ticks.push({
-        value: this._scale[key],
-        label: key,
-      })
-    }
-
-    return ticks
-  }
+  private _scale: Record<string, string>;
+  constructor(options: ScaleOptions);
+  getValue(value: string | number): string;
+  getTicks(): Tick[];
 }
-
 export default OrdinalScale;

package/dist/series.d.ts

@@ -1,4 +1,14 @@
-declare const attrs: Record<string, string>;
-declare const attrs: Record<string, string>;
-
+import type { MapInterface, SeriesOptions } from './types';
+declare class Series {
+  private _map: MapInterface;
+  private _elements: Record<string, any>;
+  private _values: Record<string, number | string>;
+  config: SeriesOptions;
+  scale: any;
+  legend?: any;
+  constructor(config: SeriesOptions, elements: Record<string, any>, map: MapInterface);
+  setValues(values: Record<string, number | string>): void;
+  setAttributes(attrs: Record<string, string>): void;
+  clear(): void;
+}
 export default Series;

package/dist/svg/base-element.d.ts

@@ -1,5 +1,19 @@
+import {  } from '../util/index';
 declare interface SVGConfig {
-  [key: string]: string | number
-}
 
+}
+declare class SVGElement {
+  node: SVGGraphicsElement;
+  protected style: {
+    initial: Record<string, string | number>
+  };
+  constructor(name: string, config?: SVGConfig);
+  protected _createElement(tagName: string): SVGGraphicsElement;
+  addClass(className: string): void;
+  getBBox(): DOMRect;
+  set(property: SVGConfig | string, value?: string | number): void;
+  get(property: string): string | number;
+  applyAttr(property: string, value: string | number): void;
+  remove(): void;
+}
 export default SVGElement;