gisviewer-vue3-arcgis 1.0.280 → 1.0.282

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

@@ -0,0 +1,408 @@
+import { reverseSubArray as I, equals as M } from "../../array.mjs";
+import { asColorLike as E } from "../../colorlike.mjs";
+import b from "../../extent/Relationship.mjs";
+import { containsCoordinate as x, coordinateRelationship as g, clone as _, buffer as O } from "../../extent.mjs";
+import { inflateCoordinates as L, inflateCoordinatesArray as y, inflateMultiCoordinatesArray as D } from "../../geom/flat/inflate.mjs";
+import T from "../VectorContext.mjs";
+import { defaultFillStyle as G, defaultStrokeStyle as k, defaultLineCap as F, defaultLineDash as W, defaultLineDashOffset as R, defaultLineJoin as P, defaultLineWidth as J, defaultMiterLimit as U } from "../canvas.mjs";
+import u from "./Instruction.mjs";
+class B extends T {
+  /**
+   * @param {number} tolerance Tolerance.
+   * @param {import("../../extent.js").Extent} maxExtent Maximum extent.
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   */
+  constructor(t, i, n, s) {
+    super(), this.tolerance = t, this.maxExtent = i, this.pixelRatio = s, this.maxLineWidth = 0, this.resolution = n, this.beginGeometryInstruction1_ = null, this.beginGeometryInstruction2_ = null, this.bufferedMaxExtent_ = null, this.instructions = [], this.coordinates = [], this.tmpCoordinate_ = [], this.hitDetectionInstructions = [], this.state = /** @type {import("../canvas.js").FillStrokeState} */
+    {};
+  }
+  /**
+   * @protected
+   * @param {Array<number>} dashArray Dash array.
+   * @return {Array<number>} Dash array with pixel ratio applied
+   */
+  applyPixelRatio(t) {
+    const i = this.pixelRatio;
+    return i == 1 ? t : t.map(function(n) {
+      return n * i;
+    });
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} stride Stride.
+   * @protected
+   * @return {number} My end
+   */
+  appendFlatPointCoordinates(t, i) {
+    const n = this.getBufferedMaxExtent(), s = this.tmpCoordinate_, o = this.coordinates;
+    let r = o.length;
+    for (let l = 0, e = t.length; l < e; l += i)
+      s[0] = t[l], s[1] = t[l + 1], x(n, s) && (o[r++] = s[0], o[r++] = s[1]);
+    return r;
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {number} end End.
+   * @param {number} stride Stride.
+   * @param {boolean} closed Last input coordinate equals first.
+   * @param {boolean} skipFirst Skip first coordinate.
+   * @protected
+   * @return {number} My end.
+   */
+  appendFlatLineCoordinates(t, i, n, s, o, r) {
+    const l = this.coordinates;
+    let e = l.length;
+    const h = this.getBufferedMaxExtent();
+    r && (i += s);
+    let c = t[i], p = t[i + 1];
+    const a = this.tmpCoordinate_;
+    let d = !0, f, S, C;
+    for (f = i + s; f < n; f += s)
+      a[0] = t[f], a[1] = t[f + 1], C = g(h, a), C !== S ? (d && (l[e++] = c, l[e++] = p, d = !1), l[e++] = a[0], l[e++] = a[1]) : C === b.INTERSECTING ? (l[e++] = a[0], l[e++] = a[1], d = !1) : d = !0, c = a[0], p = a[1], S = C;
+    return (o && d || f === i + s) && (l[e++] = c, l[e++] = p), e;
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {Array<number>} ends Ends.
+   * @param {number} stride Stride.
+   * @param {Array<number>} builderEnds Builder ends.
+   * @return {number} Offset.
+   */
+  drawCustomCoordinates_(t, i, n, s, o) {
+    for (let r = 0, l = n.length; r < l; ++r) {
+      const e = n[r], h = this.appendFlatLineCoordinates(
+        t,
+        i,
+        e,
+        s,
+        !1,
+        !1
+      );
+      o.push(h), i = e;
+    }
+    return i;
+  }
+  /**
+   * @param {import("../../geom/SimpleGeometry.js").default} geometry Geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   * @param {Function} renderer Renderer.
+   * @param {Function} hitDetectionRenderer Renderer.
+   * @param {number} [index] Render order index.
+   * @override
+   */
+  drawCustom(t, i, n, s, o) {
+    this.beginGeometry(t, i, o);
+    const r = t.getType(), l = t.getStride(), e = this.coordinates.length;
+    let h, c, p, a, d;
+    switch (r) {
+      case "MultiPolygon":
+        h = /** @type {import("../../geom/MultiPolygon.js").default} */
+        t.getOrientedFlatCoordinates(), a = [];
+        const f = (
+          /** @type {import("../../geom/MultiPolygon.js").default} */
+          t.getEndss()
+        );
+        d = 0;
+        for (let S = 0, C = f.length; S < C; ++S) {
+          const m = [];
+          d = this.drawCustomCoordinates_(
+            h,
+            d,
+            f[S],
+            l,
+            m
+          ), a.push(m);
+        }
+        this.instructions.push([
+          u.CUSTOM,
+          e,
+          a,
+          t,
+          n,
+          D,
+          o
+        ]), this.hitDetectionInstructions.push([
+          u.CUSTOM,
+          e,
+          a,
+          t,
+          s || n,
+          D,
+          o
+        ]);
+        break;
+      case "Polygon":
+      case "MultiLineString":
+        p = [], h = r == "Polygon" ? (
+          /** @type {import("../../geom/Polygon.js").default} */
+          t.getOrientedFlatCoordinates()
+        ) : t.getFlatCoordinates(), d = this.drawCustomCoordinates_(
+          h,
+          0,
+          /** @type {import("../../geom/Polygon.js").default|import("../../geom/MultiLineString.js").default} */
+          t.getEnds(),
+          l,
+          p
+        ), this.instructions.push([
+          u.CUSTOM,
+          e,
+          p,
+          t,
+          n,
+          y,
+          o
+        ]), this.hitDetectionInstructions.push([
+          u.CUSTOM,
+          e,
+          p,
+          t,
+          s || n,
+          y,
+          o
+        ]);
+        break;
+      case "LineString":
+      case "Circle":
+        h = t.getFlatCoordinates(), c = this.appendFlatLineCoordinates(
+          h,
+          0,
+          h.length,
+          l,
+          !1,
+          !1
+        ), this.instructions.push([
+          u.CUSTOM,
+          e,
+          c,
+          t,
+          n,
+          L,
+          o
+        ]), this.hitDetectionInstructions.push([
+          u.CUSTOM,
+          e,
+          c,
+          t,
+          s || n,
+          L,
+          o
+        ]);
+        break;
+      case "MultiPoint":
+        h = t.getFlatCoordinates(), c = this.appendFlatPointCoordinates(h, l), c > e && (this.instructions.push([
+          u.CUSTOM,
+          e,
+          c,
+          t,
+          n,
+          L,
+          o
+        ]), this.hitDetectionInstructions.push([
+          u.CUSTOM,
+          e,
+          c,
+          t,
+          s || n,
+          L,
+          o
+        ]));
+        break;
+      case "Point":
+        h = t.getFlatCoordinates(), this.coordinates.push(h[0], h[1]), c = this.coordinates.length, this.instructions.push([
+          u.CUSTOM,
+          e,
+          c,
+          t,
+          n,
+          void 0,
+          o
+        ]), this.hitDetectionInstructions.push([
+          u.CUSTOM,
+          e,
+          c,
+          t,
+          s || n,
+          void 0,
+          o
+        ]);
+        break;
+    }
+    this.endGeometry(i);
+  }
+  /**
+   * @protected
+   * @param {import("../../geom/Geometry").default|import("../Feature.js").default} geometry The geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   * @param {number} index Render order index
+   */
+  beginGeometry(t, i, n) {
+    this.beginGeometryInstruction1_ = [
+      u.BEGIN_GEOMETRY,
+      i,
+      0,
+      t,
+      n
+    ], this.instructions.push(this.beginGeometryInstruction1_), this.beginGeometryInstruction2_ = [
+      u.BEGIN_GEOMETRY,
+      i,
+      0,
+      t,
+      n
+    ], this.hitDetectionInstructions.push(this.beginGeometryInstruction2_);
+  }
+  /**
+   * @return {import("../canvas.js").SerializableInstructions} the serializable instructions.
+   */
+  finish() {
+    return {
+      instructions: this.instructions,
+      hitDetectionInstructions: this.hitDetectionInstructions,
+      coordinates: this.coordinates
+    };
+  }
+  /**
+   * Reverse the hit detection instructions.
+   */
+  reverseHitDetectionInstructions() {
+    const t = this.hitDetectionInstructions;
+    t.reverse();
+    let i;
+    const n = t.length;
+    let s, o, r = -1;
+    for (i = 0; i < n; ++i)
+      s = t[i], o = /** @type {import("./Instruction.js").default} */
+      s[0], o == u.END_GEOMETRY ? r = i : o == u.BEGIN_GEOMETRY && (s[2] = i, I(this.hitDetectionInstructions, r, i), r = -1);
+  }
+  /**
+   * @param {import("../../style/Fill.js").default} fillStyle Fill style.
+   * @param {import('../canvas.js').FillStrokeState} [state] State.
+   * @return {import('../canvas.js').FillStrokeState} State.
+   */
+  fillStyleToState(t, i = (
+    /** @type {import('../canvas.js').FillStrokeState} */
+    {}
+  )) {
+    if (t) {
+      const n = t.getColor();
+      i.fillPatternScale = n && typeof n == "object" && "src" in n ? this.pixelRatio : 1, i.fillStyle = E(
+        n || G
+      );
+    } else
+      i.fillStyle = void 0;
+    return i;
+  }
+  /**
+   * @param {import("../../style/Stroke.js").default} strokeStyle Stroke style.
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   * @return {import("../canvas.js").FillStrokeState} State.
+   */
+  strokeStyleToState(t, i = (
+    /** @type {import('../canvas.js').FillStrokeState} */
+    {}
+  )) {
+    if (t) {
+      const n = t.getColor();
+      i.strokeStyle = E(
+        n || k
+      );
+      const s = t.getLineCap();
+      i.lineCap = s !== void 0 ? s : F;
+      const o = t.getLineDash();
+      i.lineDash = o ? o.slice() : W;
+      const r = t.getLineDashOffset();
+      i.lineDashOffset = r || R;
+      const l = t.getLineJoin();
+      i.lineJoin = l !== void 0 ? l : P;
+      const e = t.getWidth();
+      i.lineWidth = e !== void 0 ? e : J;
+      const h = t.getMiterLimit();
+      i.miterLimit = h !== void 0 ? h : U, i.lineWidth > this.maxLineWidth && (this.maxLineWidth = i.lineWidth, this.bufferedMaxExtent_ = null);
+    } else
+      i.strokeStyle = void 0, i.lineCap = void 0, i.lineDash = null, i.lineDashOffset = void 0, i.lineJoin = void 0, i.lineWidth = void 0, i.miterLimit = void 0;
+    return i;
+  }
+  /**
+   * @param {import("../../style/Fill.js").default} fillStyle Fill style.
+   * @param {import("../../style/Stroke.js").default} strokeStyle Stroke style.
+   * @override
+   */
+  setFillStrokeStyle(t, i) {
+    const n = this.state;
+    this.fillStyleToState(t, n), this.strokeStyleToState(i, n);
+  }
+  /**
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   * @return {Array<*>} Fill instruction.
+   */
+  createFill(t) {
+    const i = t.fillStyle, n = [u.SET_FILL_STYLE, i];
+    return typeof i != "string" && n.push(t.fillPatternScale), n;
+  }
+  /**
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   */
+  applyStroke(t) {
+    this.instructions.push(this.createStroke(t));
+  }
+  /**
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   * @return {Array<*>} Stroke instruction.
+   */
+  createStroke(t) {
+    return [
+      u.SET_STROKE_STYLE,
+      t.strokeStyle,
+      t.lineWidth * this.pixelRatio,
+      t.lineCap,
+      t.lineJoin,
+      t.miterLimit,
+      t.lineDash ? this.applyPixelRatio(t.lineDash) : null,
+      t.lineDashOffset * this.pixelRatio
+    ];
+  }
+  /**
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   * @param {function(this:CanvasBuilder, import("../canvas.js").FillStrokeState):Array<*>} createFill Create fill.
+   */
+  updateFillStyle(t, i) {
+    const n = t.fillStyle;
+    (typeof n != "string" || t.currentFillStyle != n) && (this.instructions.push(i.call(this, t)), t.currentFillStyle = n);
+  }
+  /**
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   * @param {function(this:CanvasBuilder, import("../canvas.js").FillStrokeState): void} applyStroke Apply stroke.
+   */
+  updateStrokeStyle(t, i) {
+    const n = t.strokeStyle, s = t.lineCap, o = t.lineDash, r = t.lineDashOffset, l = t.lineJoin, e = t.lineWidth, h = t.miterLimit;
+    (t.currentStrokeStyle != n || t.currentLineCap != s || o != t.currentLineDash && !M(t.currentLineDash, o) || t.currentLineDashOffset != r || t.currentLineJoin != l || t.currentLineWidth != e || t.currentMiterLimit != h) && (i.call(this, t), t.currentStrokeStyle = n, t.currentLineCap = s, t.currentLineDash = o, t.currentLineDashOffset = r, t.currentLineJoin = l, t.currentLineWidth = e, t.currentMiterLimit = h);
+  }
+  /**
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   */
+  endGeometry(t) {
+    this.beginGeometryInstruction1_[2] = this.instructions.length, this.beginGeometryInstruction1_ = null, this.beginGeometryInstruction2_[2] = this.hitDetectionInstructions.length, this.beginGeometryInstruction2_ = null;
+    const i = [u.END_GEOMETRY, t];
+    this.instructions.push(i), this.hitDetectionInstructions.push(i);
+  }
+  /**
+   * Get the buffered rendering extent.  Rendering will be clipped to the extent
+   * provided to the constructor.  To account for symbolizers that may intersect
+   * this extent, we calculate a buffered extent (e.g. based on stroke width).
+   * @return {import("../../extent.js").Extent} The buffered rendering extent.
+   * @protected
+   */
+  getBufferedMaxExtent() {
+    if (!this.bufferedMaxExtent_ && (this.bufferedMaxExtent_ = _(this.maxExtent), this.maxLineWidth > 0)) {
+      const t = this.resolution * (this.maxLineWidth + 1) / 2;
+      O(this.bufferedMaxExtent_, t, this.bufferedMaxExtent_);
+    }
+    return this.bufferedMaxExtent_;
+  }
+}
+const V = B;
+export {
+  V as default
+};

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

@@ -0,0 +1,64 @@
+import l from "./Builder.mjs";
+import u from "./ImageBuilder.mjs";
+import d from "./LineStringBuilder.mjs";
+import o from "./PolygonBuilder.mjs";
+import a from "./TextBuilder.mjs";
+const c = {
+  Circle: o,
+  Default: l,
+  Image: u,
+  LineString: d,
+  Polygon: o,
+  Text: a
+};
+class f {
+  /**
+   * @param {number} tolerance Tolerance.
+   * @param {import("../../extent.js").Extent} maxExtent Max extent.
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   */
+  constructor(e, t, r, i) {
+    this.tolerance_ = e, this.maxExtent_ = t, this.pixelRatio_ = i, this.resolution_ = r, this.buildersByZIndex_ = {};
+  }
+  /**
+   * @return {!Object<string, !Object<import("../canvas.js").BuilderType, import("./Builder.js").SerializableInstructions>>} The serializable instructions
+   */
+  finish() {
+    const e = {};
+    for (const t in this.buildersByZIndex_) {
+      e[t] = e[t] || {};
+      const r = this.buildersByZIndex_[t];
+      for (const i in r) {
+        const n = r[i].finish();
+        e[t][i] = n;
+      }
+    }
+    return e;
+  }
+  /**
+   * @param {number|undefined} zIndex Z index.
+   * @param {import("../canvas.js").BuilderType} builderType Replay type.
+   * @return {import("../VectorContext.js").default} Replay.
+   */
+  getBuilder(e, t) {
+    const r = e !== void 0 ? e.toString() : "0";
+    let i = this.buildersByZIndex_[r];
+    i === void 0 && (i = {}, this.buildersByZIndex_[r] = i);
+    let n = i[t];
+    if (n === void 0) {
+      const s = c[t];
+      n = new s(
+        this.tolerance_,
+        this.maxExtent_,
+        this.resolution_,
+        this.pixelRatio_
+      ), i[t] = n;
+    }
+    return n;
+  }
+}
+const y = f;
+export {
+  y as default
+};