gisviewer-vue3-arcgis 1.0.281 → 1.0.283

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/renderer/canvas/VectorLayer.mjs

@@ -0,0 +1,372 @@
+import G from "../../ViewHint.mjs";
+import { equals as B } from "../../array.mjs";
+import { wrapX as S } from "../../coordinate.mjs";
+import { createCanvasContext2D as z, releaseCanvas as $ } from "../../dom.mjs";
+import { createEmpty as O, getWidth as v, getHeight as k, intersects as q, containsExtent as F, buffer as J, wrapX as K } from "../../extent.mjs";
+import { fromUserExtent as Q, toUserExtent as Y } from "../../proj.mjs";
+import N from "../../render/EventType.mjs";
+import Z from "../../render/canvas/BuilderGroup.mjs";
+import ee, { ALL as te, DECLUTTER as re, NON_DECLUTTER as ne } from "../../render/canvas/ExecutorGroup.mjs";
+import { HIT_DETECT_RESOLUTION as D, createHitDetectionImageData as ie, hitDetect as se } from "../../render/canvas/hitdetect.mjs";
+import { getUid as oe } from "../../util.mjs";
+import { getSquaredTolerance as j, getTolerance as ae, renderFeature as H, defaultOrder as de } from "../vector.mjs";
+import ce, { canvasPool as P } from "./Layer.mjs";
+class he extends ce {
+  /**
+   * @param {import("../../layer/BaseVector.js").default} vectorLayer Vector layer.
+   */
+  constructor(e) {
+    super(e), this.boundHandleStyleImageChange_ = this.handleStyleImageChange_.bind(this), this.animatingOrInteracting_, this.hitDetectionImageData_ = null, this.clipped_ = !1, this.renderedFeatures_ = null, this.renderedRevision_ = -1, this.renderedResolution_ = NaN, this.renderedExtent_ = O(), this.wrappedRenderedExtent_ = O(), this.renderedRotation_, this.renderedCenter_ = null, this.renderedProjection_ = null, this.renderedPixelRatio_ = 1, this.renderedRenderOrder_ = null, this.renderedFrameDeclutter_, this.replayGroup_ = null, this.replayGroupChanged = !0, this.clipping = !0, this.targetContext_ = null, this.opacity_ = 1;
+  }
+  /**
+   * @param {ExecutorGroup} executorGroup Executor group.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {boolean} [declutterable] `true` to only render declutterable items,
+   *     `false` to only render non-declutterable items, `undefined` to render all.
+   */
+  renderWorlds(e, t, r) {
+    const o = t.extent, n = t.viewState, p = n.center, a = n.resolution, i = n.projection, g = n.rotation, d = i.getExtent(), h = this.getLayer().getSource(), y = this.getLayer().getDeclutter(), E = t.pixelRatio, x = t.viewHints, c = !(x[G.ANIMATING] || x[G.INTERACTING]), l = this.context, s = Math.round(v(o) / a * E), _ = Math.round(k(o) / a * E), C = h.getWrapX() && i.canWrapX(), R = C ? v(d) : null, I = C ? Math.ceil((o[2] - d[2]) / R) + 1 : 1;
+    let L = C ? Math.floor((o[0] - d[0]) / R) : 0;
+    do {
+      let w = this.getRenderTransform(
+        p,
+        a,
+        0,
+        E,
+        s,
+        _,
+        L * R
+      );
+      t.declutter && (w = w.slice(0)), e.execute(
+        l,
+        [l.canvas.width, l.canvas.height],
+        w,
+        g,
+        c,
+        r === void 0 ? te : r ? re : ne,
+        r ? y && t.declutter[y] : void 0
+      );
+    } while (++L < I);
+  }
+  /**
+   * @private
+   */
+  setDrawContext_() {
+    this.opacity_ !== 1 && (this.targetContext_ = this.context, this.context = z(
+      this.context.canvas.width,
+      this.context.canvas.height,
+      P
+    ));
+  }
+  /**
+   * @private
+   */
+  resetDrawContext_() {
+    if (this.opacity_ !== 1 && this.targetContext_) {
+      const e = this.targetContext_.globalAlpha;
+      this.targetContext_.globalAlpha = this.opacity_, this.targetContext_.drawImage(this.context.canvas, 0, 0), this.targetContext_.globalAlpha = e, $(this.context), P.push(this.context.canvas), this.context = this.targetContext_, this.targetContext_ = null;
+    }
+  }
+  /**
+   * Render declutter items for this layer
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   */
+  renderDeclutter(e) {
+    !this.replayGroup_ || !this.getLayer().getDeclutter() || this.renderWorlds(this.replayGroup_, e, !0);
+  }
+  /**
+   * Render deferred instructions.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @override
+   */
+  renderDeferredInternal(e) {
+    this.replayGroup_ && (this.replayGroup_.renderDeferred(), this.clipped_ && this.context.restore(), this.resetDrawContext_());
+  }
+  /**
+   * Render the layer.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {HTMLElement|null} target Target that may be used to render content to.
+   * @return {HTMLElement} The rendered element.
+   * @override
+   */
+  renderFrame(e, t) {
+    const r = e.layerStatesArray[e.layerIndex];
+    this.opacity_ = r.opacity;
+    const o = e.viewState;
+    this.prepareContainer(e, t);
+    const n = this.context, p = this.replayGroup_;
+    let a = p && !p.isEmpty();
+    if (!a && !(this.getLayer().hasListener(N.PRERENDER) || this.getLayer().hasListener(N.POSTRENDER)))
+      return this.container;
+    if (this.setDrawContext_(), this.preRender(n, e), o.projection, this.clipped_ = !1, a && r.extent && this.clipping) {
+      const i = Q(r.extent);
+      a = q(i, e.extent), this.clipped_ = a && !F(i, e.extent), this.clipped_ && this.clipUnrotated(n, e, i);
+    }
+    return a && this.renderWorlds(
+      p,
+      e,
+      this.getLayer().getDeclutter() ? !1 : void 0
+    ), !e.declutter && this.clipped_ && n.restore(), this.postRender(n, e), this.renderedRotation_ !== o.rotation && (this.renderedRotation_ = o.rotation, this.hitDetectionImageData_ = null), e.declutter || this.resetDrawContext_(), this.container;
+  }
+  /**
+   * Asynchronous layer level hit detection.
+   * @param {import("../../pixel.js").Pixel} pixel Pixel.
+   * @return {Promise<Array<import("../../Feature").default>>} Promise
+   * that resolves with an array of features.
+   * @override
+   */
+  getFeatures(e) {
+    return new Promise((t) => {
+      if (this.frameState && !this.hitDetectionImageData_ && !this.animatingOrInteracting_) {
+        const r = this.frameState.size.slice(), o = this.renderedCenter_, n = this.renderedResolution_, p = this.renderedRotation_, a = this.renderedProjection_, i = this.wrappedRenderedExtent_, g = this.getLayer(), d = [], h = r[0] * D, y = r[1] * D;
+        d.push(
+          this.getRenderTransform(
+            o,
+            n,
+            p,
+            D,
+            h,
+            y,
+            0
+          ).slice()
+        );
+        const E = g.getSource(), x = a.getExtent();
+        if (E.getWrapX() && a.canWrapX() && !F(x, i)) {
+          let c = i[0];
+          const l = v(x);
+          let s = 0, _;
+          for (; c < x[0]; )
+            --s, _ = l * s, d.push(
+              this.getRenderTransform(
+                o,
+                n,
+                p,
+                D,
+                h,
+                y,
+                _
+              ).slice()
+            ), c += l;
+          for (s = 0, c = i[2]; c > x[2]; )
+            ++s, _ = l * s, d.push(
+              this.getRenderTransform(
+                o,
+                n,
+                p,
+                D,
+                h,
+                y,
+                _
+              ).slice()
+            ), c -= l;
+        }
+        this.hitDetectionImageData_ = ie(
+          r,
+          d,
+          this.renderedFeatures_,
+          g.getStyleFunction(),
+          i,
+          n,
+          p,
+          j(n, this.renderedPixelRatio_),
+          null
+        );
+      }
+      t(
+        se(e, this.renderedFeatures_, this.hitDetectionImageData_)
+      );
+    });
+  }
+  /**
+   * @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {number} hitTolerance Hit tolerance in pixels.
+   * @param {import("../vector.js").FeatureCallback<T>} callback Feature callback.
+   * @param {Array<import("../Map.js").HitMatch<T>>} matches The hit detected matches with tolerance.
+   * @return {T|undefined} Callback result.
+   * @template T
+   * @override
+   */
+  forEachFeatureAtCoordinate(e, t, r, o, n) {
+    var y, E;
+    if (!this.replayGroup_)
+      return;
+    const p = t.viewState.resolution, a = t.viewState.rotation, i = this.getLayer(), g = {}, d = function(x, c, l) {
+      const s = oe(x), _ = g[s];
+      if (_) {
+        if (_ !== !0 && l < _.distanceSq) {
+          if (l === 0)
+            return g[s] = !0, n.splice(n.lastIndexOf(_), 1), o(x, i, c);
+          _.geometry = c, _.distanceSq = l;
+        }
+      } else {
+        if (l === 0)
+          return g[s] = !0, o(x, i, c);
+        n.push(
+          g[s] = {
+            feature: x,
+            layer: i,
+            geometry: c,
+            distanceSq: l,
+            callback: o
+          }
+        );
+      }
+    }, h = this.getLayer().getDeclutter();
+    return this.replayGroup_.forEachFeatureAtCoordinate(
+      e,
+      p,
+      a,
+      r,
+      d,
+      h ? (E = (y = t.declutter) == null ? void 0 : y[h]) == null ? void 0 : E.all().map((x) => x.value) : null
+    );
+  }
+  /**
+   * Perform action necessary to get the layer rendered after new fonts have loaded
+   * @override
+   */
+  handleFontsChanged() {
+    const e = this.getLayer();
+    e.getVisible() && this.replayGroup_ && e.changed();
+  }
+  /**
+   * Handle changes in image style state.
+   * @param {import("../../events/Event.js").default} event Image style change event.
+   * @private
+   */
+  handleStyleImageChange_(e) {
+    this.renderIfReadyAndVisible();
+  }
+  /**
+   * Determine whether render should be called.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {boolean} Layer is ready to be rendered.
+   * @override
+   */
+  prepareFrame(e) {
+    const t = this.getLayer(), r = t.getSource();
+    if (!r)
+      return !1;
+    const o = e.viewHints[G.ANIMATING], n = e.viewHints[G.INTERACTING], p = t.getUpdateWhileAnimating(), a = t.getUpdateWhileInteracting();
+    if (this.ready && !p && o || !a && n)
+      return this.animatingOrInteracting_ = !0, !0;
+    this.animatingOrInteracting_ = !1;
+    const i = e.extent, g = e.viewState, d = g.projection, h = g.resolution, y = e.pixelRatio, E = t.getRevision(), x = t.getRenderBuffer();
+    let c = t.getRenderOrder();
+    c === void 0 && (c = de);
+    const l = g.center.slice(), s = J(
+      i,
+      x * h
+    ), _ = s.slice(), C = [s.slice()], R = d.getExtent();
+    if (r.getWrapX() && d.canWrapX() && !F(R, e.extent)) {
+      const u = v(R), m = Math.max(v(s) / 2, u);
+      s[0] = R[0] - m, s[2] = R[2] + m, S(l, d);
+      const f = K(C[0], d);
+      f[0] < R[0] && f[2] < R[2] ? C.push([
+        f[0] + u,
+        f[1],
+        f[2] + u,
+        f[3]
+      ]) : f[0] > R[0] && f[2] > R[2] && C.push([
+        f[0] - u,
+        f[1],
+        f[2] - u,
+        f[3]
+      ]);
+    }
+    if (this.ready && this.renderedResolution_ == h && this.renderedRevision_ == E && this.renderedRenderOrder_ == c && this.renderedFrameDeclutter_ === !!e.declutter && F(this.wrappedRenderedExtent_, s))
+      return B(this.renderedExtent_, _) || (this.hitDetectionImageData_ = null, this.renderedExtent_ = _), this.renderedCenter_ = l, this.replayGroupChanged = !1, !0;
+    this.replayGroup_ = null;
+    const I = new Z(
+      ae(h, y),
+      s,
+      h,
+      y
+    );
+    let L;
+    for (let u = 0, m = C.length; u < m; ++u)
+      r.loadFeatures(C[u], h, d);
+    const w = j(h, y);
+    let W = !0;
+    const X = (
+      /**
+       * @param {import("../../Feature.js").default} feature Feature.
+       * @param {number} index Index.
+       */
+      (u, m) => {
+        let f;
+        const A = u.getStyleFunction() || t.getStyleFunction();
+        if (A && (f = A(u, h)), f) {
+          const V = this.renderFeature(
+            u,
+            w,
+            f,
+            I,
+            L,
+            this.getLayer().getDeclutter(),
+            m
+          );
+          W = W && !V;
+        }
+      }
+    ), U = Y(s), T = r.getFeaturesInExtent(U);
+    c && T.sort(c);
+    for (let u = 0, m = T.length; u < m; ++u)
+      X(T[u], u);
+    this.renderedFeatures_ = T, this.ready = W;
+    const b = I.finish(), M = new ee(
+      s,
+      h,
+      y,
+      r.getOverlaps(),
+      b,
+      t.getRenderBuffer(),
+      !!e.declutter
+    );
+    return this.renderedResolution_ = h, this.renderedRevision_ = E, this.renderedRenderOrder_ = c, this.renderedFrameDeclutter_ = !!e.declutter, this.renderedExtent_ = _, this.wrappedRenderedExtent_ = s, this.renderedCenter_ = l, this.renderedProjection_ = d, this.renderedPixelRatio_ = y, this.replayGroup_ = M, this.hitDetectionImageData_ = null, this.replayGroupChanged = !0, !0;
+  }
+  /**
+   * @param {import("../../Feature.js").default} feature Feature.
+   * @param {number} squaredTolerance Squared render tolerance.
+   * @param {import("../../style/Style.js").default|Array<import("../../style/Style.js").default>} styles The style or array of styles.
+   * @param {import("../../render/canvas/BuilderGroup.js").default} builderGroup Builder group.
+   * @param {import("../../proj.js").TransformFunction} [transform] Transform from user to view projection.
+   * @param {boolean} [declutter] Enable decluttering.
+   * @param {number} [index] Render order index.
+   * @return {boolean} `true` if an image is loading.
+   */
+  renderFeature(e, t, r, o, n, p, a) {
+    if (!r)
+      return !1;
+    let i = !1;
+    if (Array.isArray(r))
+      for (let g = 0, d = r.length; g < d; ++g)
+        i = H(
+          o,
+          e,
+          r[g],
+          t,
+          this.boundHandleStyleImageChange_,
+          n,
+          p,
+          a
+        ) || i;
+    else
+      i = H(
+        o,
+        e,
+        r,
+        t,
+        this.boundHandleStyleImageChange_,
+        n,
+        p,
+        a
+      );
+    return i;
+  }
+}
+const De = he;
+export {
+  De as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/renderer/vector.mjs

@@ -0,0 +1,196 @@
+import S from "../ImageState.mjs";
+import { getUid as f } from "../util.mjs";
+const u = 0.5, m = {
+  Point: Z,
+  LineString: k,
+  Polygon: F,
+  MultiPoint: L,
+  MultiLineString: w,
+  MultiPolygon: B,
+  GeometryCollection: P,
+  Circle: R
+};
+function M(r, n) {
+  return parseInt(f(r), 10) - parseInt(f(n), 10);
+}
+function D(r, n) {
+  const e = I(r, n);
+  return e * e;
+}
+function I(r, n) {
+  return u * r / n;
+}
+function R(r, n, e, g, l) {
+  const c = e.getFill(), o = e.getStroke();
+  if (c || o) {
+    const i = r.getBuilder(e.getZIndex(), "Circle");
+    i.setFillStrokeStyle(c, o), i.drawCircle(n, g, l);
+  }
+  const t = e.getText();
+  if (t && t.getText()) {
+    const i = r.getBuilder(e.getZIndex(), "Text");
+    i.setTextStyle(t), i.drawText(n, g);
+  }
+}
+function C(r, n, e, g, l, c, o, t) {
+  const i = [], d = e.getImage();
+  if (d) {
+    let T = !0;
+    const s = d.getImageState();
+    s == S.LOADED || s == S.ERROR ? T = !1 : s == S.IDLE && d.load(), T && i.push(d.ready());
+  }
+  const a = e.getFill();
+  a && a.loading() && i.push(a.ready());
+  const x = i.length > 0;
+  return x && Promise.all(i).then(() => l(null)), p(
+    r,
+    n,
+    e,
+    g,
+    c,
+    o,
+    t
+  ), x;
+}
+function p(r, n, e, g, l, c, o) {
+  const t = e.getGeometryFunction()(n);
+  if (!t)
+    return;
+  const i = t.simplifyTransformed(
+    g,
+    l
+  );
+  if (e.getRenderer())
+    y(r, i, e, n, o);
+  else {
+    const a = m[i.getType()];
+    a(
+      r,
+      i,
+      e,
+      n,
+      o,
+      c
+    );
+  }
+}
+function y(r, n, e, g, l) {
+  if (n.getType() == "GeometryCollection") {
+    const o = (
+      /** @type {import("../geom/GeometryCollection.js").default} */
+      n.getGeometries()
+    );
+    for (let t = 0, i = o.length; t < i; ++t)
+      y(r, o[t], e, g, l);
+    return;
+  }
+  r.getBuilder(e.getZIndex(), "Default").drawCustom(
+    /** @type {import("../geom/SimpleGeometry.js").default} */
+    n,
+    g,
+    e.getRenderer(),
+    e.getHitDetectionRenderer(),
+    l
+  );
+}
+function P(r, n, e, g, l, c) {
+  const o = n.getGeometriesArray();
+  let t, i;
+  for (t = 0, i = o.length; t < i; ++t) {
+    const d = m[o[t].getType()];
+    d(
+      r,
+      o[t],
+      e,
+      g,
+      l,
+      c
+    );
+  }
+}
+function k(r, n, e, g, l) {
+  const c = e.getStroke();
+  if (c) {
+    const t = r.getBuilder(
+      e.getZIndex(),
+      "LineString"
+    );
+    t.setFillStrokeStyle(null, c), t.drawLineString(n, g, l);
+  }
+  const o = e.getText();
+  if (o && o.getText()) {
+    const t = r.getBuilder(e.getZIndex(), "Text");
+    t.setTextStyle(o), t.drawText(n, g, l);
+  }
+}
+function w(r, n, e, g, l) {
+  const c = e.getStroke();
+  if (c) {
+    const t = r.getBuilder(
+      e.getZIndex(),
+      "LineString"
+    );
+    t.setFillStrokeStyle(null, c), t.drawMultiLineString(n, g, l);
+  }
+  const o = e.getText();
+  if (o && o.getText()) {
+    const t = r.getBuilder(e.getZIndex(), "Text");
+    t.setTextStyle(o), t.drawText(n, g, l);
+  }
+}
+function B(r, n, e, g, l) {
+  const c = e.getFill(), o = e.getStroke();
+  if (o || c) {
+    const i = r.getBuilder(e.getZIndex(), "Polygon");
+    i.setFillStrokeStyle(c, o), i.drawMultiPolygon(n, g, l);
+  }
+  const t = e.getText();
+  if (t && t.getText()) {
+    const i = r.getBuilder(e.getZIndex(), "Text");
+    i.setTextStyle(t), i.drawText(n, g, l);
+  }
+}
+function Z(r, n, e, g, l, c) {
+  const o = e.getImage(), t = e.getText(), i = t && t.getText(), d = c && o && i ? {} : void 0;
+  if (o) {
+    if (o.getImageState() != S.LOADED)
+      return;
+    const a = r.getBuilder(e.getZIndex(), "Image");
+    a.setImageStyle(o, d), a.drawPoint(n, g, l);
+  }
+  if (i) {
+    const a = r.getBuilder(e.getZIndex(), "Text");
+    a.setTextStyle(t, d), a.drawText(n, g, l);
+  }
+}
+function L(r, n, e, g, l, c) {
+  const o = e.getImage(), t = o && o.getOpacity() !== 0, i = e.getText(), d = i && i.getText(), a = c && t && d ? {} : void 0;
+  if (t) {
+    if (o.getImageState() != S.LOADED)
+      return;
+    const x = r.getBuilder(e.getZIndex(), "Image");
+    x.setImageStyle(o, a), x.drawMultiPoint(n, g, l);
+  }
+  if (d) {
+    const x = r.getBuilder(e.getZIndex(), "Text");
+    x.setTextStyle(i, a), x.drawText(n, g, l);
+  }
+}
+function F(r, n, e, g, l) {
+  const c = e.getFill(), o = e.getStroke();
+  if (c || o) {
+    const i = r.getBuilder(e.getZIndex(), "Polygon");
+    i.setFillStrokeStyle(c, o), i.drawPolygon(n, g, l);
+  }
+  const t = e.getText();
+  if (t && t.getText()) {
+    const i = r.getBuilder(e.getZIndex(), "Text");
+    i.setTextStyle(t), i.drawText(n, g, l);
+  }
+}
+export {
+  M as defaultOrder,
+  D as getSquaredTolerance,
+  I as getTolerance,
+  C as renderFeature
+};