gisviewer-vue3-arcgis 1.0.281 → 1.0.283

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/render/canvas.mjs

@@ -0,0 +1,177 @@
+import H from "../Object.mjs";
+import { getFontParameters as g, fontWeights as T } from "../css.mjs";
+import { createCanvasContext2D as L } from "../dom.mjs";
+import { WORKER_OFFSCREEN_CANVAS as b } from "../has.mjs";
+import { clear as W } from "../obj.mjs";
+const P = "10px sans-serif", R = "#000", $ = "round", j = [], O = 0, K = "round", S = 10, _ = "#000", J = "center", V = "middle", q = [0, 0, 0, 0], z = 1, d = new H();
+let h = null, F;
+const y = {}, k = /* @__PURE__ */ new Set([
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-serif",
+  "ui-sans-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "emoji",
+  "math",
+  "fangsong"
+]);
+function v(e, t, n) {
+  return `${e} ${t} 16px "${n}"`;
+}
+const G = function() {
+  let t, n;
+  async function s(l) {
+    await n.ready;
+    const o = await n.load(l);
+    if (o.length === 0)
+      return !1;
+    const u = g(l), r = u.families[0].toLowerCase(), a = u.weight;
+    return o.some(
+      /**
+       * @param {import('../css.js').FontParameters} f Font.
+       * @return {boolean} Font matches.
+       */
+      (i) => {
+        const c = i.family.replace(/^['"]|['"]$/g, "").toLowerCase(), m = T[i.weight] || i.weight;
+        return c === r && i.style === u.style && m == a;
+      }
+    );
+  }
+  async function f() {
+    await n.ready;
+    let l = !0;
+    const o = d.getProperties(), u = Object.keys(o).filter(
+      (r) => o[r] < 100
+    );
+    for (let r = u.length - 1; r >= 0; --r) {
+      const a = u[r];
+      let i = o[a];
+      i < 100 && (await s(a) ? (W(y), d.set(a, 100)) : (i += 10, d.set(a, i, !0), i < 100 && (l = !1)));
+    }
+    t = void 0, l || (t = setTimeout(f, 100));
+  }
+  return async function(l) {
+    n || (n = b ? self.fonts : document.fonts);
+    const o = g(l);
+    if (!o)
+      return;
+    const u = o.families;
+    let r = !1;
+    for (const a of u) {
+      if (k.has(a))
+        continue;
+      const i = v(o.style, o.weight, a);
+      d.get(i) === void 0 && (d.set(i, 0, !0), r = !0);
+    }
+    r && (clearTimeout(t), t = setTimeout(f, 100));
+  };
+}(), x = function() {
+  let e;
+  return function(t) {
+    let n = y[t];
+    if (n == null) {
+      if (b) {
+        const s = g(t), f = A(t, "Žg");
+        n = (isNaN(Number(s.lineHeight)) ? 1.2 : Number(s.lineHeight)) * (f.actualBoundingBoxAscent + f.actualBoundingBoxDescent);
+      } else
+        e || (e = document.createElement("div"), e.innerHTML = "M", e.style.minHeight = "0", e.style.maxHeight = "none", e.style.height = "auto", e.style.padding = "0", e.style.border = "none", e.style.position = "absolute", e.style.display = "block", e.style.left = "-99999px"), e.style.font = t, document.body.appendChild(e), n = e.offsetHeight, document.body.removeChild(e);
+      y[t] = n;
+    }
+    return n;
+  };
+}();
+function A(e, t) {
+  return h || (h = L(1, 1)), e != F && (h.font = e, F = h.font), h.measureText(t);
+}
+function C(e, t) {
+  return A(e, t).width;
+}
+function Q(e, t, n) {
+  if (t in n)
+    return n[t];
+  const s = t.split(`
+`).reduce((f, l) => Math.max(f, C(e, l)), 0);
+  return n[t] = s, s;
+}
+function U(e, t) {
+  const n = [], s = [], f = [];
+  let l = 0, o = 0, u = 0, r = 0;
+  for (let a = 0, i = t.length; a <= i; a += 2) {
+    const c = t[a];
+    if (c === `
+` || a === i) {
+      l = Math.max(l, o), f.push(o), o = 0, u += r, r = 0;
+      continue;
+    }
+    const m = t[a + 1] || e.font, p = C(m, c);
+    n.push(p), o += p;
+    const w = x(m);
+    s.push(w), r = Math.max(r, w);
+  }
+  return { width: l, height: u, widths: n, heights: s, lineWidths: f };
+}
+function Z(e, t, n, s, f, l, o, u, r, a, i) {
+  e.save(), n !== 1 && (e.globalAlpha === void 0 ? e.globalAlpha = (c) => c.globalAlpha *= n : e.globalAlpha *= n), t && e.transform.apply(e, t), /** @type {*} */
+  s.contextInstructions ? (e.translate(r, a), e.scale(i[0], i[1]), B(
+    /** @type {Label} */
+    s,
+    e
+  )) : i[0] < 0 || i[1] < 0 ? (e.translate(r, a), e.scale(i[0], i[1]), e.drawImage(
+    /** @type {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} */
+    s,
+    f,
+    l,
+    o,
+    u,
+    0,
+    0,
+    o,
+    u
+  )) : e.drawImage(
+    /** @type {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} */
+    s,
+    f,
+    l,
+    o,
+    u,
+    r,
+    a,
+    o * i[0],
+    u * i[1]
+  ), e.restore();
+}
+function B(e, t) {
+  const n = e.contextInstructions;
+  for (let s = 0, f = n.length; s < f; s += 2)
+    Array.isArray(n[s + 1]) ? t[n[s]].apply(
+      t,
+      n[s + 1]
+    ) : t[n[s]] = n[s + 1];
+}
+export {
+  d as checkedFonts,
+  R as defaultFillStyle,
+  P as defaultFont,
+  $ as defaultLineCap,
+  j as defaultLineDash,
+  O as defaultLineDashOffset,
+  K as defaultLineJoin,
+  z as defaultLineWidth,
+  S as defaultMiterLimit,
+  q as defaultPadding,
+  _ as defaultStrokeStyle,
+  J as defaultTextAlign,
+  V as defaultTextBaseline,
+  Z as drawImageOrLabel,
+  U as getTextDimensions,
+  Q as measureAndCacheTextWidth,
+  x as measureTextHeight,
+  C as measureTextWidth,
+  G as registerFont,
+  y as textHeights
+};

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

@@ -0,0 +1,124 @@
+import g from "../ObjectEventType.mjs";
+import { CLASS_UNSELECTABLE as E } from "../css.mjs";
+import { createMockDiv as _, replaceChildren as C, isCanvas as m } from "../dom.mjs";
+import { listen as v, unlistenByKey as R } from "../events.mjs";
+import { WORKER_OFFSCREEN_CANVAS as w } from "../has.mjs";
+import b from "../layer/BaseVector.mjs";
+import { inView as x } from "../layer/Layer.mjs";
+import T from "../render/Event.mjs";
+import f from "../render/EventType.mjs";
+import { checkedFonts as A } from "../render/canvas.mjs";
+import { fromString as M } from "../transform.mjs";
+import O from "./Map.mjs";
+class V extends O {
+  /**
+   * @param {import("../Map.js").default} map Map.
+   */
+  constructor(e) {
+    super(e), this.fontChangeListenerKey_ = v(
+      A,
+      g.PROPERTYCHANGE,
+      e.redrawText,
+      e
+    ), this.element_ = w ? _() : document.createElement("div");
+    const n = this.element_.style;
+    n.position = "absolute", n.width = "100%", n.height = "100%", n.zIndex = "0", this.element_.className = E + " ol-layers";
+    const i = e.getViewport();
+    i && i.insertBefore(this.element_, i.firstChild || null), this.children_ = [], this.renderedVisible_ = !0;
+  }
+  /**
+   * @param {import("../render/EventType.js").default} type Event type.
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @override
+   */
+  dispatchRenderEvent(e, n) {
+    const i = this.getMap();
+    if (i.hasListener(e)) {
+      const l = new T(e, void 0, n);
+      i.dispatchEvent(l);
+    }
+  }
+  /**
+   * @override
+   */
+  disposeInternal() {
+    R(this.fontChangeListenerKey_), this.element_.remove(), super.disposeInternal();
+  }
+  /**
+   * Render.
+   * @param {?import("../Map.js").FrameState} frameState Frame state.
+   * @override
+   */
+  renderFrame(e) {
+    if (!e) {
+      this.renderedVisible_ && (this.element_.style.display = "none", this.renderedVisible_ = !1);
+      return;
+    }
+    this.calculateMatrices2D(e), this.dispatchRenderEvent(f.PRECOMPOSE, e);
+    const n = e.layerStatesArray.sort(
+      (t, s) => t.zIndex - s.zIndex
+    );
+    n.some(
+      (t) => t.layer instanceof b && t.layer.getDeclutter()
+    ) && (e.declutter = {});
+    const l = e.viewState;
+    this.children_.length = 0;
+    const d = [];
+    let p = null;
+    for (let t = 0, s = n.length; t < s; ++t) {
+      const r = n[t];
+      e.layerIndex = t;
+      const c = r.layer, h = c.getSourceState();
+      if (!x(r, l) || h != "ready" && h != "undefined") {
+        c.unrender();
+        continue;
+      }
+      const o = c.render(e, p);
+      o && (o !== p && (this.children_.push(o), p = o), d.push(r));
+    }
+    this.declutter(e, d), C(this.element_, this.children_);
+    const a = this.getMap().getTargetElement();
+    if (m(a)) {
+      const t = a.getContext("2d");
+      for (const s of this.children_) {
+        const r = s.firstElementChild || s, c = s.style.backgroundColor;
+        if (c && (!m(r) || r.width > 0) && (t.fillStyle = c, t.fillRect(0, 0, a.width, a.height)), m(r) && r.width > 0) {
+          const h = s.style.opacity || r.style.opacity;
+          t.globalAlpha = h === "" ? 1 : Number(h);
+          const o = r.style.transform;
+          if (o)
+            t.setTransform(
+              .../** @type {[number, number, number, number, number, number]} */
+              M(o)
+            );
+          else {
+            const u = parseFloat(r.style.width) / r.width, y = parseFloat(r.style.height) / r.height;
+            t.setTransform(u, 0, 0, y, 0, 0);
+          }
+          t.drawImage(r, 0, 0);
+        }
+      }
+      t.globalAlpha = 1, t.setTransform(1, 0, 0, 1, 0, 0);
+    }
+    this.dispatchRenderEvent(f.POSTCOMPOSE, e), this.renderedVisible_ || (this.element_.style.display = "", this.renderedVisible_ = !0), this.scheduleExpireIconCache(e);
+  }
+  /**
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @param {Array<import('../layer/Layer.js').State>} layerStates Layers.
+   */
+  declutter(e, n) {
+    if (e.declutter) {
+      for (let i = n.length - 1; i >= 0; --i) {
+        const l = n[i], d = l.layer;
+        d.getDeclutter() && d.renderDeclutter(e, l);
+      }
+      n.forEach(
+        (i) => i.layer.renderDeferred(e)
+      );
+    }
+  }
+}
+const U = V;
+export {
+  U as default
+};

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

@@ -0,0 +1,130 @@
+import a from "../ImageState.mjs";
+import s from "../Observable.mjs";
+import n from "../events/EventType.mjs";
+import { abstract as r } from "../util.mjs";
+const i = 5;
+class l extends s {
+  /**
+   * @param {LayerType} layer Layer.
+   */
+  constructor(e) {
+    super(), this.ready = !0, this.boundHandleImageChange_ = this.handleImageChange_.bind(this), this.layer_ = e, this.staleKeys_ = new Array(), this.maxStaleKeys = i;
+  }
+  /**
+   * @return {Array<string>} Get the list of stale keys.
+   */
+  getStaleKeys() {
+    return this.staleKeys_;
+  }
+  /**
+   * @param {string} key The new stale key.
+   */
+  prependStaleKey(e) {
+    this.staleKeys_.unshift(e), this.staleKeys_.length > this.maxStaleKeys && (this.staleKeys_.length = this.maxStaleKeys);
+  }
+  /**
+   * Asynchronous layer level hit detection.
+   * @param {import("../pixel.js").Pixel} pixel Pixel.
+   * @return {Promise<Array<import("../Feature").FeatureLike>>} Promise that resolves with
+   * an array of features.
+   */
+  getFeatures(e) {
+    return r();
+  }
+  /**
+   * @param {import("../pixel.js").Pixel} pixel Pixel.
+   * @return {Uint8ClampedArray|Uint8Array|Float32Array|DataView|null} Pixel data.
+   */
+  getData(e) {
+    return null;
+  }
+  /**
+   * Determine whether render should be called.
+   * @abstract
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @return {boolean} Layer is ready to be rendered.
+   */
+  prepareFrame(e) {
+    return r();
+  }
+  /**
+   * Render the layer.
+   * @abstract
+   * @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.
+   */
+  renderFrame(e, t) {
+    return r();
+  }
+  /**
+   * @abstract
+   * @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
+   */
+  forEachFeatureAtCoordinate(e, t, h, o, g) {
+  }
+  /**
+   * @return {LayerType} Layer.
+   */
+  getLayer() {
+    return this.layer_;
+  }
+  /**
+   * Perform action necessary to get the layer rendered after new fonts have loaded
+   * @abstract
+   */
+  handleFontsChanged() {
+  }
+  /**
+   * Handle changes in image state.
+   * @param {import("../events/Event.js").default} event Image change event.
+   * @private
+   */
+  handleImageChange_(e) {
+    const t = (
+      /** @type {import("../Image.js").default} */
+      e.target
+    );
+    (t.getState() === a.LOADED || t.getState() === a.ERROR) && this.renderIfReadyAndVisible();
+  }
+  /**
+   * Load the image if not already loaded, and register the image change
+   * listener if needed.
+   * @param {import("../Image.js").default} image Image.
+   * @return {boolean} `true` if the image is already loaded, `false` otherwise.
+   * @protected
+   */
+  loadImage(e) {
+    let t = e.getState();
+    return t != a.LOADED && t != a.ERROR && e.addEventListener(n.CHANGE, this.boundHandleImageChange_), t == a.IDLE && (e.load(), t = e.getState()), t == a.LOADED;
+  }
+  /**
+   * @protected
+   */
+  renderIfReadyAndVisible() {
+    const e = this.getLayer();
+    e && e.getVisible() && e.getSourceState() === "ready" && e.changed();
+  }
+  /**
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   */
+  renderDeferred(e) {
+  }
+  /**
+   * Clean up.
+   * @override
+   */
+  disposeInternal() {
+    delete this.layer_, super.disposeInternal();
+  }
+}
+const S = l;
+export {
+  S as default
+};

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

@@ -0,0 +1,151 @@
+import M from "../Disposable.mjs";
+import { wrapX as W } from "../coordinate.mjs";
+import { getWidth as k } from "../extent.mjs";
+import { TRUE as q } from "../functions.mjs";
+import { inView as I } from "../layer/Layer.mjs";
+import { shared as T } from "../style/IconImageCache.mjs";
+import { compose as X, makeInverse as z } from "../transform.mjs";
+import { abstract as F } from "../util.mjs";
+class D extends M {
+  /**
+   * @param {import("../Map.js").default} map Map.
+   */
+  constructor(e) {
+    super(), this.map_ = e;
+  }
+  /**
+   * @abstract
+   * @param {import("../render/EventType.js").default} type Event type.
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   */
+  dispatchRenderEvent(e, r) {
+    F();
+  }
+  /**
+   * @param {import("../Map.js").FrameState} frameState FrameState.
+   * @protected
+   */
+  calculateMatrices2D(e) {
+    const r = e.viewState, n = e.coordinateToPixelTransform, c = e.pixelToCoordinateTransform;
+    X(
+      n,
+      e.size[0] / 2,
+      e.size[1] / 2,
+      1 / r.resolution,
+      -1 / r.resolution,
+      -r.rotation,
+      -r.center[0],
+      -r.center[1]
+    ), z(c, n);
+  }
+  /**
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {import("../Map.js").FrameState} frameState FrameState.
+   * @param {number} hitTolerance Hit tolerance in pixels.
+   * @param {boolean} checkWrapped Check for wrapped geometries.
+   * @param {import("./vector.js").FeatureCallback<T>} callback Feature callback.
+   * @param {S} thisArg Value to use as `this` when executing `callback`.
+   * @param {function(this: U, import("../layer/Layer.js").default): boolean} layerFilter Layer filter
+   *     function, only layers which are visible and for which this function
+   *     returns `true` will be tested for features.  By default, all visible
+   *     layers will be tested.
+   * @param {U} thisArg2 Value to use as `this` when executing `layerFilter`.
+   * @return {T|undefined} Callback result.
+   * @template S,T,U
+   */
+  forEachFeatureAtCoordinate(e, r, n, c, p, u, m, S) {
+    let i;
+    const g = r.viewState;
+    function w(t, o, l, s) {
+      return p.call(u, o, t ? l : null, s);
+    }
+    const f = g.projection, v = W(e.slice(), f), d = [[0, 0]];
+    if (f.canWrapX() && c) {
+      const t = f.getExtent(), o = k(t);
+      d.push([-o, 0], [o, 0]);
+    }
+    const x = r.layerStatesArray, A = x.length, a = (
+      /** @type {Array<HitMatch<T>>} */
+      []
+    ), h = [];
+    for (let t = 0; t < d.length; t++)
+      for (let o = A - 1; o >= 0; --o) {
+        const l = x[o], s = l.layer;
+        if (s.hasRenderer() && I(l, g) && m.call(S, s)) {
+          const C = s.getRenderer(), y = s.getSource();
+          if (C && y) {
+            const E = y.getWrapX() ? v : e, j = w.bind(
+              null,
+              l.managed
+            );
+            h[0] = E[0] + d[t][0], h[1] = E[1] + d[t][1], i = C.forEachFeatureAtCoordinate(
+              h,
+              r,
+              n,
+              j,
+              a
+            );
+          }
+          if (i)
+            return i;
+        }
+      }
+    if (a.length === 0)
+      return;
+    const b = 1 / a.length;
+    return a.forEach((t, o) => t.distanceSq += o * b), a.sort((t, o) => t.distanceSq - o.distanceSq), a.some((t) => i = t.callback(t.feature, t.layer, t.geometry)), i;
+  }
+  /**
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {import("../Map.js").FrameState} frameState FrameState.
+   * @param {number} hitTolerance Hit tolerance in pixels.
+   * @param {boolean} checkWrapped Check for wrapped geometries.
+   * @param {function(this: U, import("../layer/Layer.js").default): boolean} layerFilter Layer filter
+   *     function, only layers which are visible and for which this function
+   *     returns `true` will be tested for features.  By default, all visible
+   *     layers will be tested.
+   * @param {U} thisArg Value to use as `this` when executing `layerFilter`.
+   * @return {boolean} Is there a feature at the given coordinate?
+   * @template U
+   */
+  hasFeatureAtCoordinate(e, r, n, c, p, u) {
+    return this.forEachFeatureAtCoordinate(
+      e,
+      r,
+      n,
+      c,
+      q,
+      this,
+      p,
+      u
+    ) !== void 0;
+  }
+  /**
+   * @return {import("../Map.js").default} Map.
+   */
+  getMap() {
+    return this.map_;
+  }
+  /**
+   * Render.
+   * @abstract
+   * @param {?import("../Map.js").FrameState} frameState Frame state.
+   */
+  renderFrame(e) {
+    F();
+  }
+  /**
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @protected
+   */
+  scheduleExpireIconCache(e) {
+    T.canExpireCache() && e.postRenderFunctions.push(P);
+  }
+}
+function P(R, e) {
+  T.expire();
+}
+const J = D;
+export {
+  J as default
+};