gisviewer-vue3-arcgis 1.0.284 → 1.0.286

package/es/src/gis-map-ol/utils/overlay/overlay-controller.d.ts

@@ -0,0 +1,116 @@
+import Feature from 'ol/Feature';
+import { Geometry } from 'ol/geom';
+import VectorLayer from 'ol/layer/Vector';
+import { default as OlMap } from 'ol/Map';
+import VectorSource from 'ol/source/Vector';
+import { ILineSymbol, IOverlayParam, IPointSymbol, IPolygonSymbol, IResult } from '../../../types';
+interface IOverlayOptions {
+    id?: string;
+}
+export default class OverlayController {
+    private map;
+    overlayLayer: VectorLayer<VectorSource<Feature<Geometry>>>;
+    private vectorSource;
+    constructor(map: OlMap, options?: IOverlayOptions);
+    private defaultPointSymbol;
+    /**
+     * 添加覆盖物
+     * @param params
+     */
+    addOverlays(params: IOverlayParam): IResult;
+    /**
+     * 添加或更新单个覆盖物
+     * @param overlay 覆盖物对象
+     * @param symbol 符号
+     * @param properties 属性
+     * @param visible 是否可见
+     */
+    private addOverlay;
+    /**
+     * 创建几何对象
+     * @param geometryConfig 几何配置
+     */
+    private createGeometry;
+    /**
+     * 获取样式
+     * @param geometryType 几何类型
+     * @param symbol 符号配置
+     * @param attributes 属性
+     */
+    private getStyle;
+    /**
+     * 按type移除覆盖物
+     * @param types
+     */
+    removeOverlaysByType(types: string[] | string): IResult;
+    /**
+     * 按id移除覆盖物
+     * @param ids
+     */
+    removeOverlaysById(ids: string[] | string): IResult;
+    /**
+     * 按id显示或隐藏覆盖物
+     * @param ids
+     * @param isShow
+     */
+    isShowOverlaysByIds(ids: string[], isShow: boolean): void;
+    /**
+     * 显示全部覆盖物
+     */
+    showAllOverlays(): void;
+    /**
+     * 删除全部覆盖物
+     * @returns
+     */
+    removeAllOverlays(): IResult;
+    /**
+     * 更新覆盖物符号
+     * @param ids 覆盖物id数组
+     * @param symbol 新的符号配置
+     */
+    updateOverlaysSymbol(ids: string[], symbol: IPointSymbol | ILineSymbol | IPolygonSymbol): IResult;
+    /**
+     * 按type更新覆盖物符号
+     * @param types 类型数组
+     * @param symbol 新的符号配置
+     */
+    updateOverlaysSymbolByType(types: string[], symbol: IPointSymbol | ILineSymbol | IPolygonSymbol): IResult;
+    /**
+     * 获取几何类型字符串
+     * @param geometry
+     */
+    private getGeometryType;
+    /**
+     * 按id获取覆盖物Feature
+     * @param id
+     */
+    getOverlayById(id: string): Feature<Geometry> | undefined;
+    /**
+     * 按type获取覆盖物Feature数组
+     * @param type
+     */
+    getOverlaysByType(type: string): Feature<Geometry>[];
+    /**
+     * 隐藏图层
+     */
+    hideLayer(): void;
+    /**
+     * 显示图层
+     */
+    showLayer(): void;
+    /**
+     * 删除指定的Feature
+     * @param features
+     */
+    removeFeatures(features: Feature<Geometry> | Feature<Geometry>[]): void;
+    /**
+     * 查找屏幕坐标处的覆盖物
+     * @param pixel 屏幕像素坐标 [x, y]
+     */
+    findFeaturesAtPixel(pixel: number[]): Feature<Geometry>[];
+    /**
+     * 销毁
+     */
+    destroy(): void;
+}
+export {};

package/es/src/gis-map-ol/utils/overlay/overlay-controller.mjs

@@ -0,0 +1,276 @@
+import u from "ol/Feature";
+import { Polygon as h, LineString as y, MultiLineString as d, Point as p } from "ol/geom";
+import v from "ol/layer/Vector";
+import g from "ol/source/Vector";
+import c from "ol/style/Style";
+import { getLineStyle as S } from "../style/line-style.mjs";
+import { getPointStyle as f } from "../style/point-style.mjs";
+import { getPolygonStyle as m } from "../style/polygon-style.mjs";
+class G {
+  constructor(e, s) {
+    this.defaultPointSymbol = {
+      type: "simple-marker",
+      style: "circle",
+      color: "yellow",
+      size: 10
+    }, this.map = e, this.vectorSource = new g(), this.overlayLayer = new v({
+      source: this.vectorSource,
+      properties: {
+        id: (s == null ? void 0 : s.id) ?? "overlay-layer"
+      }
+    }), this.map.addLayer(this.overlayLayer);
+  }
+  /**
+   * 添加覆盖物
+   * @param params
+   */
+  addOverlays(e) {
+    let s = 0, r = 0;
+    e.defaultVisible = e.defaultVisible ?? !0;
+    for (const t of e.overlays) {
+      t.properties ? (t.properties.type || (t.properties.type = e.type), t.properties.id || (t.properties.id = t.id)) : t.properties = { type: e.type, id: t.id };
+      const i = t.symbol || e.defaultSymbol || this.defaultPointSymbol, o = t.visible == null ? e.defaultVisible : t.visible;
+      this.addOverlay(
+        t,
+        i,
+        t.properties,
+        o
+      ).message === "add" ? s++ : r++;
+    }
+    return e.needZoom === !0 && this.map.getView().fit(this.vectorSource.getExtent(), {
+      padding: [50, 50, 50, 50]
+    }), { status: 0, message: `新增${s}, 更新${r}` };
+  }
+  /**
+   * 添加或更新单个覆盖物
+   * @param overlay 覆盖物对象
+   * @param symbol 符号
+   * @param properties 属性
+   * @param visible 是否可见
+   */
+  addOverlay(e, s, r, t) {
+    let i, o = !0;
+    e.id && (i = this.vectorSource.getFeatures().find((l) => l.get("id") === e.id));
+    const n = this.createGeometry(e.geometry);
+    if (!n)
+      return { status: -1, message: "不支持的几何类型" };
+    i ? (i.setGeometry(n), o = !1) : (i = new u({
+      geometry: n
+    }), this.vectorSource.addFeature(i), o = !0);
+    const a = this.getStyle(e.geometry.type, s, r);
+    return a && i.setStyle(a), i.setProperties(r), t || i.setStyle(new c({})), i.set("_visible", t), i.set("_originalStyle", a), { status: 0, message: o ? "add" : "update" };
+  }
+  /**
+   * 创建几何对象
+   * @param geometryConfig 几何配置
+   */
+  createGeometry(e) {
+    var r;
+    switch ((r = e.type) == null ? void 0 : r.toLowerCase()) {
+      case "point":
+        return new p([e.x, e.y]);
+      case "line":
+      case "polyline":
+        if (e.paths && e.paths.length > 0) {
+          const t = e.paths[0];
+          return Array.isArray(t) && Array.isArray(t[0]) ? e.paths.length === 1 ? new y(e.paths[0]) : new d(e.paths) : new y(e.paths);
+        }
+        return null;
+      case "polygon":
+        return e.rings && e.rings.length > 0 ? new h(e.rings) : null;
+      default:
+        return null;
+    }
+  }
+  /**
+   * 获取样式
+   * @param geometryType 几何类型
+   * @param symbol 符号配置
+   * @param attributes 属性
+   */
+  getStyle(e, s, r) {
+    switch (e == null ? void 0 : e.toLowerCase()) {
+      case "point":
+        return f(s, r);
+      case "line":
+      case "polyline":
+        return S(s, r);
+      case "polygon":
+        return m(s, r);
+      default:
+        return null;
+    }
+  }
+  /**
+   * 按type移除覆盖物
+   * @param types
+   */
+  removeOverlaysByType(e) {
+    const r = this.vectorSource.getFeatures().filter((t) => {
+      const i = t.get("type");
+      return Array.isArray(e) ? e.includes(i) : i === e;
+    });
+    return r.forEach((t) => {
+      this.vectorSource.removeFeature(t);
+    }), { status: 0, message: `删除${r.length}` };
+  }
+  /**
+   * 按id移除覆盖物
+   * @param ids
+   */
+  removeOverlaysById(e) {
+    const r = this.vectorSource.getFeatures().filter((t) => {
+      const i = t.get("id");
+      return Array.isArray(e) ? e.includes(i) : i === e;
+    });
+    return r.forEach((t) => {
+      this.vectorSource.removeFeature(t);
+    }), { status: 0, message: `删除${r.length}` };
+  }
+  /**
+   * 按id显示或隐藏覆盖物
+   * @param ids
+   * @param isShow
+   */
+  isShowOverlaysByIds(e, s) {
+    this.vectorSource.getFeatures().forEach((r) => {
+      const t = r.get("id");
+      if (e.includes(t)) {
+        if (s) {
+          const i = r.get("_originalStyle");
+          i && r.setStyle(i);
+        } else
+          r.setStyle(new c({}));
+        r.set("_visible", s);
+      } else {
+        if (s)
+          r.setStyle(new c({}));
+        else {
+          const i = r.get("_originalStyle");
+          i && r.setStyle(i);
+        }
+        r.set("_visible", !s);
+      }
+    });
+  }
+  /**
+   * 显示全部覆盖物
+   */
+  showAllOverlays() {
+    this.vectorSource.getFeatures().forEach((e) => {
+      const s = e.get("_originalStyle");
+      s && e.setStyle(s), e.set("_visible", !0);
+    });
+  }
+  /**
+   * 删除全部覆盖物
+   * @returns
+   */
+  removeAllOverlays() {
+    const e = this.vectorSource.getFeatures().length;
+    return this.vectorSource.clear(), { status: 0, message: `删除${e}` };
+  }
+  /**
+   * 更新覆盖物符号
+   * @param ids 覆盖物id数组
+   * @param symbol 新的符号配置
+   */
+  updateOverlaysSymbol(e, s) {
+    let r = 0;
+    return this.vectorSource.getFeatures().forEach((t) => {
+      const i = t.get("id");
+      if (e.includes(i)) {
+        const o = t.getGeometry();
+        if (o) {
+          const n = this.getGeometryType(o), a = t.getProperties(), l = this.getStyle(n, s, a);
+          l && (t.setStyle(l), t.set("_originalStyle", l), r++);
+        }
+      }
+    }), { status: 0, message: `更新${r}个覆盖物符号` };
+  }
+  /**
+   * 按type更新覆盖物符号
+   * @param types 类型数组
+   * @param symbol 新的符号配置
+   */
+  updateOverlaysSymbolByType(e, s) {
+    let r = 0;
+    return this.vectorSource.getFeatures().forEach((t) => {
+      const i = t.get("type");
+      if (e.includes(i)) {
+        const o = t.getGeometry();
+        if (o) {
+          const n = this.getGeometryType(o), a = t.getProperties(), l = this.getStyle(n, s, a);
+          l && (t.setStyle(l), t.set("_originalStyle", l), r++);
+        }
+      }
+    }), { status: 0, message: `更新${r}个覆盖物符号` };
+  }
+  /**
+   * 获取几何类型字符串
+   * @param geometry
+   */
+  getGeometryType(e) {
+    return e instanceof p ? "point" : e instanceof y ? "polyline" : e instanceof h ? "polygon" : "";
+  }
+  /**
+   * 按id获取覆盖物Feature
+   * @param id
+   */
+  getOverlayById(e) {
+    return this.vectorSource.getFeatures().find((s) => s.get("id") === e);
+  }
+  /**
+   * 按type获取覆盖物Feature数组
+   * @param type
+   */
+  getOverlaysByType(e) {
+    return this.vectorSource.getFeatures().filter((s) => s.get("type") === e);
+  }
+  /**
+   * 隐藏图层
+   */
+  hideLayer() {
+    this.overlayLayer.setVisible(!1);
+  }
+  /**
+   * 显示图层
+   */
+  showLayer() {
+    this.overlayLayer.setVisible(!0);
+  }
+  /**
+   * 删除指定的Feature
+   * @param features
+   */
+  removeFeatures(e) {
+    Array.isArray(e) || (e = [e]), e.forEach((s) => {
+      this.vectorSource.removeFeature(s);
+    });
+  }
+  /**
+   * 查找屏幕坐标处的覆盖物
+   * @param pixel 屏幕像素坐标 [x, y]
+   */
+  findFeaturesAtPixel(e) {
+    const s = [];
+    return this.map.forEachFeatureAtPixel(
+      e,
+      (r, t) => {
+        t === this.overlayLayer && r instanceof u && s.push(r);
+      },
+      {
+        layerFilter: (r) => r === this.overlayLayer
+      }
+    ), s;
+  }
+  /**
+   * 销毁
+   */
+  destroy() {
+    this.vectorSource.clear(), this.map.removeLayer(this.overlayLayer), this.overlayLayer.dispose();
+  }
+}
+export {
+  G as default
+};

package/es/src/gis-map-ol/utils/police-area-controller.d.ts

@@ -0,0 +1,16 @@
+import { default as OlMap } from 'ol/Map';
+import { IShowJurisdictionParams } from '../../types';
+export default class PoliceAreaController {
+    private map;
+    private source;
+    private policeAreaLayer;
+    private zdBoundaryLayer;
+    private initialized;
+    private ddMap;
+    private zdMap;
+    constructor(map: OlMap);
+    initialize(): Promise<void>;
+    private isMultiPolygon;
+    showJurisdiction(params: IShowJurisdictionParams): Promise<void>;
+    clearJurisdiction(): void;
+}

package/es/src/gis-map-ol/utils/police-area-controller.mjs

@@ -0,0 +1,155 @@
+import h from "ol/Feature";
+import { Polygon as y, Point as D } from "ol/geom";
+import m from "ol/layer/Vector";
+import z from "ol/source/Vector";
+import { Style as g, Stroke as w, Text as L, Fill as E } from "ol/style";
+import { getLineStyle as P } from "./style/line-style.mjs";
+class V {
+  constructor(s) {
+    this.initialized = !1, this.ddMap = /* @__PURE__ */ new Map(), this.zdMap = /* @__PURE__ */ new Map(), this.map = s, this.source = new z(), this.policeAreaLayer = new m({
+      source: this.source
+    }), this.policeAreaLayer.set("id", "police-area-layer"), this.map.addLayer(this.policeAreaLayer), this.zdBoundaryLayer = new m({
+      source: new z()
+    }), this.zdBoundaryLayer.set("id", "zd-boundary-layer"), this.map.addLayer(this.zdBoundaryLayer);
+  }
+  async initialize() {
+    (await (await fetch("/GisViewerAssets/ShangHai/Layers/dd.json")).json()).features.forEach((t) => {
+      this.ddMap.set(t.properties.DD_CODE, {
+        name: t.properties.DD_NAME,
+        coordinates: t.geometry.coordinates,
+        zdCode: t.properties.ZD_CODE
+      });
+    }), (await (await fetch("/GisViewerAssets/ShangHai/Layers/zd.json")).json()).features.forEach((t) => {
+      this.zdMap.set(t.properties.ZD_CODE, {
+        name: t.properties.ZD_NAME,
+        coordinates: t.geometry.coordinates
+      });
+    }), this.zdMap.forEach((t, c) => {
+      var a;
+      const e = [];
+      this.isMultiPolygon(t.coordinates) ? t.coordinates.forEach((n) => {
+        n.forEach((l) => e.push(l));
+      }) : t.coordinates.forEach((n) => {
+        e.push(n);
+      });
+      const o = new y(e), r = new h({
+        geometry: o,
+        type: "zd-boundary",
+        id: c,
+        name: t.name
+      });
+      r.setStyle(
+        new g({
+          stroke: new w({
+            color: "rgba(30, 144, 255, 0.8)",
+            width: 2,
+            lineDash: [10, 20]
+          })
+        })
+      ), (a = this.zdBoundaryLayer.getSource()) == null || a.addFeature(r);
+    });
+  }
+  // 判断 coordinates 是 Polygon（三维）还是 MultiPolygon（四维）
+  isMultiPolygon(s) {
+    return Array.isArray(s) && Array.isArray(s[0]) && Array.isArray(s[0][0]) && Array.isArray(s[0][0][0]);
+  }
+  async showJurisdiction(s) {
+    this.initialized || (await this.initialize(), this.initialized = !0), this.source.clear();
+    const d = [
+      [
+        [-180, -90],
+        [-180, 90],
+        [180, 90],
+        [180, -90],
+        [-180, -90]
+      ]
+    ], i = [], p = (e) => {
+      this.isMultiPolygon(e) ? e.forEach((o) => {
+        o.forEach((r) => {
+          i.push(r);
+        });
+      }) : e.forEach((o) => {
+        i.push(o);
+      });
+    };
+    if (s.type === "zd") {
+      const e = this.zdMap.get(s.id);
+      e && p(e.coordinates), this.ddMap.forEach((o, r) => {
+        if (o.zdCode === s.id) {
+          const a = [];
+          this.isMultiPolygon(o.coordinates) ? o.coordinates.forEach((u) => {
+            u.forEach((M) => a.push(M));
+          }) : o.coordinates.forEach((u) => {
+            a.push(u);
+          });
+          const n = new y(a), l = new h({
+            geometry: n,
+            type: "dd-boundary",
+            id: r,
+            name: o.name
+          });
+          l.setStyle(
+            P({
+              type: "simple-line",
+              style: "dash",
+              width: 2,
+              color: [30, 144, 255, 0.8]
+            })
+          ), this.source.addFeature(l);
+          const A = n.getInteriorPoint().getCoordinates(), f = new h({
+            geometry: new D(A),
+            type: "dd-label",
+            id: r,
+            name: o.name
+          });
+          f.setStyle(
+            new g({
+              text: new L({
+                text: o.name,
+                font: "bold 14px sans-serif",
+                fill: new E({
+                  color: "rgba(30, 144, 255, 1)"
+                }),
+                stroke: new w({
+                  color: "#fff",
+                  width: 3
+                })
+              })
+            })
+          ), this.source.addFeature(f);
+        }
+      });
+    } else if (s.type === "dd") {
+      const e = this.ddMap.get(s.id);
+      e && p(e.coordinates);
+    }
+    console.log("holesToCut:", i), i.forEach((e) => {
+      d.push(e);
+    });
+    const t = new y(d), c = new h({
+      geometry: t
+    });
+    if (console.log("maskCoords:", d), c.setStyle(
+      new g({
+        fill: new E({
+          color: "rgba(128, 128, 128, 0.6)"
+        }),
+        stroke: new w({
+          color: "rgba(30, 144, 255, 1)",
+          width: 2
+        })
+      })
+    ), this.source.addFeature(c), i.length > 0) {
+      const o = new y(i).getExtent();
+      this.map.getView().fit(o, {
+        padding: [50, 50, 50, 50]
+      });
+    }
+  }
+  clearJurisdiction() {
+    this.source.clear();
+  }
+}
+export {
+  V as default
+};

package/es/src/gis-map-ol/utils/signal-control/signal-cross-controller.d.ts

@@ -0,0 +1,33 @@
+import { default as OlMap } from 'ol/Map';
+import { IResult, IShowSignalCrossParams } from '../../../types';
+export default class SignalCrossController {
+    private map;
+    private crossLayer;
+    private source;
+    private view;
+    private clusterCalculator;
+    private showName;
+    private showStyle;
+    private viewChangeKey;
+    private mapMoveKey;
+    private resolutionChangeTimeout;
+    private locations;
+    constructor(map: OlMap);
+    showSignalCross(params: IShowSignalCrossParams): IResult;
+    private calculateCluster;
+    clearSignalCross(): void;
+    changeShowName(showName: string): void;
+    private updateScatterSymbol;
+    /**
+     * 配置矢量图层样式：复用 Icon，并为不同 feature 渲染不同 Text。
+     * - 使用 resolution 判断是否显示文字（在指定缩放级别后才显示）
+     * - 使用缓存避免每次渲染都创建新的 Style/Icon/数组对象
+     */
+    private configureVectorLayerStyle;
+    private createCrossFeature;
+    private getClusterStyle;
+    private getBrandLabel;
+    private getOnlineLabel;
+    private getMalfunctionLabel;
+    private showClusterResult;
+}