@gis_victory/gismap 1.0.34 → 1.0.36

package/dist/index.es.js

@@ -33416,15 +33416,15 @@ function normalizeStringPosix(path, allowAboveRoot) {
 }
 const isBoolean$2 = (x2) => typeof x2 === "boolean";
 const isFunction$3 = (x2) => typeof x2 === "function";
-const isObject$4 = (x2) => x2 !== null && typeof x2 === "object";
-const isPureObject = (x2) => isObject$4(x2) && x2.constructor === {}.constructor;
+const isObject$5 = (x2) => x2 !== null && typeof x2 === "object";
+const isPureObject = (x2) => isObject$5(x2) && x2.constructor === {}.constructor;
 const isIterable$1 = (x2) => Boolean(x2) && typeof x2[Symbol.iterator] === "function";
 const isAsyncIterable$1 = (x2) => x2 && typeof x2[Symbol.asyncIterator] === "function";
 const isResponse$1 = (x2) => typeof Response !== "undefined" && x2 instanceof Response || x2 && x2.arrayBuffer && x2.text && x2.json;
 const isBlob$1 = (x2) => typeof Blob !== "undefined" && x2 instanceof Blob;
 const isBuffer$2 = (x2) => x2 && typeof x2 === "object" && x2.isBuffer;
-const isReadableDOMStream = (x2) => typeof ReadableStream !== "undefined" && x2 instanceof ReadableStream || isObject$4(x2) && isFunction$3(x2.tee) && isFunction$3(x2.cancel) && isFunction$3(x2.getReader);
-const isReadableNodeStream = (x2) => isObject$4(x2) && isFunction$3(x2.read) && isFunction$3(x2.pipe) && isBoolean$2(x2.readable);
+const isReadableDOMStream = (x2) => typeof ReadableStream !== "undefined" && x2 instanceof ReadableStream || isObject$5(x2) && isFunction$3(x2.tee) && isFunction$3(x2.cancel) && isFunction$3(x2.getReader);
+const isReadableNodeStream = (x2) => isObject$5(x2) && isFunction$3(x2.read) && isFunction$3(x2.pipe) && isBoolean$2(x2.readable);
 const isReadableStream$1 = (x2) => isReadableDOMStream(x2) || isReadableNodeStream(x2);
 class FetchError extends Error {
   constructor(message2, info) {
@@ -33740,7 +33740,7 @@ function validateOptionsObject(options, id, defaultOptions2, deprecatedOptions,
   const loaderName = id || "Top level";
   const prefix = id ? `${id}.` : "";
   for (const key in options) {
-    const isSubOptions = !id && isObject$4(options[key]);
+    const isSubOptions = !id && isObject$5(options[key]);
     const isBaseUriOption = key === "baseUri" && !id;
     const isWorkerUrlOption = key === "workerUrl" && id;
     if (!(key in defaultOptions2) && !isBaseUriOption && !isWorkerUrlOption) {
@@ -34173,7 +34173,7 @@ function getFetchFunction(options, context) {
   if (typeof loaderOptions.fetch === "function") {
     return loaderOptions.fetch;
   }
-  if (isObject$4(loaderOptions.fetch)) {
+  if (isObject$5(loaderOptions.fetch)) {
     return (url) => fetchFile(url, loaderOptions.fetch);
   }
   if (context?.fetch) {
@@ -62642,9 +62642,9 @@ class WEBGLCommandBuffer extends CommandBuffer {
 }
 function _copyBufferToBuffer(device, options) {
   const source2 = options.sourceBuffer;
-  const destination = options.destinationBuffer;
+  const destination2 = options.destinationBuffer;
   device.gl.bindBuffer(36662, source2.handle);
-  device.gl.bindBuffer(36663, destination.handle);
+  device.gl.bindBuffer(36663, destination2.handle);
   device.gl.copyBufferSubData(36662, 36663, options.sourceOffset ?? 0, options.destinationOffset ?? 0, options.size);
   device.gl.bindBuffer(36662, null);
   device.gl.bindBuffer(36663, null);
@@ -62820,7 +62820,7 @@ class WEBGLCommandEncoder extends CommandEncoder {
   }
   insertDebugMarker(markerLabel) {
   }
-  resolveQuerySet(querySet, destination, options) {
+  resolveQuerySet(querySet, destination2, options) {
   }
 }
 function fillArray(options) {
@@ -66509,7 +66509,7 @@ function diffUpdateTrigger(props, oldProps, triggerName) {
 const ERR_NOT_OBJECT = "count(): argument not an object";
 const ERR_NOT_CONTAINER = "count(): argument not a container";
 function count(container) {
-  if (!isObject$3(container)) {
+  if (!isObject$4(container)) {
     throw new Error(ERR_NOT_OBJECT);
   }
   if (typeof container.count === "function") {
@@ -66529,7 +66529,7 @@ function count(container) {
 function isPlainObject$2(value) {
   return value !== null && typeof value === "object" && value.constructor === Object;
 }
-function isObject$3(value) {
+function isObject$4(value) {
   return value !== null && typeof value === "object";
 }
 function mergeShaders(target, source2) {
@@ -81955,6 +81955,685 @@ class GSMarker extends mapboxgl.Marker {
     return this.data;
   }
 }
+var earthRadius = 63710088e-1;
+var factors = {
+  centimeters: earthRadius * 100,
+  centimetres: earthRadius * 100,
+  degrees: 360 / (2 * Math.PI),
+  feet: earthRadius * 3.28084,
+  inches: earthRadius * 39.37,
+  kilometers: earthRadius / 1e3,
+  kilometres: earthRadius / 1e3,
+  meters: earthRadius,
+  metres: earthRadius,
+  miles: earthRadius / 1609.344,
+  millimeters: earthRadius * 1e3,
+  millimetres: earthRadius * 1e3,
+  nauticalmiles: earthRadius / 1852,
+  radians: 1,
+  yards: earthRadius * 1.0936
+};
+function feature$4(geom, properties, options = {}) {
+  const feat = { type: "Feature" };
+  if (options.id === 0 || options.id) {
+    feat.id = options.id;
+  }
+  if (options.bbox) {
+    feat.bbox = options.bbox;
+  }
+  feat.properties = properties || {};
+  feat.geometry = geom;
+  return feat;
+}
+function point$1(coordinates, properties, options = {}) {
+  if (!coordinates) {
+    throw new Error("coordinates is required");
+  }
+  if (!Array.isArray(coordinates)) {
+    throw new Error("coordinates must be an Array");
+  }
+  if (coordinates.length < 2) {
+    throw new Error("coordinates must be at least 2 numbers long");
+  }
+  if (!isNumber$3(coordinates[0]) || !isNumber$3(coordinates[1])) {
+    throw new Error("coordinates must contain numbers");
+  }
+  const geom = {
+    type: "Point",
+    coordinates
+  };
+  return feature$4(geom, properties, options);
+}
+function lengthToRadians(distance2, units = "kilometers") {
+  const factor = factors[units];
+  if (!factor) {
+    throw new Error(units + " units is invalid");
+  }
+  return distance2 / factor;
+}
+function radiansToDegrees(radians2) {
+  const normalisedRadians = radians2 % (2 * Math.PI);
+  return normalisedRadians * 180 / Math.PI;
+}
+function degreesToRadians(degrees2) {
+  const normalisedDegrees = degrees2 % 360;
+  return normalisedDegrees * Math.PI / 180;
+}
+function isNumber$3(num) {
+  return !isNaN(num) && num !== null && !Array.isArray(num);
+}
+function getCoord(coord) {
+  if (!coord) {
+    throw new Error("coord is required");
+  }
+  if (!Array.isArray(coord)) {
+    if (coord.type === "Feature" && coord.geometry !== null && coord.geometry.type === "Point") {
+      return [...coord.geometry.coordinates];
+    }
+    if (coord.type === "Point") {
+      return [...coord.coordinates];
+    }
+  }
+  if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
+    return [...coord];
+  }
+  throw new Error("coord must be GeoJSON Point or an Array of numbers");
+}
+function destination(origin2, distance2, bearing, options = {}) {
+  const coordinates1 = getCoord(origin2);
+  const longitude1 = degreesToRadians(coordinates1[0]);
+  const latitude1 = degreesToRadians(coordinates1[1]);
+  const bearingRad = degreesToRadians(bearing);
+  const radians2 = lengthToRadians(distance2, options.units);
+  const latitude2 = Math.asin(
+    Math.sin(latitude1) * Math.cos(radians2) + Math.cos(latitude1) * Math.sin(radians2) * Math.cos(bearingRad)
+  );
+  const longitude2 = longitude1 + Math.atan2(
+    Math.sin(bearingRad) * Math.sin(radians2) * Math.cos(latitude1),
+    Math.cos(radians2) - Math.sin(latitude1) * Math.sin(latitude2)
+  );
+  const lng = radiansToDegrees(longitude2);
+  const lat = radiansToDegrees(latitude2);
+  return point$1([lng, lat], options.properties);
+}
+function feature$3(geom, properties, options = {}) {
+  const feat = { type: "Feature" };
+  if (options.id === 0 || options.id) {
+    feat.id = options.id;
+  }
+  if (options.bbox) {
+    feat.bbox = options.bbox;
+  }
+  feat.properties = properties || {};
+  feat.geometry = geom;
+  return feat;
+}
+function point(coordinates, properties, options = {}) {
+  if (!coordinates) {
+    throw new Error("coordinates is required");
+  }
+  if (!Array.isArray(coordinates)) {
+    throw new Error("coordinates must be an Array");
+  }
+  if (coordinates.length < 2) {
+    throw new Error("coordinates must be at least 2 numbers long");
+  }
+  if (!isNumber$2(coordinates[0]) || !isNumber$2(coordinates[1])) {
+    throw new Error("coordinates must contain numbers");
+  }
+  const geom = {
+    type: "Point",
+    coordinates
+  };
+  return feature$3(geom, properties, options);
+}
+function isNumber$2(num) {
+  return !isNaN(num) && num !== null && !Array.isArray(num);
+}
+function coordEach$1(geojson, callback, excludeWrapCoord) {
+  if (geojson === null) return;
+  var j2, k2, l2, geometry2, stopG, coords, geometryMaybeCollection, wrapShrink = 0, coordIndex = 0, isGeometryCollection, type = geojson.type, isFeatureCollection = type === "FeatureCollection", isFeature = type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
+  for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
+    geometryMaybeCollection = isFeatureCollection ? geojson.features[featureIndex].geometry : isFeature ? geojson.geometry : geojson;
+    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+    for (var geomIndex = 0; geomIndex < stopG; geomIndex++) {
+      var multiFeatureIndex = 0;
+      var geometryIndex = 0;
+      geometry2 = isGeometryCollection ? geometryMaybeCollection.geometries[geomIndex] : geometryMaybeCollection;
+      if (geometry2 === null) continue;
+      coords = geometry2.coordinates;
+      var geomType = geometry2.type;
+      wrapShrink = geomType === "Polygon" || geomType === "MultiPolygon" ? 1 : 0;
+      switch (geomType) {
+        case null:
+          break;
+        case "Point":
+          if (callback(
+            coords,
+            coordIndex,
+            featureIndex,
+            multiFeatureIndex,
+            geometryIndex
+          ) === false)
+            return false;
+          coordIndex++;
+          multiFeatureIndex++;
+          break;
+        case "LineString":
+        case "MultiPoint":
+          for (j2 = 0; j2 < coords.length; j2++) {
+            if (callback(
+              coords[j2],
+              coordIndex,
+              featureIndex,
+              multiFeatureIndex,
+              geometryIndex
+            ) === false)
+              return false;
+            coordIndex++;
+            if (geomType === "MultiPoint") multiFeatureIndex++;
+          }
+          if (geomType === "LineString") multiFeatureIndex++;
+          break;
+        case "Polygon":
+        case "MultiLineString":
+          for (j2 = 0; j2 < coords.length; j2++) {
+            for (k2 = 0; k2 < coords[j2].length - wrapShrink; k2++) {
+              if (callback(
+                coords[j2][k2],
+                coordIndex,
+                featureIndex,
+                multiFeatureIndex,
+                geometryIndex
+              ) === false)
+                return false;
+              coordIndex++;
+            }
+            if (geomType === "MultiLineString") multiFeatureIndex++;
+            if (geomType === "Polygon") geometryIndex++;
+          }
+          if (geomType === "Polygon") multiFeatureIndex++;
+          break;
+        case "MultiPolygon":
+          for (j2 = 0; j2 < coords.length; j2++) {
+            geometryIndex = 0;
+            for (k2 = 0; k2 < coords[j2].length; k2++) {
+              for (l2 = 0; l2 < coords[j2][k2].length - wrapShrink; l2++) {
+                if (callback(
+                  coords[j2][k2][l2],
+                  coordIndex,
+                  featureIndex,
+                  multiFeatureIndex,
+                  geometryIndex
+                ) === false)
+                  return false;
+                coordIndex++;
+              }
+              geometryIndex++;
+            }
+            multiFeatureIndex++;
+          }
+          break;
+        case "GeometryCollection":
+          for (j2 = 0; j2 < geometry2.geometries.length; j2++)
+            if (coordEach$1(geometry2.geometries[j2], callback) === false)
+              return false;
+          break;
+        default:
+          throw new Error("Unknown Geometry Type");
+      }
+    }
+  }
+}
+function centroid(geojson, options = {}) {
+  let xSum = 0;
+  let ySum = 0;
+  let len2 = 0;
+  coordEach$1(
+    geojson,
+    function(coord) {
+      xSum += coord[0];
+      ySum += coord[1];
+      len2++;
+    }
+  );
+  return point([xSum / len2, ySum / len2], options.properties);
+}
+function feature$2(geom, properties, options = {}) {
+  const feat = { type: "Feature" };
+  if (options.id === 0 || options.id) {
+    feat.id = options.id;
+  }
+  if (options.bbox) {
+    feat.bbox = options.bbox;
+  }
+  feat.properties = properties || {};
+  feat.geometry = geom;
+  return feat;
+}
+function polygon$1(coordinates, properties, options = {}) {
+  for (const ring of coordinates) {
+    if (ring.length < 4) {
+      throw new Error(
+        "Each LinearRing of a Polygon must have 4 or more Positions."
+      );
+    }
+    if (ring[ring.length - 1].length !== ring[0].length) {
+      throw new Error("First and last Position are not equivalent.");
+    }
+    for (let j2 = 0; j2 < ring[ring.length - 1].length; j2++) {
+      if (ring[ring.length - 1][j2] !== ring[0][j2]) {
+        throw new Error("First and last Position are not equivalent.");
+      }
+    }
+  }
+  const geom = {
+    type: "Polygon",
+    coordinates
+  };
+  return feature$2(geom, properties, options);
+}
+function circle(center, radius, options = {}) {
+  const steps = options.steps || 64;
+  const properties = options.properties ? options.properties : !Array.isArray(center) && center.type === "Feature" && center.properties ? center.properties : {};
+  const coordinates = [];
+  for (let i2 = 0; i2 < steps; i2++) {
+    coordinates.push(
+      destination(center, radius, i2 * -360 / steps, options).geometry.coordinates
+    );
+  }
+  coordinates.push(coordinates[0]);
+  return polygon$1([coordinates], properties);
+}
+function feature$1(geom, properties, options = {}) {
+  const feat = { type: "Feature" };
+  if (options.id === 0 || options.id) {
+    feat.id = options.id;
+  }
+  if (options.bbox) {
+    feat.bbox = options.bbox;
+  }
+  feat.properties = properties || {};
+  feat.geometry = geom;
+  return feat;
+}
+function lineString(coordinates, properties, options = {}) {
+  if (coordinates.length < 2) {
+    throw new Error("coordinates must be an array of two or more positions");
+  }
+  const geom = {
+    type: "LineString",
+    coordinates
+  };
+  return feature$1(geom, properties, options);
+}
+function lineArc(center, radius, bearing1, bearing2, options = {}) {
+  const steps = options.steps || 64;
+  const angle1 = convertAngleTo360$1(bearing1);
+  const angle2 = convertAngleTo360$1(bearing2);
+  const properties = !Array.isArray(center) && center.type === "Feature" ? center.properties : {};
+  if (angle1 === angle2) {
+    return lineString(
+      circle(center, radius, options).geometry.coordinates[0],
+      properties
+    );
+  }
+  const arcStartDegree = angle1;
+  const arcEndDegree = angle1 < angle2 ? angle2 : angle2 + 360;
+  let alpha = arcStartDegree;
+  const coordinates = [];
+  let i2 = 0;
+  const arcStep = (arcEndDegree - arcStartDegree) / steps;
+  while (alpha <= arcEndDegree) {
+    coordinates.push(
+      destination(center, radius, alpha, options).geometry.coordinates
+    );
+    i2++;
+    alpha = arcStartDegree + i2 * arcStep;
+  }
+  return lineString(coordinates, properties);
+}
+function convertAngleTo360$1(alpha) {
+  let beta = alpha % 360;
+  if (beta < 0) {
+    beta += 360;
+  }
+  return beta;
+}
+function feature(geom, properties, options = {}) {
+  const feat = { type: "Feature" };
+  if (options.id === 0 || options.id) {
+    feat.id = options.id;
+  }
+  if (options.bbox) {
+    feat.bbox = options.bbox;
+  }
+  feat.properties = properties || {};
+  feat.geometry = geom;
+  return feat;
+}
+function polygon(coordinates, properties, options = {}) {
+  for (const ring of coordinates) {
+    if (ring.length < 4) {
+      throw new Error(
+        "Each LinearRing of a Polygon must have 4 or more Positions."
+      );
+    }
+    if (ring[ring.length - 1].length !== ring[0].length) {
+      throw new Error("First and last Position are not equivalent.");
+    }
+    for (let j2 = 0; j2 < ring[ring.length - 1].length; j2++) {
+      if (ring[ring.length - 1][j2] !== ring[0][j2]) {
+        throw new Error("First and last Position are not equivalent.");
+      }
+    }
+  }
+  const geom = {
+    type: "Polygon",
+    coordinates
+  };
+  return feature(geom, properties, options);
+}
+function isObject$3(input) {
+  return input !== null && typeof input === "object" && !Array.isArray(input);
+}
+function coordEach(geojson, callback, excludeWrapCoord) {
+  if (geojson === null) return;
+  var j2, k2, l2, geometry2, stopG, coords, geometryMaybeCollection, wrapShrink = 0, coordIndex = 0, isGeometryCollection, type = geojson.type, isFeatureCollection = type === "FeatureCollection", isFeature = type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
+  for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
+    geometryMaybeCollection = isFeatureCollection ? geojson.features[featureIndex].geometry : isFeature ? geojson.geometry : geojson;
+    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+    for (var geomIndex = 0; geomIndex < stopG; geomIndex++) {
+      var multiFeatureIndex = 0;
+      var geometryIndex = 0;
+      geometry2 = isGeometryCollection ? geometryMaybeCollection.geometries[geomIndex] : geometryMaybeCollection;
+      if (geometry2 === null) continue;
+      coords = geometry2.coordinates;
+      var geomType = geometry2.type;
+      wrapShrink = 0;
+      switch (geomType) {
+        case null:
+          break;
+        case "Point":
+          if (callback(
+            coords,
+            coordIndex,
+            featureIndex,
+            multiFeatureIndex,
+            geometryIndex
+          ) === false)
+            return false;
+          coordIndex++;
+          multiFeatureIndex++;
+          break;
+        case "LineString":
+        case "MultiPoint":
+          for (j2 = 0; j2 < coords.length; j2++) {
+            if (callback(
+              coords[j2],
+              coordIndex,
+              featureIndex,
+              multiFeatureIndex,
+              geometryIndex
+            ) === false)
+              return false;
+            coordIndex++;
+            if (geomType === "MultiPoint") multiFeatureIndex++;
+          }
+          if (geomType === "LineString") multiFeatureIndex++;
+          break;
+        case "Polygon":
+        case "MultiLineString":
+          for (j2 = 0; j2 < coords.length; j2++) {
+            for (k2 = 0; k2 < coords[j2].length - wrapShrink; k2++) {
+              if (callback(
+                coords[j2][k2],
+                coordIndex,
+                featureIndex,
+                multiFeatureIndex,
+                geometryIndex
+              ) === false)
+                return false;
+              coordIndex++;
+            }
+            if (geomType === "MultiLineString") multiFeatureIndex++;
+            if (geomType === "Polygon") geometryIndex++;
+          }
+          if (geomType === "Polygon") multiFeatureIndex++;
+          break;
+        case "MultiPolygon":
+          for (j2 = 0; j2 < coords.length; j2++) {
+            geometryIndex = 0;
+            for (k2 = 0; k2 < coords[j2].length; k2++) {
+              for (l2 = 0; l2 < coords[j2][k2].length - wrapShrink; l2++) {
+                if (callback(
+                  coords[j2][k2][l2],
+                  coordIndex,
+                  featureIndex,
+                  multiFeatureIndex,
+                  geometryIndex
+                ) === false)
+                  return false;
+                coordIndex++;
+              }
+              geometryIndex++;
+            }
+            multiFeatureIndex++;
+          }
+          break;
+        case "GeometryCollection":
+          for (j2 = 0; j2 < geometry2.geometries.length; j2++)
+            if (coordEach(geometry2.geometries[j2], callback) === false)
+              return false;
+          break;
+        default:
+          throw new Error("Unknown Geometry Type");
+      }
+    }
+  }
+}
+function getCoords(coords) {
+  if (Array.isArray(coords)) {
+    return coords;
+  }
+  if (coords.type === "Feature") {
+    if (coords.geometry !== null) {
+      return coords.geometry.coordinates;
+    }
+  } else {
+    if (coords.coordinates) {
+      return coords.coordinates;
+    }
+  }
+  throw new Error(
+    "coords must be GeoJSON Feature, Geometry Object or an Array"
+  );
+}
+function sector(center, radius, bearing1, bearing2, options = {}) {
+  options = options || {};
+  if (!isObject$3(options)) throw new Error("options is invalid");
+  const properties = options.properties;
+  if (!center) throw new Error("center is required");
+  if (bearing1 === void 0 || bearing1 === null)
+    throw new Error("bearing1 is required");
+  if (bearing2 === void 0 || bearing2 === null)
+    throw new Error("bearing2 is required");
+  if (!radius) throw new Error("radius is required");
+  if (typeof options !== "object") throw new Error("options must be an object");
+  if (convertAngleTo360(bearing1) === convertAngleTo360(bearing2)) {
+    return circle(center, radius, options);
+  }
+  const coords = getCoords(center);
+  const arc = lineArc(center, radius, bearing1, bearing2, options);
+  const sliceCoords = [[coords]];
+  coordEach(arc, function(currentCoords) {
+    sliceCoords[0].push(currentCoords);
+  });
+  sliceCoords[0].push(coords);
+  return polygon(sliceCoords, properties);
+}
+function convertAngleTo360(alpha) {
+  let beta = alpha % 360;
+  if (beta < 0) {
+    beta += 360;
+  }
+  return beta;
+}
+class RadarManager {
+  map;
+  id = `radar-${Math.random()}`;
+  radius = 100;
+  // 半径（米）
+  period = 3e3;
+  // 扫描一圈时间（毫秒）
+  backgroundColor = "rgba(255,0,0,0.1)";
+  // 背景颜色
+  borderColor = "rgba(255,0,0,0.8)";
+  // 边框颜色
+  borderWidth = 2;
+  // 边框宽度
+  sectorVisible = false;
+  // 扇形是否可见
+  sectorAngle = 30;
+  // 扫描扇形角度（度）
+  sectorColor = "rgba(0,255,0,0.4)";
+  // 扇形颜色
+  sectorBorderColor = "rgba(0,0,255,0.8)";
+  // 扇形边框颜色
+  center = [0, 0];
+  animationId = null;
+  // 添加动画ID属性
+  constructor(map2) {
+    this.map = map2;
+  }
+  add(options) {
+    this.center = options.center;
+    if (options.radius) {
+      this.radius = options.radius;
+    }
+    if (options.period) {
+      this.period = options.period;
+    }
+    if (options.backgroundColor) {
+      this.backgroundColor = options.backgroundColor;
+    }
+    if (options.borderColor) {
+      this.borderColor = options.borderColor;
+    }
+    if (options.borderWidth) {
+      this.borderWidth = options.borderWidth;
+    }
+    if (options.sectorVisible) {
+      this.sectorVisible = options.sectorVisible;
+    }
+    if (options.sectorAngle) {
+      this.sectorAngle = options.sectorAngle;
+    }
+    if (options.sectorColor) {
+      this.sectorColor = options.sectorColor;
+    }
+    if (options.sectorBorderColor) {
+      this.sectorBorderColor = options.sectorBorderColor;
+    }
+    const circle$1 = circle(this.center, this.radius, {
+      steps: 64,
+      units: "meters"
+    });
+    const sector$1 = sector(this.center, this.radius, 0, this.sectorAngle, {
+      steps: 64,
+      units: "meters"
+    });
+    this.map?.addSource(this.id + "-circle", {
+      type: "geojson",
+      data: circle$1
+    });
+    this.map?.addSource(this.id + "-sector", {
+      type: "geojson",
+      data: sector$1
+    });
+    this.map?.addLayer({
+      id: this.id + "-circle-fill",
+      type: "fill",
+      source: this.id + "-circle",
+      paint: {
+        "fill-color": this.backgroundColor,
+        "fill-outline-color": this.borderColor
+      }
+    });
+    this.map?.addLayer({
+      id: this.id + "-circle-outline",
+      type: "line",
+      source: this.id + "-circle",
+      paint: {
+        "line-color": this.borderColor,
+        "line-width": this.borderWidth
+      }
+    });
+    if (this.sectorVisible) {
+      this.map?.addLayer({
+        id: this.id + "-sector-fill",
+        type: "fill",
+        source: this.id + "-sector",
+        paint: {
+          "fill-color": this.sectorColor,
+          "fill-outline-color": this.sectorBorderColor
+        }
+      });
+    }
+    return this;
+  }
+  // 扫描
+  startScan() {
+    if (!this.sectorVisible) {
+      return this;
+    }
+    this.stopScan();
+    let startTime = performance.now();
+    const animate = (time) => {
+      let elapsed = time - startTime;
+      let angle2 = elapsed % this.period / this.period * 360;
+      const newSector = sector(this.center, this.radius, angle2, angle2 + this.sectorAngle, {
+        steps: 64,
+        units: "meters"
+      });
+      if (this.map?.getSource(this.id + "-sector")) {
+        this.map?.getSource(this.id + "-sector")?.setData(
+          newSector
+        );
+      }
+      this.animationId = requestAnimationFrame(animate);
+    };
+    this.animationId = requestAnimationFrame(animate);
+    return this;
+  }
+  stopScan() {
+    if (this.animationId) {
+      cancelAnimationFrame(this.animationId);
+      this.animationId = null;
+    }
+    return this;
+  }
+  remove() {
+    this.stopScan();
+    if (this.map?.getLayer(this.id + "-circle-fill")) {
+      this.map?.removeLayer(this.id + "-circle-fill");
+    }
+    if (this.map?.getLayer(this.id + "-circle-outline")) {
+      this.map?.removeLayer(this.id + "-circle-outline");
+    }
+    if (this.map?.getLayer(this.id + "-sector-fill")) {
+      this.map?.removeLayer(this.id + "-sector-fill");
+    }
+    if (this.map?.getSource(this.id + "-circle")) {
+      this.map?.removeSource(this.id + "-circle");
+    }
+    if (this.map?.getSource(this.id + "-sector")) {
+      this.map?.removeSource(this.id + "-sector");
+    }
+  }
+}
 class PlaceholderManager {
   map;
   sourceId = `gismap_placeholder_source_${Math.random().toString(10)}`;
@@ -82829,150 +83508,6 @@ class FogManager {
     this.map.setFog({ ...this.options, ...options });
   }
 }
-function feature(geom, properties, options = {}) {
-  const feat = { type: "Feature" };
-  if (options.id === 0 || options.id) {
-    feat.id = options.id;
-  }
-  if (options.bbox) {
-    feat.bbox = options.bbox;
-  }
-  feat.properties = properties || {};
-  feat.geometry = geom;
-  return feat;
-}
-function point(coordinates, properties, options = {}) {
-  if (!coordinates) {
-    throw new Error("coordinates is required");
-  }
-  if (!Array.isArray(coordinates)) {
-    throw new Error("coordinates must be an Array");
-  }
-  if (coordinates.length < 2) {
-    throw new Error("coordinates must be at least 2 numbers long");
-  }
-  if (!isNumber$2(coordinates[0]) || !isNumber$2(coordinates[1])) {
-    throw new Error("coordinates must contain numbers");
-  }
-  const geom = {
-    type: "Point",
-    coordinates
-  };
-  return feature(geom, properties, options);
-}
-function isNumber$2(num) {
-  return !isNaN(num) && num !== null && !Array.isArray(num);
-}
-function coordEach(geojson, callback, excludeWrapCoord) {
-  if (geojson === null) return;
-  var j2, k2, l2, geometry2, stopG, coords, geometryMaybeCollection, wrapShrink = 0, coordIndex = 0, isGeometryCollection, type = geojson.type, isFeatureCollection = type === "FeatureCollection", isFeature = type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
-  for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
-    geometryMaybeCollection = isFeatureCollection ? geojson.features[featureIndex].geometry : isFeature ? geojson.geometry : geojson;
-    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
-    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
-    for (var geomIndex = 0; geomIndex < stopG; geomIndex++) {
-      var multiFeatureIndex = 0;
-      var geometryIndex = 0;
-      geometry2 = isGeometryCollection ? geometryMaybeCollection.geometries[geomIndex] : geometryMaybeCollection;
-      if (geometry2 === null) continue;
-      coords = geometry2.coordinates;
-      var geomType = geometry2.type;
-      wrapShrink = geomType === "Polygon" || geomType === "MultiPolygon" ? 1 : 0;
-      switch (geomType) {
-        case null:
-          break;
-        case "Point":
-          if (callback(
-            coords,
-            coordIndex,
-            featureIndex,
-            multiFeatureIndex,
-            geometryIndex
-          ) === false)
-            return false;
-          coordIndex++;
-          multiFeatureIndex++;
-          break;
-        case "LineString":
-        case "MultiPoint":
-          for (j2 = 0; j2 < coords.length; j2++) {
-            if (callback(
-              coords[j2],
-              coordIndex,
-              featureIndex,
-              multiFeatureIndex,
-              geometryIndex
-            ) === false)
-              return false;
-            coordIndex++;
-            if (geomType === "MultiPoint") multiFeatureIndex++;
-          }
-          if (geomType === "LineString") multiFeatureIndex++;
-          break;
-        case "Polygon":
-        case "MultiLineString":
-          for (j2 = 0; j2 < coords.length; j2++) {
-            for (k2 = 0; k2 < coords[j2].length - wrapShrink; k2++) {
-              if (callback(
-                coords[j2][k2],
-                coordIndex,
-                featureIndex,
-                multiFeatureIndex,
-                geometryIndex
-              ) === false)
-                return false;
-              coordIndex++;
-            }
-            if (geomType === "MultiLineString") multiFeatureIndex++;
-            if (geomType === "Polygon") geometryIndex++;
-          }
-          if (geomType === "Polygon") multiFeatureIndex++;
-          break;
-        case "MultiPolygon":
-          for (j2 = 0; j2 < coords.length; j2++) {
-            geometryIndex = 0;
-            for (k2 = 0; k2 < coords[j2].length; k2++) {
-              for (l2 = 0; l2 < coords[j2][k2].length - wrapShrink; l2++) {
-                if (callback(
-                  coords[j2][k2][l2],
-                  coordIndex,
-                  featureIndex,
-                  multiFeatureIndex,
-                  geometryIndex
-                ) === false)
-                  return false;
-                coordIndex++;
-              }
-              geometryIndex++;
-            }
-            multiFeatureIndex++;
-          }
-          break;
-        case "GeometryCollection":
-          for (j2 = 0; j2 < geometry2.geometries.length; j2++)
-            if (coordEach(geometry2.geometries[j2], callback) === false)
-              return false;
-          break;
-        default:
-          throw new Error("Unknown Geometry Type");
-      }
-    }
-  }
-}
-function centroid(geojson, options = {}) {
-  let xSum = 0;
-  let ySum = 0;
-  let len2 = 0;
-  coordEach(
-    geojson,
-    function(coord) {
-      xSum += coord[0];
-      ySum += coord[1];
-      len2++;
-    }
-  );
-  return point([xSum / len2, ySum / len2], options.properties);
-}
 class QuickSearchManager {
   map;
   markers = /* @__PURE__ */ new Map();
@@ -97826,5 +98361,6 @@ export {
   _sfc_main$F as GisMapView,
   _sfc_main as MapPage,
   MarkerLayer,
+  RadarManager,
   Tile3DLayer2 as Tile3DLayer
 };