ts-maps 0.3.1 → 0.3.2

package/dist/index.js

@@ -275,17 +275,17 @@ var init_storage = __esm(() => {
 // src/core-map/core/Util.ts
 var exports_Util = {};
 __export(exports_Util, {
-  wrapNum: () => wrapNum,
-  throttle: () => throttle,
-  template: () => template,
-  stamp: () => stamp,
-  splitWords: () => splitWords,
-  setOptions: () => setOptions,
-  setLastId: () => setLastId,
-  noop: () => noop,
-  lastId: () => lastId,
+  falseFn: () => falseFn,
   formatNum: () => formatNum,
-  falseFn: () => falseFn
+  lastId: () => lastId,
+  noop: () => noop,
+  setLastId: () => setLastId,
+  setOptions: () => setOptions,
+  splitWords: () => splitWords,
+  stamp: () => stamp,
+  template: () => template,
+  throttle: () => throttle,
+  wrapNum: () => wrapNum
 });
 function stamp(obj) {
   if (!("_tsmap_id" in obj)) {
@@ -1810,10 +1810,10 @@ var init_Browser = __esm(() => {
 // src/core-map/dom/DomEvent.PointerEvents.ts
 var exports_DomEvent_PointerEvents = {};
 __export(exports_DomEvent_PointerEvents, {
-  getPointers: () => getPointers,
-  enablePointerDetection: () => enablePointerDetection,
+  cleanupPointers: () => cleanupPointers,
   disablePointerDetection: () => disablePointerDetection,
-  cleanupPointers: () => cleanupPointers
+  enablePointerDetection: () => enablePointerDetection,
+  getPointers: () => getPointers
 });
 function enablePointerDetection(el) {
   el.addEventListener("pointerdown", _onSet, { capture: true });
@@ -1930,21 +1930,21 @@ var init_DomEvent_DoubleTap = __esm(() => {
 // src/core-map/dom/DomUtil.ts
 var exports_DomUtil = {};
 __export(exports_DomUtil, {
-  toFront: () => toFront,
-  toBack: () => toBack,
-  setTransform: () => setTransform,
-  setPosition: () => setPosition,
-  restoreOutline: () => restoreOutline,
-  preventOutline: () => preventOutline,
-  getSizedParentNode: () => getSizedParentNode,
-  getScale: () => getScale,
-  getPosition: () => getPosition,
-  get: () => get,
-  enableTextSelection: () => enableTextSelection,
-  enableImageDrag: () => enableImageDrag,
-  disableTextSelection: () => disableTextSelection,
+  create: () => create,
   disableImageDrag: () => disableImageDrag,
-  create: () => create
+  disableTextSelection: () => disableTextSelection,
+  enableImageDrag: () => enableImageDrag,
+  enableTextSelection: () => enableTextSelection,
+  get: () => get,
+  getPosition: () => getPosition,
+  getScale: () => getScale,
+  getSizedParentNode: () => getSizedParentNode,
+  preventOutline: () => preventOutline,
+  restoreOutline: () => restoreOutline,
+  setPosition: () => setPosition,
+  setTransform: () => setTransform,
+  toBack: () => toBack,
+  toFront: () => toFront
 });
 function get(id) {
   return typeof id === "string" ? document.getElementById(id) : id;
@@ -2054,19 +2054,19 @@ var init_DomUtil = __esm(() => {
 // src/core-map/dom/DomEvent.ts
 var exports_DomEvent = {};
 __export(exports_DomEvent, {
-  stopPropagation: () => stopPropagation,
-  stop: () => stop,
-  preventDefault: () => preventDefault,
-  on: () => on,
-  off: () => off,
-  isExternalTarget: () => isExternalTarget,
-  getWheelPxFactor: () => getWheelPxFactor,
-  getWheelDelta: () => getWheelDelta,
-  getPropagationPath: () => getPropagationPath,
-  getPointerPosition: () => getPointerPosition,
-  disableScrollPropagation: () => disableScrollPropagation,
+  PointerEvents: () => exports_DomEvent_PointerEvents,
   disableClickPropagation: () => disableClickPropagation,
-  PointerEvents: () => exports_DomEvent_PointerEvents
+  disableScrollPropagation: () => disableScrollPropagation,
+  getPointerPosition: () => getPointerPosition,
+  getPropagationPath: () => getPropagationPath,
+  getWheelDelta: () => getWheelDelta,
+  getWheelPxFactor: () => getWheelPxFactor,
+  isExternalTarget: () => isExternalTarget,
+  off: () => off,
+  on: () => on,
+  preventDefault: () => preventDefault,
+  stop: () => stop,
+  stopPropagation: () => stopPropagation
 });
 function on(obj, types2, fn, context) {
   if (types2 && typeof types2 === "object") {
@@ -2489,18 +2489,18 @@ var init_Events = __esm(() => {
 // src/core-map/dom/easing.ts
 var exports_easing = {};
 __export(exports_easing, {
-  linear: () => linear,
-  easeOutQuart: () => easeOutQuart,
-  easeOutQuad: () => easeOutQuad,
-  easeOutCubic: () => easeOutCubic,
-  easeOutBack: () => easeOutBack,
-  easeInQuart: () => easeInQuart,
-  easeInQuad: () => easeInQuad,
-  easeInOutQuart: () => easeInOutQuart,
-  easeInOutQuad: () => easeInOutQuad,
-  easeInOutCubic: () => easeInOutCubic,
+  cubicBezier: () => cubicBezier,
   easeInCubic: () => easeInCubic,
-  cubicBezier: () => cubicBezier
+  easeInOutCubic: () => easeInOutCubic,
+  easeInOutQuad: () => easeInOutQuad,
+  easeInOutQuart: () => easeInOutQuart,
+  easeInQuad: () => easeInQuad,
+  easeInQuart: () => easeInQuart,
+  easeOutBack: () => easeOutBack,
+  easeOutCubic: () => easeOutCubic,
+  easeOutQuad: () => easeOutQuad,
+  easeOutQuart: () => easeOutQuart,
+  linear: () => linear
 });
 function linear(t) {
   return t;
@@ -11870,23 +11870,23 @@ init_LatLngBounds();
 init_Point();
 var exports_LineUtil = {};
 __export(exports_LineUtil, {
-  simplify: () => simplify,
-  polylineCenter: () => polylineCenter,
-  pointToSegmentDistance: () => pointToSegmentDistance,
-  isFlat: () => isFlat,
-  closestPointOnSegment: () => closestPointOnSegment,
-  clipSegment: () => clipSegment,
-  _sqClosestPointOnSegment: () => _sqClosestPointOnSegment,
+  _getBitCode: () => _getBitCode,
   _getEdgeIntersection: () => _getEdgeIntersection,
-  _getBitCode: () => _getBitCode
+  _sqClosestPointOnSegment: () => _sqClosestPointOnSegment,
+  clipSegment: () => clipSegment,
+  closestPointOnSegment: () => closestPointOnSegment,
+  isFlat: () => isFlat,
+  pointToSegmentDistance: () => pointToSegmentDistance,
+  polylineCenter: () => polylineCenter,
+  simplify: () => simplify
 });
 
 // src/core-map/geometry/PolyUtil.ts
 var exports_PolyUtil = {};
 __export(exports_PolyUtil, {
-  polygonCenter: () => polygonCenter,
+  centroid: () => centroid,
   clipPolygon: () => clipPolygon,
-  centroid: () => centroid
+  polygonCenter: () => polygonCenter
 });
 init_LatLng();
 init_LatLngBounds();
@@ -12161,10 +12161,10 @@ init_TerrainSource();
 // src/core-map/geo/projection/index.ts
 var exports_projection = {};
 __export(exports_projection, {
-  SphericalMercator: () => SphericalMercator,
-  Mercator: () => Mercator,
+  Globe: () => Globe,
   LonLat: () => LonLat,
-  Globe: () => Globe
+  Mercator: () => Mercator,
+  SphericalMercator: () => SphericalMercator
 });
 
 // src/core-map/geo/projection/Projection.Globe.ts
@@ -12323,26 +12323,26 @@ class SimpleCRS extends CRS {
 // src/core-map/services/index.ts
 var exports_services = {};
 __export(exports_services, {
-  valhallaMatrix: () => valhallaMatrix,
-  valhallaDirections: () => valhallaDirections,
-  defaultMatrix: () => defaultMatrix,
-  defaultIsochrone: () => defaultIsochrone,
-  defaultGeocoder: () => defaultGeocoder,
-  defaultDirections: () => defaultDirections,
-  ValhallaMatrix: () => ValhallaMatrix,
-  ValhallaIsochrone: () => ValhallaIsochrone,
-  ValhallaDirections: () => ValhallaDirections,
-  PhotonGeocoder: () => PhotonGeocoder,
-  OSRMMatrix: () => OSRMMatrix,
-  OSRMDirections: () => OSRMDirections,
-  NominatimGeocoder: () => NominatimGeocoder,
-  MaptilerGeocoder: () => MaptilerGeocoder,
-  MapboxMatrix: () => MapboxMatrix,
-  MapboxIsochrone: () => MapboxIsochrone,
-  MapboxGeocoder: () => MapboxGeocoder,
-  MapboxDirections: () => MapboxDirections,
+  GoogleDirections: () => GoogleDirections,
   GoogleGeocoder: () => GoogleGeocoder,
-  GoogleDirections: () => GoogleDirections
+  MapboxDirections: () => MapboxDirections,
+  MapboxGeocoder: () => MapboxGeocoder,
+  MapboxIsochrone: () => MapboxIsochrone,
+  MapboxMatrix: () => MapboxMatrix,
+  MaptilerGeocoder: () => MaptilerGeocoder,
+  NominatimGeocoder: () => NominatimGeocoder,
+  OSRMDirections: () => OSRMDirections,
+  OSRMMatrix: () => OSRMMatrix,
+  PhotonGeocoder: () => PhotonGeocoder,
+  ValhallaDirections: () => ValhallaDirections,
+  ValhallaIsochrone: () => ValhallaIsochrone,
+  ValhallaMatrix: () => ValhallaMatrix,
+  defaultDirections: () => defaultDirections,
+  defaultGeocoder: () => defaultGeocoder,
+  defaultIsochrone: () => defaultIsochrone,
+  defaultMatrix: () => defaultMatrix,
+  valhallaDirections: () => valhallaDirections,
+  valhallaMatrix: () => valhallaMatrix
 });
 
 // src/core-map/services/providers/Google.ts
@@ -13807,6 +13807,152 @@ LayersControl.setDefaultOptions({
     return nameA < nameB ? -1 : nameB < nameA ? 1 : 0;
   }
 });
+// src/core-map/control/LocateControl.ts
+init_DomEvent();
+init_DomUtil();
+var CLASS = "tsmap-control-locate";
+
+class LocateControl extends Control {
+  onAdd(map) {
+    const options = this.options;
+    const container = create("div", `${CLASS} tsmap-bar`);
+    const link = create("a", `${CLASS}-button`, container);
+    link.href = "#";
+    link.title = options.title ?? "Show your location";
+    link.setAttribute("role", "button");
+    link.setAttribute("aria-label", link.title);
+    link.innerHTML = '<span class="tsmap-locate-icon" aria-hidden="true"></span>';
+    disableClickPropagation(link);
+    on(link, "click", stop);
+    on(link, "click", this._onClick, this);
+    this._button = link;
+    this._setState("idle");
+    map.on("dragstart zoomstart", this._stopFollowing, this);
+    return container;
+  }
+  onRemove(map) {
+    map.off("dragstart zoomstart", this._stopFollowing, this);
+    this._clearWatch();
+    this._clearMarker();
+  }
+  start() {
+    this._locate();
+    return this;
+  }
+  stop() {
+    this._clearWatch();
+    this._clearMarker();
+    this._setState("idle");
+    return this;
+  }
+  _onClick() {
+    if (this._following) {
+      this.stop();
+      return;
+    }
+    this._locate();
+  }
+  _locate() {
+    const nav = typeof navigator !== "undefined" ? navigator : undefined;
+    if (!nav?.geolocation) {
+      this._setState("denied");
+      this._map?.fire?.("locateerror", { message: "Geolocation is not available in this browser" });
+      return;
+    }
+    const options = this.options;
+    this._setState("locating");
+    const positionOptions = {
+      enableHighAccuracy: options.enableHighAccuracy ?? true,
+      timeout: options.timeout ?? 1e4,
+      maximumAge: options.maximumAge ?? 60000
+    };
+    const onError = (error) => {
+      this._clearWatch();
+      this._setState("denied");
+      this._map?.fire?.("locateerror", { code: error.code, message: error.message });
+    };
+    if (options.follow === false) {
+      nav.geolocation.getCurrentPosition((p) => this._onPosition(p, true), onError, positionOptions);
+      return;
+    }
+    this._following = true;
+    this._watchId = nav.geolocation.watchPosition((p) => this._onPosition(p, true), onError, positionOptions);
+  }
+  _onPosition(position, recenter) {
+    const options = this.options;
+    const { latitude, longitude, accuracy } = position.coords;
+    const latlng = [latitude, longitude];
+    this._setState(this._following ? "active" : "idle");
+    if (recenter && this._map) {
+      const zoom = options.zoom === null ? this._map.getZoom() : options.zoom ?? 16;
+      this._map.setView(latlng, zoom);
+    }
+    if (options.showMarker !== false)
+      this._updateMarker(latlng, accuracy);
+    this._map?.fire?.("locatefound", { latlng, accuracy, position });
+  }
+  _updateMarker(latlng, accuracy) {
+    const map = this._map;
+    if (!map)
+      return;
+    const circleFactory = map.circle ?? globalThis.tsmapCircle;
+    if (typeof circleFactory !== "function")
+      return;
+    if (this._accuracyCircle) {
+      this._accuracyCircle.setLatLng?.(latlng);
+      this._accuracyCircle.setRadius?.(accuracy);
+      return;
+    }
+    this._accuracyCircle = circleFactory.call(map, latlng, {
+      radius: accuracy,
+      className: "tsmap-locate-accuracy",
+      interactive: false
+    });
+    this._accuracyCircle?.addTo?.(map);
+  }
+  _clearMarker() {
+    this._accuracyCircle?.remove?.();
+    this._accuracyCircle = undefined;
+    this._marker?.remove?.();
+    this._marker = undefined;
+  }
+  _stopFollowing() {
+    if (!this._following)
+      return;
+    this._following = false;
+    this._clearWatch();
+    this._setState("idle");
+  }
+  _clearWatch() {
+    if (this._watchId !== undefined && typeof navigator !== "undefined")
+      navigator.geolocation?.clearWatch(this._watchId);
+    this._watchId = undefined;
+    this._following = false;
+  }
+  _setState(state) {
+    const button = this._button;
+    if (!button)
+      return;
+    const options = this.options;
+    for (const name of ["idle", "locating", "active", "denied"])
+      button.classList.remove(`${CLASS}-${name}`);
+    button.classList.add(`${CLASS}-${state}`);
+    const title = state === "locating" ? options.titleLocating ?? "Finding your location…" : state === "active" ? options.titleActive ?? "Following your location" : state === "denied" ? options.titleDenied ?? "Location unavailable — check browser permissions" : options.title ?? "Show your location";
+    button.title = title;
+    button.setAttribute("aria-label", title);
+    button.setAttribute("aria-pressed", String(state === "active"));
+    button.setAttribute("data-state", state);
+  }
+}
+LocateControl.setDefaultOptions({
+  position: "topright",
+  zoom: 16,
+  follow: true,
+  enableHighAccuracy: true,
+  timeout: 1e4,
+  maximumAge: 60000,
+  showMarker: true
+});
 // src/core-map/control/ScaleControl.ts
 init_DomUtil();
 class ScaleControl extends Control {
@@ -18445,7 +18591,8 @@ var control2 = Object.assign(factory(Control), {
   zoom: factory(ZoomControl),
   layers: factory(LayersControl),
   attribution: factory(AttributionControl),
-  scale: factory(ScaleControl)
+  scale: factory(ScaleControl),
+  locate: factory(LocateControl)
 });
 var tsMap = {
   version,
@@ -18532,132 +18679,133 @@ if (typeof window !== "undefined")
   window.tsMap ??= tsMap;
 var core_map_default = tsMap;
 export {
-  videoOverlay,
-  version,
-  vectorTileLayer,
-  tooltip,
-  toTransformation,
-  toPoint,
-  toLatLngBounds,
-  toLatLng,
-  toBounds,
-  tileLayer,
-  svgOverlay,
-  exports_services as services,
-  saveOfflineRegion,
-  sampleElevationBilinear,
-  resetDefaultCache,
-  rectangle,
-  rasterDEMLayer,
-  popup,
-  polyline,
-  polygon,
-  marker2 as marker,
-  map2 as map,
-  layerGroup,
-  imageOverlay,
-  icon,
-  heatmapLayer,
-  gridLayer,
-  getElevationDecoder,
-  getDefaultCache,
-  geoJson,
-  geoJSON,
-  flatten,
-  featureGroup,
-  exports_easing as easing,
-  earcut,
-  divIcon,
-  deviation,
-  core_map_default as default,
-  decodeTerrariumRGB,
-  decodeMapboxRGB,
-  decodeElevationGrid,
-  createMap,
-  control2 as control,
-  computeTileCoords,
-  circleMarker,
-  circle,
-  cachedFetch,
-  buildTerrainMesh,
-  ZoomControl,
-  WebGLUnsupportedError,
-  WebGLTileRenderer,
-  WMSTileLayer,
-  VideoOverlay,
-  VectorTileMapLayer,
-  exports_Util as Util,
-  TwoFingerRotateHandler,
-  TwoFingerPitchHandler,
-  TsMap,
-  Transformation,
-  Tooltip,
-  TileLayer,
-  TileCache,
-  TerrainSource,
-  TapHoldHandler,
-  SimpleCRS,
-  ScrollWheelZoomHandler,
-  ScaleControl,
-  SVGOverlay,
-  SVG,
-  Renderer,
-  Rectangle,
-  RasterDEMLayer,
-  RTree,
-  exports_projection as Projection,
-  PosAnimation,
-  Popup,
-  Polyline,
-  Polygon,
-  exports_PolyUtil as PolyUtil,
-  Point,
-  PinchZoomHandler,
-  Path,
-  MarkerDrag,
-  Marker,
-  Map2 as Map,
-  exports_LineUtil as LineUtil,
-  LayersControl,
-  LayerGroup,
-  Layer,
-  LatLngBounds,
-  LatLng,
-  KeyboardHandler,
-  KDBush,
-  ImageOverlay,
-  Icon,
-  HillshadeLayer,
-  HeatmapLayer,
-  Handler,
-  GridLayer,
-  GeoJSONClusterSource,
-  GeoJSON,
-  FeatureGroup,
-  Evented,
-  EarthCRS,
-  EPSG900913,
-  EPSG4326,
-  EPSG3857,
-  EPSG3395,
-  Draggable,
-  DragHandler,
-  DoubleClickZoomHandler,
-  exports_DomUtil as DomUtil,
-  exports_DomEvent as DomEvent,
-  DivOverlay,
-  DivIcon,
-  DefaultIcon,
-  Control,
-  Class,
-  CircleMarker,
-  Circle,
-  Canvas,
-  CRS,
-  Browser_default as Browser,
-  BoxZoomHandler,
-  Bounds,
-  BlanketOverlay,
+  Animation,
   AttributionControl,
-  Animation
+  BlanketOverlay,
+  Bounds,
+  BoxZoomHandler,
+  Browser_default as Browser,
+  CRS,
+  Canvas,
+  Circle,
+  CircleMarker,
+  Class,
+  Control,
+  DefaultIcon,
+  DivIcon,
+  DivOverlay,
+  exports_DomEvent as DomEvent,
+  exports_DomUtil as DomUtil,
+  DoubleClickZoomHandler,
+  DragHandler,
+  Draggable,
+  EPSG3395,
+  EPSG3857,
+  EPSG4326,
+  EPSG900913,
+  EarthCRS,
+  Evented,
+  FeatureGroup,
+  GeoJSON,
+  GeoJSONClusterSource,
+  GridLayer,
+  Handler,
+  HeatmapLayer,
+  HillshadeLayer,
+  Icon,
+  ImageOverlay,
+  KDBush,
+  KeyboardHandler,
+  LatLng,
+  LatLngBounds,
+  Layer,
+  LayerGroup,
+  LayersControl,
+  exports_LineUtil as LineUtil,
+  LocateControl,
+  Map2 as Map,
+  Marker,
+  MarkerDrag,
+  Path,
+  PinchZoomHandler,
+  Point,
+  exports_PolyUtil as PolyUtil,
+  Polygon,
+  Polyline,
+  Popup,
+  PosAnimation,
+  exports_projection as Projection,
+  RTree,
+  RasterDEMLayer,
+  Rectangle,
+  Renderer,
+  SVG,
+  SVGOverlay,
+  ScaleControl,
+  ScrollWheelZoomHandler,
+  SimpleCRS,
+  TapHoldHandler,
+  TerrainSource,
+  TileCache,
+  TileLayer,
+  Tooltip,
+  Transformation,
+  TsMap,
+  TwoFingerPitchHandler,
+  TwoFingerRotateHandler,
+  exports_Util as Util,
+  VectorTileMapLayer,
+  VideoOverlay,
+  WMSTileLayer,
+  WebGLTileRenderer,
+  WebGLUnsupportedError,
+  ZoomControl,
+  buildTerrainMesh,
+  cachedFetch,
+  circle,
+  circleMarker,
+  computeTileCoords,
+  control2 as control,
+  createMap,
+  decodeElevationGrid,
+  decodeMapboxRGB,
+  decodeTerrariumRGB,
+  core_map_default as default,
+  deviation,
+  divIcon,
+  earcut,
+  exports_easing as easing,
+  featureGroup,
+  flatten,
+  geoJSON,
+  geoJson,
+  getDefaultCache,
+  getElevationDecoder,
+  gridLayer,
+  heatmapLayer,
+  icon,
+  imageOverlay,
+  layerGroup,
+  map2 as map,
+  marker2 as marker,
+  polygon,
+  polyline,
+  popup,
+  rasterDEMLayer,
+  rectangle,
+  resetDefaultCache,
+  sampleElevationBilinear,
+  saveOfflineRegion,
+  exports_services as services,
+  svgOverlay,
+  tileLayer,
+  toBounds,
+  toLatLng,
+  toLatLngBounds,
+  toPoint,
+  toTransformation,
+  tooltip,
+  vectorTileLayer,
+  version,
+  videoOverlay
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ts-maps",
   "type": "module",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "A modern vector map library.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -90,7 +90,7 @@
   "devDependencies": {
     "bun-plugin-dtsx": "^0.11.5",
     "bunfig": "^0.15.6",
-    "typescript": "^5.9.3",
+    "typescript": "^7.0.2",
     "very-happy-dom": "^0.1.4"
   },
   "lint-staged": {