@bitalltech-maplibre/core 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,1046 @@
+import maplibregl from "maplibre-gl";
+import { default as default2 } from "maplibre-gl";
+const config = {};
+const setMaplibreToolsConfig = (options) => {
+  Object.assign(config, options);
+};
+const getMaplibreToolsConfig = () => ({ ...config });
+const OPENFREEMAP_STYLE_BASE_URL = "https://tiles.openfreemap.org/styles";
+const createOpenFreeMapStyle = (type, label, path) => ({
+  type,
+  label,
+  style: `${OPENFREEMAP_STYLE_BASE_URL}/${path}`
+});
+const OPENFREEMAP_STYLES = {
+  "openfreemap-liberty": createOpenFreeMapStyle(
+    "openfreemap-liberty",
+    "OpenFreeMap Liberty",
+    "liberty"
+  ),
+  "openfreemap-bright": createOpenFreeMapStyle(
+    "openfreemap-bright",
+    "OpenFreeMap Bright",
+    "bright"
+  ),
+  "openfreemap-positron": createOpenFreeMapStyle(
+    "openfreemap-positron",
+    "OpenFreeMap Positron",
+    "positron"
+  ),
+  "openfreemap-dark": createOpenFreeMapStyle(
+    "openfreemap-dark",
+    "OpenFreeMap Dark",
+    "dark"
+  ),
+  "openfreemap-fiord": createOpenFreeMapStyle(
+    "openfreemap-fiord",
+    "OpenFreeMap Fiord",
+    "fiord"
+  )
+};
+const OPENFREEMAP_STYLE_TYPES = Object.keys(
+  OPENFREEMAP_STYLES
+);
+const getOpenFreeMapStyle = (type = "openfreemap-liberty") => OPENFREEMAP_STYLES[type].style;
+const TDT_SUBDOMAINS = ["0", "1", "2", "3", "4", "5", "6", "7"];
+const TDT_ATTRIBUTION = "© 天地图";
+const TDT_MAX_ZOOM = 18;
+const TDT_STYLE_TYPES = ["tdt-image", "tdt-image-label"];
+const getToken = (token) => {
+  const tdtToken = token || getMaplibreToolsConfig().tdtToken;
+  if (!tdtToken) {
+    throw new Error("Tianditu token is required. Pass token or call setMaplibreToolsConfig({ tdtToken }).");
+  }
+  return tdtToken;
+};
+const createTdtTileUrls = (tileType, token) => {
+  const tdtToken = getToken(token);
+  return TDT_SUBDOMAINS.map(
+    (subdomain) => `https://t${subdomain}.tianditu.gov.cn/DataServer?T=${tileType}&x={x}&y={y}&l={z}&tk=${tdtToken}`
+  );
+};
+const createTiandituRasterSource = (tileType, options = {}) => ({
+  type: "raster",
+  tiles: createTdtTileUrls(tileType, options.token),
+  tileSize: 256,
+  minzoom: 0,
+  maxzoom: TDT_MAX_ZOOM,
+  attribution: TDT_ATTRIBUTION
+});
+const createTiandituImageStyle = (options = {}) => {
+  const withLabel = options.label !== false;
+  const sources = {
+    "tdt-image": createTiandituRasterSource("img_w", options)
+  };
+  const layers = [
+    {
+      id: "tdt-image",
+      type: "raster",
+      source: "tdt-image"
+    }
+  ];
+  if (withLabel) {
+    sources["tdt-image-label"] = createTiandituRasterSource("cia_w", options);
+    layers.push({
+      id: "tdt-image-label",
+      type: "raster",
+      source: "tdt-image-label"
+    });
+  }
+  return {
+    version: 8,
+    sources,
+    layers
+  };
+};
+const BASE_MAP_TYPES = [
+  ...Object.keys(OPENFREEMAP_STYLES),
+  "tdt-image",
+  "tdt-image-label"
+];
+const isBaseMapType = (type) => BASE_MAP_TYPES.includes(type);
+const getBaseMapStyle = (type = "openfreemap-liberty", options = {}) => {
+  if (type === "tdt-image") {
+    return createTiandituImageStyle({ ...options, label: false });
+  }
+  if (type === "tdt-image-label") {
+    return createTiandituImageStyle({ ...options, label: true });
+  }
+  return getOpenFreeMapStyle(type);
+};
+const setBaseMap = (map, type, options = {}) => {
+  const { diff = false, ...styleOptions } = options;
+  map.setStyle(getBaseMapStyle(type, styleOptions), { diff });
+};
+const EARTH_RADIUS = 6378137;
+const DEFAULT_SEGMENTS = 64;
+const toRadians = (value) => value * Math.PI / 180;
+const toDegrees = (value) => value * 180 / Math.PI;
+const normalizeLongitude = (value) => {
+  if (value > 180) {
+    return value - 360;
+  }
+  if (value < -180) {
+    return value + 360;
+  }
+  return value;
+};
+const normalizeAngle = (angle) => (angle % 360 + 360) % 360;
+const getSweepAngle = (startAngle, endAngle) => {
+  const sweep = normalizeAngle(endAngle) - normalizeAngle(startAngle);
+  return sweep <= 0 ? sweep + 360 : sweep;
+};
+const getDestination = (center, distance, bearing) => {
+  const angularDistance = distance / EARTH_RADIUS;
+  const bearingRadians = toRadians(bearing);
+  const latitudeRadians = toRadians(center[1]);
+  const longitudeRadians = toRadians(center[0]);
+  const nextLatitude = Math.asin(
+    Math.sin(latitudeRadians) * Math.cos(angularDistance) + Math.cos(latitudeRadians) * Math.sin(angularDistance) * Math.cos(bearingRadians)
+  );
+  const nextLongitude = longitudeRadians + Math.atan2(
+    Math.sin(bearingRadians) * Math.sin(angularDistance) * Math.cos(latitudeRadians),
+    Math.cos(angularDistance) - Math.sin(latitudeRadians) * Math.sin(nextLatitude)
+  );
+  return [
+    normalizeLongitude(toDegrees(nextLongitude)),
+    toDegrees(nextLatitude)
+  ];
+};
+const createAngleStops = (startAngle, endAngle, segmentCount = DEFAULT_SEGMENTS) => {
+  const sweep = getSweepAngle(startAngle, endAngle);
+  const segments = Math.max(12, Math.ceil(segmentCount * sweep / 360));
+  return Array.from(
+    { length: segments + 1 },
+    (_value, index) => normalizeAngle(startAngle + sweep * index / segments)
+  );
+};
+const closeCoordinates = (coordinates) => {
+  if (coordinates.length === 0) {
+    return coordinates;
+  }
+  const [firstLongitude, firstLatitude] = coordinates[0];
+  const lastCoordinate = coordinates[coordinates.length - 1];
+  if (lastCoordinate[0] === firstLongitude && lastCoordinate[1] === firstLatitude) {
+    return coordinates;
+  }
+  return [...coordinates, [firstLongitude, firstLatitude]];
+};
+const createCircleCoordinates = (center, radius, segmentCount = DEFAULT_SEGMENTS) => closeCoordinates(
+  Array.from(
+    { length: segmentCount },
+    (_value, index) => getDestination(center, radius, 360 * index / segmentCount)
+  )
+);
+const createCirclePolygon = (center, radius, segmentCount = DEFAULT_SEGMENTS) => ({
+  type: "Polygon",
+  coordinates: [createCircleCoordinates(center, radius, segmentCount)]
+});
+const createCircleLine = (center, radius, segmentCount = DEFAULT_SEGMENTS) => ({
+  type: "LineString",
+  coordinates: createCircleCoordinates(center, radius, segmentCount)
+});
+const createSectorPolygon = (center, radius, startAngle, endAngle, segmentCount = DEFAULT_SEGMENTS) => {
+  const arcCoordinates = createAngleStops(
+    startAngle,
+    endAngle,
+    segmentCount
+  ).map((bearing) => getDestination(center, radius, bearing));
+  return {
+    type: "Polygon",
+    coordinates: [[center, ...arcCoordinates, center]]
+  };
+};
+const createArcLine = (center, radius, startAngle, endAngle, segmentCount = DEFAULT_SEGMENTS) => ({
+  type: "LineString",
+  coordinates: createAngleStops(startAngle, endAngle, segmentCount).map(
+    (bearing) => getDestination(center, radius, bearing)
+  )
+});
+const createRayLine = (center, radius, bearing) => ({
+  type: "LineString",
+  coordinates: [center, getDestination(center, radius, bearing)]
+});
+const createFeature = (geometry, properties) => ({
+  type: "Feature",
+  geometry,
+  properties
+});
+const createFeatureCollection = (features) => ({
+  type: "FeatureCollection",
+  features
+});
+const removeLayerIfExists = (map, id) => {
+  if (map.getLayer(id)) {
+    map.removeLayer(id);
+  }
+};
+const removeSourceIfExists = (map, id) => {
+  if (map.getSource(id)) {
+    map.removeSource(id);
+  }
+};
+const setLayersVisibility = (map, layerIds, visible) => {
+  const visibility = visible ? "visible" : "none";
+  layerIds.forEach((layerId) => {
+    if (map.getLayer(layerId)) {
+      map.setLayoutProperty(layerId, "visibility", visibility);
+    }
+  });
+};
+const createManagedEffect = (map, initialOptions, renderEffect) => {
+  const effectId = initialOptions.id;
+  const sourceId = `${effectId}-source`;
+  let options = { ...initialOptions };
+  let layerIds = [];
+  let sourceIds = [sourceId];
+  let removed = false;
+  let waitingForStyle = false;
+  let disposeAnimation;
+  const stopAnimation = () => {
+    disposeAnimation == null ? void 0 : disposeAnimation();
+    disposeAnimation = void 0;
+  };
+  const clearEffect = () => {
+    stopAnimation();
+    [...layerIds].reverse().forEach((layerId) => {
+      removeLayerIfExists(map, layerId);
+    });
+    [...sourceIds].reverse().forEach((id) => {
+      removeSourceIfExists(map, id);
+    });
+    layerIds = [];
+    sourceIds = [sourceId];
+  };
+  const setData = (data) => {
+    const source = map.getSource(sourceId);
+    if (source) {
+      source.setData(data);
+    }
+  };
+  const renderNow = () => {
+    var _a, _b;
+    if (removed) {
+      return;
+    }
+    clearEffect();
+    const nextRender = renderEffect(options);
+    map.addSource(sourceId, {
+      type: "geojson",
+      data: nextRender.data
+    });
+    (_a = nextRender.canvasSources) == null ? void 0 : _a.forEach((canvasSource) => {
+      map.addSource(canvasSource.id, canvasSource.source);
+    });
+    sourceIds = [
+      sourceId,
+      ...((_b = nextRender.canvasSources) == null ? void 0 : _b.map((canvasSource) => canvasSource.id)) || []
+    ];
+    layerIds = nextRender.layers.map((layer) => layer.id);
+    nextRender.layers.forEach((layer) => {
+      var _a2;
+      const layerSource = layer.type === "raster" && ((_a2 = nextRender.canvasSources) == null ? void 0 : _a2[0]) ? nextRender.canvasSources[0].id : sourceId;
+      map.addLayer(
+        {
+          ...layer,
+          source: layerSource
+        },
+        options.beforeId
+      );
+    });
+    setLayersVisibility(map, layerIds, options.visible !== false);
+    if (nextRender.startAnimation) {
+      disposeAnimation = nextRender.startAnimation({
+        getOptions: () => options,
+        setData
+      }) || void 0;
+    }
+  };
+  const handleStyleData = () => {
+    if (!waitingForStyle || removed || !map.isStyleLoaded()) {
+      return;
+    }
+    waitingForStyle = false;
+    map.off("styledata", handleStyleData);
+    renderNow();
+  };
+  const requestRender = () => {
+    if (removed) {
+      return;
+    }
+    if (!map.isStyleLoaded()) {
+      if (!waitingForStyle) {
+        waitingForStyle = true;
+        map.on("styledata", handleStyleData);
+      }
+      return;
+    }
+    if (waitingForStyle) {
+      waitingForStyle = false;
+      map.off("styledata", handleStyleData);
+    }
+    renderNow();
+  };
+  requestRender();
+  return {
+    id: effectId,
+    update(nextOptions) {
+      if (removed) {
+        return;
+      }
+      options = {
+        ...options,
+        ...nextOptions,
+        id: effectId
+      };
+      requestRender();
+    },
+    show() {
+      if (removed) {
+        return;
+      }
+      options = {
+        ...options,
+        visible: true
+      };
+      setLayersVisibility(map, layerIds, true);
+    },
+    hide() {
+      if (removed) {
+        return;
+      }
+      options = {
+        ...options,
+        visible: false
+      };
+      setLayersVisibility(map, layerIds, false);
+    },
+    remove() {
+      if (removed) {
+        return;
+      }
+      removed = true;
+      if (waitingForStyle) {
+        waitingForStyle = false;
+        map.off("styledata", handleStyleData);
+      }
+      clearEffect();
+    }
+  };
+};
+const createPulseEffectData = (options, phase = 0) => {
+  const baseRadius = Math.max(10, options.radius ?? 70);
+  const maxRadius = Math.max(baseRadius, options.maxRadius ?? baseRadius * 2.3);
+  const pulseCount = Math.max(1, options.pulseCount ?? 2);
+  const lineWidth = Math.max(1, options.lineWidth ?? 2);
+  const pulseOpacity = options.pulseOpacity ?? 0.9;
+  const features = [
+    createFeature(createCirclePolygon(options.center, baseRadius), {
+      kind: "core"
+    })
+  ];
+  for (let index = 0; index < pulseCount; index += 1) {
+    const progress = (phase + index / pulseCount) % 1;
+    const currentRadius = baseRadius + (maxRadius - baseRadius) * progress;
+    features.push(
+      createFeature(createCircleLine(options.center, currentRadius), {
+        kind: "pulse",
+        opacity: pulseOpacity * (1 - progress),
+        width: lineWidth * (1 - progress * 0.35)
+      })
+    );
+  }
+  return createFeatureCollection(features);
+};
+const createPulseMarkerRender = (options) => {
+  const color = options.color || "#ff3b30";
+  const fillColor = options.fillColor || color;
+  return {
+    data: createPulseEffectData(options),
+    layers: [
+      {
+        id: `${options.id}-core`,
+        type: "fill",
+        filter: ["==", ["get", "kind"], "core"],
+        paint: {
+          "fill-color": fillColor,
+          "fill-opacity": options.fillOpacity ?? 0.28
+        }
+      },
+      {
+        id: `${options.id}-pulse`,
+        type: "line",
+        filter: ["==", ["get", "kind"], "pulse"],
+        paint: {
+          "line-color": color,
+          "line-opacity": ["coalesce", ["get", "opacity"], options.pulseOpacity ?? 0.9],
+          "line-width": ["coalesce", ["get", "width"], options.lineWidth ?? 2]
+        }
+      }
+    ],
+    startAnimation({ getOptions, setData }) {
+      const duration = Math.max(400, getOptions().duration ?? 1800);
+      let frameId = 0;
+      const startTime = performance.now();
+      const tick = (timestamp) => {
+        const currentOptions = getOptions();
+        const phase = (timestamp - startTime) % duration / duration;
+        setData(createPulseEffectData(currentOptions, phase));
+        frameId = requestAnimationFrame(tick);
+      };
+      frameId = requestAnimationFrame(tick);
+      return () => {
+        cancelAnimationFrame(frameId);
+      };
+    }
+  };
+};
+const createRingPulseEffectData = (options, phase = 0) => {
+  var _a, _b;
+  const baseRadius = Math.max(16, options.radius ?? 110);
+  const pulseScale = Math.max(0, options.pulseScale ?? 0.16);
+  const pulseProgress = (1 - Math.cos(phase * Math.PI * 2)) / 2;
+  const currentRadius = baseRadius * (1 + pulseScale * pulseProgress);
+  const haloRadius = currentRadius * 1.28;
+  const ringCount = Math.max(1, options.ringCount ?? ((_a = options.radii) == null ? void 0 : _a.length) ?? 3);
+  const maxRadius = Math.max(
+    currentRadius * 2.2,
+    options.maxRadius ?? (((_b = options.radii) == null ? void 0 : _b.length) ? Math.max(...options.radii) : baseRadius * (ringCount * 2.5))
+  );
+  const ringSpacing = maxRadius / ringCount;
+  const features = [
+    createFeature(createCirclePolygon(options.center, haloRadius), {
+      kind: "halo",
+      opacity: (options.haloOpacity ?? 0.16) * (0.75 + pulseProgress * 0.65)
+    }),
+    createFeature(createCirclePolygon(options.center, currentRadius), {
+      kind: "core",
+      opacity: (options.fillOpacity ?? 0.28) * (0.88 + pulseProgress * 0.2)
+    }),
+    createFeature(createCircleLine(options.center, currentRadius * 1.06), {
+      kind: "core-ring",
+      opacity: (options.lineOpacity ?? 0.95) * (0.8 + pulseProgress * 0.2),
+      width: Math.max(1, (options.lineWidth ?? 3) * (0.92 + pulseProgress * 0.12))
+    })
+  ];
+  for (let index = 0; index < ringCount; index += 1) {
+    const logicalRadius = (index + phase + 1) * ringSpacing % maxRadius || maxRadius;
+    const radiusProgress = logicalRadius / maxRadius;
+    features.push(
+      createFeature(createCircleLine(options.center, logicalRadius), {
+        kind: "ring",
+        opacity: Math.max(
+          0.18,
+          (options.lineOpacity ?? 0.95) * (1 - radiusProgress * 0.42)
+        ),
+        width: Math.max(
+          1,
+          (options.lineWidth ?? 3) * (1 - radiusProgress * 0.18)
+        )
+      })
+    );
+  }
+  return createFeatureCollection(features);
+};
+const createRingPulseMarkerRender = (options) => {
+  const color = options.color || "#ef4444";
+  const fillColor = options.fillColor || color;
+  return {
+    data: createRingPulseEffectData(options),
+    layers: [
+      {
+        id: `${options.id}-halo`,
+        type: "fill",
+        filter: ["==", ["get", "kind"], "halo"],
+        paint: {
+          "fill-color": fillColor,
+          "fill-opacity": ["coalesce", ["get", "opacity"], options.haloOpacity ?? 0.16]
+        }
+      },
+      {
+        id: `${options.id}-core`,
+        type: "fill",
+        filter: ["==", ["get", "kind"], "core"],
+        paint: {
+          "fill-color": fillColor,
+          "fill-opacity": ["coalesce", ["get", "opacity"], options.fillOpacity ?? 0.28]
+        }
+      },
+      {
+        id: `${options.id}-rings`,
+        type: "line",
+        filter: [
+          "any",
+          ["==", ["get", "kind"], "ring"]
+          // ["==", ["get", "kind"], "core-ring"],
+        ],
+        paint: {
+          "line-color": color,
+          "line-opacity": ["coalesce", ["get", "opacity"], options.lineOpacity ?? 0.95],
+          "line-width": ["coalesce", ["get", "width"], options.lineWidth ?? 3]
+        }
+      }
+    ],
+    startAnimation({ getOptions, setData }) {
+      const duration = Math.max(600, getOptions().duration ?? 2e3);
+      let frameId = 0;
+      const startTime = performance.now();
+      const tick = (timestamp) => {
+        const currentOptions = getOptions();
+        const phase = (timestamp - startTime) % duration / duration;
+        setData(createRingPulseEffectData(currentOptions, phase));
+        frameId = requestAnimationFrame(tick);
+      };
+      frameId = requestAnimationFrame(tick);
+      return () => {
+        cancelAnimationFrame(frameId);
+      };
+    }
+  };
+};
+const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+const parseColor = (color) => {
+  const value = color.trim();
+  const hex = value.match(/^#([0-9a-f]{3}|[0-9a-f]{6})$/i);
+  if (hex) {
+    const source = hex[1];
+    const normalized = source.length === 3 ? source.split("").map((item) => item + item).join("") : source;
+    return [
+      parseInt(normalized.slice(0, 2), 16),
+      parseInt(normalized.slice(2, 4), 16),
+      parseInt(normalized.slice(4, 6), 16)
+    ];
+  }
+  const rgb = value.match(
+    /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)/i
+  );
+  if (rgb) {
+    return [
+      clamp(Number(rgb[1]), 0, 255),
+      clamp(Number(rgb[2]), 0, 255),
+      clamp(Number(rgb[3]), 0, 255)
+    ];
+  }
+  return void 0;
+};
+const normalizeCanvasAngle = (angle) => (angle % 360 + 360) % 360;
+const getClockwiseSweep = (startAngle, endAngle) => {
+  const sweep = normalizeCanvasAngle(endAngle) - normalizeCanvasAngle(startAngle);
+  return sweep <= 0 ? sweep + 360 : sweep;
+};
+const getCanvasArcAngle = (bearing) => (bearing - 90) * Math.PI / 180;
+const toRgbaColor = (color, opacity) => {
+  const rgb = parseColor(color);
+  if (!rgb) {
+    return color;
+  }
+  return `rgba(${rgb[0]}, ${rgb[1]}, ${rgb[2]}, ${clamp(opacity, 0, 1)})`;
+};
+const createSectorCanvasCoordinates = (center, radius) => {
+  const north = getDestination(center, radius, 0)[1];
+  const east = getDestination(center, radius, 90)[0];
+  const south = getDestination(center, radius, 180)[1];
+  const west = getDestination(center, radius, 270)[0];
+  return [
+    [west, north],
+    [east, north],
+    [east, south],
+    [west, south]
+  ];
+};
+const createSectorCanvas = () => {
+  const canvas = document.createElement("canvas");
+  canvas.width = 768;
+  canvas.height = 768;
+  return canvas;
+};
+const getSectorGradientColors = (options) => {
+  var _a;
+  const colors = (_a = options.gradient) == null ? void 0 : _a.colors;
+  return Array.isArray(colors) && colors.length >= 2 ? colors : void 0;
+};
+const drawSectorGradientCanvas = (canvas, options, angleOffset = 0) => {
+  const context = canvas.getContext("2d");
+  const colors = getSectorGradientColors(options);
+  if (!context || !options.gradient || !colors) {
+    return;
+  }
+  const size = canvas.width;
+  const center = size / 2;
+  const radius = center - 2;
+  const startAngle = options.startAngle + angleOffset;
+  const sweep = getClockwiseSweep(startAngle, options.endAngle + angleOffset);
+  const startCanvasAngle = getCanvasArcAngle(startAngle);
+  const endCanvasAngle = startCanvasAngle + sweep * Math.PI / 180;
+  const baseOpacity = options.gradient.opacity ?? options.opacity ?? 0.28;
+  const centerOpacity = options.gradient.centerOpacity ?? options.gradient.tailOpacity ?? baseOpacity * 0.25;
+  const edgeOpacity = options.gradient.edgeOpacity ?? options.gradient.headOpacity ?? baseOpacity;
+  const gradient = context.createRadialGradient(
+    center,
+    center,
+    0,
+    center,
+    center,
+    radius
+  );
+  colors.forEach((color, index) => {
+    const progress = index / Math.max(1, colors.length - 1);
+    const opacity = centerOpacity + (edgeOpacity - centerOpacity) * progress;
+    gradient.addColorStop(progress, toRgbaColor(color, opacity));
+  });
+  context.clearRect(0, 0, size, size);
+  context.save();
+  context.beginPath();
+  context.moveTo(center, center);
+  context.arc(center, center, radius, startCanvasAngle, endCanvasAngle, false);
+  context.closePath();
+  context.clip();
+  context.fillStyle = gradient;
+  context.fillRect(0, 0, size, size);
+  context.restore();
+};
+const createSectorGradientCanvas = (options) => {
+  if (!getSectorGradientColors(options)) {
+    return void 0;
+  }
+  const canvas = createSectorCanvas();
+  drawSectorGradientCanvas(canvas, options);
+  return canvas;
+};
+const createSectorFillFeatures = (options, startAngle, endAngle) => {
+  if (getSectorGradientColors(options)) {
+    return [];
+  }
+  return [
+    createFeature(
+      createSectorPolygon(options.center, options.radius, startAngle, endAngle),
+      {
+        kind: "sector",
+        color: options.color || "#ff453a",
+        opacity: options.opacity ?? 0.28
+      }
+    )
+  ];
+};
+const createSectorScanData = (options, angleOffset = 0) => {
+  const startAngle = options.startAngle + angleOffset;
+  const endAngle = options.endAngle + angleOffset;
+  const features = [
+    ...createSectorFillFeatures(options, startAngle, endAngle),
+    createFeature(createRayLine(options.center, options.radius, startAngle), {
+      kind: "frame"
+    }),
+    createFeature(createRayLine(options.center, options.radius, endAngle), {
+      kind: "frame"
+    })
+  ];
+  return createFeatureCollection(features);
+};
+const createSectorScanRender = (options) => {
+  const canvas = createSectorGradientCanvas(options);
+  const fillLayer = canvas ? {
+    id: `${options.id}-sector-fill`,
+    type: "raster",
+    paint: {
+      "raster-opacity": 1,
+      "raster-fade-duration": 0
+    }
+  } : {
+    id: `${options.id}-sector-fill`,
+    type: "fill",
+    filter: ["==", ["get", "kind"], "sector"],
+    paint: {
+      "fill-color": ["coalesce", ["get", "color"], options.color || "#ff453a"],
+      "fill-opacity": ["coalesce", ["get", "opacity"], options.opacity ?? 0.28],
+      "fill-antialias": false
+    }
+  };
+  return {
+    data: createSectorScanData(options),
+    canvasSources: canvas ? [
+      {
+        id: `${options.id}-canvas-source`,
+        source: {
+          type: "canvas",
+          canvas,
+          coordinates: createSectorCanvasCoordinates(
+            options.center,
+            options.radius
+          ),
+          animate: Boolean(options.rotationSpeed && options.rotationSpeed !== 0)
+        }
+      }
+    ] : void 0,
+    layers: [
+      fillLayer,
+      {
+        id: `${options.id}-sector-frame`,
+        type: "line",
+        filter: ["==", ["get", "kind"], "frame"],
+        paint: {
+          "line-color": options.outlineColor || options.color || "#ff453a",
+          "line-opacity": options.outlineOpacity ?? 0.95,
+          "line-width": options.outlineWidth ?? 2
+        }
+      }
+    ],
+    startAnimation: options.rotationSpeed && options.rotationSpeed !== 0 ? ({ getOptions, setData }) => {
+      const startTime = performance.now();
+      let frameId = 0;
+      const tick = (timestamp) => {
+        const currentOptions = getOptions();
+        const angleOffset = (timestamp - startTime) / 1e3 * (currentOptions.rotationSpeed || 0);
+        if (canvas) {
+          drawSectorGradientCanvas(canvas, currentOptions, angleOffset);
+        }
+        setData(createSectorScanData(currentOptions, angleOffset));
+        frameId = requestAnimationFrame(tick);
+      };
+      frameId = requestAnimationFrame(tick);
+      return () => {
+        cancelAnimationFrame(frameId);
+      };
+    } : void 0
+  };
+};
+const createDirectionalPulseData = (options, leadingDistance) => {
+  const radius = Math.max(40, options.radius);
+  const direction = options.direction ?? 270;
+  const spread = Math.min(180, Math.max(8, options.spread ?? 72));
+  const lineCount = Math.max(1, options.lineCount ?? 7);
+  const lineSpacing = Math.max(20, options.lineSpacing ?? Math.max(80, radius / 9));
+  const phaseDistance = leadingDistance ?? 0;
+  const innerRadius = Math.max(
+    0,
+    Math.min(radius * 0.35, options.innerRadius ?? Math.min(lineSpacing * 0.4, 120))
+  );
+  const startAngle = direction - spread / 2;
+  const endAngle = direction + spread / 2;
+  const features = [];
+  for (let index = 0; index < lineCount; index += 1) {
+    const currentRadius = innerRadius + phaseDistance + index * lineSpacing;
+    if (currentRadius > radius) {
+      continue;
+    }
+    const distanceProgress = currentRadius / radius;
+    const headProgress = 1 - index / Math.max(1, lineCount);
+    features.push(
+      createFeature(
+        createArcLine(options.center, currentRadius, startAngle, endAngle),
+        {
+          kind: "directional-pulse-line",
+          opacity: Math.max(
+            0.08,
+            (options.opacity ?? 0.92) * (0.42 + headProgress * 0.58) * (1 - distanceProgress * 0.28)
+          ),
+          width: Math.max(
+            1,
+            (options.lineWidth ?? 2.8) * (0.86 + headProgress * 0.24) * (1 - distanceProgress * 0.08)
+          )
+        }
+      )
+    );
+  }
+  return createFeatureCollection(features);
+};
+const createDirectionalPulseRender = (options) => ({
+  data: createDirectionalPulseData(options),
+  layers: [
+    {
+      id: `${options.id}-directional-pulse`,
+      type: "line",
+      filter: ["==", ["get", "kind"], "directional-pulse-line"],
+      layout: {
+        "line-cap": "round",
+        "line-join": "round"
+      },
+      paint: {
+        "line-color": options.color || "#ef4444",
+        "line-opacity": ["coalesce", ["get", "opacity"], options.opacity ?? 0.92],
+        "line-width": ["coalesce", ["get", "width"], options.lineWidth ?? 2.8]
+      }
+    }
+  ],
+  startAnimation: options.speed && options.speed > 0 ? ({ getOptions, setData }) => {
+    const startTime = performance.now();
+    let frameId = 0;
+    const tick = (timestamp) => {
+      const currentOptions = getOptions();
+      const radius = Math.max(40, currentOptions.radius);
+      const effectiveLineSpacing = Math.max(
+        20,
+        currentOptions.lineSpacing ?? Math.max(80, radius / 9)
+      );
+      const leadingDistance = (timestamp - startTime) / 1e3 * (currentOptions.speed ?? 0) % effectiveLineSpacing;
+      setData(createDirectionalPulseData(currentOptions, leadingDistance));
+      frameId = requestAnimationFrame(tick);
+    };
+    frameId = requestAnimationFrame(tick);
+    return () => {
+      cancelAnimationFrame(frameId);
+    };
+  } : void 0
+});
+const createRadarSweepData = (options, angleOffset = 0) => {
+  var _a;
+  const ringCount = Math.max(0, options.ringCount ?? 4);
+  const trailCount = Math.max(1, options.trailCount ?? 8);
+  const sweepAngle = Math.max(12, options.sweepAngle ?? 42);
+  const trailGap = sweepAngle * 0.22;
+  const tailOpacity = options.tailOpacity ?? 0.04;
+  const headOpacity = options.headOpacity ?? Math.max(0.24, options.opacity ?? 0.3);
+  const sweepStartAngle = (options.sweepStartAngle ?? 0) + angleOffset;
+  const showCrosshair = options.showCrosshair !== false;
+  const showDistanceLabels = options.showDistanceLabels !== false;
+  const coreRadius = Math.max(
+    20,
+    options.coreRadius ?? Math.min(160, options.radius * 0.035)
+  );
+  const features = [];
+  for (let index = ringCount; index >= 1; index -= 1) {
+    const distance = options.radius * index / ringCount;
+    features.push(
+      createFeature(
+        createCircleLine(options.center, distance),
+        {
+          kind: "ring"
+        }
+      )
+    );
+    if (showDistanceLabels) {
+      const text = ((_a = options.distanceLabelFormatter) == null ? void 0 : _a.call(options, distance, index)) ?? `${Math.round(distance)}`;
+      [
+        { bearing: 0, textAnchor: "bottom" },
+        { bearing: 90, textAnchor: "left" },
+        { bearing: 180, textAnchor: "top" },
+        { bearing: 270, textAnchor: "right" }
+      ].forEach((label) => {
+        features.push(
+          createFeature(
+            {
+              type: "Point",
+              coordinates: getDestination(options.center, distance, label.bearing)
+            },
+            {
+              kind: "distance-label",
+              text,
+              textAnchor: label.textAnchor
+            }
+          )
+        );
+      });
+    }
+  }
+  if (showCrosshair) {
+    features.push(
+      createFeature(
+        {
+          type: "LineString",
+          coordinates: [
+            getDestination(options.center, options.radius, 180),
+            getDestination(options.center, options.radius, 0)
+          ]
+        },
+        {
+          kind: "crosshair"
+        }
+      ),
+      createFeature(
+        {
+          type: "LineString",
+          coordinates: [
+            getDestination(options.center, options.radius, 270),
+            getDestination(options.center, options.radius, 90)
+          ]
+        },
+        {
+          kind: "crosshair"
+        }
+      )
+    );
+  }
+  features.push(
+    createFeature(createCirclePolygon(options.center, coreRadius), {
+      kind: "core"
+    })
+  );
+  for (let index = trailCount - 1; index >= 0; index -= 1) {
+    const startAngle = sweepStartAngle - trailGap * index;
+    const endAngle = startAngle + sweepAngle;
+    const progress = (trailCount - index) / trailCount;
+    const opacity = tailOpacity + (headOpacity - tailOpacity) * progress * progress;
+    features.push(
+      createFeature(
+        createSectorPolygon(options.center, options.radius, startAngle, endAngle),
+        {
+          kind: "sweep",
+          opacity
+        }
+      )
+    );
+  }
+  features.push(
+    createFeature(
+      createSectorPolygon(
+        options.center,
+        options.radius,
+        sweepStartAngle + sweepAngle * 0.42,
+        sweepStartAngle + sweepAngle
+      ),
+      {
+        kind: "head",
+        opacity: Math.min(1, headOpacity + 0.08)
+      }
+    )
+  );
+  return createFeatureCollection(features);
+};
+const createRadarSweepRender = (options) => ({
+  data: createRadarSweepData(options),
+  layers: [
+    {
+      id: `${options.id}-radar-trail`,
+      type: "fill",
+      filter: ["==", ["get", "kind"], "sweep"],
+      paint: {
+        "fill-color": options.color || "#22c55e",
+        "fill-opacity": ["coalesce", ["get", "opacity"], options.opacity ?? 0.32]
+      }
+    },
+    {
+      id: `${options.id}-radar-rings`,
+      type: "line",
+      filter: ["==", ["get", "kind"], "ring"],
+      paint: {
+        "line-color": options.ringColor || options.color || "#22c55e",
+        "line-opacity": options.ringOpacity ?? 0.95,
+        "line-width": options.ringWidth ?? 2
+      }
+    },
+    {
+      id: `${options.id}-radar-crosshair`,
+      type: "line",
+      filter: ["==", ["get", "kind"], "crosshair"],
+      paint: {
+        "line-color": options.crosshairColor || options.ringColor || options.color || "#22c55e",
+        "line-opacity": options.crosshairOpacity ?? 0.5,
+        "line-width": options.crosshairWidth ?? 1.4
+      }
+    },
+    {
+      id: `${options.id}-radar-distance-labels`,
+      type: "symbol",
+      filter: ["==", ["get", "kind"], "distance-label"],
+      layout: {
+        "text-field": ["get", "text"],
+        "text-size": options.distanceLabelSize ?? 12,
+        "text-anchor": ["get", "textAnchor"],
+        "text-allow-overlap": true,
+        "text-ignore-placement": true
+      },
+      paint: {
+        "text-color": options.distanceLabelColor || options.ringColor || options.color || "#22c55e",
+        "text-opacity": options.distanceLabelOpacity ?? 0.92,
+        "text-halo-color": options.distanceLabelHaloColor || "rgba(15, 23, 42, 0.42)",
+        "text-halo-width": 1
+      }
+    }
+  ],
+  startAnimation({ getOptions, setData }) {
+    const startTime = performance.now();
+    let frameId = 0;
+    const tick = (timestamp) => {
+      const currentOptions = getOptions();
+      const angleOffset = (timestamp - startTime) / 1e3 * (currentOptions.rotationSpeed ?? 36);
+      setData(createRadarSweepData(currentOptions, angleOffset));
+      frameId = requestAnimationFrame(tick);
+    };
+    frameId = requestAnimationFrame(tick);
+    return () => {
+      cancelAnimationFrame(frameId);
+    };
+  }
+});
+const addPulseMarker = (map, options) => createManagedEffect(map, options, createPulseMarkerRender);
+const addRingPulseMarker = (map, options) => createManagedEffect(map, options, createRingPulseMarkerRender);
+const addSectorScan = (map, options) => createManagedEffect(map, options, createSectorScanRender);
+const addDirectionalPulse = (map, options) => createManagedEffect(map, options, createDirectionalPulseRender);
+const addRadarSweep = (map, options) => createManagedEffect(map, options, createRadarSweepRender);
+const resolveStyle = (style, tdtToken) => {
+  if (!style) {
+    return getBaseMapStyle("openfreemap-liberty");
+  }
+  if (typeof style === "string" && isBaseMapType(style)) {
+    return getBaseMapStyle(style, { token: tdtToken });
+  }
+  return style;
+};
+const createMap = (options) => {
+  const { style, tdtToken, ...mapOptions } = options;
+  return new maplibregl.Map({
+    ...mapOptions,
+    style: resolveStyle(style, tdtToken)
+  });
+};
+export {
+  BASE_MAP_TYPES,
+  OPENFREEMAP_STYLES,
+  OPENFREEMAP_STYLE_BASE_URL,
+  OPENFREEMAP_STYLE_TYPES,
+  TDT_STYLE_TYPES,
+  addDirectionalPulse,
+  addPulseMarker,
+  addRadarSweep,
+  addRingPulseMarker,
+  addSectorScan,
+  createMap,
+  createTiandituImageStyle,
+  createTiandituRasterSource,
+  getBaseMapStyle,
+  getMaplibreToolsConfig,
+  getOpenFreeMapStyle,
+  isBaseMapType,
+  default2 as maplibregl,
+  setBaseMap,
+  setMaplibreToolsConfig
+};