@agrotools1/at-components 0.6.16 → 0.6.17

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

@@ -0,0 +1,556 @@
+import { _ as v } from "../../../chunks/tslib.es6.js";
+import "../../../geometry.js";
+import x from "../../../Graphic.js";
+import { createTask as D } from "../../../core/asyncUtils.js";
+import k from "../../../core/Collection.js";
+import F from "../../../core/Error.js";
+import U from "../../../core/Evented.js";
+import L from "../../../core/Logger.js";
+import { destroyMaybe as M, abortMaybe as E } from "../../../core/maybe.js";
+import { zeroMeters as I } from "../../../core/quantityUtils.js";
+import { when as P, pausable as S, watch as T, syncAndInitial as K, initial as q } from "../../../core/reactiveUtils.js";
+import { createScreenPoint as O } from "../../../core/screenUtils.js";
+import { property as y } from "../../../core/accessorSupport/decorators/property.js";
+import "../../../core/has.js";
+import "../../../core/RandomLCG.js";
+import { subclass as B } from "../../../core/accessorSupport/decorators/subclass.js";
+import { closeRingsAndFixWinding as N, geometryToCoordinates as b, getMidpoint as C } from "../../../geometry/support/coordsUtils.js";
+import W from "../../../layers/GraphicsLayer.js";
+import G from "../../../symbols/SimpleMarkerSymbol.js";
+import { ViewingMode as j } from "../../ViewingMode.js";
+import { SnappingVisualizer2D as J } from "../../2d/interactive/SnappingVisualizer2D.js";
+import { cloneMove as Q } from "./drawUtils.js";
+import X from "./GraphicMover.js";
+import Y from "./HighlightHelper.js";
+import { addUniqueLayer as Z } from "./layerUtils.js";
+import { settings as tt } from "./settings.js";
+import { ViewEventPriorities as et } from "../../input/InputManager.js";
+import { sketchKeys as it } from "../../interactive/keybindings.js";
+import { EditGeometryOperations as st } from "../../interactive/editGeometry/EditGeometryOperations.js";
+import $ from "../../interactive/sketch/SketchOptions.js";
+import { SnappingContext as ot } from "../../interactive/snapping/SnappingContext.js";
+import { Tooltip as rt } from "../../interactive/tooltip/Tooltip.js";
+import { TranslateGraphicTooltipInfo as nt, TranslateVertexTooltipInfo as at } from "../../interactive/tooltip/TranslateTooltipInfos.js";
+import { autoArea2D as ht } from "../../support/automaticAreaMeasurementUtils.js";
+import { autoDistanceBetweenPoints2D as R, autoLength2D as pt } from "../../support/automaticLengthMeasurementUtils.js";
+import ct from "../../../geometry/Polyline.js";
+import f from "../../../geometry/Point.js";
+class lt {
+  constructor(e, i, s) {
+    this.graphic = e, this.mover = i, this.selected = s, this.type = "reshape-start";
+  }
+}
+class dt {
+  constructor(e, i, s) {
+    this.graphic = e, this.mover = i, this.selected = s, this.type = "reshape";
+  }
+}
+class mt {
+  constructor(e, i, s) {
+    this.graphic = e, this.mover = i, this.selected = s, this.type = "reshape-stop";
+  }
+}
+class vt {
+  constructor(e, i, s) {
+    this.mover = e, this.dx = i, this.dy = s, this.type = "move-start";
+  }
+}
+class yt {
+  constructor(e, i, s) {
+    this.mover = e, this.dx = i, this.dy = s, this.type = "move";
+  }
+}
+class _t {
+  constructor(e, i, s) {
+    this.mover = e, this.dx = i, this.dy = s, this.type = "move-stop";
+  }
+}
+class gt {
+  constructor(e) {
+    this.added = e, this.type = "vertex-select";
+  }
+}
+class ut {
+  constructor(e) {
+    this.removed = e, this.type = "vertex-deselect";
+  }
+}
+class ft {
+  constructor(e, i, s, o) {
+    this.added = e, this.graphic = i, this.oldGraphic = s, this.vertices = o, this.type = "vertex-add";
+  }
+}
+class xt {
+  constructor(e, i, s, o) {
+    this.removed = e, this.graphic = i, this.oldGraphic = s, this.vertices = o, this.type = "vertex-remove";
+  }
+}
+const g = tt.reshapeGraphics, Gt = { vertices: { default: new G({ style: "circle", size: g.vertex.size, color: g.vertex.color, outline: { color: g.vertex.outlineColor, width: 1 } }), hover: new G({ style: "circle", size: g.vertex.hoverSize, color: g.vertex.hoverColor, outline: { color: g.vertex.hoverOutlineColor, width: 1 } }), selected: new G({ style: "circle", size: g.selected.size, color: g.selected.color, outline: { color: g.selected.outlineColor, width: 1 } }) }, midpoints: { default: new G({ style: "circle", size: g.midpoint.size, color: g.midpoint.color, outline: { color: g.midpoint.outlineColor, width: 1 } }), hover: new G({ style: "circle", size: g.midpoint.size, color: g.midpoint.color, outline: { color: g.midpoint.outlineColor, width: 1 } }) } };
+let d = class extends U.EventedAccessor {
+  constructor(t) {
+    super(t), this._activeOperationInfo = null, this._editGeometryOperations = null, this._graphicAttributes = { esriSketchTool: "box" }, this._mover = null, this._snappingContext = null, this._hoverGraphic = null, this._snappingTask = null, this._stagedVertex = null, this.tooltip = null, this._translateGraphicTooltipInfo = null, this._translateVertexTooltipInfo = null, this.callbacks = { onReshapeStart() {
+    }, onReshape() {
+    }, onReshapeStop() {
+    }, onMoveStart() {
+    }, onMove() {
+    }, onMoveStop() {
+    }, onGraphicClick() {
+    } }, this.enableMidpoints = !0, this.enableMovement = !0, this.enableVertices = !0, this.graphic = null, this.layer = null, this.midpointGraphics = new k(), this.midpointSymbol = new G({ style: "circle", size: 6, color: [200, 200, 200], outline: { color: [100, 100, 100], width: 1 } }), this.selectedVertices = [], this.snappingManager = null, this.symbols = Gt, this.sketchOptions = new $(), this.type = "reshape", this.vertexGraphics = new k(), this.view = null;
+  }
+  initialize() {
+    const t = this.view;
+    this._highlightHelper = new Y({ view: t }), this._setup(), this.addHandles([P(() => t == null ? void 0 : t.ready, () => {
+      const { layer: e, view: i } = this;
+      Z(i, e), this.addHandles(i.on("key-down", (s) => this._keyDownHandler(s), et.TOOL));
+    }, { once: !0, initial: !0 }), S(() => this.graphic, () => this.refresh()), S(() => this.layer, (e, i) => {
+      i && (this._clearSelection(), this._resetGraphics(i)), this.refresh();
+    }), S(() => this.enableMidpoints, () => this.refresh()), T(() => this.sketchOptions.tooltips.effectiveEnabled, (e) => {
+      this.tooltip = e ? new rt({ view: this.view }) : M(this.tooltip);
+    }, K), T(() => this.view.effectiveTheme.accentColor, () => this._updateSymbolsForTheme(), q)]);
+  }
+  destroy() {
+    var t;
+    this._reset(), (t = this._mover) == null || t.destroy(), this._mover = null, this.tooltip = M(this.tooltip);
+  }
+  set highlightsEnabled(t) {
+    var e;
+    (e = this._highlightHelper) == null || e.removeAll(), this._set("highlightsEnabled", t), this._setUpHighlights();
+  }
+  get state() {
+    const t = this.view.ready, e = !(!this.graphic || !this.layer);
+    return t && e ? "active" : t ? "ready" : "disabled";
+  }
+  isUIGraphic(t) {
+    const e = [];
+    return this.graphic && e.push(this.graphic), e.concat(this.vertexGraphics.items, this.midpointGraphics.items), e.length > 0 && e.includes(t);
+  }
+  refresh() {
+    this._reset(), this._setup();
+  }
+  reset() {
+    this.graphic = null;
+  }
+  clearSelection() {
+    this._clearSelection();
+  }
+  removeSelectedVertices() {
+    this.selectedVertices.length && this._removeVertices(this.selectedVertices);
+  }
+  _setup() {
+    const { graphic: t, layer: e } = this;
+    if (!e || (t == null ? void 0 : t.geometry) == null)
+      return;
+    const i = t.geometry;
+    i.type !== "mesh" && i.type !== "extent" ? (i.type === "polygon" && N(i), this._setUpHighlights(), this._setupGraphics(), this._setupMover()) : this._logGeometryTypeError();
+  }
+  _setUpHighlights() {
+    var t;
+    this.highlightsEnabled && this.graphic && ((t = this._highlightHelper) == null || t.add(this.graphic));
+  }
+  _setUpGeometryHelper() {
+    const t = this.graphic.geometry;
+    if (t == null || t.type === "mesh" || t.type === "extent")
+      return void this._logGeometryTypeError();
+    const e = t.type === "multipoint" ? new ct({ paths: t.points, spatialReference: t.spatialReference }) : t;
+    this._editGeometryOperations = st.fromGeometry(e, j.Local);
+  }
+  _saveSnappingContextForHandle(t, e) {
+    var i;
+    this._snappingGraphicsLayer = new W({ listMode: "hide", internal: !0, title: "Reshape snapping layer" }), this.view.map.layers.add(this._snappingGraphicsLayer), this._snappingContext = new ot({ editGeometryOperations: this._editGeometryOperations, elevationInfo: { mode: "on-the-ground", offset: 0 }, pointer: ((i = e.viewEvent) == null ? void 0 : i.pointerType) || "mouse", excludeFeature: this.graphic, feature: this.graphic, visualizer: new J(this._snappingGraphicsLayer), vertexHandle: this._getVertexFromEditGeometry(t) });
+  }
+  _reset() {
+    var t;
+    this._clearSelection(), (t = this._highlightHelper) == null || t.removeAll(), this._updateTooltip(), this._resetGraphics(), this._resetSnappingStateVars(), this._activeOperationInfo = null, this._mover && this._mover.destroy(), this._mover = null, this.view.cursor = "default";
+  }
+  _resetSnappingStateVars() {
+    var t;
+    this.snappingManager != null && this.snappingManager.doneSnapping(), this._snappingGraphicsLayer != null && ((t = this.view) != null && t.map && this.view.map.layers.remove(this._snappingGraphicsLayer), this._snappingGraphicsLayer.destroy()), this._editGeometryOperations = M(this._editGeometryOperations), this._snappingTask = E(this._snappingTask), this._snappingTask = null, this._snappingContext = null, this._stagedVertex = null;
+  }
+  _resetGraphics(t) {
+    this._removeMidpointGraphics(t), this._removeVertexGraphics(t), this._set("selectedVertices", []);
+  }
+  _removeMidpointGraphics(t) {
+    const e = t || this.layer;
+    e && e.removeMany(this.midpointGraphics.items), this.midpointGraphics.items.forEach((i) => i.destroy()), this.midpointGraphics.removeAll();
+  }
+  _removeVertexGraphics(t) {
+    const e = t || this.layer;
+    e && e.removeMany(this.vertexGraphics.items), this.vertexGraphics.items.forEach((i) => i.destroy()), this.vertexGraphics.removeAll();
+  }
+  _getCoordinatesForUI(t) {
+    const e = b(t.clone());
+    if (t.type === "polygon")
+      for (const i of e) {
+        const s = i[i.length - 1];
+        i[0][0] === s[0] && i[0][1] === s[1] && i.length > 2 && i.pop();
+      }
+    return e;
+  }
+  _setupGraphics() {
+    const t = this.graphic.geometry;
+    if (t != null && (t.type === "polyline" || t.type === "polygon")) {
+      const e = this._getCoordinatesForUI(t);
+      this.enableMidpoints && this._setUpMidpointGraphics(e), this.enableVertices && this._setUpVertexGraphics(e);
+    }
+  }
+  _setUpMidpointGraphics(t) {
+    this._removeMidpointGraphics();
+    const e = this._createMidpointGraphics(t);
+    this.midpointGraphics.addMany(e), this.layer.addMany(e);
+  }
+  _setUpVertexGraphics(t) {
+    this._removeVertexGraphics();
+    const e = this._createVertexGraphics(t);
+    this.vertexGraphics.addMany(e), this._storeRelatedVertexIndices(), this.layer.addMany(e);
+  }
+  _createVertexGraphics(t) {
+    const { _graphicAttributes: e, symbols: i, view: { spatialReference: s } } = this, o = [];
+    return t == null || t.forEach((n, r) => {
+      n.forEach((h, p) => {
+        var m;
+        const [a, c, l] = h;
+        o.push(new x({ geometry: new f({ x: a, y: c, z: l, spatialReference: s }), symbol: (m = i == null ? void 0 : i.vertices) == null ? void 0 : m.default, attributes: { ...e, pathIndex: r, pointIndex: p } }));
+      });
+    }), o;
+  }
+  _createMidpointGraphics(t) {
+    const { _graphicAttributes: e, symbols: i, view: { spatialReference: s } } = this, o = [];
+    return t == null || t.forEach((n, r) => {
+      n.forEach((h, p) => {
+        var _;
+        const [a, c, l] = h, m = n[p + 1] ? p + 1 : 0;
+        if (((_ = this.graphic.geometry) == null ? void 0 : _.type) === "polygon" || m !== 0) {
+          const [u, V, w] = n[m], [H, A, z] = C([a, c, l], [u, V, w]);
+          o.push(new x({ geometry: new f({ x: H, y: A, z, spatialReference: s }), symbol: i.midpoints.default, attributes: { ...e, pathIndex: r, pointIndexStart: p, pointIndexEnd: m } }));
+        }
+      });
+    }), o;
+  }
+  _updateSymbolsForTheme() {
+    var e;
+    const t = this.view.effectiveTheme.accentColor;
+    this.symbols = { vertices: { ...this.symbols.vertices, default: this.symbols.vertices.default.clone().set("color", t), hover: (e = this.symbols.vertices.hover) == null ? void 0 : e.clone().set("color", t) }, midpoints: { ...this.symbols.midpoints } };
+    for (const i of this.vertexGraphics)
+      this._isSelected(i) ? i.symbol = this.symbols.vertices.selected : this._hoverGraphic === i ? i.symbol = this.symbols.vertices.hover : i.symbol = this.symbols.vertices.default;
+  }
+  _storeRelatedVertexIndices() {
+    const t = this.vertexGraphics.items;
+    if (!t)
+      return;
+    const e = t.map(({ geometry: i }) => ({ x: i.x, y: i.y }));
+    for (let i = 0; i < e.length; i++) {
+      const s = [];
+      for (let o = 0; o < e.length; o++) {
+        if (i === o)
+          continue;
+        const n = e[i], r = e[o];
+        n.x === r.x && n.y === r.y && s.push(o);
+      }
+      t[i].attributes.relatedGraphicIndices = s;
+    }
+  }
+  _setupMover() {
+    const { enableMovement: t, graphic: e, midpointGraphics: i, vertexGraphics: s, view: o } = this, n = s.concat(i).items;
+    t && n.push(e), this._mover = new X({ enableMoveAllGraphics: !1, highlightsEnabled: !1, indicatorsEnabled: !1, graphics: n, view: o, callbacks: { onGraphicClick: (r) => this._onGraphicClickCallback(r), onGraphicMoveStart: (r) => this._onGraphicMoveStartCallback(r), onGraphicMove: (r) => this._onGraphicMoveCallback(r), onGraphicMoveStop: (r) => this._onGraphicMoveStopCallback(r), onGraphicPointerOver: (r) => this._onGraphicPointerOverCallback(r), onGraphicPointerOut: (r) => this._onGraphicPointerOutCallback(r) } });
+  }
+  _onGraphicClickCallback(t) {
+    t.viewEvent.stopPropagation();
+    const e = t.graphic;
+    if (e === this.graphic)
+      this.clearSelection(), this.emit("graphic-click", t), this.callbacks.onGraphicClick && this.callbacks.onGraphicClick(t);
+    else if (this._isMidpoint(e)) {
+      if (t.viewEvent.button === 2)
+        return;
+      const i = this.graphic.clone(), s = this._createVertexFromMidpoint(e);
+      this.refresh(), this._emitVertexAddEvent([e], i, s);
+    } else
+      this._isVertex(e) && (t.viewEvent.stopPropagation(), t.viewEvent.button === 2 ? this._removeVertices(e) : (t.viewEvent.native.shiftKey || this._clearSelection(), this.selectedVertices.includes(e) ? this._removeFromSelection(e, !0) : this._addToSelection(e)));
+  }
+  _setUpOperation(t) {
+    const { graphic: e, dx: i, dy: s } = t, o = e === this.graphic;
+    this._resetSnappingStateVars(), this._setUpGeometryHelper(), this._saveSnappingContextForHandle(e, t), this._activeOperationInfo = { target: this.graphic, mover: e, operationType: o ? "move" : "reshape", totalDx: i, totalDy: s };
+  }
+  _onGraphicMoveStartCallback(t) {
+    const { dx: e, dy: i, graphic: s } = t;
+    if (s === this.graphic) {
+      const { geometry: o } = s;
+      return this._setUpOperation(t), this._emitMoveStartEvent(e, i), void (o != null && o.type === "point" && this._onHandleMove(s, e, i, t, () => {
+        this._updateTooltip(this.graphic, t.viewEvent), this._emitMoveEvent(e, i);
+      }));
+    }
+    if (!this.selectedVertices.includes(s)) {
+      if (this._clearSelection(), this._isMidpoint(s)) {
+        const o = this.graphic.clone(), n = this._createVertexFromMidpoint(s);
+        this._emitVertexAddEvent([s], o, n);
+      }
+      this._addToSelection(s);
+    }
+    this._setUpOperation(t), this._emitReshapeStartEvent(s), this._onHandleMove(s, e, i, t, () => {
+      this._updateTooltip(s, t.viewEvent), this._emitReshapeEvent(s);
+    });
+  }
+  _onGraphicMoveCallback(t) {
+    const e = this._activeOperationInfo;
+    if (!e)
+      return;
+    const { dx: i, dy: s, graphic: o } = t;
+    e.totalDx += i, e.totalDy += s;
+    const { operationType: n } = e, { geometry: r } = o;
+    if (r != null) {
+      if (n !== "move")
+        this._onHandleMove(o, i, s, t, () => {
+          this._updateTooltip(o, t.viewEvent), this._emitReshapeEvent(o);
+        });
+      else if (r.type === "point")
+        this._onHandleMove(o, i, s, t, () => {
+          this._updateTooltip(this.graphic, t.viewEvent), this._emitMoveEvent(i, s);
+        });
+      else if (r.type === "polyline" || r.type === "polygon") {
+        const h = this._getCoordinatesForUI(r);
+        this._updateVertexGraphicLocations(h), this._updateTooltip(this.graphic, t.viewEvent), this._emitMoveEvent(i, s);
+      }
+    }
+  }
+  _onGraphicMoveStopCallback(t) {
+    const e = this._activeOperationInfo;
+    if (!e)
+      return;
+    const { dx: i, dy: s, graphic: o } = t, { operationType: n } = e;
+    e.totalDx += i, e.totalDy += s, this._onHandleMove(o, i, s, t, () => n === "move" ? this._emitMoveStopEvent() : this._emitReshapeStopEvent(o)), this._isMidpoint(o) ? this.refresh() : (this._updateTooltip(this._isVertex(o) ? o : null), this._resetSnappingStateVars(), this._activeOperationInfo = null);
+  }
+  _updateVertexGraphicLocations(t) {
+    const e = this.view.spatialReference;
+    for (const i of this.vertexGraphics) {
+      const { pathIndex: s, pointIndex: o } = i.attributes, [n, r, h] = t[s][o];
+      i.geometry = new f({ x: n, y: r, z: h, spatialReference: e });
+    }
+    this._updateMidpointGraphicLocations(t);
+  }
+  _updateMidpointGraphicLocations(t) {
+    for (const e of this.midpointGraphics) {
+      const { pathIndex: i, pointIndexStart: s, pointIndexEnd: o } = e.attributes, [n, r, h] = t[i][s], [p, a, c] = t[i][o], [l, m, _] = C([n, r, h], [p, a, c]);
+      e.geometry = new f({ x: l, y: m, z: _, spatialReference: this.view.spatialReference });
+    }
+  }
+  _getIndicesForVertexGraphic({ attributes: t }) {
+    return [(t == null ? void 0 : t.pathIndex) || 0, (t == null ? void 0 : t.pointIndex) || 0];
+  }
+  _getVertexFromEditGeometry(t) {
+    const [e, i] = this._getIndicesForVertexGraphic(t);
+    return this._editGeometryOperations.data.components[e].vertices[i];
+  }
+  _onHandleMove(t, e, i, s, o) {
+    E(this._snappingTask);
+    const n = this._snappingContext;
+    if (!n)
+      return;
+    const r = t.geometry, h = s.type === "graphic-move-stop";
+    if (this.snappingManager != null && this.selectedVertices.length < 2 && !h) {
+      const p = this.snappingManager;
+      this._stagedVertex = p.update({ point: r, context: n }), this._syncGeometryAfterVertexMove(t, new f(this._stagedVertex), e, i, h), o(), this._snappingTask = D(async (a) => {
+        const c = await p.snap({ point: r, context: n, signal: a });
+        c.valid && (this._stagedVertex = c.apply(), this._syncGeometryAfterVertexMove(t, new f(this._stagedVertex), e, i, h), o());
+      });
+    } else {
+      const p = this._stagedVertex != null ? new f(this._stagedVertex) : r;
+      this._syncGeometryAfterVertexMove(t, p, e, i, h), o();
+    }
+  }
+  async _syncGeometryAfterVertexMove(t, e, i, s, o = !1) {
+    const n = this._editGeometryOperations.data.geometry;
+    if (n.type === "point")
+      t.geometry = e;
+    else if (n.type === "mesh")
+      t.geometry = n.centerAt(e), t.notifyGeometryChanged();
+    else {
+      const { x: r, y: h, z: p } = e, [a, c] = this._getIndicesForVertexGraphic(t);
+      let l = b(n);
+      const m = l[a].length - 1, _ = p != null ? [r, h, p] : [r, h];
+      l[a][c] = _, n.type === "polygon" && (c === 0 ? l[a][m] = _ : c === m && (l[a][0] = _)), this._isVertex(t) && (l = this._moveRelatedCoordinates(l, t, _), l = this._moveSelectedHandleCoordinates(l, t, i, s, n.type === "polygon"), this._updateMidpointGraphicLocations(l)), this.graphic.geometry = n.clone();
+      const u = this._getVertexFromEditGeometry(t), V = r - u.pos[0], w = h - u.pos[1];
+      this._editGeometryOperations.moveVertices([u], V, w, 0), o && (this._mover ? this._mover.updateGeometry(this._mover.graphics.indexOf(t), e) : t.geometry = e);
+    }
+  }
+  _moveRelatedCoordinates(t, e, i) {
+    const { relatedGraphicIndices: s } = e.attributes;
+    for (const o of s) {
+      const n = this.vertexGraphics.at(o), { pathIndex: r, pointIndex: h } = n.attributes;
+      t[r][h] = i, n.geometry = e.geometry;
+    }
+    return t;
+  }
+  _moveSelectedHandleCoordinates(t, e, i, s, o) {
+    for (const n of this.selectedVertices)
+      if (n !== e) {
+        const { pathIndex: r, pointIndex: h, relatedGraphicIndices: p } = n.attributes, a = Q(n.geometry, i, s, this.view), c = t[r].length - 1;
+        t[r][h] = [a.x, a.y], n.geometry = a, o && (h === 0 ? t[r][c] = [a.x, a.y] : h === c && (t[r][0] = [a.x, a.y]));
+        for (const l of p) {
+          const m = this.vertexGraphics.at(l), { pathIndex: _, pointIndex: u } = m.attributes;
+          t[_][u] = [a.x, a.y], m.geometry = a;
+        }
+      }
+    return t;
+  }
+  _onGraphicPointerOverCallback(t) {
+    const e = t.graphic;
+    this._hoverGraphic = e;
+    const i = this._isVertex(e);
+    i && !this._isSelected(e) && (e.symbol = this.symbols.vertices.hover), this._updateTooltip(i ? e : null), this._updateHoverCursor(e);
+  }
+  _onGraphicPointerOutCallback(t) {
+    const e = t.graphic;
+    this._hoverGraphic = null, this._isVertex(e) && !this._isSelected(e) && (e.symbol = this.symbols.vertices.default), this.view.cursor = "default", this._updateTooltip();
+  }
+  _createVertexFromMidpoint(t) {
+    const { _graphicAttributes: e, graphic: i } = this, s = i.geometry;
+    if (s == null || s.type !== "polygon" && s.type !== "polyline")
+      return [];
+    const o = s.clone(), n = [], { pathIndex: r, pointIndexStart: h, pointIndexEnd: p } = t.attributes, { x: a, y: c, z: l } = t.geometry, m = p === 0 ? h + 1 : p, _ = b(o);
+    return _[r].splice(m, 0, l != null ? [a, c, l] : [a, c]), t.attributes = { ...e, pathIndex: r, pointIndex: m, relatedGraphicIndices: [] }, n.push({ coordinates: _[r][m], componentIndex: r, vertexIndex: m }), this.graphic.geometry = o, n;
+  }
+  _addToSelection(t) {
+    t instanceof x && (t = [t]);
+    for (const e of t)
+      e.symbol = this.symbols.vertices.selected;
+    this._set("selectedVertices", this.selectedVertices.concat(t)), this._emitSelectEvent(t);
+  }
+  _removeFromSelection(t, e) {
+    const { vertices: i } = this.symbols, s = e ? i.hover : i.default;
+    t instanceof x && (t = [t]);
+    for (const o of t)
+      this.selectedVertices.splice(this.selectedVertices.indexOf(o), 1), this._set("selectedVertices", this.selectedVertices), o.set("symbol", s);
+    this._emitDeselectEvent(t);
+  }
+  _clearSelection() {
+    if (this.selectedVertices.length) {
+      const t = this.selectedVertices;
+      for (const e of this.selectedVertices)
+        e.set("symbol", this.symbols.vertices.default);
+      this._set("selectedVertices", []), this._emitDeselectEvent(t);
+    }
+  }
+  _keyDownHandler(t) {
+    it.delete.includes(t.key) && !t.repeat && this.selectedVertices.length && this._removeVertices(this.selectedVertices);
+  }
+  _removeVertices(t) {
+    const e = this.graphic.geometry;
+    if (e == null || e.type !== "polygon" && e.type !== "polyline" || e.type === "polygon" && this.vertexGraphics.length < 4 || this.vertexGraphics.length < 3)
+      return;
+    t instanceof x && (t = [t]);
+    const i = this.graphic.clone(), s = e.clone();
+    let o = b(s);
+    const n = [];
+    t instanceof x && (t = [t]);
+    for (const r of t) {
+      const { x: h, y: p } = r.geometry;
+      for (let a = 0; a < o.length; a++) {
+        const c = o[a];
+        for (let l = 0; l < c.length; l++) {
+          const [m, _] = c[l];
+          h === m && p === _ && (n.push({ coordinates: o[a][l], componentIndex: a, vertexIndex: l }), o[a].splice(Number(l), 1));
+        }
+      }
+    }
+    if (s.type === "polygon")
+      o = o.filter((r) => {
+        if (r.length < 2)
+          return !1;
+        const [h, p] = r[0], [a, c] = r[r.length - 1];
+        return (r.length !== 2 || h !== a || p !== c) && (h === a && p === c || r.push(r[0]), !0);
+      }), s.rings = o;
+    else {
+      for (const r of o)
+        r.length === 1 && o.splice(o.indexOf(r), 1);
+      s.paths = o;
+    }
+    this.graphic.geometry = s, this.refresh(), this._emitVertexRemoveEvent(t, i, n);
+  }
+  _isVertex(t) {
+    return this.vertexGraphics.includes(t);
+  }
+  _isSelected(t) {
+    return this._isVertex(t) && this.selectedVertices.includes(t);
+  }
+  _isMidpoint(t) {
+    return this.midpointGraphics.includes(t);
+  }
+  _updateHoverCursor(t) {
+    this.view.cursor = this._isMidpoint(t) ? "copy" : "move";
+  }
+  _updateTooltip(t, e) {
+    this.tooltip != null && (t ? t === this.graphic ? this._updateMoveGraphicTooltip(e) : this._updateMoveVertexTooltip(e) : this.tooltip.clear());
+  }
+  _updateMoveGraphicTooltip(t) {
+    const { tooltip: e, sketchOptions: i, view: s } = this;
+    if (e == null)
+      return;
+    const o = this._translateGraphicTooltipInfo ?? (this._translateGraphicTooltipInfo = new nt({ sketchOptions: i }));
+    if (o.clear(), o.sketchOptions = i, t) {
+      const { x: n, y: r } = t.origin, h = s.toMap(t), p = s.toMap(O(n, r)), a = R(p, h);
+      o.distance = a ?? I;
+    }
+    e.info = o;
+  }
+  _updateMoveVertexTooltip(t) {
+    const { tooltip: e, graphic: { geometry: i }, sketchOptions: s, view: o } = this;
+    if (e == null)
+      return;
+    const n = this._translateVertexTooltipInfo ?? (this._translateVertexTooltipInfo = new at({ sketchOptions: s }));
+    if (n.clear(), n.sketchOptions = s, (i == null ? void 0 : i.type) === "polygon" ? n.area = ht(i) : (i == null ? void 0 : i.type) === "polyline" && (n.totalLength = pt(i)), t) {
+      const { x: r, y: h } = t.origin, p = o.toMap(t), a = o.toMap(O(r, h)), c = R(a, p);
+      n.distance = c ?? I;
+    }
+    e.info = n;
+  }
+  _emitMoveStartEvent(t, e) {
+    const i = new vt(this.graphic, t, e);
+    this.emit("move-start", i), this.callbacks.onMoveStart && this.callbacks.onMoveStart(i);
+  }
+  _emitMoveEvent(t, e) {
+    const i = new yt(this.graphic, t, e);
+    this.emit("move", i), this.callbacks.onMove && this.callbacks.onMove(i);
+  }
+  _emitMoveStopEvent() {
+    const t = this._activeOperationInfo;
+    if (!t)
+      return;
+    const { totalDx: e, totalDy: i } = t, s = new _t(this.graphic, e, i);
+    this.emit("move-stop", s), this.callbacks.onMoveStop && this.callbacks.onMoveStop(s);
+  }
+  _emitReshapeStartEvent(t) {
+    const e = new lt(this.graphic, t, this.selectedVertices);
+    this.emit("reshape-start", e), this.callbacks.onReshapeStart && this.callbacks.onReshapeStart(e);
+  }
+  _emitReshapeEvent(t) {
+    const e = new dt(this.graphic, t, this.selectedVertices);
+    this.emit("reshape", e), this.callbacks.onReshape && this.callbacks.onReshape(e);
+  }
+  _emitReshapeStopEvent(t) {
+    const e = new mt(this.graphic, t, this.selectedVertices);
+    this.emit("reshape-stop", e), this.callbacks.onReshapeStop && this.callbacks.onReshapeStop(e);
+  }
+  _emitSelectEvent(t) {
+    const e = new gt(t);
+    this.emit("select", e), this.callbacks.onVertexSelect && this.callbacks.onVertexSelect(e);
+  }
+  _emitDeselectEvent(t) {
+    const e = new ut(t);
+    this.emit("deselect", e), this.callbacks.onVertexDeselect && this.callbacks.onVertexDeselect(e);
+  }
+  _emitVertexAddEvent(t, e, i) {
+    const s = new ft(t, this.graphic, e, i);
+    this.emit("vertex-add", s), this.callbacks.onVertexAdd && this.callbacks.onVertexAdd(s);
+  }
+  _emitVertexRemoveEvent(t, e, i) {
+    const s = new xt(t, this.graphic, e, i);
+    this.emit("vertex-remove", s), this.callbacks.onVertexRemove && this.callbacks.onVertexRemove(s);
+  }
+  _logGeometryTypeError() {
+    L.getLogger(this).error(new F("reshape:invalid-geometry", "Reshape operation not supported for the provided graphic. The geometry type is not supported."));
+  }
+};
+v([y()], d.prototype, "tooltip", void 0), v([y()], d.prototype, "_translateGraphicTooltipInfo", void 0), v([y()], d.prototype, "_translateVertexTooltipInfo", void 0), v([y()], d.prototype, "callbacks", void 0), v([y()], d.prototype, "enableMidpoints", void 0), v([y()], d.prototype, "enableMovement", void 0), v([y()], d.prototype, "enableVertices", void 0), v([y()], d.prototype, "graphic", void 0), v([y({ value: !0 })], d.prototype, "highlightsEnabled", null), v([y()], d.prototype, "layer", void 0), v([y({ readOnly: !0 })], d.prototype, "midpointGraphics", void 0), v([y()], d.prototype, "midpointSymbol", void 0), v([y({ readOnly: !0 })], d.prototype, "selectedVertices", void 0), v([y()], d.prototype, "snappingManager", void 0), v([y({ readOnly: !0 })], d.prototype, "state", null), v([y()], d.prototype, "symbols", void 0), v([y({ type: $ })], d.prototype, "sketchOptions", void 0), v([y({ readOnly: !0 })], d.prototype, "type", void 0), v([y({ readOnly: !0 })], d.prototype, "vertexGraphics", void 0), v([y()], d.prototype, "view", void 0), d = v([B("esri.views.draw.support.Reshape")], d);
+const re = d;
+export {
+  re as default
+};

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

@@ -0,0 +1,118 @@
+import "../../../geometry.js";
+import { equals as D, isSome as U } from "../../../core/arrayUtils.js";
+import { clone as O } from "../../../core/lang.js";
+import { getMetersPerUnitForSR as V } from "../../../core/unitUtils.js";
+import { m as A } from "../../../chunks/vec32.js";
+import { create as q } from "../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import F from "../../../geometry/Circle.js";
+import { simplify as G, distance as N } from "../../../geometry/geometryEngine.js";
+import { unnormalizeGeometryOnDatelineCrossing as C, isClockwise as W, unnormalizeVerticesOnDatelineCrossing as B } from "../../../geometry/support/coordsUtils.js";
+import { isValid as E } from "../../../geometry/support/spatialReferenceUtils.js";
+import { makeSurfacePoint as o } from "./surfaceCoordinateSystems.js";
+import H from "../../../geometry/Point.js";
+import J from "../../../geometry/Multipoint.js";
+import K from "../../../geometry/Polyline.js";
+import Q from "../../../geometry/Polygon.js";
+function d(s, t) {
+  const l = new H({ x: s[0], y: s[1], spatialReference: t });
+  return s.length > 2 && (l.z = s[2]), l;
+}
+function ut(s, t) {
+  return new J({ points: s, spatialReference: t });
+}
+function yt(s, t, l) {
+  const n = new K({ paths: s, spatialReference: t });
+  return l && C(n), n;
+}
+function z(s, t, l, n = !0) {
+  const r = O(s);
+  r.forEach((e) => {
+    const c = e[0], i = e[e.length - 1];
+    D(c, i) && e.length !== 1 || e.push(e[0]);
+  });
+  let a = new Q({ rings: r, spatialReference: t });
+  return a.rings.forEach((e) => {
+    W(e) || e.reverse();
+  }), l && C(a), n && a.isSelfIntersecting && E(t) && (a = G(a)), a;
+}
+function xt(s, t, l) {
+  const n = t.mapToLocalMultiple(s), r = [], a = { x: n[0].x, y: n[0].y }, e = { x: n[1].x, y: n[1].y }, c = Math.round(e.x - a.x), i = Math.round(e.y - a.y), y = Math.max(Math.abs(c), Math.abs(i));
+  if (l) {
+    const p = { x: a.x + y, y: a.y + y }, f = { x: a.x - y, y: a.y - y };
+    r.push(o(p.x, f.y), o(f.x, f.y), o(f.x, p.y), o(p.x, p.y));
+  } else {
+    const p = { x: c > 0 ? a.x + y : a.x - y, y: i > 0 ? a.y + y : a.y - y };
+    r.push(o(a.x, a.y), o(p.x, a.y), o(p.x, p.y), o(a.x, p.y));
+  }
+  return j(z([r.map((p) => t.localToMap(p)).filter(U)], t.spatialReference, t.doUnnormalization, !0), r, t);
+}
+function ft(s, t, l) {
+  let n = t.mapToLocalMultiple(s);
+  if (n.length === 1) {
+    const i = n[0];
+    n = [o(i.x - 48, i.y + 48), o(i.x + 48, i.y - 48), o(i.x + 48, i.y - 48), o(i.x - 48, i.y + 48)];
+  }
+  const r = [], a = { x: n[0].x, y: n[0].y }, e = { x: n[1].x, y: n[1].y };
+  if (l) {
+    const c = Math.round(e.x - a.x), i = Math.round(e.y - a.y);
+    r.push(o(a.x - c, a.y - i), o(e.x, a.y - i), o(e.x, e.y), o(a.x - c, e.y));
+  } else
+    r.push(o(a.x, a.y), o(e.x, a.y), o(e.x, e.y), o(a.x, e.y));
+  return j(z([r.map((c) => t.localToMap(c)).filter(U)], t.spatialReference, t.doUnnormalization, !0), r, t);
+}
+function j(s, t, l) {
+  const n = $(t[3], t[2], l), r = $(t[1], t[2], l), a = $(t[0], t[1], l), e = $(t[0], t[3], l);
+  return { geometry: s, midpoints: n != null && r != null && a != null && e != null ? { top: n, right: r, bottom: a, left: e } : null };
+}
+function $(s, t, l) {
+  T[0] = s.x, T[1] = s.y, T[2] = 0, b[0] = t.x, b[1] = t.y, b[2] = 0, A(T, T, b, 0.5), w.x = T[0], w.y = b[1], w.z = b[2];
+  const n = l.localToMap(w);
+  return n != null ? d(n, l.spatialReference) : null;
+}
+const w = o(0, 0, 0), T = q(), b = q();
+function mt(s, t, l, n) {
+  const r = t.mapToLocalMultiple(s);
+  let a = null, e = null;
+  if (l)
+    a = r[0], e = r[1];
+  else {
+    const u = r[0], x = r[1], R = Math.round(x.x - u.x), g = Math.round(x.y - u.y), m = Math.max(Math.abs(R), Math.abs(g));
+    a = o(R > 0 ? u.x + m / 2 : u.x - m / 2, g > 0 ? u.y + m / 2 : u.y - m / 2), e = o(Math.abs(R) > Math.abs(g) ? a.x - m / 2 : a.x, Math.abs(R) > Math.abs(g) ? a.y : a.y - m / 2);
+  }
+  const c = t.localToMap(a), i = t.localToMap(e);
+  if (c == null || i == null)
+    return null;
+  t.doUnnormalization && B([[c, i]], t.spatialReference);
+  const y = d(c, t.spatialReference), p = d(i, t.spatialReference), f = V(t.spatialReference);
+  let M = 0;
+  if (E(t.spatialReference))
+    M = f * N(y, p, null);
+  else {
+    const u = a.x - e.x, x = a.y - e.y;
+    M = f * Math.sqrt(u * u + x * x) * (n || 1);
+  }
+  const P = new F({ center: y, radius: M, radiusUnit: "meters", spatialReference: t.spatialReference });
+  return { geometry: z(P.rings, P.spatialReference, !1), center: y, edge: p };
+}
+function Mt(s, t, l) {
+  const n = t.mapToLocalMultiple(s), r = n[0], a = n[1], e = Math.round(a.x - r.x), c = Math.round(a.y - r.y), i = o(l ? r.x : r.x + e / 2, l ? r.y : r.y + c / 2), y = l ? e : e / 2, p = l ? c : c / 2, f = 60, M = [], P = 2 * Math.PI / f;
+  function u(h) {
+    const k = Math.cos(h), v = Math.sin(h);
+    return o(y * k + i.x, p * v + i.y);
+  }
+  for (let h = 0; h < f; h++)
+    M.push(u(h * P));
+  M.push(M[0]);
+  const { spatialReference: x, doUnnormalization: R } = t, g = z([M.map((h) => t.localToMap(h)).filter(U)], x, R, !1), m = t.localToMap(u(Math.PI / 2)), I = t.localToMap(u(0)), L = t.localToMap(u(-Math.PI / 2)), S = t.localToMap(u(Math.PI));
+  return { geometry: g, midpoints: m != null && I != null && L != null && S != null ? { top: d(m, x), right: d(I, x), bottom: d(L, x), left: d(S, x) } : null };
+}
+export {
+  mt as createCircle,
+  Mt as createEllipse,
+  ut as createMultipoint,
+  d as createPoint,
+  z as createPolygon,
+  yt as createPolyline,
+  ft as createRectangle,
+  xt as createSquare
+};