ts-maps 0.2.7 → 0.3.0

package/dist/core-map/services/index.js

@@ -0,0 +1,1230 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// 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,
+  formatNum: () => formatNum,
+  falseFn: () => falseFn
+});
+function stamp(obj) {
+  if (!("_tsmap_id" in obj)) {
+    obj._tsmap_id = ++lastId;
+  }
+  return obj._tsmap_id;
+}
+function setLastId(id) {
+  lastId = id;
+}
+function throttle(fn, time, context) {
+  let lock = false;
+  let queuedArgs = false;
+  function later() {
+    lock = false;
+    if (queuedArgs) {
+      wrapperFn.apply(context, queuedArgs);
+      queuedArgs = false;
+    }
+  }
+  function wrapperFn(...args) {
+    if (lock) {
+      queuedArgs = args;
+    } else {
+      fn.apply(context, args);
+      setTimeout(later, time);
+      lock = true;
+    }
+  }
+  return wrapperFn;
+}
+function wrapNum(x, range, includeMax) {
+  const max = range[1];
+  const min = range[0];
+  const d = max - min;
+  return x === max && includeMax ? x : ((x - min) % d + d) % d + min;
+}
+function falseFn(..._args) {
+  return false;
+}
+function formatNum(num, precision) {
+  if (precision === false)
+    return num;
+  const pow = 10 ** (precision === undefined ? 6 : precision);
+  return Math.round(num * pow) / pow;
+}
+function splitWords(str) {
+  return str.trim().split(/\s+/);
+}
+function setOptions(obj, options) {
+  if (!Object.hasOwn(obj, "options")) {
+    obj.options = obj.options ? Object.create(obj.options) : {};
+  }
+  if (options) {
+    for (const i in options) {
+      if (Object.hasOwn(options, i)) {
+        obj.options[i] = options[i];
+      }
+    }
+  }
+  return obj.options;
+}
+function template(str, data) {
+  return str.replace(templateRe, (match, key) => {
+    const k = key.trim();
+    let value = data[k];
+    if (value === undefined)
+      throw new Error(`No value provided for variable ${match}`);
+    else if (typeof value === "function")
+      value = value(data);
+    return value;
+  });
+}
+function noop() {}
+var lastId = 0, templateRe;
+var init_Util = __esm(() => {
+  templateRe = /\{([^{}]+)\}/g;
+});
+
+// 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,
+  GoogleGeocoder: () => GoogleGeocoder,
+  GoogleDirections: () => GoogleDirections
+});
+
+// src/core-map/services/providers/Google.ts
+var DEFAULT_BASE = "https://maps.googleapis.com/maps/api";
+function requireKey(apiKey) {
+  if (!apiKey)
+    throw new Error("Google provider requires an apiKey");
+  return apiKey;
+}
+var profileMap = {
+  driving: "driving",
+  walking: "walking",
+  cycling: "bicycling"
+};
+function decodePolyline(encoded, precision = 5) {
+  const factor = 10 ** precision;
+  const len = encoded.length;
+  let index = 0;
+  let lat = 0;
+  let lng = 0;
+  const out = [];
+  while (index < len) {
+    let shift = 0;
+    let result = 0;
+    let byte;
+    do {
+      byte = encoded.charCodeAt(index++) - 63;
+      result |= (byte & 31) << shift;
+      shift += 5;
+    } while (byte >= 32);
+    const dLat = result & 1 ? ~(result >> 1) : result >> 1;
+    lat += dLat;
+    shift = 0;
+    result = 0;
+    do {
+      byte = encoded.charCodeAt(index++) - 63;
+      result |= (byte & 31) << shift;
+      shift += 5;
+    } while (byte >= 32);
+    const dLng = result & 1 ? ~(result >> 1) : result >> 1;
+    lng += dLng;
+    out.push({ lat: lat / factor, lng: lng / factor });
+  }
+  return out;
+}
+async function fetchJson(url, signal) {
+  const res = await fetch(url, { signal });
+  if (!res.ok)
+    throw new Error(`Google request failed: ${res.status} ${res.statusText}`);
+  return res.json();
+}
+function mapTypes(types) {
+  if (!types)
+    return;
+  if (types.includes("country"))
+    return "country";
+  if (types.includes("administrative_area_level_1"))
+    return "region";
+  if (types.includes("administrative_area_level_2"))
+    return "district";
+  if (types.includes("postal_code"))
+    return "postcode";
+  if (types.includes("locality") || types.includes("sublocality"))
+    return "place";
+  if (types.includes("street_address") || types.includes("route") || types.includes("premise"))
+    return "address";
+  if (types.includes("point_of_interest") || types.includes("establishment"))
+    return "poi";
+  return;
+}
+function toResult(r) {
+  const out = {
+    text: r.formatted_address,
+    center: { lat: r.geometry.location.lat, lng: r.geometry.location.lng },
+    properties: { place_id: r.place_id, types: r.types, address_components: r.address_components }
+  };
+  const b = r.geometry.bounds ?? r.geometry.viewport;
+  if (b)
+    out.bbox = [b.southwest.lng, b.southwest.lat, b.northeast.lng, b.northeast.lat];
+  const pt = mapTypes(r.types);
+  if (pt)
+    out.placeType = pt;
+  return out;
+}
+
+class GoogleGeocoder {
+  name = "google";
+  apiKey;
+  baseUrl;
+  constructor(opts) {
+    this.apiKey = requireKey(opts.apiKey);
+    this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE).replace(/\/$/, "");
+  }
+  async search(query, opts) {
+    const params = new URLSearchParams;
+    params.set("address", query);
+    params.set("key", this.apiKey);
+    if (opts?.language)
+      params.set("language", opts.language);
+    if (opts?.bbox) {
+      const [w, s, e, n] = opts.bbox;
+      params.set("bounds", `${s},${w}|${n},${e}`);
+    }
+    if (opts?.countries && opts.countries.length > 0)
+      params.set("components", opts.countries.map((c) => `country:${c}`).join("|"));
+    const url = `${this.baseUrl}/geocode/json?${params.toString()}`;
+    const raw = await fetchJson(url, opts?.signal);
+    if (raw.status !== "OK" && raw.status !== "ZERO_RESULTS")
+      throw new Error(`Google geocoding error: ${raw.status}${raw.error_message ? ` — ${raw.error_message}` : ""}`);
+    const results = (raw.results ?? []).map(toResult);
+    return typeof opts?.limit === "number" ? results.slice(0, opts.limit) : results;
+  }
+  async reverse(center, opts) {
+    const params = new URLSearchParams;
+    params.set("latlng", `${center.lat},${center.lng}`);
+    params.set("key", this.apiKey);
+    if (opts?.language)
+      params.set("language", opts.language);
+    const url = `${this.baseUrl}/geocode/json?${params.toString()}`;
+    const raw = await fetchJson(url, opts?.signal);
+    if (raw.status !== "OK" && raw.status !== "ZERO_RESULTS")
+      throw new Error(`Google reverse-geocoding error: ${raw.status}${raw.error_message ? ` — ${raw.error_message}` : ""}`);
+    const results = (raw.results ?? []).map(toResult);
+    return typeof opts?.limit === "number" ? results.slice(0, opts.limit) : results;
+  }
+}
+function stripHtml(html) {
+  return html ? html.replace(/<[^>]+>/g, "") : "";
+}
+function stepToStep(step) {
+  const out = {
+    distance: step.distance?.value ?? 0,
+    duration: step.duration?.value ?? 0,
+    instruction: stripHtml(step.html_instructions),
+    geometry: step.polyline ? decodePolyline(step.polyline.points) : []
+  };
+  if (step.maneuver)
+    out.maneuver = step.maneuver;
+  return out;
+}
+function routeToRoute(r) {
+  const legs = r.legs ?? [];
+  const steps = legs.flatMap((l) => (l.steps ?? []).map(stepToStep));
+  const distance = legs.reduce((sum, l) => sum + (l.distance?.value ?? 0), 0);
+  const duration = legs.reduce((sum, l) => sum + (l.duration?.value ?? 0), 0);
+  const geometry = r.overview_polyline ? decodePolyline(r.overview_polyline.points) : steps.flatMap((s) => s.geometry);
+  return { distance, duration, geometry, steps };
+}
+
+class GoogleDirections {
+  name = "google";
+  apiKey;
+  baseUrl;
+  constructor(opts) {
+    this.apiKey = requireKey(opts.apiKey);
+    this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE).replace(/\/$/, "");
+  }
+  async getDirections(waypoints, opts) {
+    if (waypoints.length < 2)
+      throw new Error("Google directions requires at least two waypoints");
+    const params = new URLSearchParams;
+    params.set("key", this.apiKey);
+    params.set("mode", profileMap[opts?.profile ?? "driving"]);
+    const origin = waypoints[0];
+    const destination = waypoints[waypoints.length - 1];
+    params.set("origin", `${origin.lat},${origin.lng}`);
+    params.set("destination", `${destination.lat},${destination.lng}`);
+    if (waypoints.length > 2) {
+      const via = waypoints.slice(1, -1).map((p) => `${p.lat},${p.lng}`).join("|");
+      params.set("waypoints", via);
+    }
+    if (opts?.alternatives)
+      params.set("alternatives", "true");
+    if (opts?.language)
+      params.set("language", opts.language);
+    const url = `${this.baseUrl}/directions/json?${params.toString()}`;
+    const raw = await fetchJson(url, opts?.signal);
+    if (raw.status !== "OK" && raw.status !== "ZERO_RESULTS")
+      throw new Error(`Google directions error: ${raw.status}${raw.error_message ? ` — ${raw.error_message}` : ""}`);
+    return (raw.routes ?? []).map(routeToRoute);
+  }
+}
+// src/core-map/services/providers/Mapbox.ts
+var DEFAULT_BASE2 = "https://api.mapbox.com";
+function requireToken(token) {
+  if (!token)
+    throw new Error("Mapbox provider requires an accessToken");
+  return token;
+}
+var profileMap2 = {
+  driving: "mapbox/driving",
+  walking: "mapbox/walking",
+  cycling: "mapbox/cycling"
+};
+var isochroneProfileMap = {
+  driving: "mapbox/driving",
+  walking: "mapbox/walking",
+  cycling: "mapbox/cycling"
+};
+async function fetchJson2(url, signal) {
+  const res = await fetch(url, { signal });
+  if (!res.ok)
+    throw new Error(`Mapbox request failed: ${res.status} ${res.statusText}`);
+  return res.json();
+}
+function mapFeatureType(t) {
+  switch (t) {
+    case "country":
+    case "region":
+    case "district":
+    case "postcode":
+    case "place":
+    case "address":
+    case "poi":
+      return t;
+    default:
+      return;
+  }
+}
+function featureToResult(f) {
+  const coords = f.geometry?.coordinates ?? [0, 0];
+  const result = {
+    text: f.properties?.full_address ?? f.properties?.name ?? "",
+    center: { lat: coords[1], lng: coords[0] },
+    properties: f.properties
+  };
+  if (f.properties?.bbox)
+    result.bbox = f.properties.bbox;
+  const pt = mapFeatureType(f.properties?.feature_type);
+  if (pt)
+    result.placeType = pt;
+  if (typeof f.relevance === "number")
+    result.relevance = f.relevance;
+  return result;
+}
+
+class MapboxGeocoder {
+  name = "mapbox";
+  accessToken;
+  baseUrl;
+  constructor(opts) {
+    this.accessToken = requireToken(opts.accessToken);
+    this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE2).replace(/\/$/, "");
+  }
+  async search(query, opts) {
+    const params = new URLSearchParams;
+    params.set("q", query);
+    params.set("access_token", this.accessToken);
+    params.set("limit", String(opts?.limit ?? 5));
+    if (opts?.language)
+      params.set("language", opts.language);
+    if (opts?.proximity)
+      params.set("proximity", `${opts.proximity.lng},${opts.proximity.lat}`);
+    if (opts?.bbox)
+      params.set("bbox", opts.bbox.join(","));
+    if (opts?.countries && opts.countries.length > 0)
+      params.set("country", opts.countries.join(","));
+    const url = `${this.baseUrl}/search/geocode/v6/forward?${params.toString()}`;
+    const raw = await fetchJson2(url, opts?.signal);
+    return (raw.features ?? []).map(featureToResult);
+  }
+  async reverse(center, opts) {
+    const params = new URLSearchParams;
+    params.set("longitude", String(center.lng));
+    params.set("latitude", String(center.lat));
+    params.set("access_token", this.accessToken);
+    params.set("limit", String(opts?.limit ?? 1));
+    if (opts?.language)
+      params.set("language", opts.language);
+    const url = `${this.baseUrl}/search/geocode/v6/reverse?${params.toString()}`;
+    const raw = await fetchJson2(url, opts?.signal);
+    return (raw.features ?? []).map(featureToResult);
+  }
+}
+function coords(arr) {
+  return arr.map(([lng, lat]) => ({ lat, lng }));
+}
+function mbStepToStep(s) {
+  const out = {
+    distance: s.distance,
+    duration: s.duration,
+    instruction: s.maneuver?.instruction ?? s.name ?? "",
+    geometry: coords(s.geometry?.coordinates ?? [])
+  };
+  if (s.maneuver?.type) {
+    out.maneuver = s.maneuver.modifier ? `${s.maneuver.type}-${s.maneuver.modifier}`.replace(/\s+/g, "-") : s.maneuver.type;
+  }
+  return out;
+}
+function mbRouteToRoute(r) {
+  const steps = (r.legs ?? []).flatMap((l) => (l.steps ?? []).map(mbStepToStep));
+  return {
+    distance: r.distance,
+    duration: r.duration,
+    geometry: coords(r.geometry?.coordinates ?? []),
+    steps
+  };
+}
+
+class MapboxDirections {
+  name = "mapbox";
+  accessToken;
+  baseUrl;
+  constructor(opts) {
+    this.accessToken = requireToken(opts.accessToken);
+    this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE2).replace(/\/$/, "");
+  }
+  async getDirections(waypoints, opts) {
+    if (waypoints.length < 2)
+      throw new Error("Mapbox directions requires at least two waypoints");
+    const profile = profileMap2[opts?.profile ?? "driving"];
+    const coordStr = waypoints.map((w) => `${w.lng},${w.lat}`).join(";");
+    const params = new URLSearchParams;
+    params.set("access_token", this.accessToken);
+    params.set("geometries", "geojson");
+    params.set("overview", "full");
+    params.set("steps", "true");
+    params.set("alternatives", opts?.alternatives ? "true" : "false");
+    if (opts?.language)
+      params.set("language", opts.language);
+    const url = `${this.baseUrl}/directions/v5/${profile}/${coordStr}?${params.toString()}`;
+    const raw = await fetchJson2(url, opts?.signal);
+    if (raw.code !== "Ok")
+      throw new Error(`Mapbox directions error: ${raw.code}${raw.message ? ` — ${raw.message}` : ""}`);
+    return (raw.routes ?? []).map(mbRouteToRoute);
+  }
+}
+
+class MapboxIsochrone {
+  name = "mapbox";
+  accessToken;
+  baseUrl;
+  constructor(opts) {
+    this.accessToken = requireToken(opts.accessToken);
+    this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE2).replace(/\/$/, "");
+  }
+  async getIsochrones(center, opts) {
+    const profile = isochroneProfileMap[opts.profile ?? "driving"];
+    const metric = opts.contourMetric ?? "time";
+    const params = new URLSearchParams;
+    params.set("access_token", this.accessToken);
+    if (metric === "distance")
+      params.set("contours_meters", opts.contours.join(","));
+    else
+      params.set("contours_minutes", opts.contours.join(","));
+    params.set("polygons", "true");
+    if (typeof opts.denoise === "number")
+      params.set("denoise", String(opts.denoise));
+    if (typeof opts.generalize === "number")
+      params.set("generalize", String(opts.generalize));
+    const url = `${this.baseUrl}/isochrone/v1/${profile}/${center.lng},${center.lat}?${params.toString()}`;
+    const raw = await fetchJson2(url, opts.signal);
+    const out = [];
+    for (const f of raw.features ?? []) {
+      const contour = f.properties?.contour ?? 0;
+      if (f.geometry.type === "Polygon") {
+        const rings = f.geometry.coordinates;
+        if (rings.length === 0)
+          continue;
+        const p = {
+          geometry: coords(rings[0]),
+          contour
+        };
+        if (rings.length > 1)
+          p.holes = rings.slice(1).map((r) => coords(r));
+        out.push(p);
+      } else if (f.geometry.type === "LineString") {
+        out.push({
+          geometry: coords(f.geometry.coordinates),
+          contour
+        });
+      }
+    }
+    return out;
+  }
+}
+
+class MapboxMatrix {
+  name = "mapbox";
+  accessToken;
+  baseUrl;
+  constructor(opts) {
+    this.accessToken = requireToken(opts.accessToken);
+    this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE2).replace(/\/$/, "");
+  }
+  async getMatrix(origins, destinations, opts) {
+    const profile = profileMap2[opts?.profile ?? "driving"];
+    const all = [...origins, ...destinations];
+    const coordStr = all.map((w) => `${w.lng},${w.lat}`).join(";");
+    const sources = origins.map((_, i) => i).join(";");
+    const destinations_ = destinations.map((_, i) => i + origins.length).join(";");
+    const params = new URLSearchParams;
+    params.set("access_token", this.accessToken);
+    params.set("sources", sources);
+    params.set("destinations", destinations_);
+    const annotations = [];
+    const metric = opts?.metric ?? "time";
+    if (metric === "distance" || metric === "time") {
+      annotations.push("duration", "distance");
+    }
+    params.set("annotations", annotations.join(","));
+    const url = `${this.baseUrl}/directions-matrix/v1/${profile}/${coordStr}?${params.toString()}`;
+    const raw = await fetchJson2(url, opts?.signal);
+    if (raw.code !== "Ok")
+      throw new Error(`Mapbox matrix error: ${raw.code}${raw.message ? ` — ${raw.message}` : ""}`);
+    const result = {};
+    if (raw.durations)
+      result.durations = raw.durations;
+    if (raw.distances)
+      result.distances = raw.distances;
+    return result;
+  }
+}
+// src/core-map/services/providers/Maptiler.ts
+var DEFAULT_BASE3 = "https://api.maptiler.com";
+function mapPlaceType(types) {
+  if (!types || types.length === 0)
+    return;
+  const t = types[0];
+  switch (t) {
+    case "country":
+    case "region":
+    case "district":
+    case "postcode":
+    case "place":
+    case "address":
+    case "poi":
+      return t;
+    default:
+      return;
+  }
+}
+function toResult2(f) {
+  const center = f.center ?? [0, 0];
+  const out = {
+    text: f.place_name ?? f.text ?? "",
+    center: { lat: center[1], lng: center[0] },
+    properties: f.properties
+  };
+  if (f.bbox)
+    out.bbox = f.bbox;
+  const pt = mapPlaceType(f.place_type);
+  if (pt)
+    out.placeType = pt;
+  if (typeof f.relevance === "number")
+    out.relevance = f.relevance;
+  return out;
+}
+
+class MaptilerGeocoder {
+  name = "maptiler";
+  apiKey;
+  baseUrl;
+  constructor(opts) {
+    if (!opts.apiKey)
+      throw new Error("Maptiler provider requires an apiKey");
+    this.apiKey = opts.apiKey;
+    this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE3).replace(/\/$/, "");
+  }
+  buildParams(opts) {
+    const params = new URLSearchParams;
+    params.set("key", this.apiKey);
+    if (opts?.limit)
+      params.set("limit", String(opts.limit));
+    if (opts?.language)
+      params.set("language", opts.language);
+    if (opts?.proximity)
+      params.set("proximity", `${opts.proximity.lng},${opts.proximity.lat}`);
+    if (opts?.bbox)
+      params.set("bbox", opts.bbox.join(","));
+    if (opts?.countries && opts.countries.length > 0)
+      params.set("country", opts.countries.join(","));
+    return params;
+  }
+  async fetch(url, signal) {
+    const res = await fetch(url, { signal });
+    if (!res.ok)
+      throw new Error(`Maptiler request failed: ${res.status} ${res.statusText}`);
+    return await res.json();
+  }
+  async search(query, opts) {
+    const params = this.buildParams(opts);
+    const url = `${this.baseUrl}/geocoding/${encodeURIComponent(query)}.json?${params.toString()}`;
+    const raw = await this.fetch(url, opts?.signal);
+    return (raw.features ?? []).map(toResult2);
+  }
+  async reverse(center, opts) {
+    const params = this.buildParams(opts);
+    const url = `${this.baseUrl}/geocoding/${center.lng},${center.lat}.json?${params.toString()}`;
+    const raw = await this.fetch(url, opts?.signal);
+    return (raw.features ?? []).map(toResult2);
+  }
+}
+// src/core-map/services/providers/Nominatim.ts
+init_Util();
+function mapPlaceType2(klass, type) {
+  if (klass === "boundary" && type === "administrative")
+    return "region";
+  if (type === "country")
+    return "country";
+  if (type === "state" || type === "province")
+    return "region";
+  if (type === "city" || type === "town" || type === "village")
+    return "place";
+  if (type === "postcode")
+    return "postcode";
+  if (type === "administrative")
+    return "district";
+  if (klass === "highway" || klass === "place" && type === "house")
+    return "address";
+  if (klass === "amenity" || klass === "shop" || klass === "tourism")
+    return "poi";
+  return;
+}
+function parseRaw(raw) {
+  const lat = Number.parseFloat(raw.lat);
+  const lng = Number.parseFloat(raw.lon);
+  const result = {
+    text: raw.display_name,
+    center: { lat, lng },
+    properties: { ...raw.address, osm_id: raw.osm_id, osm_type: raw.osm_type, class: raw.class, type: raw.type }
+  };
+  if (raw.boundingbox) {
+    const [south, north, west, east] = raw.boundingbox.map(Number.parseFloat);
+    result.bbox = [west, south, east, north];
+  }
+  const placeType = mapPlaceType2(raw.class, raw.type);
+  if (placeType)
+    result.placeType = placeType;
+  if (typeof raw.importance === "number")
+    result.relevance = Math.max(0, Math.min(1, raw.importance));
+  return result;
+}
+
+class NominatimGeocoder {
+  name = "nominatim";
+  baseUrl;
+  userAgent;
+  scheduleRequest;
+  constructor(opts = {}) {
+    this.baseUrl = (opts.baseUrl ?? "https://nominatim.openstreetmap.org").replace(/\/$/, "");
+    this.userAgent = opts.userAgent ?? "ts-maps";
+    this.scheduleRequest = throttle((run) => run(), 250);
+  }
+  gate(work) {
+    return new Promise((resolve, reject) => {
+      this.scheduleRequest(() => {
+        work().then(resolve, reject);
+      });
+    });
+  }
+  buildSearchUrl(query, opts) {
+    const params = new URLSearchParams;
+    params.set("q", query);
+    params.set("format", "json");
+    params.set("addressdetails", "1");
+    params.set("limit", String(opts?.limit ?? 5));
+    if (opts?.language)
+      params.set("accept-language", opts.language);
+    if (opts?.countries && opts.countries.length > 0)
+      params.set("countrycodes", opts.countries.join(","));
+    if (opts?.bbox) {
+      const [w, s, e, n] = opts.bbox;
+      params.set("viewbox", `${w},${n},${e},${s}`);
+      params.set("bounded", "1");
+    }
+    return `${this.baseUrl}/search?${params.toString()}`;
+  }
+  buildReverseUrl(center, opts) {
+    const params = new URLSearchParams;
+    params.set("lat", String(center.lat));
+    params.set("lon", String(center.lng));
+    params.set("format", "json");
+    params.set("addressdetails", "1");
+    if (opts?.language)
+      params.set("accept-language", opts.language);
+    return `${this.baseUrl}/reverse?${params.toString()}`;
+  }
+  async fetch(url, signal) {
+    const res = await fetch(url, {
+      headers: { "User-Agent": this.userAgent, Accept: "application/json" },
+      signal
+    });
+    if (!res.ok)
+      throw new Error(`Nominatim request failed: ${res.status} ${res.statusText}`);
+    return res.json();
+  }
+  async search(query, opts) {
+    if (!query)
+      return [];
+    const url = this.buildSearchUrl(query, opts);
+    return this.gate(async () => {
+      const raw = await this.fetch(url, opts?.signal);
+      return Array.isArray(raw) ? raw.map(parseRaw) : [];
+    });
+  }
+  async reverse(center, opts) {
+    const url = this.buildReverseUrl(center, opts);
+    return this.gate(async () => {
+      const raw = await this.fetch(url, opts?.signal);
+      if (!raw || raw.error)
+        return [];
+      return [parseRaw(raw)];
+    });
+  }
+}
+// src/core-map/services/providers/OSRM.ts
+var profileMap3 = {
+  driving: "driving",
+  walking: "foot",
+  cycling: "bike"
+};
+function coordsToLatLng(coords2) {
+  return coords2.map(([lng, lat]) => ({ lat, lng }));
+}
+function stepInstruction(step) {
+  if (step.maneuver?.instruction)
+    return step.maneuver.instruction;
+  const parts = [];
+  if (step.maneuver?.type)
+    parts.push(step.maneuver.type);
+  if (step.maneuver?.modifier)
+    parts.push(step.maneuver.modifier);
+  if (step.name)
+    parts.push(`onto ${step.name}`);
+  return parts.join(" ").trim() || "continue";
+}
+function stepManeuver(step) {
+  if (!step.maneuver?.type)
+    return;
+  if (step.maneuver.modifier)
+    return `${step.maneuver.type}-${step.maneuver.modifier}`.replace(/\s+/g, "-");
+  return step.maneuver.type;
+}
+function parseStep(step) {
+  const out = {
+    distance: step.distance,
+    duration: step.duration,
+    instruction: stepInstruction(step),
+    geometry: coordsToLatLng(step.geometry?.coordinates ?? [])
+  };
+  const m = stepManeuver(step);
+  if (m)
+    out.maneuver = m;
+  return out;
+}
+function parseLeg(leg) {
+  const steps = (leg.steps ?? []).map(parseStep);
+  const geometry = steps.flatMap((s) => s.geometry);
+  return {
+    distance: leg.distance,
+    duration: leg.duration,
+    geometry,
+    steps
+  };
+}
+function parseRoute(route) {
+  const steps = (route.legs ?? []).flatMap((leg) => (leg.steps ?? []).map(parseStep));
+  return {
+    distance: route.distance,
+    duration: route.duration,
+    geometry: coordsToLatLng(route.geometry?.coordinates ?? []),
+    steps,
+    legs: (route.legs ?? []).map(parseLeg)
+  };
+}
+
+class OSRMDirections {
+  name = "osrm";
+  baseUrl;
+  constructor(opts = {}) {
+    this.baseUrl = (opts.baseUrl ?? "https://router.project-osrm.org").replace(/\/$/, "");
+  }
+  async getDirections(waypoints, opts) {
+    if (waypoints.length < 2)
+      throw new Error("OSRM requires at least two waypoints");
+    const profile = profileMap3[opts?.profile ?? "driving"] ?? "driving";
+    const coords2 = waypoints.map((w) => `${w.lng},${w.lat}`).join(";");
+    const params = new URLSearchParams;
+    params.set("overview", "full");
+    params.set("geometries", "geojson");
+    params.set("steps", "true");
+    params.set("alternatives", opts?.alternatives ? "true" : "false");
+    const url = `${this.baseUrl}/route/v1/${profile}/${coords2}?${params.toString()}`;
+    const res = await fetch(url, { signal: opts?.signal });
+    if (!res.ok)
+      throw new Error(`OSRM request failed: ${res.status} ${res.statusText}`);
+    const body = await res.json();
+    if (body.code !== "Ok")
+      throw new Error(`OSRM error: ${body.code}${body.message ? ` — ${body.message}` : ""}`);
+    return (body.routes ?? []).map(parseRoute);
+  }
+}
+
+class OSRMMatrix {
+  name = "osrm";
+  baseUrl;
+  constructor(opts = {}) {
+    this.baseUrl = (opts.baseUrl ?? "https://router.project-osrm.org").replace(/\/$/, "");
+  }
+  async getMatrix(origins, destinations, opts) {
+    if (origins.length === 0 || destinations.length === 0)
+      throw new Error("OSRM matrix requires at least one origin and one destination");
+    const profile = profileMap3[opts?.profile ?? "driving"] ?? "driving";
+    const all = [...origins, ...destinations];
+    const coords2 = all.map((w) => `${w.lng},${w.lat}`).join(";");
+    const sources = origins.map((_, i) => i).join(";");
+    const destinationsParam = destinations.map((_, i) => origins.length + i).join(";");
+    const annotations = opts?.metric === "distance" ? "distance" : "duration";
+    const params = new URLSearchParams;
+    params.set("sources", sources);
+    params.set("destinations", destinationsParam);
+    params.set("annotations", annotations);
+    const url = `${this.baseUrl}/table/v1/${profile}/${coords2}?${params.toString()}`;
+    const res = await fetch(url, { signal: opts?.signal });
+    if (!res.ok)
+      throw new Error(`OSRM matrix request failed: ${res.status} ${res.statusText}`);
+    const body = await res.json();
+    if (body.code !== "Ok")
+      throw new Error(`OSRM matrix error: ${body.code}${body.message ? ` — ${body.message}` : ""}`);
+    const result = {};
+    if (body.durations)
+      result.durations = body.durations.map((row) => row.map((v) => v ?? Number.POSITIVE_INFINITY));
+    if (body.distances)
+      result.distances = body.distances.map((row) => row.map((v) => v ?? Number.POSITIVE_INFINITY));
+    return result;
+  }
+}
+// src/core-map/services/providers/Photon.ts
+function mapType(props) {
+  if (!props)
+    return;
+  if (props.osm_value === "country" || props.type === "country")
+    return "country";
+  if (props.osm_value === "state" || props.type === "state")
+    return "region";
+  if (props.type === "county")
+    return "district";
+  if (props.osm_key === "place" && (props.osm_value === "city" || props.osm_value === "town" || props.osm_value === "village"))
+    return "place";
+  if (props.osm_key === "highway" || props.housenumber)
+    return "address";
+  if (props.postcode && props.type === "postcode")
+    return "postcode";
+  if (props.osm_key === "amenity" || props.osm_key === "shop" || props.osm_key === "tourism")
+    return "poi";
+  return;
+}
+function buildLabel(props) {
+  if (!props)
+    return "";
+  const parts = [];
+  if (props.name)
+    parts.push(props.name);
+  if (props.street) {
+    const street = props.housenumber ? `${props.street} ${props.housenumber}` : props.street;
+    if (!parts.length || parts[0] !== street)
+      parts.push(street);
+  }
+  if (props.postcode || props.city) {
+    parts.push([props.postcode, props.city].filter(Boolean).join(" "));
+  }
+  if (props.country)
+    parts.push(props.country);
+  return parts.filter(Boolean).join(", ");
+}
+function toResult3(f) {
+  const coords2 = f.geometry?.coordinates ?? [0, 0];
+  const out = {
+    text: buildLabel(f.properties),
+    center: { lat: coords2[1], lng: coords2[0] },
+    properties: f.properties
+  };
+  if (f.properties?.extent) {
+    const [w, n, e, s] = f.properties.extent;
+    out.bbox = [w, s, e, n];
+  }
+  const pt = mapType(f.properties);
+  if (pt)
+    out.placeType = pt;
+  return out;
+}
+
+class PhotonGeocoder {
+  name = "photon";
+  baseUrl;
+  constructor(opts = {}) {
+    this.baseUrl = (opts.baseUrl ?? "https://photon.komoot.io").replace(/\/$/, "");
+  }
+  async search(query, opts) {
+    if (!query)
+      return [];
+    const params = new URLSearchParams;
+    params.set("q", query);
+    params.set("limit", String(opts?.limit ?? 5));
+    if (opts?.language)
+      params.set("lang", opts.language);
+    if (opts?.proximity) {
+      params.set("lat", String(opts.proximity.lat));
+      params.set("lon", String(opts.proximity.lng));
+    }
+    if (opts?.bbox)
+      params.set("bbox", opts.bbox.join(","));
+    const url = `${this.baseUrl}/api?${params.toString()}`;
+    const res = await fetch(url, { signal: opts?.signal });
+    if (!res.ok)
+      throw new Error(`Photon request failed: ${res.status} ${res.statusText}`);
+    const raw = await res.json();
+    return (raw.features ?? []).map(toResult3);
+  }
+  async reverse(center, opts) {
+    const params = new URLSearchParams;
+    params.set("lat", String(center.lat));
+    params.set("lon", String(center.lng));
+    if (opts?.limit)
+      params.set("limit", String(opts.limit));
+    if (opts?.language)
+      params.set("lang", opts.language);
+    const url = `${this.baseUrl}/reverse?${params.toString()}`;
+    const res = await fetch(url, { signal: opts?.signal });
+    if (!res.ok)
+      throw new Error(`Photon reverse request failed: ${res.status} ${res.statusText}`);
+    const raw = await res.json();
+    return (raw.features ?? []).map(toResult3);
+  }
+}
+// src/core-map/services/providers/Valhalla.ts
+var DEFAULT_BASE_URL = "https://valhalla1.openstreetmap.de";
+var costingMap = {
+  driving: "auto",
+  walking: "pedestrian",
+  cycling: "bicycle"
+};
+function decodePolyline2(encoded, precision = 6) {
+  const factor = 10 ** precision;
+  const len = encoded.length;
+  let index = 0;
+  let lat = 0;
+  let lng = 0;
+  const out = [];
+  while (index < len) {
+    let shift = 0;
+    let result = 0;
+    let byte;
+    do {
+      byte = encoded.charCodeAt(index++) - 63;
+      result |= (byte & 31) << shift;
+      shift += 5;
+    } while (byte >= 32);
+    const dLat = result & 1 ? ~(result >> 1) : result >> 1;
+    lat += dLat;
+    shift = 0;
+    result = 0;
+    do {
+      byte = encoded.charCodeAt(index++) - 63;
+      result |= (byte & 31) << shift;
+      shift += 5;
+    } while (byte >= 32);
+    const dLng = result & 1 ? ~(result >> 1) : result >> 1;
+    lng += dLng;
+    out.push({ lat: lat / factor, lng: lng / factor });
+  }
+  return out;
+}
+function legToRoute(leg) {
+  const shape = leg.shape ? decodePolyline2(leg.shape) : [];
+  const steps = (leg.maneuvers ?? []).map((m) => {
+    const start = m.begin_shape_index ?? 0;
+    const end = m.end_shape_index ?? start;
+    return {
+      distance: (m.length ?? 0) * 1000,
+      duration: m.time ?? 0,
+      instruction: m.instruction ?? "",
+      geometry: shape.slice(start, end + 1)
+    };
+  });
+  return {
+    distance: (leg.summary?.length ?? 0) * 1000,
+    duration: leg.summary?.time ?? 0,
+    geometry: shape,
+    steps
+  };
+}
+function tripToRoute(trip) {
+  const legs = (trip.legs ?? []).map(legToRoute);
+  const geometry = legs.flatMap((l) => l.geometry);
+  const steps = legs.flatMap((l) => l.steps);
+  return {
+    distance: (trip.summary?.length ?? 0) * 1000,
+    duration: trip.summary?.time ?? 0,
+    geometry,
+    steps,
+    legs
+  };
+}
+async function postJson(url, body, signal) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Accept: "application/json" },
+    body: JSON.stringify(body),
+    signal
+  });
+  if (!res.ok)
+    throw new Error(`Valhalla request failed: ${res.status} ${res.statusText}`);
+  return res.json();
+}
+function buildUrl(base, path, apiKey) {
+  const root = base.replace(/\/$/, "");
+  const suffix = apiKey ? `?api_key=${encodeURIComponent(apiKey)}` : "";
+  return `${root}${path}${suffix}`;
+}
+
+class ValhallaDirections {
+  name = "valhalla";
+  baseUrl;
+  apiKey;
+  constructor(opts = {}) {
+    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+    this.apiKey = opts.apiKey;
+  }
+  async getDirections(waypoints, opts) {
+    if (waypoints.length < 2)
+      throw new Error("Valhalla requires at least two waypoints");
+    const body = {
+      locations: waypoints.map((w) => ({ lat: w.lat, lon: w.lng })),
+      costing: costingMap[opts?.profile ?? "driving"] ?? "auto",
+      directions_options: { language: opts?.language ?? "en-US" }
+    };
+    if (opts?.alternatives)
+      body.alternates = 1;
+    const url = buildUrl(this.baseUrl, "/route", this.apiKey);
+    const raw = await postJson(url, body, opts?.signal);
+    const routes = [];
+    if (raw.trip)
+      routes.push(tripToRoute(raw.trip));
+    if (raw.alternates) {
+      for (const alt of raw.alternates) {
+        if (alt.trip)
+          routes.push(tripToRoute(alt.trip));
+      }
+    }
+    return routes;
+  }
+}
+function ringToLatLng(ring) {
+  return ring.map(([lng, lat]) => ({ lat, lng }));
+}
+
+class ValhallaIsochrone {
+  name = "valhalla";
+  baseUrl;
+  apiKey;
+  constructor(opts = {}) {
+    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+    this.apiKey = opts.apiKey;
+  }
+  async getIsochrones(center, opts) {
+    const metric = opts.contourMetric ?? "time";
+    const body = {
+      locations: [{ lat: center.lat, lon: center.lng }],
+      costing: costingMap[opts.profile ?? "driving"] ?? "auto",
+      contours: opts.contours.map((v) => metric === "distance" ? { distance: v } : { time: v }),
+      polygons: true
+    };
+    if (typeof opts.denoise === "number")
+      body.denoise = opts.denoise;
+    if (typeof opts.generalize === "number")
+      body.generalize = opts.generalize;
+    const url = buildUrl(this.baseUrl, "/isochrone", this.apiKey);
+    const raw = await postJson(url, body, opts.signal);
+    const out = [];
+    for (const feature of raw.features ?? []) {
+      const contour = feature.properties?.contour ?? 0;
+      const { geometry } = feature;
+      if (geometry.type === "Polygon") {
+        const rings = geometry.coordinates;
+        if (rings.length === 0)
+          continue;
+        const polygon = {
+          geometry: ringToLatLng(rings[0]),
+          contour
+        };
+        if (rings.length > 1)
+          polygon.holes = rings.slice(1).map(ringToLatLng);
+        out.push(polygon);
+      } else if (geometry.type === "MultiPolygon") {
+        const polys = geometry.coordinates;
+        for (const rings of polys) {
+          if (rings.length === 0)
+            continue;
+          const polygon = {
+            geometry: ringToLatLng(rings[0]),
+            contour
+          };
+          if (rings.length > 1)
+            polygon.holes = rings.slice(1).map(ringToLatLng);
+          out.push(polygon);
+        }
+      } else if (geometry.type === "LineString") {
+        out.push({
+          geometry: ringToLatLng(geometry.coordinates),
+          contour
+        });
+      }
+    }
+    return out;
+  }
+}
+
+class ValhallaMatrix {
+  name = "valhalla";
+  baseUrl;
+  apiKey;
+  constructor(opts = {}) {
+    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+    this.apiKey = opts.apiKey;
+  }
+  async getMatrix(origins, destinations, opts) {
+    const body = {
+      sources: origins.map((o) => ({ lat: o.lat, lon: o.lng })),
+      targets: destinations.map((d) => ({ lat: d.lat, lon: d.lng })),
+      costing: costingMap[opts?.profile ?? "driving"] ?? "auto"
+    };
+    const url = buildUrl(this.baseUrl, "/sources_to_targets", this.apiKey);
+    const raw = await postJson(url, body, opts?.signal);
+    const durations = [];
+    const distances = [];
+    for (const row of raw.sources_to_targets ?? []) {
+      const dRow = [];
+      const distRow = [];
+      for (const cell of row) {
+        dRow.push(cell.time ?? 0);
+        distRow.push((cell.distance ?? 0) * 1000);
+      }
+      durations.push(dRow);
+      distances.push(distRow);
+    }
+    const metric = opts?.metric ?? "time";
+    const result = {};
+    if (metric === "time" || metric === "distance") {
+      result.durations = durations;
+      result.distances = distances;
+    }
+    return result;
+  }
+}
+// src/core-map/services/index.ts
+var defaultGeocoder = () => new NominatimGeocoder;
+var defaultDirections = () => new OSRMDirections;
+var defaultIsochrone = () => new ValhallaIsochrone;
+var defaultMatrix = () => new OSRMMatrix;
+var valhallaMatrix = () => new ValhallaMatrix;
+var valhallaDirections = () => new ValhallaDirections;
+export {
+  valhallaMatrix,
+  valhallaDirections,
+  defaultMatrix,
+  defaultIsochrone,
+  defaultGeocoder,
+  defaultDirections,
+  ValhallaMatrix,
+  ValhallaIsochrone,
+  ValhallaDirections,
+  PhotonGeocoder,
+  OSRMMatrix,
+  OSRMDirections,
+  NominatimGeocoder,
+  MaptilerGeocoder,
+  MapboxMatrix,
+  MapboxIsochrone,
+  MapboxGeocoder,
+  MapboxDirections,
+  GoogleGeocoder,
+  GoogleDirections
+};