gisviewer-vue3-arcgis 1.0.281 → 1.0.283

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/style/RegularShape.mjs

@@ -0,0 +1,336 @@
+import d from "../ImageState.mjs";
+import { asArray as P } from "../color.mjs";
+import { asColorLike as L } from "../colorlike.mjs";
+import { createCanvasContext2D as C } from "../dom.mjs";
+import { defaultStrokeStyle as p, defaultLineWidth as w, defaultLineJoin as M, defaultLineCap as z, defaultMiterLimit as R, defaultFillStyle as I } from "../render/canvas.mjs";
+import W from "./IconImage.mjs";
+import { shared as v } from "./IconImageCache.mjs";
+import b from "./Image.mjs";
+class _ extends b {
+  /**
+   * @param {Options} options Options.
+   */
+  constructor(t) {
+    super({
+      opacity: 1,
+      rotateWithView: t.rotateWithView !== void 0 ? t.rotateWithView : !1,
+      rotation: t.rotation !== void 0 ? t.rotation : 0,
+      scale: t.scale !== void 0 ? t.scale : 1,
+      displacement: t.displacement !== void 0 ? t.displacement : [0, 0],
+      declutterMode: t.declutterMode
+    }), this.hitDetectionCanvas_ = null, this.fill_ = t.fill !== void 0 ? t.fill : null, this.origin_ = [0, 0], this.points_ = t.points, this.radius = t.radius, this.radius2_ = t.radius2, this.angle_ = t.angle !== void 0 ? t.angle : 0, this.stroke_ = t.stroke !== void 0 ? t.stroke : null, this.size_, this.renderOptions_, this.imageState_ = this.fill_ && this.fill_.loading() ? d.LOADING : d.LOADED, this.imageState_ === d.LOADING && this.ready().then(() => this.imageState_ = d.LOADED), this.render();
+  }
+  /**
+   * Clones the style.
+   * @return {RegularShape} The cloned style.
+   * @api
+   * @override
+   */
+  clone() {
+    const t = this.getScale(), e = new _({
+      fill: this.getFill() ? this.getFill().clone() : void 0,
+      points: this.getPoints(),
+      radius: this.getRadius(),
+      radius2: this.getRadius2(),
+      angle: this.getAngle(),
+      stroke: this.getStroke() ? this.getStroke().clone() : void 0,
+      rotation: this.getRotation(),
+      rotateWithView: this.getRotateWithView(),
+      scale: Array.isArray(t) ? t.slice() : t,
+      displacement: this.getDisplacement().slice(),
+      declutterMode: this.getDeclutterMode()
+    });
+    return e.setOpacity(this.getOpacity()), e;
+  }
+  /**
+   * Get the anchor point in pixels. The anchor determines the center point for the
+   * symbolizer.
+   * @return {Array<number>} Anchor.
+   * @api
+   * @override
+   */
+  getAnchor() {
+    const t = this.size_, e = this.getDisplacement(), s = this.getScaleArray();
+    return [
+      t[0] / 2 - e[0] / s[0],
+      t[1] / 2 + e[1] / s[1]
+    ];
+  }
+  /**
+   * Get the angle used in generating the shape.
+   * @return {number} Shape's rotation in radians.
+   * @api
+   */
+  getAngle() {
+    return this.angle_;
+  }
+  /**
+   * Get the fill style for the shape.
+   * @return {import("./Fill.js").default|null} Fill style.
+   * @api
+   */
+  getFill() {
+    return this.fill_;
+  }
+  /**
+   * Set the fill style.
+   * @param {import("./Fill.js").default|null} fill Fill style.
+   * @api
+   */
+  setFill(t) {
+    this.fill_ = t, this.render();
+  }
+  /**
+   * @return {HTMLCanvasElement|OffscreenCanvas} Image element.
+   * @override
+   */
+  getHitDetectionImage() {
+    return this.hitDetectionCanvas_ || (this.hitDetectionCanvas_ = this.createHitDetectionCanvas_(
+      this.renderOptions_
+    )), this.hitDetectionCanvas_;
+  }
+  /**
+   * Get the image icon.
+   * @param {number} pixelRatio Pixel ratio.
+   * @return {HTMLCanvasElement|OffscreenCanvas} Image or Canvas element.
+   * @api
+   * @override
+   */
+  getImage(t) {
+    var a, r;
+    const e = (a = this.fill_) == null ? void 0 : a.getKey(), s = `${t},${this.angle_},${this.radius},${this.radius2_},${this.points_},${e}` + Object.values(this.renderOptions_).join(",");
+    let i = (
+      /** @type {HTMLCanvasElement|OffscreenCanvas} */
+      (r = v.get(s, null, null)) == null ? void 0 : r.getImage(1)
+    );
+    if (!i) {
+      const l = this.renderOptions_, n = Math.ceil(l.size * t), h = C(n, n);
+      this.draw_(l, h, t), i = h.canvas, v.set(
+        s,
+        null,
+        null,
+        new W(i, void 0, null, d.LOADED, null)
+      );
+    }
+    return i;
+  }
+  /**
+   * Get the image pixel ratio.
+   * @param {number} pixelRatio Pixel ratio.
+   * @return {number} Pixel ratio.
+   * @override
+   */
+  getPixelRatio(t) {
+    return t;
+  }
+  /**
+   * @return {import("../size.js").Size} Image size.
+   * @override
+   */
+  getImageSize() {
+    return this.size_;
+  }
+  /**
+   * @return {import("../ImageState.js").default} Image state.
+   * @override
+   */
+  getImageState() {
+    return this.imageState_;
+  }
+  /**
+   * Get the origin of the symbolizer.
+   * @return {Array<number>} Origin.
+   * @api
+   * @override
+   */
+  getOrigin() {
+    return this.origin_;
+  }
+  /**
+   * Get the number of points for generating the shape.
+   * @return {number} Number of points for stars and regular polygons.
+   * @api
+   */
+  getPoints() {
+    return this.points_;
+  }
+  /**
+   * Get the (primary) radius for the shape.
+   * @return {number} Radius.
+   * @api
+   */
+  getRadius() {
+    return this.radius;
+  }
+  /**
+   * Get the secondary radius for the shape.
+   * @return {number|undefined} Radius2.
+   * @api
+   */
+  getRadius2() {
+    return this.radius2_;
+  }
+  /**
+   * Get the size of the symbolizer (in pixels).
+   * @return {import("../size.js").Size} Size.
+   * @api
+   * @override
+   */
+  getSize() {
+    return this.size_;
+  }
+  /**
+   * Get the stroke style for the shape.
+   * @return {import("./Stroke.js").default|null} Stroke style.
+   * @api
+   */
+  getStroke() {
+    return this.stroke_;
+  }
+  /**
+   * Set the stroke style.
+   * @param {import("./Stroke.js").default|null} stroke Stroke style.
+   * @api
+   */
+  setStroke(t) {
+    this.stroke_ = t, this.render();
+  }
+  /**
+   * @param {function(import("../events/Event.js").default): void} listener Listener function.
+   * @override
+   */
+  listenImageChange(t) {
+  }
+  /**
+   * Load not yet loaded URI.
+   * @override
+   */
+  load() {
+  }
+  /**
+   * @param {function(import("../events/Event.js").default): void} listener Listener function.
+   * @override
+   */
+  unlistenImageChange(t) {
+  }
+  /**
+   * Calculate additional canvas size needed for the miter.
+   * @param {string} lineJoin Line join
+   * @param {number} strokeWidth Stroke width
+   * @param {number} miterLimit Miter limit
+   * @return {number} Additional canvas size needed
+   * @private
+   */
+  calculateLineJoinSize_(t, e, s) {
+    if (e === 0 || this.points_ === 1 / 0 || t !== "bevel" && t !== "miter")
+      return e;
+    let i = this.radius, a = this.radius2_ === void 0 ? i : this.radius2_;
+    if (i < a) {
+      const g = i;
+      i = a, a = g;
+    }
+    const r = this.radius2_ === void 0 ? this.points_ : this.points_ * 2, l = 2 * Math.PI / r, n = a * Math.sin(l), h = Math.sqrt(a * a - n * n), o = i - h, m = Math.sqrt(n * n + o * o), f = m / n;
+    if (t === "miter" && f <= s)
+      return f * e;
+    const D = e / 2 / f, y = e / 2 * (o / m), c = Math.sqrt((i + D) * (i + D) + y * y) - i;
+    if (this.radius2_ === void 0 || t === "bevel")
+      return c * 2;
+    const u = i * Math.sin(l), A = Math.sqrt(i * i - u * u), S = a - A, k = Math.sqrt(u * u + S * S) / u;
+    if (k <= s) {
+      const g = k * e / 2 - a - i;
+      return 2 * Math.max(c, g);
+    }
+    return c * 2;
+  }
+  /**
+   * @return {RenderOptions}  The render options
+   * @protected
+   */
+  createRenderOptions() {
+    let t = z, e = M, s = 0, i = null, a = 0, r, l = 0;
+    this.stroke_ && (r = L(this.stroke_.getColor() ?? p), l = this.stroke_.getWidth() ?? w, i = this.stroke_.getLineDash(), a = this.stroke_.getLineDashOffset() ?? 0, e = this.stroke_.getLineJoin() ?? M, t = this.stroke_.getLineCap() ?? z, s = this.stroke_.getMiterLimit() ?? R);
+    const n = this.calculateLineJoinSize_(e, l, s), h = Math.max(this.radius, this.radius2_ || 0), o = Math.ceil(2 * h + n);
+    return {
+      strokeStyle: r,
+      strokeWidth: l,
+      size: o,
+      lineCap: t,
+      lineDash: i,
+      lineDashOffset: a,
+      lineJoin: e,
+      miterLimit: s
+    };
+  }
+  /**
+   * @protected
+   */
+  render() {
+    this.renderOptions_ = this.createRenderOptions();
+    const t = this.renderOptions_.size;
+    this.hitDetectionCanvas_ = null, this.size_ = [t, t];
+  }
+  /**
+   * @private
+   * @param {RenderOptions} renderOptions Render options.
+   * @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} context The rendering context.
+   * @param {number} pixelRatio The pixel ratio.
+   */
+  draw_(t, e, s) {
+    if (e.scale(s, s), e.translate(t.size / 2, t.size / 2), this.createPath_(e), this.fill_) {
+      let i = this.fill_.getColor();
+      i === null && (i = I), e.fillStyle = L(i), e.fill();
+    }
+    t.strokeStyle && (e.strokeStyle = t.strokeStyle, e.lineWidth = t.strokeWidth, t.lineDash && (e.setLineDash(t.lineDash), e.lineDashOffset = t.lineDashOffset), e.lineCap = t.lineCap, e.lineJoin = t.lineJoin, e.miterLimit = t.miterLimit, e.stroke());
+  }
+  /**
+   * @private
+   * @param {RenderOptions} renderOptions Render options.
+   * @return {HTMLCanvasElement|OffscreenCanvas} Canvas containing the icon
+   */
+  createHitDetectionCanvas_(t) {
+    let e;
+    if (this.fill_) {
+      let s = this.fill_.getColor(), i = 0;
+      typeof s == "string" && (s = P(s)), s === null ? i = 1 : Array.isArray(s) && (i = s.length === 4 ? s[3] : 1), i === 0 && (e = C(t.size, t.size), this.drawHitDetectionCanvas_(t, e));
+    }
+    return e ? e.canvas : this.getImage(1);
+  }
+  /**
+   * @private
+   * @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} context The context to draw in.
+   */
+  createPath_(t) {
+    let e = this.points_;
+    const s = this.radius;
+    if (e === 1 / 0)
+      t.arc(0, 0, s, 0, 2 * Math.PI);
+    else {
+      const i = this.radius2_ === void 0 ? s : this.radius2_;
+      this.radius2_ !== void 0 && (e *= 2);
+      const a = this.angle_ - Math.PI / 2, r = 2 * Math.PI / e;
+      for (let l = 0; l < e; l++) {
+        const n = a + l * r, h = l % 2 === 0 ? s : i;
+        t.lineTo(h * Math.cos(n), h * Math.sin(n));
+      }
+      t.closePath();
+    }
+  }
+  /**
+   * @private
+   * @param {RenderOptions} renderOptions Render options.
+   * @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} context The context.
+   */
+  drawHitDetectionCanvas_(t, e) {
+    e.translate(t.size / 2, t.size / 2), this.createPath_(e), e.fillStyle = I, e.fill(), t.strokeStyle && (e.strokeStyle = t.strokeStyle, e.lineWidth = t.strokeWidth, t.lineDash && (e.setLineDash(t.lineDash), e.lineDashOffset = t.lineDashOffset), e.lineJoin = t.lineJoin, e.miterLimit = t.miterLimit, e.stroke());
+  }
+  /**
+   * @override
+   */
+  ready() {
+    return this.fill_ ? this.fill_.ready() : Promise.resolve();
+  }
+}
+const G = _;
+export {
+  G as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/style/Stroke.mjs

@@ -0,0 +1,148 @@
+class e {
+  /**
+   * @param {Options} [options] Options.
+   */
+  constructor(i) {
+    i = i || {}, this.color_ = i.color !== void 0 ? i.color : null, this.lineCap_ = i.lineCap, this.lineDash_ = i.lineDash !== void 0 ? i.lineDash : null, this.lineDashOffset_ = i.lineDashOffset, this.lineJoin_ = i.lineJoin, this.miterLimit_ = i.miterLimit, this.width_ = i.width;
+  }
+  /**
+   * Clones the style.
+   * @return {Stroke} The cloned style.
+   * @api
+   */
+  clone() {
+    const i = this.getColor();
+    return new e({
+      color: Array.isArray(i) ? i.slice() : i || void 0,
+      lineCap: this.getLineCap(),
+      lineDash: this.getLineDash() ? this.getLineDash().slice() : void 0,
+      lineDashOffset: this.getLineDashOffset(),
+      lineJoin: this.getLineJoin(),
+      miterLimit: this.getMiterLimit(),
+      width: this.getWidth()
+    });
+  }
+  /**
+   * Get the stroke color.
+   * @return {import("../color.js").Color|import("../colorlike.js").ColorLike} Color.
+   * @api
+   */
+  getColor() {
+    return this.color_;
+  }
+  /**
+   * Get the line cap type for the stroke.
+   * @return {CanvasLineCap|undefined} Line cap.
+   * @api
+   */
+  getLineCap() {
+    return this.lineCap_;
+  }
+  /**
+   * Get the line dash style for the stroke.
+   * @return {Array<number>|null} Line dash.
+   * @api
+   */
+  getLineDash() {
+    return this.lineDash_;
+  }
+  /**
+   * Get the line dash offset for the stroke.
+   * @return {number|undefined} Line dash offset.
+   * @api
+   */
+  getLineDashOffset() {
+    return this.lineDashOffset_;
+  }
+  /**
+   * Get the line join type for the stroke.
+   * @return {CanvasLineJoin|undefined} Line join.
+   * @api
+   */
+  getLineJoin() {
+    return this.lineJoin_;
+  }
+  /**
+   * Get the miter limit for the stroke.
+   * @return {number|undefined} Miter limit.
+   * @api
+   */
+  getMiterLimit() {
+    return this.miterLimit_;
+  }
+  /**
+   * Get the stroke width.
+   * @return {number|undefined} Width.
+   * @api
+   */
+  getWidth() {
+    return this.width_;
+  }
+  /**
+   * Set the color.
+   *
+   * @param {import("../color.js").Color|import("../colorlike.js").ColorLike} color Color.
+   * @api
+   */
+  setColor(i) {
+    this.color_ = i;
+  }
+  /**
+   * Set the line cap.
+   *
+   * @param {CanvasLineCap|undefined} lineCap Line cap.
+   * @api
+   */
+  setLineCap(i) {
+    this.lineCap_ = i;
+  }
+  /**
+   * Set the line dash.
+   *
+   * @param {Array<number>|null} lineDash Line dash.
+   * @api
+   */
+  setLineDash(i) {
+    this.lineDash_ = i;
+  }
+  /**
+   * Set the line dash offset.
+   *
+   * @param {number|undefined} lineDashOffset Line dash offset.
+   * @api
+   */
+  setLineDashOffset(i) {
+    this.lineDashOffset_ = i;
+  }
+  /**
+   * Set the line join.
+   *
+   * @param {CanvasLineJoin|undefined} lineJoin Line join.
+   * @api
+   */
+  setLineJoin(i) {
+    this.lineJoin_ = i;
+  }
+  /**
+   * Set the miter limit.
+   *
+   * @param {number|undefined} miterLimit Miter limit.
+   * @api
+   */
+  setMiterLimit(i) {
+    this.miterLimit_ = i;
+  }
+  /**
+   * Set the width.
+   *
+   * @param {number|undefined} width Width.
+   * @api
+   */
+  setWidth(i) {
+    this.width_ = i;
+  }
+}
+const t = e;
+export {
+  t as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/style/Style.mjs

@@ -0,0 +1,238 @@
+import { assert as u } from "../asserts.mjs";
+import d from "./Circle.mjs";
+import f from "./Fill.mjs";
+import o from "./Stroke.mjs";
+class r {
+  /**
+   * @param {Options} [options] Style options.
+   */
+  constructor(e) {
+    e = e || {}, this.geometry_ = null, this.geometryFunction_ = s, e.geometry !== void 0 && this.setGeometry(e.geometry), this.fill_ = e.fill !== void 0 ? e.fill : null, this.image_ = e.image !== void 0 ? e.image : null, this.renderer_ = e.renderer !== void 0 ? e.renderer : null, this.hitDetectionRenderer_ = e.hitDetectionRenderer !== void 0 ? e.hitDetectionRenderer : null, this.stroke_ = e.stroke !== void 0 ? e.stroke : null, this.text_ = e.text !== void 0 ? e.text : null, this.zIndex_ = e.zIndex;
+  }
+  /**
+   * Clones the style.
+   * @return {Style} The cloned style.
+   * @api
+   */
+  clone() {
+    let e = this.getGeometry();
+    return e && typeof e == "object" && (e = /** @type {import("../geom/Geometry.js").default} */
+    e.clone()), new r({
+      geometry: e ?? void 0,
+      fill: this.getFill() ? this.getFill().clone() : void 0,
+      image: this.getImage() ? this.getImage().clone() : void 0,
+      renderer: this.getRenderer() ?? void 0,
+      stroke: this.getStroke() ? this.getStroke().clone() : void 0,
+      text: this.getText() ? this.getText().clone() : void 0,
+      zIndex: this.getZIndex()
+    });
+  }
+  /**
+   * Get the custom renderer function that was configured with
+   * {@link #setRenderer} or the `renderer` constructor option.
+   * @return {RenderFunction|null} Custom renderer function.
+   * @api
+   */
+  getRenderer() {
+    return this.renderer_;
+  }
+  /**
+   * Sets a custom renderer function for this style. When set, `fill`, `stroke`
+   * and `image` options of the style will be ignored.
+   * @param {RenderFunction|null} renderer Custom renderer function.
+   * @api
+   */
+  setRenderer(e) {
+    this.renderer_ = e;
+  }
+  /**
+   * Sets a custom renderer function for this style used
+   * in hit detection.
+   * @param {RenderFunction|null} renderer Custom renderer function.
+   * @api
+   */
+  setHitDetectionRenderer(e) {
+    this.hitDetectionRenderer_ = e;
+  }
+  /**
+   * Get the custom renderer function that was configured with
+   * {@link #setHitDetectionRenderer} or the `hitDetectionRenderer` constructor option.
+   * @return {RenderFunction|null} Custom renderer function.
+   * @api
+   */
+  getHitDetectionRenderer() {
+    return this.hitDetectionRenderer_;
+  }
+  /**
+   * Get the geometry to be rendered.
+   * @return {string|import("../geom/Geometry.js").default|GeometryFunction|null}
+   * Feature property or geometry or function that returns the geometry that will
+   * be rendered with this style.
+   * @api
+   */
+  getGeometry() {
+    return this.geometry_;
+  }
+  /**
+   * Get the function used to generate a geometry for rendering.
+   * @return {!GeometryFunction} Function that is called with a feature
+   * and returns the geometry to render instead of the feature's geometry.
+   * @api
+   */
+  getGeometryFunction() {
+    return this.geometryFunction_;
+  }
+  /**
+   * Get the fill style.
+   * @return {import("./Fill.js").default|null} Fill style.
+   * @api
+   */
+  getFill() {
+    return this.fill_;
+  }
+  /**
+   * Set the fill style.
+   * @param {import("./Fill.js").default|null} fill Fill style.
+   * @api
+   */
+  setFill(e) {
+    this.fill_ = e;
+  }
+  /**
+   * Get the image style.
+   * @return {import("./Image.js").default|null} Image style.
+   * @api
+   */
+  getImage() {
+    return this.image_;
+  }
+  /**
+   * Set the image style.
+   * @param {import("./Image.js").default} image Image style.
+   * @api
+   */
+  setImage(e) {
+    this.image_ = e;
+  }
+  /**
+   * Get the stroke style.
+   * @return {import("./Stroke.js").default|null} Stroke style.
+   * @api
+   */
+  getStroke() {
+    return this.stroke_;
+  }
+  /**
+   * Set the stroke style.
+   * @param {import("./Stroke.js").default|null} stroke Stroke style.
+   * @api
+   */
+  setStroke(e) {
+    this.stroke_ = e;
+  }
+  /**
+   * Get the text style.
+   * @return {import("./Text.js").default|null} Text style.
+   * @api
+   */
+  getText() {
+    return this.text_;
+  }
+  /**
+   * Set the text style.
+   * @param {import("./Text.js").default} text Text style.
+   * @api
+   */
+  setText(e) {
+    this.text_ = e;
+  }
+  /**
+   * Get the z-index for the style.
+   * @return {number|undefined} ZIndex.
+   * @api
+   */
+  getZIndex() {
+    return this.zIndex_;
+  }
+  /**
+   * Set a geometry that is rendered instead of the feature's geometry.
+   *
+   * @param {string|import("../geom/Geometry.js").default|GeometryFunction|null} geometry
+   *     Feature property or geometry or function returning a geometry to render
+   *     for this style.
+   * @api
+   */
+  setGeometry(e) {
+    typeof e == "function" ? this.geometryFunction_ = e : typeof e == "string" ? this.geometryFunction_ = function(n) {
+      return (
+        /** @type {import("../geom/Geometry.js").default} */
+        n.get(e)
+      );
+    } : e ? e !== void 0 && (this.geometryFunction_ = function() {
+      return (
+        /** @type {import("../geom/Geometry.js").default} */
+        e
+      );
+    }) : this.geometryFunction_ = s, this.geometry_ = e;
+  }
+  /**
+   * Set the z-index.
+   *
+   * @param {number|undefined} zIndex ZIndex.
+   * @api
+   */
+  setZIndex(e) {
+    this.zIndex_ = e;
+  }
+}
+function y(t) {
+  let e;
+  if (typeof t == "function")
+    e = t;
+  else {
+    let n;
+    Array.isArray(t) ? n = t : (u(
+      typeof /** @type {?} */
+      t.getZIndex == "function",
+      "Expected an `Style` or an array of `Style`"
+    ), n = [
+      /** @type {Style} */
+      t
+    ]), e = function() {
+      return n;
+    };
+  }
+  return e;
+}
+let l = null;
+function _(t, e) {
+  if (!l) {
+    const n = new f({
+      color: "rgba(255,255,255,0.4)"
+    }), i = new o({
+      color: "#3399CC",
+      width: 1.25
+    });
+    l = [
+      new r({
+        image: new d({
+          fill: n,
+          stroke: i,
+          radius: 5
+        }),
+        fill: n,
+        stroke: i
+      })
+    ];
+  }
+  return l;
+}
+function s(t) {
+  return t.getGeometry();
+}
+const a = r;
+export {
+  _ as createDefaultStyle,
+  a as default,
+  y as toFunction
+};