ts-maps 0.0.0

package/dist/interactable.d.ts

@@ -0,0 +1,7 @@
+declare interface Label {
+  render?: (...args: any[]) => string
+  offsets?: ((key: string) => [number, number]) | Array<[number, number]>
+}
+declare const params: any[];
+
+export default Interactable;

package/dist/italy.d.ts

@@ -0,0 +1 @@
+export default italy;

package/dist/legend.d.ts

@@ -0,0 +1,6 @@
+declare const ticks: unknown;
+declare const legendTitle: unknown;
+declare const tick: unknown;
+declare const tickText: unknown;
+
+export default Legend;

package/dist/line.d.ts

@@ -0,0 +1,29 @@
+declare const LINE_CLASS: 'jvm-line';
+declare interface LineOptions {
+  index: string
+  group: SVGElement
+  map: any
+  animate?: boolean
+  x1: number
+  y1: number
+  x2: number
+  y2: number
+  curvature?: number
+  config?: any
+}
+declare interface LineStyle {
+  initial?: Record<string, string | number>
+  hover?: Record<string, string | number>
+  selected?: Record<string, string | number>
+}
+declare const config: {
+  d: unknown;
+  fill: 'none';
+  dataIndex: unknown
+};
+const { x1, y1, x2, y2 } = this._options
+    return `M${x1},${y1}${this._getQCommand(x1, y1, x2, y2)}${x2},${y2}`
+  }
+declare const curvature: unknown;
+
+export default Line;

package/dist/map.d.ts

@@ -0,0 +1,422 @@
+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`;
+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?: SVGGElement
+  _markersGroup?: SVGGElement
+  _markerLabelsGroup?: SVGGElement
+  _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.node
+    }
+
+    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.node
+      this._markerLabelsGroup = labelsGroup.node
+    }
+
+    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)
+  }
+
+  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 } => {
+      return { x: lng, y: lat } 
+    },
+  }
+
+  miller = {
+    convert: (lat: number, lng: number): false | { x: number, y: number } => {
+      return { x: lng, y: lat } 
+    },
+  }
+
+  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[]): 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/marker.d.ts

@@ -0,0 +1,31 @@
+declare const NAME: 'marker' const JVM_PREFIX = 'jvm-' const MARKER_CLASS = `${JVM_PREFIX}element ${JVM_PREFIX}marker` const MARKER_LABEL_CLASS = `${JVM_PREFIX}element ${JVM_PREFIX}label`;
+declare interface MarkerOptions {
+  index: string
+  map: any
+  group: SVGElement
+  labelsGroup: SVGElement
+  cx: number
+  cy: number
+  label?: {
+    render?: (config: any, key: string) => string
+    offsets?: ((key: string) => [number, number]) | Array<[number, number]>
+  }
+  config?: {
+    offsets?: [number, number]
+    [key: string]: any
+  }
+  isRecentlyCreated?: boolean
+}
+declare interface MarkerStyle {
+  initial: {
+    image?: string
+    [key: string]: any
+  }
+  hover?: Record<string, any>
+  selected?: Record<string, any>
+}
+declare const map: unknown;
+declare const shapeType: unknown;
+declare const labelText: unknown;
+
+export default Marker;

package/dist/options.d.ts

@@ -0,0 +1,5 @@
+import type { MapOptions } from '../types';
+
+declare const defaultOptions: MapOptions;
+
+export default defaultOptions;

package/dist/ordinal-scale.d.ts

@@ -0,0 +1,32 @@
+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
+  }
+}
+
+export default OrdinalScale;

package/dist/projection.d.ts

@@ -0,0 +1,18 @@
+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/region.d.ts

@@ -0,0 +1,21 @@
+declare interface RegionOptions {
+  map: any
+  code: string
+  path: string
+  style: RegionStyle
+  label?: {
+    render?: (key: string) => string
+    offsets?: ((key: string) => [number, number]) | Array<[number, number]>
+  }
+  labelStyle?: Record<string, any>
+  labelsGroup?: SVGElement
+}
+declare interface RegionStyle {
+  initial: Record<string, any>
+  hover?: Record<string, any>
+  selected?: Record<string, any>
+}
+declare const text: unknown;
+declare const regionPath: unknown;
+
+export default Region;

package/dist/reposition-labels.d.ts

@@ -0,0 +1,27 @@
+export default function repositionLabels(this: MapInterface): void {
+  const labels = this.params.labels || {}
+
+  if (labels.regions) {
+    for (const code in this.regions) {
+      const region = this.regions[code] as any
+      if (region.label) {
+        const x = region.labelX * this.scale + this.transX * this.scale
+        const y = region.labelY * this.scale + this.transY * this.scale
+
+        region.label.set({
+          x: Number.isNaN(x) ? 0 : x,
+          y: Number.isNaN(y) ? 0 : y,
+        })
+      }
+    }
+  }
+
+  if (labels.markers) {
+    for (const index in this._markers) {
+      const marker = this._markers[index] as any
+      if (marker && typeof marker.updateLabelPosition === 'function') {
+        marker.updateLabelPosition()
+      }
+    }
+  }
+};

package/dist/reposition-lines.d.ts

@@ -0,0 +1,32 @@
+export default function repositionLines(this: MapInterface): void {
+  const curvature = (this.params.lines?.curvature as number) || 0.5
+
+  Object.values(this._lines || {}).forEach((line: Line) => {
+    const startMarker = Object.values(this._markers || {}).find(
+      ({ config }) => config.name === line.getConfig().from,
+    )
+
+    const endMarker = Object.values(this._markers || {}).find(
+      ({ config }) => config.name === line.getConfig().to,
+    )
+
+    if (startMarker && endMarker) {
+      const point1 = this.getMarkerPosition(startMarker.config)
+      const point2 = this.getMarkerPosition(endMarker.config)
+
+      if (point1 && point2) {
+        const { x: x1, y: y1 } = point1
+        const { x: x2, y: y2 } = point2
+
+        const midX = (x1 + x2) / 2
+        const midY = (y1 + y2) / 2
+        const curveX = midX + curvature * (y2 - y1)
+        const curveY = midY - curvature * (x2 - x1)
+
+        line.setStyle({
+          d: `M${x1},${y1} Q${curveX},${curveY} ${x2},${y2}`,
+        })
+      }
+    }
+  })
+};

package/dist/reposition-markers.d.ts

@@ -0,0 +1,26 @@
+export default function repositionMarkers(this: MapInterface): void {
+  if (!this._markers)
+    return
+
+  for (const index in this._markers) {
+    const marker = this._markers[index] as any
+    if (!marker || !marker.shape)
+      continue
+
+    const point = this.getMarkerPosition(marker.config)
+
+    if (point !== false) {
+      const cx = Number.isNaN(point.x) ? 0 : point.x
+      const cy = Number.isNaN(point.y) ? 0 : point.y
+
+      marker.shape.set({
+        cx,
+        cy,
+      })
+
+      if (marker.label) {
+        marker.updateLabelPosition()
+      }
+    }
+  }
+};

package/dist/resize.d.ts

@@ -0,0 +1,5 @@
+import type { MapInterface } from '../types';
+
+export declare function resize(this: MapInterface): void;
+
+export default resize;

package/dist/series.d.ts

@@ -0,0 +1,4 @@
+declare const attrs: Record<string, string>;
+declare const attrs: Record<string, string>;
+
+export default Series;