ts-maps 0.2.5 → 0.2.6

package/dist/components/base.d.ts

@@ -1,9 +1,3 @@
-declare interface BBox {
-  x: number
-  y: number
-  width: number
-  height: number
-}
 declare interface BaseComponentShape {
   remove: () => void
   setStyle: (property: string | Record<string, any>, value?: string | number) => void
@@ -15,5 +9,9 @@ declare interface BaseComponentShape {
   isSelected?: boolean
   updateStyle?: () => void
 }
-
+declare class BaseComponent {
+  protected _tooltip?: HTMLElement;
+  protected shape?: BaseComponentShape;
+  dispose(): void;
+}
 export default BaseComponent;

package/dist/components/concerns/interactable.d.ts

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

package/dist/components/line.d.ts

@@ -1,4 +1,4 @@
-declare const LINE_CLASS: 'jvm-line';
+import BaseComponent from './base';
 declare interface LineOptions {
   index: string
   group: SVGElement
@@ -16,14 +16,14 @@ declare interface LineStyle {
   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;
-
+declare class Line extends BaseComponent {
+  private _options: LineOptions;
+  private _style: LineStyle;
+  constructor(options: LineOptions, style: LineStyle);
+  setStyle(property: string, value: string | number): void;
+  getConfig(): any;
+  _draw(): void;
+  _getDAttribute(): string;
+  _getQCommand(x1: number, y1: number, x2: number, y2: number): string;
+}
 export default Line;

package/dist/components/marker.d.ts

@@ -1,4 +1,4 @@
-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`;
+import BaseComponent from './base';
 declare interface MarkerOptions {
   index: string
   map: any
@@ -24,8 +24,27 @@ declare interface MarkerStyle {
   hover?: Record<string, any>
   selected?: Record<string, any>
 }
-declare const map: unknown;
-declare const shapeType: unknown;
-declare const labelText: unknown;
-
+declare class Marker extends BaseComponent {
+  private _options: MarkerOptions;
+  private _style: MarkerStyle;
+  private _labelX: number | null;
+  private _labelY: number | null;
+  private _offsets: [number, number] | null;
+  private _isImage: boolean;
+  label?: any;
+  isHovered?: boolean;
+  isSelected: boolean;
+  setStyle: (property: string, value: any) => void;
+  remove: () => void;
+  hover: (state: boolean) => void;
+  select: (state: boolean) => void;
+  protected _setStatus: (property: string, state: boolean) => void;
+  constructor(options: MarkerOptions, style: MarkerStyle);
+  getConfig(): any;
+  updateLabelPosition(): void;
+  _draw(): void;
+  _drawLabel(): void;
+  getLabelText(key: string, label?: any): string | undefined;
+  getLabelOffsets(key: string, label?: any): [number, number];
+}
 export default Marker;

package/dist/components/region.d.ts

@@ -1,3 +1,4 @@
+import BaseComponent from './base';
 declare interface RegionOptions {
   map: any
   code: string
@@ -15,7 +16,31 @@ declare interface RegionStyle {
   hover?: Record<string, any>
   selected?: Record<string, any>
 }
-declare const text: unknown;
-declare const regionPath: unknown;
-
+declare class Region extends BaseComponent {
+  private _map: any;
+  labelX: number;
+  labelY: number;
+  label?: any;
+  isHovered?: boolean;
+  isSelected: boolean;
+  shape: any;
+  setStyle: (property: string, value: any) => void;
+  remove: () => void;
+  hover: (state: boolean) => void;
+  select: (state: boolean) => void;
+  protected _setStatus: (property: string, state: boolean) => void;
+  constructor({
+  map,
+  code,
+  path,
+  style,
+  label,
+  labelStyle,
+  labelsGroup,
+}: RegionOptions);
+  _createRegion(path: string, code: string, style: RegionStyle): any;
+  updateLabelPosition(): void;
+  getLabelText(key: string, label?: any): string | undefined;
+  getLabelOffsets(key: string, label?: any): [number, number];
+}
 export default Region;

package/dist/components/tooltip.d.ts

@@ -1,80 +1,22 @@
+import {  } from '../util';
+import BaseComponent from './base';
 import type { MapInterface } from '../types';
-
 export declare class Tooltip extends BaseComponent {
-  private _map: MapInterface
-  protected _tooltip: HTMLElement
-  private _hoveredRegion: string | null = null
-  private _hoveredMarker: string | null = null
-  private _customPositioning: boolean = true 
-
-  constructor(map: MapInterface) {
-    super()
-
-    this._map = map
-    this._tooltip = createElement('div', 'jvm-tooltip', '')
-    this._tooltip.style.display = 'none'
-    this._map.container.appendChild(this._tooltip)
-
-
-    return this
-  }
-
-  getElement(): HTMLElement {
-    return this._tooltip
-  }
-
-  show(text: string): void {
-    this._tooltip.style.display = 'block'
-    this._tooltip.innerHTML = text
-    this._tooltip.classList.add('active')
-  }
-
-  hide(): void {
-    this._tooltip.style.display = 'none'
-    this._tooltip.classList.remove('active')
-    this._hoveredRegion = null
-    this._hoveredMarker = null
-  }
-
-  text(text: string): void {
-    if (this._tooltip) {
-      this._tooltip.innerHTML = text
-    }
-  }
-
-  html(html: string): void {
-    if (this._tooltip) {
-      this._tooltip.innerHTML = html
-    }
-  }
-
-  css(css: Record<string, string>): this {
-    if (this._customPositioning && (css.top || css.left)) {
-      return this
-    }
-
-    for (const style in css) {
-      this._tooltip.style[style as any] = css[style]
-    }
-
-    return this
-  }
-
-  setHoveredRegion(code: string): void {
-    this._hoveredRegion = code
-  }
-
-  getHoveredRegion(): string | null {
-    return this._hoveredRegion
-  }
-
-  setHoveredMarker(index: string): void {
-    this._hoveredMarker = index
-  }
-
-  getHoveredMarker(): string | null {
-    return this._hoveredMarker
-  }
+  private _map: MapInterface;
+  protected _tooltip: HTMLElement;
+  private _hoveredRegion: string | null;
+  private _hoveredMarker: string | null;
+  private _customPositioning: boolean;
+  constructor(map: MapInterface);
+  getElement(): HTMLElement;
+  show(text: string): void;
+  hide(): void;
+  text(text: string): void;
+  html(html: string): void;
+  css(css: Record<string, string>): this;
+  setHoveredRegion(code: string): void;
+  getHoveredRegion(): string | null;
+  setHoveredMarker(index: string): void;
+  getHoveredMarker(): string | null;
 }
-
 export default Tooltip;

package/dist/core/apply-transform.d.ts

@@ -1,47 +1,7 @@
-export default function applyTransform(this: MapInterface): void {
-  let maxTransX: number, maxTransY: number, minTransX: number, minTransY: number
-
-  if (this._defaultWidth * this.scale <= this._width) {
-    maxTransX = (this._width - this._defaultWidth * this.scale) / (2 * this.scale)
-    minTransX = (this._width - this._defaultWidth * this.scale) / (2 * this.scale)
-  }
-  else {
-    maxTransX = 0
-    minTransX = (this._width - this._defaultWidth * this.scale) / this.scale
-  }
-
-  if (this._defaultHeight * this.scale <= this._height) {
-    maxTransY = (this._height - this._defaultHeight * this.scale) / (2 * this.scale)
-    minTransY = (this._height - this._defaultHeight * this.scale) / (2 * this.scale)
-  }
-  else {
-    maxTransY = 0
-    minTransY = (this._height - this._defaultHeight * this.scale) / this.scale
-  }
-
-  if (this.transY > maxTransY) {
-    this.transY = maxTransY
-  }
-  else if (this.transY < minTransY) {
-    this.transY = minTransY
-  }
-
-  if (this.transX > maxTransX) {
-    this.transX = maxTransX
-  }
-  else if (this.transX < minTransX) {
-    this.transX = minTransX
-  }
-
-  this.canvas.applyTransformParams(this.scale, this.transX, this.transY)
-
-  if (this._markers) {
-    this._repositionMarkers()
-  }
-
-  if (this._lines) {
-    this._repositionLines()
-  }
-
-  this._repositionLabels()
-};
+import type { MapInterface } from '../types';
+/**
+ * Apply transformation to the map
+ * This function calculates the appropriate translation and scale values
+ * and applies them to the map canvas
+ */
+export declare function applyTransform(this: MapInterface): void;

package/dist/core/coords-to-point.d.ts

@@ -1,28 +1,12 @@
+import type { MapInterface } from '../types';
+/**
+ * Convert latitude and longitude to point coordinates
+ * @param lat - Latitude
+ * @param lng - Longitude
+ * @returns Point coordinates or false if the point is outside the map
+ */
+export declare function coordsToPoint(this: MapInterface, lat: number, lng: number): Point | false;
 declare interface Point {
   x: number
   y: number
-}
-
-export default function coordsToPoint(this: MapInterface, lat: number, lng: number): Point | false {
-  const projection = this.params.map?.projection || 'mercator'
-  const coords = projection === 'mercator' ? this.mercator.convert(lat, lng) : this.miller.convert(lat, lng)
-
-  if (coords === false) {
-    return false
-  }
-
-  const inset = this.getInsetForPoint(coords.x, coords.y)
-  if (!inset) {
-    return false
-  }
-
-  const { bbox } = inset
-
-  const x = (coords.x - bbox[0].x) / (bbox[1].x - bbox[0].x) * inset.width * this.scale
-  const y = (coords.y - bbox[0].y) / (bbox[1].y - bbox[0].y) * inset.height * this.scale
-
-  return {
-    x: x + this.transX * this.scale + inset.left * this.scale,
-    y: y + this.transY * this.scale + inset.top * this.scale,
-  }
-};
+}

package/dist/core/create-lines.d.ts

@@ -1,39 +1,2 @@
-export default function createLines(this: MapInterface, lines: LineConfig[]): void {
-  const markers = this._markers || {}
-  const { style, elements: _, ...rest } = this.params.lines || {}
-
-  let point1: { x: number, y: number } | false = false
-  let point2: { x: number, y: number } | false = false
-
-  for (const index in lines) {
-    const lineConfig = lines[index]
-
-    for (const { config: markerConfig } of Object.values(markers)) {
-      if (markerConfig.name === lineConfig.from) {
-        point1 = this.getMarkerPosition(markerConfig)
-      }
-
-      if (markerConfig.name === lineConfig.to) {
-        point2 = this.getMarkerPosition(markerConfig)
-      }
-    }
-
-    if (point1 !== false && point2 !== false) {
-      this._lines = this._lines || {}
-      this._lines[getLineUid(lineConfig.from, lineConfig.to)] = new Line(
-        {
-          index,
-          map: this,
-          group: this._linesGroup,
-          config: lineConfig,
-          x1: point1.x,
-          y1: point1.y,
-          x2: point2.x,
-          y2: point2.y,
-          ...rest,
-        },
-        merge({ initial: style }, { initial: lineConfig.style || {} }, true),
-      )
-    }
-  }
-};
+import type { LineConfig, MapInterface } from '../types';
+export declare function createLines(this: MapInterface, lines: LineConfig[]): void;

package/dist/core/create-markers.d.ts

@@ -1,50 +1,2 @@
-export default function createMarkers(
-  this: MapInterface,
-  markers: Record<string, MarkerConfig> = {},
-  isRecentlyCreated = false,
-): void {
-  for (let index in markers) {
-    const config = markers[index]
-    const point = this.getMarkerPosition(config)
-    const uid = config.coords.join(':')
-
-    if (!point) {
-      continue
-    }
-
-    if (isRecentlyCreated) {
-      if (
-        Object.keys(this._markers || {}).filter(i => this._markers?.[i]._uid === uid).length
-      ) {
-        continue
-      }
-
-      index = String(Object.keys(this._markers || {}).length)
-    }
-
-    const marker = new Marker(
-      {
-        index,
-        map: this,
-        label: this.params.labels?.markers,
-        labelsGroup: this._markerLabelsGroup,
-        cx: point.x,
-        cy: point.y,
-        group: this._markersGroup,
-        config,
-        isRecentlyCreated,
-      },
-      merge({ initial: {} }, merge(this.params.markerStyle || {}, { ...(config.style || {}) }, true)),
-    )
-
-    if (this._markers?.[index]) {
-      this.removeMarkers([index])
-    }
-
-    this._markers[index] = {
-      _uid: uid,
-      config,
-      element: marker as unknown as MarkerInstance,
-    }
-  }
-};
+import type { MapInterface, MarkerConfig } from '../types';
+export declare function createMarkers(this: MapInterface, markers?: Record<string, MarkerConfig>, isRecentlyCreated?: any): void;

package/dist/core/create-regions.d.ts

@@ -1,22 +1,2 @@
-export default function createRegions(this: MapInterface): void {
-  this._regionLabelsGroup = this._regionLabelsGroup || this.canvas.createGroup('jvm-regions-labels-group')
-
-  for (const code in this._mapData.paths) {
-    const region = new Region({
-      map: this,
-      code,
-      path: this._mapData.paths[code].path,
-      style: merge({ initial: {} }, this.params.regionStyle || {}),
-      labelStyle: this.params.regionLabelStyle,
-      labelsGroup: this._regionLabelsGroup,
-      label: this.params.labels?.regions ? {} : undefined,
-    })
-
-    this.regions[code] = {
-      config: this._mapData.paths[code],
-      element: region,
-      path: this._mapData.paths[code].path,
-      name: code,
-    } as RegionType
-  }
-};
+import type { MapInterface } from '../types';
+export declare function createRegions(this: MapInterface): void;

package/dist/core/create-series.d.ts

@@ -1,20 +1,3 @@
 import type { MapInterface } from '../types';
-
-declare type SeriesKey = 'markers' | 'regions'
-
-export default function createSeries(this: MapInterface): void {
-  this.series = { markers: [], regions: [] }
-
-  for (const key in this.params.series) {
-    const seriesKey = key as SeriesKey
-    if (this.params.series[seriesKey]) {
-      for (let i = 0; i < this.params.series[seriesKey].length; i++) {
-        this.series[seriesKey][i] = new Series(
-          this.params.series[seriesKey][i],
-          seriesKey === 'markers' ? (this._markers || {}) : this.regions,
-          this,
-        )
-      }
-    }
-  }
-}
+export declare function createSeries(this: MapInterface): void;
+declare type SeriesKey = 'markers' | 'regions'

package/dist/core/get-inset-for-point.d.ts

@@ -1,3 +1,5 @@
+import type { MapInterface } from '../types';
+export declare function getInsetForPoint(this: MapInterface, x: number, y: number): Inset | undefined;
 declare interface Point {
   x: number
   y: number
@@ -8,33 +10,4 @@ declare interface Inset {
   height: number
   left: number
   top: number
-  [key: string]: any
-}
-
-export default function getInsetForPoint(this: MapInterface, x: number, y: number): Inset | undefined {
-  const insets = Map.maps[this.params.map.name].insets
-
-  if (!insets || insets.length === 0) {
-    return undefined
-  }
-
-  for (let index = 0; index < insets.length; index++) {
-    const inset = insets[index]
-
-    if (!inset || !inset.bbox || inset.bbox.length < 2) {
-      continue
-    }
-
-    const [start, end] = inset.bbox
-
-    if (!start || !end) {
-      continue
-    }
-
-    if (x > start.x && x < end.x && y > start.y && y < end.y) {
-      return inset
-    }
-  }
-
-  return undefined
-};
+}

package/dist/core/get-marker-position.d.ts

@@ -1,15 +1,6 @@
+import type { MapInterface, MarkerConfig } from '../types';
+export declare function getMarkerPosition(this: MapInterface, { coords }: MarkerConfig): Point | false;
 declare interface Point {
   x: number
   y: number
-}
-
-export default function getMarkerPosition(this: MapInterface, { coords }: MarkerConfig): Point | false {
-  if (Map.maps[this.params.map.name].projection) {
-    return this.coordsToPoint(...coords)
-  }
-
-  return {
-    x: coords[0] * this.scale + this.transX * this.scale,
-    y: coords[1] * this.scale + this.transY * this.scale,
-  }
-};
+}

package/dist/core/index.d.ts

@@ -1,24 +1 @@
-declare interface CoreModule {
-  _setupContainerEvents: typeof _setupContainerEvents
-  _setupElementEvents: typeof _setupElementEvents
-  _setupZoomButtons: typeof _setupZoomButtons
-  _setupContainerTouchEvents: typeof _setupContainerTouchEvents
-  _createRegions: typeof _createRegions
-  _createLines: typeof _createLines
-  _createMarkers: typeof _createMarkers
-  _createSeries: typeof _createSeries
-  _applyTransform: typeof _applyTransform
-  _resize: typeof _resize
-  _setScale: typeof _setScale
-  setFocus: typeof setFocus
-  updateSize: typeof updateSize
-  coordsToPoint: typeof coordsToPoint
-  getInsetForPoint: typeof getInsetForPoint
-  getMarkerPosition: typeof getMarkerPosition
-  _repositionLines: typeof _repositionLines
-  _repositionMarkers: typeof _repositionMarkers
-  _repositionLabels: typeof _repositionLabels
-}
-declare const core: CoreModule;
-
 export default core;

package/dist/core/reposition-labels.d.ts

@@ -1,23 +1,2 @@
-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 || !region.element || !region.element.label) {
-        continue
-      }
-      region.element.updateLabelPosition()
-    }
-  }
-
-  if (labels.markers) {
-    for (const index in this._markers) {
-      const marker = this._markers[index] as any
-      if (marker.element && typeof marker.element.updateLabelPosition === 'function') {
-        marker.element.updateLabelPosition()
-      }
-    }
-  }
-};
+import type { MapInterface } from '../types';
+export declare function repositionLabels(this: MapInterface): void;

package/dist/core/reposition-lines.d.ts

@@ -1,32 +1,2 @@
-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}`,
-        })
-      }
-    }
-  })
-};
+import type { MapInterface } from '../types';
+export declare function repositionLines(this: MapInterface): void;

package/dist/core/reposition-markers.d.ts

@@ -1,23 +1,2 @@
-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.element || !marker.element.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.element.shape.set({
-        cx,
-        cy,
-      })
-    }
-  }
-};
+import type { MapInterface } from '../types';
+export declare function repositionMarkers(this: MapInterface): void;

package/dist/core/resize.d.ts

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