@agrotools1/at-components 0.6.15 → 0.6.17

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/draw/support/GraphicMover.js

@@ -0,0 +1,211 @@
+import { _ as l } from "../../../chunks/tslib.es6.js";
+import "../../../symbols.js";
+import k from "../../../core/Evented.js";
+import { clone as E } from "../../../core/lang.js";
+import { watch as y, when as O } from "../../../core/reactiveUtils.js";
+import { property as p } from "../../../core/accessorSupport/decorators/property.js";
+import "../../../core/has.js";
+import "../../../core/Logger.js";
+import { subclass as M } from "../../../core/accessorSupport/decorators/subclass.js";
+import x from "../../../layers/GraphicsLayer.js";
+import { cloneMove as u } from "./drawUtils.js";
+import H from "./HighlightHelper.js";
+import { addUniqueLayer as P, findLayerView as D } from "./layerUtils.js";
+import { GraphicClickEvent as U, GraphicDoubleClickEvent as S, GraphicPointerDownEvent as T, GraphicPointerUpEvent as L, GraphicPointerOutEvent as G, GraphicMoveStartEvent as V, GraphicMoveEvent as $, GraphicMoveStopEvent as I, GraphicPointerOverEvent as A } from "./input/GraphicMoverEvents.js";
+import { ViewEventPriorities as d } from "../../input/InputManager.js";
+import { GraphicManipulator as C } from "../../interactive/GraphicManipulator.js";
+import { createScreenPointFromEvent as _ } from "../../support/screenUtils.js";
+import m from "../../../symbols/SimpleMarkerSymbol.js";
+import z from "../../../symbols/SimpleLineSymbol.js";
+import q from "../../../symbols/SimpleFillSymbol.js";
+const w = "indicator-symbols";
+let c = class extends k.EventedAccessor {
+  constructor(t) {
+    super(t), this._activeGraphic = null, this._dragEvent = null, this._hoverGraphic = null, this._indicators = [], this._initialDragGeometry = null, this._manipulators = [], this._layerViews = null, this.type = "graphic-mover", this.callbacks = { onGraphicClick() {
+    }, onGraphicDoubleClick() {
+    }, onGraphicMoveStart() {
+    }, onGraphicMove() {
+    }, onGraphicMoveStop() {
+    }, onGraphicPointerOver() {
+    }, onGraphicPointerOut() {
+    }, onGraphicPointerDown() {
+    }, onGraphicPointerUp() {
+    } }, this.enableMoveAllGraphics = !1, this.graphics = [], this.indicatorsEnabled = !1, this.layer = new x({ listMode: "hide", internal: !0, title: "GraphicMover highlight layer" }), this.view = null;
+  }
+  initialize() {
+    P(this.view, this.layer), this._highlightHelper = new H({ view: this.view }), this.refresh(), this.addHandles([y(() => this.graphics.length, () => this.refresh()), O(() => {
+      var t;
+      return (t = this.view) == null ? void 0 : t.ready;
+    }, () => {
+      this.addHandles([this.view.on("immediate-click", (t) => this._clickHandler(t), d.TOOL), this.view.on("double-click", (t) => this._doubleClickHandler(t), d.TOOL), this.view.on("pointer-down", (t) => this._pointerDownHandler(t), d.TOOL), this.view.on("pointer-move", (t) => this._pointerMoveHandler(t), d.TOOL), this.view.on("pointer-up", (t) => this._pointerUpHandler(t), d.TOOL), this.view.on("drag", (t) => this._dragHandler(t), d.TOOL), this.view.on("key-down", (t) => this._keyDownHandler(t), d.TOOL)]);
+    }, { once: !0, initial: !0 }), y(() => this.view, (t) => {
+      this._highlightHelper.removeAll(), this._highlightHelper.view = t;
+    })]);
+  }
+  destroy() {
+    var t;
+    this._removeIndicators(), (t = this.view.map) == null || t.remove(this.layer), this.layer.destroy(), this.reset(), this._manipulators.forEach((e) => e.destroy()), this._manipulators = null;
+  }
+  set highlightsEnabled(t) {
+    var e, i;
+    (e = this._highlightHelper) == null || e.removeAll(), this._set("highlightsEnabled", t), t && ((i = this._highlightHelper) == null || i.add(this.graphics));
+  }
+  get state() {
+    const t = this.view.ready, e = this.graphics.length > 0, i = this._activeGraphic;
+    return t && e ? i ? "moving" : "active" : t ? "ready" : "disabled";
+  }
+  refresh() {
+    this.reset(), this._setup();
+  }
+  reset() {
+    this._activeGraphic = null, this._hoverGraphic = null, this._dragEvent = null, this._highlightHelper.removeAll();
+  }
+  updateGeometry(t, e) {
+    const i = this.graphics[t];
+    i && (i.set("geometry", e), this._setUpIndicators());
+  }
+  _setup() {
+    this._setUpHighlights(), this._setUpIndicators(), this._setUpManipulators(), this._syncLayerViews();
+  }
+  _clickHandler(t) {
+    const e = this._findTargetGraphic(_(t));
+    if (e) {
+      const i = new U(e, this.graphics.indexOf(e), t.x, t.y, t);
+      this.emit("graphic-click", i), this.callbacks.onGraphicClick && this.callbacks.onGraphicClick(i);
+    }
+  }
+  _doubleClickHandler(t) {
+    const e = this._findTargetGraphic(_(t));
+    if (e) {
+      const i = new S(e, this.graphics.indexOf(e), t.x, t.y, t);
+      this.emit("graphic-double-click", i), this.callbacks.onGraphicDoubleClick && this.callbacks.onGraphicDoubleClick(i);
+    }
+  }
+  _pointerDownHandler(t) {
+    const e = this._findTargetGraphic(_(t));
+    if (e) {
+      this._activeGraphic = e;
+      const { x: i, y: s } = t, r = new T(e, this.graphics.indexOf(e), i, s, t);
+      this.emit("graphic-pointer-down", r), this.callbacks.onGraphicPointerDown && this.callbacks.onGraphicPointerDown(r);
+    } else
+      this._activeGraphic = null;
+  }
+  _pointerUpHandler(t) {
+    if (this._activeGraphic) {
+      const { x: e, y: i } = t, s = this.graphics.indexOf(this._activeGraphic), r = new L(this._activeGraphic, s, e, i, t);
+      this.emit("graphic-pointer-up", r), this.callbacks.onGraphicPointerUp && this.callbacks.onGraphicPointerUp(r);
+    }
+  }
+  _pointerMoveHandler(t) {
+    if (this._dragEvent)
+      return;
+    const e = this._findTargetGraphic(_(t));
+    if (e) {
+      const { x: i, y: s } = t;
+      if (this._hoverGraphic) {
+        if (this._hoverGraphic === e)
+          return;
+        const a = this.graphics.indexOf(this._hoverGraphic), o = new G(this.graphics[a], a, i, s, t);
+        this._hoverGraphic = null, this.emit("graphic-pointer-out", o), this.callbacks.onGraphicPointerOut && this.callbacks.onGraphicPointerOut(o);
+      }
+      const r = this.graphics.indexOf(e), h = new A(e, r, i, s, t);
+      return this._hoverGraphic = e, this.emit("graphic-pointer-over", h), void (this.callbacks.onGraphicPointerOver && this.callbacks.onGraphicPointerOver(h));
+    }
+    if (this._hoverGraphic) {
+      const { x: i, y: s } = t, r = this.graphics.indexOf(this._hoverGraphic), h = new G(this.graphics[r], r, i, s, t);
+      this._hoverGraphic = null, this.emit("graphic-pointer-out", h), this.callbacks.onGraphicPointerOut && this.callbacks.onGraphicPointerOut(h);
+    }
+  }
+  _dragHandler(t) {
+    var f;
+    if (t.action !== "start" && !this._dragEvent || !((f = this._activeGraphic) != null && f.geometry))
+      return;
+    t.action === "start" && this._removeIndicators(), t.stopPropagation();
+    const { action: e, x: i, y: s } = t, r = this.graphics.indexOf(this._activeGraphic), h = this._dragEvent ? i - this._dragEvent.x : 0, a = this._dragEvent ? s - this._dragEvent.y : 0, o = i - t.origin.x, v = s - t.origin.y, g = e === "start" ? this._activeGraphic.geometry : this._initialDragGeometry, b = u(g, o, v, this.view);
+    if (this._activeGraphic.geometry = b, this.enableMoveAllGraphics && this.graphics.forEach((n) => {
+      n !== this._activeGraphic && (n.geometry = u(n.geometry, h, a, this.view));
+    }), this._dragEvent = t, e === "start") {
+      this._initialDragGeometry = E(g);
+      const n = new V(this._activeGraphic, this.graphics, r, i, s, h, a, o, v, t);
+      this.emit("graphic-move-start", n), this.callbacks.onGraphicMoveStart && this.callbacks.onGraphicMoveStart(n), n.defaultPrevented && this._activeGraphic.set("geometry", g);
+    } else if (e === "update") {
+      const n = new $(this._activeGraphic, this.graphics, r, i, s, h, a, o, v, t);
+      this.emit("graphic-move", n), this.callbacks.onGraphicMove && this.callbacks.onGraphicMove(n), n.defaultPrevented && (this._activeGraphic.geometry = g);
+    } else {
+      const n = new I(this._activeGraphic, this.graphics, r, i, s, h, a, o, v, t);
+      this._dragEvent = null, this._activeGraphic = null, this._setUpIndicators(), this.emit("graphic-move-stop", n), this.callbacks.onGraphicMoveStop && this.callbacks.onGraphicMoveStop(n), n.defaultPrevented && (this.graphics[r].set("geometry", this._initialDragGeometry), this._setUpIndicators()), this._initialDragGeometry = null;
+    }
+  }
+  _keyDownHandler(t) {
+    t.key !== "a" && t.key !== "d" && t.key !== "n" || this.state !== "moving" || t.stopPropagation();
+  }
+  _findTargetGraphic(t) {
+    const e = this.view.toMap(t), i = this.graphics;
+    let s = null, r = Number.MAX_VALUE;
+    this._syncLayerViews();
+    const h = this._layerViews.flatMap((a) => "graphicsViews" in a ? Array.from(a.graphicsViews(), (o) => o.hitTest(e)).flat() : a.graphicsView.hitTest(e)).filter((a) => i.includes(a)).sort((a, o) => i.indexOf(a) - i.indexOf(o));
+    return h.length ? h[0] : (this._manipulators.forEach((a) => {
+      const o = a.intersectionDistance(t);
+      o != null && o < r && (r = o, s = a.graphic);
+    }), s);
+  }
+  _syncLayerViews() {
+    this._layerViews = [];
+    const t = /* @__PURE__ */ new Set();
+    for (const e of this.graphics) {
+      const i = D(this.view, e.layer);
+      i && t.add(i);
+    }
+    this._layerViews = [...t];
+  }
+  _setUpManipulators() {
+    const { graphics: t, view: e } = this;
+    this._manipulators.forEach((i) => i.destroy()), this._manipulators = t.length ? t.map((i) => new C({ graphic: i, view: e })) : [];
+  }
+  _setUpHighlights() {
+    this.highlightsEnabled && this._highlightHelper.add(this.graphics);
+  }
+  _setUpIndicators() {
+    if (this._removeIndicators(), this.indicatorsEnabled) {
+      for (const t of this.graphics) {
+        const e = t.clone();
+        e.symbol = this._getSymbolForIndicator(t), this._indicators.push(e), this.addHandles(y(() => t.symbol, () => this._setUpIndicators()), w);
+      }
+      this.layer.addMany(this._indicators);
+    }
+  }
+  _removeIndicators() {
+    this.removeHandles(w), this._indicators.length && (this.layer.removeMany(this._indicators), this._indicators.forEach((t) => t.destroy()), this._indicators = []);
+  }
+  _getSymbolForIndicator(t) {
+    if (t.symbol == null)
+      return null;
+    switch (t.symbol.type) {
+      case "cim":
+        return new m({ style: "circle", size: 12, color: [0, 0, 0, 0], outline: { color: [255, 127, 0, 1], width: 1 } });
+      case "picture-marker": {
+        const { xoffset: i, yoffset: s, height: r, width: h } = t.symbol, a = r === h ? h : Math.max(r, h);
+        return new m({ xoffset: i, yoffset: s, size: a, style: "square", color: [0, 0, 0, 0], outline: { color: [255, 127, 0, 1], width: 1 } });
+      }
+      case "simple-marker": {
+        const { xoffset: i, yoffset: s, size: r, style: h } = t.symbol;
+        return new m({ xoffset: i, yoffset: s, style: h === "circle" ? "circle" : "square", size: r + 2, color: [0, 0, 0, 0], outline: { color: [255, 127, 0, 1], width: 1 } });
+      }
+      case "simple-fill":
+        return new q({ color: [0, 0, 0, 0], outline: { style: "dash", color: [255, 127, 0, 1], width: 1 } });
+      case "simple-line":
+        return new z({ color: [255, 127, 0, 1], style: "dash", width: 1 });
+      case "text": {
+        const { xoffset: i, yoffset: s } = t.symbol;
+        return new m({ xoffset: i, yoffset: s, size: 12, color: [0, 0, 0, 0], outline: { color: [255, 127, 0, 1], width: 1 } });
+      }
+      default:
+        return null;
+    }
+  }
+};
+l([p()], c.prototype, "_activeGraphic", void 0), l([p({ readOnly: !0 })], c.prototype, "type", void 0), l([p()], c.prototype, "callbacks", void 0), l([p()], c.prototype, "enableMoveAllGraphics", void 0), l([p()], c.prototype, "graphics", void 0), l([p({ value: !1 })], c.prototype, "highlightsEnabled", null), l([p()], c.prototype, "indicatorsEnabled", void 0), l([p()], c.prototype, "layer", void 0), l([p({ readOnly: !0 })], c.prototype, "state", null), l([p()], c.prototype, "view", void 0), c = l([M("esri.views.draw.support.GraphicMover")], c);
+const nt = c;
+export {
+  nt as default
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/draw/support/HighlightHelper.js

@@ -0,0 +1,38 @@
+import { _ as o } from "../../../chunks/tslib.es6.js";
+import h from "../../../core/Accessor.js";
+import { property as a } from "../../../core/accessorSupport/decorators/property.js";
+import "../../../core/has.js";
+import "../../../core/Logger.js";
+import "../../../core/RandomLCG.js";
+import { subclass as l } from "../../../core/accessorSupport/decorators/subclass.js";
+import { findLayerView as m } from "./layerUtils.js";
+import { highlightsSupported as p } from "../../support/layerViewUtils.js";
+import { getHighlightKeyForFeature as s } from "../../../widgets/Feature/support/featureUtils.js";
+let e = class extends h {
+  constructor(t) {
+    super(t), this.view = null;
+  }
+  add(t) {
+    const i = !t || Array.isArray(t) ? t : [t];
+    i != null && i.length && i.forEach((r) => this._highlight(r));
+  }
+  remove(t) {
+    const i = !t || Array.isArray(t) ? t : [t];
+    i != null && i.length && i.forEach((r) => this._removeHighlight(r));
+  }
+  removeAll() {
+    this.removeAllHandles();
+  }
+  _highlight(t) {
+    const i = m(this.view, t.layer);
+    p(i) && this.addHandles(i.highlight(t), s(t));
+  }
+  _removeHighlight(t) {
+    t && this.removeHandles(s(t));
+  }
+};
+o([a()], e.prototype, "view", void 0), e = o([l("esri.views.draw.support.HighlightHelper")], e);
+const A = e;
+export {
+  A as default
+};