@agrotools1/at-components 0.6.16 → 0.6.17

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/widgets/Sketch/SketchViewModel.js

@@ -0,0 +1,886 @@
+import { _ as u } from "../../chunks/tslib.es6.js";
+import { symbolTypes as A } from "../../symbols.js";
+import x from "../../core/Collection.js";
+import J from "../../core/Error.js";
+import Q from "../../core/Evented.js";
+import X from "../../core/Logger.js";
+import { destroyMaybe as M, abortMaybe as I } from "../../core/maybe.js";
+import { createAbortError as L, whenOrAbort as tt } from "../../core/promiseUtils.js";
+import { on as F, watch as k, when as et, whenOnce as V, syncAndInitial as D } from "../../core/reactiveUtils.js";
+import { property as m } from "../../core/accessorSupport/decorators/property.js";
+import "../../core/has.js";
+import "../../core/RandomLCG.js";
+import { subclass as ot } from "../../core/accessorSupport/decorators/subclass.js";
+import { getReferenceEllipsoid as at } from "../../geometry/ellipsoidUtils.js";
+import { canProjectWithoutEngine as it, isLoaded as rt, load as st, project as nt } from "../../geometry/projection.js";
+import { geometryToCoordinates as K } from "../../geometry/support/coordsUtils.js";
+import { equals as pt } from "../../geometry/support/spatialReferenceUtils.js";
+import lt from "../../layers/GraphicsLayer.js";
+import { isIntegratedMeshLayer as ht } from "../../layers/support/layerUtils.js";
+import { SupportedGraphicResult as E, isSupportedGraphicResultMessage as U } from "../../views/3d/interactive/editingTools/isSupportedGraphicUtils.js";
+import { isSupportedGraphic as ct } from "../../views/3d/interactive/editingTools/moveGraphic/isSupportedGraphic.js";
+import { isSupportedGraphic as C } from "../../views/3d/interactive/editingTools/reshapeGraphic/isSupportedGraphic.js";
+import { isSupportedGraphic as dt } from "../../views/3d/interactive/editingTools/transformGraphic/isSupportedGraphic.js";
+import { addUniqueLayer as W } from "../../views/draw/support/layerUtils.js";
+import { ViewEventPriorities as G } from "../../views/input/InputManager.js";
+import { sketchKeys as v } from "../../views/interactive/keybindings.js";
+import ut from "../../views/interactive/sketch/SketchLabelOptions.js";
+import j from "../../views/interactive/sketch/SketchOptions.js";
+import yt from "../../views/interactive/sketch/SketchTooltipOptions.js";
+import mt from "../../views/interactive/sketch/SketchValueOptions.js";
+import { SnappingManager as Z } from "../../views/interactive/snapping/SnappingManager.js";
+import B from "../../views/interactive/snapping/SnappingOptions.js";
+import { setupSnappingToggleHandles as gt } from "../../views/interactive/snapping/snappingUtils.js";
+import { findFirstGraphicHit as vt } from "../../views/support/hitTestSelectUtils.js";
+import { createScreenPointFromEvent as $ } from "../../views/support/screenUtils.js";
+import { CreateOperationHandle as ft, UpdateOperationHandle as T } from "./support/OperationHandle.js";
+import q from "../../symbols/SimpleMarkerSymbol.js";
+import _t from "../../symbols/SimpleFillSymbol.js";
+import Gt from "../../symbols/SimpleLineSymbol.js";
+import bt from "../../symbols/MeshSymbol3D.js";
+import wt from "../../symbols/FillSymbol3DLayer.js";
+const N = { defaultZ: 0 }, S = { reshapeOptions: { edgeOperation: "split", shapeOperation: "move", vertexOperation: "move" }, enableMoveAllGraphics: !0, enableRotation: !0, enableScaling: !0, multipleSelectionEnabled: !0, preserveAspectRatio: !1, toggleToolOnClick: !0, enableZ: !0, highlightOptions: { enabled: !0 }, tool: "transform" };
+let d = class extends Q.EventedAccessor {
+  constructor(t) {
+    var e;
+    super(t), this._numUpdating = 0, this._defaultSnappingManager = null, this._internalGraphicsLayer = new lt({ listMode: "hide", internal: !0, title: "SVM Internal" }), this._operationHandle = null, this._viewHandlesKey = "viewHandles", this.activeFillSymbol = null, this.activeLineSymbol = null, this.activeVertexSymbol = null, this.allowDeleteKey = !0, this.layer = null, this.pointSymbol = new q({ style: "circle", size: 6, color: [255, 255, 255], outline: { color: [50, 50, 50], width: 1 } }), this.polygonSymbol = new _t({ color: [150, 150, 150, 0.2], outline: { color: [50, 50, 50], width: 2 } }), this.polylineSymbol = new Gt({ color: [130, 130, 130, 1], width: 2 }), this.meshSymbol = new bt({ symbolLayers: new x([new wt()]) }), this.updateGraphics = new x(), this.updateOnGraphicClick = !0, this.vertexSymbol = new q({ style: "circle", size: 6, color: [255, 255, 255], outline: { color: [50, 50, 50], width: 1 } }), this.sketchOptions = new j(), this._moduleLoaderAbortController = null, this._viewReadyAbortController = null, this._originalPopupEnabled = null, this.defaultCreateOptions = N, this.defaultUpdateOptions = S, this.snappingOptions = ((e = t == null ? void 0 : t.snappingManager) == null ? void 0 : e.options) ?? (t == null ? void 0 : t.snappingOptions) ?? new B();
+  }
+  initialize() {
+    this.addHandles([F(() => {
+      var t, e;
+      return (e = (t = this.view) == null ? void 0 : t.map) == null ? void 0 : e.layers;
+    }, "change", (t) => {
+      t.removed.includes(this.layer) && this.cancel();
+    }), F(() => {
+      var t;
+      return (t = this.layer) == null ? void 0 : t.graphics;
+    }, "change", (t) => {
+      if (this._operationHandle != null)
+        for (const e of t.removed)
+          this.updateGraphics.includes(e) && (this.updateGraphics.length > 1 ? this._operationHandle.removeFromSelection(e) : this._operationHandle.cancel());
+    }), k(() => {
+      var t;
+      return ((t = this.layer) == null ? void 0 : t.elevationInfo) ?? null;
+    }, (t) => {
+      t !== this._internalGraphicsLayer.elevationInfo && (this.cancel(), this._internalGraphicsLayer.elevationInfo = t);
+    }, D), k(() => this.view, (t) => {
+      this._defaultSnappingManager = M(this._defaultSnappingManager), t && (this.snappingManager || (this._defaultSnappingManager = new Z({ view: t, options: this.snappingOptions })), t.type === "2d" ? import("../../views/2d/interactive/editingTools.js") : t.type === "3d" && (import("../../views/3d/interactive/editingTools.js"), import("../../views/3d/layers/GraphicsLayerView3D.js")));
+    }, D), k(() => {
+      var t;
+      return (t = this.view) == null ? void 0 : t.spatialReference;
+    }, (t, e) => {
+      t && e && !t.equals(e) && this.cancel();
+    })]), gt(this);
+  }
+  destroy() {
+    this.cancel(), this._removeDefaultLayer(), this._defaultSnappingManager = M(this._defaultSnappingManager), this._set("snappingManager", null), this._set("view", null), this.emit("destroy");
+  }
+  get _defaultUpdateTool() {
+    var t;
+    return ((t = this.view) == null ? void 0 : t.type) === "3d" ? "move" : "transform";
+  }
+  get updating() {
+    return this._numUpdating > 0 || this.snappingManager != null && this.snappingManager.updating;
+  }
+  get activeTool() {
+    var t;
+    return ((t = this._operationHandle) == null ? void 0 : t.tool) ?? null;
+  }
+  get activeComponent() {
+    var t;
+    return ((t = this._operationHandle) == null ? void 0 : t.activeComponent) ?? null;
+  }
+  get createGraphic() {
+    return this.activeComponent == null || this.activeComponent.type !== "draw-3d" && this.activeComponent.type !== "draw-2d" ? this._get("createGraphic") : this.activeComponent.graphic;
+  }
+  get defaultCreateOptions() {
+    return this._get("defaultCreateOptions");
+  }
+  set defaultCreateOptions(t) {
+    this._set("defaultCreateOptions", { ...N, ...t });
+  }
+  get defaultUpdateOptions() {
+    return this._get("defaultUpdateOptions");
+  }
+  set defaultUpdateOptions(t) {
+    this._set("defaultUpdateOptions", { ...S, ...t, reshapeOptions: { ...S.reshapeOptions, ...t == null ? void 0 : t.reshapeOptions }, highlightOptions: { ...S.highlightOptions, ...t == null ? void 0 : t.highlightOptions } });
+  }
+  get labelOptions() {
+    return this.sketchOptions.labels;
+  }
+  set labelOptions(t) {
+    this.sketchOptions.labels = t;
+  }
+  get snappingOptions() {
+    var t;
+    return ((t = this.snappingManager) == null ? void 0 : t.options) ?? this._get("snappingOptions");
+  }
+  set snappingOptions(t) {
+    this._defaultSnappingManager != null && (this._defaultSnappingManager.options = t), this._set("snappingOptions", t);
+  }
+  get snappingManager() {
+    return this._isOverridden("snappingManager") && this._get("snappingManager"), this._defaultSnappingManager;
+  }
+  set snappingManager(t) {
+    if (t)
+      this._isOverridden("snappingManager") || (this._defaultSnappingManager = M(this._defaultSnappingManager)), this._override("snappingManager", t);
+    else {
+      const { view: e } = this;
+      !this._defaultSnappingManager && e && (this._defaultSnappingManager = new Z({ options: this.snappingOptions, view: e })), this._clearOverride("snappingManager");
+    }
+  }
+  get state() {
+    var a;
+    const t = !(!((a = this.view) != null && a.ready) || !this.layer), e = this._operationHandle;
+    return t && e ? "active" : t ? "ready" : "disabled";
+  }
+  get tooltipOptions() {
+    return this.sketchOptions.tooltips;
+  }
+  set tooltipOptions(t) {
+    this.sketchOptions.tooltips = t;
+  }
+  get valueOptions() {
+    return this.sketchOptions.values;
+  }
+  set valueOptions(t) {
+    this.sketchOptions.values = t;
+  }
+  get view() {
+    return this._get("view");
+  }
+  set view(t) {
+    const e = this._get("view");
+    if (e) {
+      const { container: o, map: i } = e;
+      o && (e.cursor = null), i == null || i.remove(this._internalGraphicsLayer), this.removeHandles(this._viewHandlesKey), this.cancel();
+    }
+    const a = "view-ready";
+    this.removeHandles(a), t && this.addHandles(et(() => t.ready, (o) => {
+      this.removeHandles(this._viewHandlesKey), o && this.addHandles(this._generateViewHandles(t), this._viewHandlesKey);
+    }, D), a), this._set("view", t);
+  }
+  cancel() {
+    this._moduleLoaderAbortController = I(this._moduleLoaderAbortController), this._viewReadyAbortController = I(this._viewReadyAbortController), this._operationHandle && this._operationHandle.cancel();
+  }
+  complete() {
+    this._operationHandle && this._operationHandle.complete();
+  }
+  delete() {
+    const { state: t, updateGraphics: e } = this;
+    if (t === "active" && e.length) {
+      const { activeTool: a, layer: o } = this, i = e.toArray();
+      o.removeMany(i), this.cancel(), this._emitDeleteEvent({ graphics: i, tool: a });
+    }
+  }
+  duplicate() {
+    if (this.state === "active" && this.updateGraphics.length) {
+      const t = this.updateGraphics.map((e) => e.clone()).toArray();
+      return this.layer.addMany(t), this.emit("duplicate", { graphics: t, type: "duplicate" }), t;
+    }
+    return [];
+  }
+  async create(t, e) {
+    this.cancel(), await this._waitViewReady();
+    const { view: a, layer: o } = this;
+    if (!a || this.state === "disabled")
+      throw o || this._logMissingLayer(), L();
+    if (a.activeTool != null && (a.activeTool = null), !t)
+      return void this._logError("sketch:missing-parameter", "Missing parameter 'tool'.");
+    W(a, this._internalGraphicsLayer);
+    const i = await this._setupCreateOperation(t, e);
+    if (i == null || this.destroyed)
+      return void a.map.remove(this._internalGraphicsLayer);
+    const r = () => {
+      var p;
+      if (i === this._operationHandle) {
+        const s = this.createGraphic, c = this._operationHandle.cancelled;
+        this._operationHandle.destroy(), this._operationHandle = null, this._set("createGraphic", null), (p = this.view) != null && p.map && this.view.map.remove(this._internalGraphicsLayer), i.cancelled || s == null || o.add(s), this.emit("create", { graphic: s, state: c ? "cancel" : "complete", tool: t, toolEventInfo: null, type: "create" });
+      }
+    };
+    i.on("complete", r), this._operationHandle = i, a.ready && a.focus();
+  }
+  async place(t, e) {
+    return this.create("mesh", { mode: "click", hasZ: t.hasZ, geometryToPlace: t, ...e });
+  }
+  async update(t, e) {
+    this.cancel(), await this._waitViewReady();
+    const { layer: a, view: o, state: i } = this;
+    if (!o || i === "disabled")
+      throw a || this._logMissingLayer(), L();
+    o.activeTool != null && (o.activeTool = null);
+    const r = Array.isArray(t) ? t : [t];
+    if (t == null || !(r != null && r.length))
+      return void this._logError("sketch:missing-parameter", "Missing parameter 'graphics'.");
+    if (r.some((s) => s.layer !== a ? (this._logError("sketch:invalid-parameter", "Parameter 'graphics' contains one or more graphics missing from the supplied GraphicsLayer."), !0) : s.geometry == null && (this._logError("sketch:invalid-parameter", "Parameter 'graphics' contains one or more graphics with an unsupported geometry."), !0)))
+      return;
+    const p = await this._setupUpdateOperation(r, e);
+    this.destroyed || p == null || f(p) || (W(o, this._internalGraphicsLayer), this._setUpdateOperationHandle(p, e), this.emit("update", { graphics: r, state: "start", aborted: !1, tool: p.tool, toolEventInfo: null, type: "update" }));
+  }
+  async _updateSpatialReference(t) {
+    const e = this.view;
+    if (e) {
+      this._beginAsyncOperation(), t = Array.isArray(t) ? t : [t];
+      for (const a of t)
+        a.geometry == null || a.geometry.type === "mesh" || pt(a.geometry.spatialReference, e.spatialReference) || (it(a.geometry.spatialReference, e.spatialReference) || rt() || await st(), a.geometry = nt(a.geometry, e.spatialReference));
+      this._endAsyncOperation();
+    } else
+      this._logMissingView();
+  }
+  undo() {
+    var t;
+    this.canUndo() && ((t = this._operationHandle) == null || t.undo());
+  }
+  redo() {
+    var t;
+    this.canRedo() && ((t = this._operationHandle) == null || t.redo());
+  }
+  canUndo() {
+    return !(!this._operationHandle || !this._operationHandle.canUndo());
+  }
+  canRedo() {
+    return !(!this._operationHandle || !this._operationHandle.canRedo());
+  }
+  toggleUpdateTool() {
+    this._operationHandle && this._operationHandle.toggleTool && this._operationHandle.toggleTool();
+  }
+  async _getFirstHit(t) {
+    const e = this.view;
+    if (!e)
+      return this._logMissingView(), null;
+    if (e.type === "2d") {
+      const i = [];
+      e.map.allLayers.forEach((p) => {
+        p.type !== "vector-tile" && p.type !== "imagery" || i.push(p);
+      });
+      const r = await e.hitTest(t, { exclude: i });
+      return vt(r.results);
+    }
+    const a = [e.map.ground];
+    e.map.allLayers.forEach((i) => {
+      ht(i.type) && a.push(i);
+    });
+    const o = await e.hitTest(t, { exclude: a });
+    if (o.results.length > 0) {
+      const i = o.results[0];
+      if (i != null && i.type === "graphic" && i.graphic && (!o.ground.mapPoint || e.map.ground.opacity < 1 || o.ground.distance - (i.distance ?? 0) > -Math.min(3 * o.ground.distance, e.viewingMode === "global" ? at(e.renderCoordsHelper.spatialReference).radius / e.renderCoordsHelper.unitInMeters : Number.POSITIVE_INFINITY)))
+        return i;
+    }
+    return null;
+  }
+  _generateViewHandles(t) {
+    return [t.on("immediate-click", async (e) => {
+      var r;
+      const a = this.state === "active" && ((r = this._operationHandle) == null ? void 0 : r.type) === "create";
+      if (this.state === "disabled" || a || !this.updateOnGraphicClick)
+        return;
+      this._beginAsyncOperation();
+      const o = await e.async(() => this._getFirstHit($(e)));
+      let i = null;
+      if (o != null) {
+        const p = o.graphic;
+        this.updateGraphics.includes(p) || p.layer === this.layer ? (e.stopPropagation(), i = p) : t.type !== "2d" || this._isComponentGraphic(p) || this.state !== "active" || this.cancel();
+      } else
+        this.state === "active" && this.cancel();
+      i == null || this.updateGraphics.includes(i) || await this.update([i], { ...this.defaultUpdateOptions, reshapeOptions: { ...this.defaultUpdateOptions.reshapeOptions } }), this._endAsyncOperation();
+    }, G.WIDGET)];
+  }
+  async _setupCreateOperation(t, e) {
+    const a = this.view;
+    if (!a)
+      return this._logMissingView(), null;
+    const o = { hasZ: a.type === "3d", ...this.defaultCreateOptions, ...e }, i = await this._setupDrawGraphicTool(t, a, o);
+    return i == null ? null : (a.tools.add(i), a.activeTool = i, this._setupCreateOperationHandle(i));
+  }
+  async _setupDrawGraphicTool(t, e, a) {
+    if (t === "multipoint" && e.type === "3d")
+      return this._logError("sketch:create", "Multipoint geometries are not supported in SceneView."), null;
+    if (!e)
+      return this._logMissingView(), null;
+    const { cursor: o, defaultZ: i, hasZ: r, geometryToPlace: p, graphicProperties: s, mode: c, preserveAspectRatio: n } = a, h = t === "rectangle" || t === "circle" ? "hybrid" : "click", l = n ?? t !== "rectangle", y = { centered: t !== "rectangle" && !(t === "circle" && !l), cursor: o, defaultZ: i, forceUniformSize: l, graphicProperties: s, geometryToPlace: p, geometryType: t, graphicSymbol: this._getGraphicSymbolFromTool(t), hasZ: r, mode: c ?? h, snappingManager: this.snappingManager, snapToScene: !1, view: e };
+    return e.type === "2d" ? this._makeDrawGraphicTool2D(y) : this._makeDrawGraphicTool3D(y);
+  }
+  async _makeDrawGraphicTool2D(t) {
+    const e = await this._requireModule(import("../../views/2d/interactive/editingTools.js"));
+    return f(e) || this.destroyed ? null : new e.module.DrawGraphicTool2D({ ...t, activeVertexSymbol: this.activeVertexSymbol, regularVerticesSymbol: this.vertexSymbol, activeLineSymbol: this.activeLineSymbol, activeFillSymbol: Et(t.geometryType) ? this.activeFillSymbol : null, sketchOptions: this.sketchOptions });
+  }
+  async _makeDrawGraphicTool3D(t) {
+    const e = await this._requireModule(import("../../views/3d/interactive/editingTools.js"));
+    if (f(e) || this.destroyed)
+      return null;
+    const { elevationInfo: a } = this.layer;
+    return new e.module.DrawGraphicTool3D({ ...t, elevationInfo: a, snapToScene: !0, sketchOptions: this.sketchOptions });
+  }
+  _setupCreateOperationHandle(t) {
+    const e = this.view;
+    if (!e)
+      return this._logMissingView(), null;
+    let a = null;
+    const o = t.forceUniformSize, i = t.centered, r = [e.on("key-down", (s) => {
+      if (s.key === v.pan)
+        s.stopPropagation(), s.repeat || (t.enabled = !1);
+      else if (s.key === v.complete)
+        s.stopPropagation(), t.completeCreateOperation();
+      else if (s.key !== v.vertexAdd || s.repeat)
+        s.key === v.undo ? (s.stopPropagation(), p.undo()) : s.key === v.redo ? (s.stopPropagation(), p.redo()) : s.key !== v.constraint || t.geometryType !== "rectangle" && t.geometryType !== "circle" || s.repeat ? s.key === v.center && (s.repeat || (t.centered = !i, s.stopPropagation())) : (t.forceUniformSize = !o, s.stopPropagation());
+      else {
+        const c = t.drawOperation.geometryType;
+        c !== "polyline" && c !== "polygon" && c !== "multipoint" || (s.stopPropagation(), t.drawOperation.commitStagedVertex());
+      }
+    }, G.WIDGET), e.on("key-up", (s) => {
+      s.key === v.pan ? t.enabled = !0 : s.key !== v.constraint || t.geometryType !== "rectangle" && t.geometryType !== "circle" ? s.key === v.center && (t.centered = i, s.stopPropagation()) : (t.forceUniformSize = o, s.stopPropagation());
+    }, G.WIDGET), t.on("vertex-add", (s) => {
+      switch (a = a == null ? "start" : "active", s.operation) {
+        case "apply":
+          this.emit("create", { graphic: t.graphic, state: a, tool: this.activeTool, toolEventInfo: s, type: "create" });
+          break;
+        case "undo":
+          this._emitUndoEvent({ graphics: [t.graphic], tool: t.geometryType });
+          break;
+        case "redo":
+          this._emitRedoEvent({ graphics: [t.graphic], tool: t.geometryType });
+      }
+    }), t.on("cursor-update", (s) => {
+      t.drawOperation.numCommittedVertices > 0 && this.emit("create", { graphic: t.graphic, state: "active", tool: this.activeTool, toolEventInfo: { coordinates: s.vertices[0].coordinates, type: "cursor-update" }, type: "create" });
+    }), t.on("vertex-remove", (s) => {
+      switch (s.operation) {
+        case "apply":
+          this.emit("create", { graphic: t.graphic, state: "active", tool: this.activeTool, toolEventInfo: s, type: "create" });
+          break;
+        case "undo":
+          this._emitUndoEvent({ graphics: [t.graphic], tool: t.geometryType });
+          break;
+        case "redo":
+          this._emitRedoEvent({ graphics: [t.graphic], tool: t.geometryType });
+      }
+    }), t.on("complete", (s) => {
+      this._set("createGraphic", s.graphic), a = "complete", s.aborted ? p && p.cancel() : p && p.complete();
+    }), k(() => this._getGraphicSymbolFromTool(t.geometryType), (s) => {
+      t.graphicSymbol = s;
+    })], p = new ft({ activeComponent: t, tool: t.geometryType, type: "create", onEnd: () => {
+      var s;
+      r.forEach((c) => c.remove()), r.length = 0, (s = e.tools) == null || s.remove(t);
+    }, undo: () => {
+      t.canUndo && t.undo();
+    }, redo: () => {
+      t.canRedo && t.redo();
+    }, canUndo: () => t.canUndo, canRedo: () => t.canRedo });
+    return p;
+  }
+  _getGraphicSymbolFromTool(t) {
+    switch (t) {
+      case "point":
+      case "multipoint":
+        return this.pointSymbol;
+      case "polyline":
+        return this.polylineSymbol;
+      case "circle":
+      case "rectangle":
+      case "polygon":
+        return this.polygonSymbol;
+      case "mesh":
+        return this.meshSymbol;
+    }
+  }
+  async _setupUpdateOperation(t, e) {
+    var p;
+    const { layer: a, view: o } = this;
+    if (!o)
+      return this._logMissingView(), null;
+    const i = { tool: this._defaultUpdateTool, ...this.defaultUpdateOptions, ...e, reshapeOptions: { ...this.defaultUpdateOptions.reshapeOptions, ...e == null ? void 0 : e.reshapeOptions }, highlightOptions: { ...this.defaultUpdateOptions.highlightOptions, ...e == null ? void 0 : e.highlightOptions } };
+    let r = i.tool;
+    for (const s of t)
+      a.remove(s), a.add(s);
+    if (o.type === "3d") {
+      if (t.length === 0)
+        return null;
+      switch (r) {
+        case "move":
+          return this._setupMove3DOperation(t, i, o, r);
+        case "reshape": {
+          if (t.length > 1)
+            return this._logError("sketch:reshape-multiple", "Reshape operation does not support multiple graphics."), null;
+          const s = C(t[0]);
+          return s === E.SUPPORTED ? this._setupReshape3DOperation(t[0], i, o) : (this._logError("sketch:reshape", `Reshape operation not supported for provided graphic(s) (${U(s)}).`), null);
+        }
+        case "transform":
+          return this._setupGraphicTransform3DOperation(t, i, o);
+      }
+    }
+    switch (r) {
+      case "move":
+        return this._setupMove2DOperation(t, i, o);
+      case "reshape": {
+        if (t.length > 1)
+          return this._logError("sketch:reshape-multiple", "Reshape operation does not support multiple graphics."), null;
+        const s = C(t[0]);
+        return s === E.SUPPORTED ? this._setupTransformOrReshape2DOperation(t, r, i, o) : (this._logError("sketch:reshape", `Reshape operation not supported for provided graphic(s) (${U(s)}).`), null);
+      }
+      case "transform":
+        if (t.length === 1) {
+          const s = (p = t[0].geometry) == null ? void 0 : p.type;
+          s !== "point" && s !== "multipoint" || (r = "reshape");
+        }
+        return this._setupTransformOrReshape2DOperation(t, r, i, o);
+    }
+  }
+  async _setupMove3DOperation(t, e, a, o, i = !1) {
+    for (const n of t) {
+      const h = ct(n);
+      if (h !== E.SUPPORTED)
+        return this._logError("sketch:move", `Move operation not supported for provided graphic(s) (${U(h)}).`), null;
+    }
+    const r = await this._requireModule(import("../../views/3d/interactive/editingTools.js"));
+    if (f(r))
+      return r;
+    const p = new r.module.GraphicMoveTool({ view: a, enableZ: e.enableZ, snappingManager: this.snappingManager, sketchOptions: this.sketchOptions });
+    a.tools.add(p), p.graphics.addMany(t), i || this.updateGraphics.addMany(t);
+    const s = [], c = new T({ activeComponent: p, tool: o, type: "update", onEnd: () => {
+      var n;
+      s.forEach((h) => h.remove()), s.length = 0, (n = a.tools) == null || n.remove(p), p.destroyed || p.destroy();
+    }, undo: () => {
+      H(c, this.updateGraphics.toArray()), this._emitUndoEvent({ graphics: this.updateGraphics.toArray(), tool: o });
+    }, redo: () => {
+      R(c, this.updateGraphics.toArray()), this._emitRedoEvent({ graphics: this.updateGraphics.toArray(), tool: o });
+    }, addToSelection: (n) => {
+      this.updateGraphics.push(n), p.graphics.push(n), this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: [n], removed: [], type: "selection-change" }, type: "update" });
+    }, removeFromSelection: (n) => {
+      const h = this.updateGraphics.indexOf(n);
+      c.history.undo.forEach((l) => l.updates.splice(h, 1)), c.history.redo.forEach((l) => l.updates.splice(h, 1)), this.updateGraphics.remove(n), this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: [], removed: [n], type: "selection-change" }, type: "update" }), this.updateGraphics.length !== 0 ? p.graphics.remove(n) : c.complete();
+    }, toggleTool: async () => {
+      if (this.updateGraphics.length !== 1 || e.toggleToolOnClick === !1 || o !== "transform")
+        return;
+      const n = this.updateGraphics.at(0);
+      if (C(n) !== E.SUPPORTED)
+        return;
+      c.onEnd(), c.destroy();
+      const h = await this._setupReshape3DOperation(n, e, a, !0);
+      f(h) || this._setUpdateOperationHandle(h, e);
+    } });
+    return s.push(...this._getHandlesForComponent(c, e), a.on("immediate-click", (n) => this._getCommonUpdateOperationClickHandlers(c, n, e), G.WIDGET), a.on("key-down", (n) => {
+      this._getCommonUpdateOperationKeyDownHandlers(c, n);
+    }, G.WIDGET)), c;
+  }
+  _setupGraphicTransform3DOperation(t, e, a, o = !1) {
+    if (t.length === 1 && dt(t[0]) === E.SUPPORTED) {
+      const i = t[0], r = i.geometry;
+      if (r != null && (r.type === "point" || r.type === "mesh"))
+        return this._setupPointTransform3DOperation(i, e, a);
+      if (r != null && (r.type === "polygon" || r.type === "polyline"))
+        return this._setupPolyTransform3DOperation(i, e, a, o);
+    }
+    return this._setupMove3DOperation(t, e, a, "transform", o);
+  }
+  async _setupPointTransform3DOperation(t, e, a) {
+    const o = "transform", { enableRotation: i, enableScaling: r, enableZ: p } = e, s = await this._requireModule(import("../../views/3d/interactive/editingTools.js"));
+    if (f(s))
+      return s;
+    const c = new s.module.GraphicTransformTool({ graphic: t, view: a, enableRotation: i, enableScaling: r, enableZ: p, snappingManager: this.snappingManager, sketchOptions: this.sketchOptions });
+    a.tools.add(c), this.updateGraphics.add(t);
+    const n = [], h = new T({ activeComponent: c, tool: o, type: "update", onEnd: () => {
+      var l;
+      n.forEach((y) => y.remove()), n.length = 0, (l = a.tools) == null || l.remove(c), c.destroyed || c.destroy();
+    }, undo: () => {
+      H(h, this.updateGraphics.toArray()), this._emitUndoEvent({ graphics: this.updateGraphics.toArray(), tool: o });
+    }, redo: () => {
+      R(h, this.updateGraphics.toArray()), this._emitRedoEvent({ graphics: this.updateGraphics.toArray(), tool: o });
+    }, addToSelection: async (l) => {
+      this.updateGraphics.add(l), this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: [l], removed: [], type: "selection-change" }, type: "update" }), h.onEnd(), h.destroy();
+      const y = await this._setupMove3DOperation(this.updateGraphics.toArray(), e, a, "transform", !0);
+      f(y) || this._setUpdateOperationHandle(y, e);
+    }, removeFromSelection: (l) => {
+      this.updateGraphics.remove(l), this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: [], removed: [l], type: "selection-change" }, type: "update" }), h.complete();
+    }, toggleTool: () => {
+    } });
+    return n.push(...this._getHandlesForComponent(h, e), a.on("immediate-click", (l) => this._getCommonUpdateOperationClickHandlers(h, l, e), G.WIDGET), a.on("key-down", (l) => {
+      this._getCommonUpdateOperationKeyDownHandlers(h, l);
+    }, G.WIDGET)), h;
+  }
+  async _setupPolyTransform3DOperation(t, e, a, o = !1) {
+    var O, P;
+    const i = "transform", { enableRotation: r, enableScaling: p, enableZ: s, preserveAspectRatio: c } = e, n = await this._requireModule(import("../../views/3d/interactive/editingTools.js"));
+    if (f(n))
+      return n;
+    const h = (P = (O = this.view) == null ? void 0 : O.inputManager) == null ? void 0 : P.isModifierKeyDown(v.constraint), l = new n.module.ExtentTransformTool({ graphic: t, view: a, enableRotation: r, enableScaling: p, enableZ: s, preserveAspectRatio: !!c != !!h, sketchOptions: this.sketchOptions });
+    a.tools.add(l), o || this.updateGraphics.add(t);
+    const y = [], _ = new T({ activeComponent: l, tool: i, type: "update", onEnd: () => {
+      var g;
+      y.forEach((w) => w.remove()), y.length = 0, (g = a.tools) == null || g.remove(l), l.destroyed || l.destroy();
+    }, canUndo: () => l.canUndo, undo: () => {
+      l.undo(), this._emitUndoEvent({ graphics: this.updateGraphics.toArray(), tool: i });
+    }, canRedo: () => l.canRedo, redo: () => {
+      l.redo(), this._emitRedoEvent({ graphics: this.updateGraphics.toArray(), tool: i });
+    }, addToSelection: async (g) => {
+      this.updateGraphics.add(g), this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: [g], removed: [], type: "selection-change" }, type: "update" }), _.onEnd(), _.destroy();
+      const w = await this._setupMove3DOperation(this.updateGraphics.toArray(), e, a, "transform", !0);
+      f(w) || this._setUpdateOperationHandle(w, e);
+    }, removeFromSelection: (g) => {
+      this.updateGraphics.remove(g), this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: [], removed: [g], type: "selection-change" }, type: "update" }), _.complete();
+    }, toggleTool: async () => {
+      if (this.updateGraphics.length !== 1 || e.toggleToolOnClick === !1)
+        return;
+      const g = this.updateGraphics.at(0);
+      if (C(g) !== E.SUPPORTED)
+        return;
+      _.onEnd(), _.destroy();
+      const w = await this._setupReshape3DOperation(g, e, a, !0);
+      f(w) || this._setUpdateOperationHandle(w, e);
+    } });
+    return y.push(...this._getHandlesForComponent(_, e), a.on("immediate-click", (g) => this._getCommonUpdateOperationClickHandlers(_, g, e), G.WIDGET), a.on("key-down", (g) => this._getCommonUpdateOperationKeyDownHandlers(_, g), G.WIDGET), a.on("key-down", (g) => {
+      g.key !== v.constraint || g.repeat || (l.preserveAspectRatio = !l.preserveAspectRatio, g.stopPropagation());
+    }, G.WIDGET), a.on("key-up", (g) => {
+      g.key === v.constraint && (l.preserveAspectRatio = !l.preserveAspectRatio, g.stopPropagation());
+    }, G.WIDGET)), _;
+  }
+  async _setupMove2DOperation(t, e, a) {
+    const o = "move";
+    this.updateGraphics.addMany(t), await this._updateSpatialReference(t);
+    const i = await this._getGraphicMover(t, e, a);
+    if (f(i))
+      return i;
+    const r = new T({ activeComponent: i, tool: o, type: "update", onEnd: () => {
+      var n;
+      this._displayDefaultCursor(), c.forEach((h) => h.remove()), s.forEach((h) => h.remove()), c = [], s = [], i.destroy(), (n = this._internalGraphicsLayer) == null || n.removeMany([...this.updateGraphics.toArray()]);
+    }, undo: () => {
+      const n = this.updateGraphics.toArray();
+      H(r, n), r.refreshComponent(), this._emitUndoEvent({ graphics: n, tool: o });
+    }, redo: () => {
+      const n = this.updateGraphics.toArray();
+      R(r, n), r.refreshComponent(), this._emitRedoEvent({ graphics: n, tool: o });
+    }, addToSelection: async (n) => {
+      await this._updateSpatialReference(n), this.updateGraphics.push(n), i.graphics = this.updateGraphics.toArray(), this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: [n], removed: [], type: "selection-change" }, type: "update" });
+    }, removeFromSelection: (n) => {
+      const h = this.updateGraphics.indexOf(n);
+      r.history.undo.forEach((y) => y.updates.splice(h, 1)), r.history.redo.forEach((y) => y.updates.splice(h, 1)), this.updateGraphics.remove(n);
+      const l = this.updateGraphics.toArray();
+      this.emit("update", { graphics: l, state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: [], removed: [n], type: "selection-change" }, type: "update" }), this.updateGraphics.length !== 0 ? i.graphics = l : r.complete();
+    } });
+    let p = !1, s = [a.on("immediate-click", (n) => this._getCommonUpdateOperationClickHandlers(r, n, e), G.WIDGET), a.on("key-down", (n) => {
+      this._getCommonUpdateOperationKeyDownHandlers(r, n), n.key !== v.constraint || n.repeat || (p = !0, i.enableMoveAllGraphics = !i.enableMoveAllGraphics);
+    }, G.WIDGET), a.on("key-up", (n) => {
+      n.key === v.constraint && p && (p = !1, i.enableMoveAllGraphics = !i.enableMoveAllGraphics);
+    }, G.WIDGET)], c = this._getHandlesForComponent(r, e);
+    return r;
+  }
+  async _setupReshape3DOperation(t, e, a, o = !1) {
+    const i = "reshape", r = await this._requireModule(import("../../views/3d/interactive/editingTools.js"));
+    if (f(r))
+      return r;
+    const p = e.reshapeOptions, s = new r.module.GraphicReshapeTool({ view: a, graphic: t, enableZVertex: e.enableZ && (p == null ? void 0 : p.vertexOperation) === "move", enableZShape: e.enableZ && (p == null ? void 0 : p.shapeOperation) === "move", enableMoveGraphic: (p == null ? void 0 : p.shapeOperation) === "move" || (p == null ? void 0 : p.shapeOperation) === "move-xy", enableMidpoints: (p == null ? void 0 : p.edgeOperation) === "split", enableEdgeOffset: (p == null ? void 0 : p.edgeOperation) === "offset", snappingManager: this.snappingManager, sketchOptions: this.sketchOptions });
+    a.tools.add(s), o || this.updateGraphics.add(t);
+    const c = [], n = new T({ activeComponent: s, tool: i, type: "update", onEnd: () => {
+      var h;
+      c.forEach((l) => l.remove()), c.length = 0, (h = a.tools) == null || h.remove(s), s.destroyed || s.destroy();
+    }, canUndo: () => s.canUndo, undo: () => {
+      s.undo(), this._emitUndoEvent({ graphics: this.updateGraphics.toArray(), tool: i });
+    }, canRedo: () => s.canRedo, redo: () => {
+      s.redo(), this._emitRedoEvent({ graphics: this.updateGraphics.toArray(), tool: i });
+    }, addToSelection: async (h) => {
+      this.updateGraphics.add(h), this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: [h], removed: [], type: "selection-change" }, type: "update" }), n.onEnd(), n.destroy();
+      const l = await this._setupMove3DOperation(this.updateGraphics.toArray(), e, a, "transform", !0);
+      f(l) || this._setUpdateOperationHandle(l, e);
+    }, removeFromSelection: (h) => {
+      this.updateGraphics.remove(h), this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: [], removed: [h], type: "selection-change" }, type: "update" }), n.complete();
+    }, toggleTool: async () => {
+      if (e.toggleToolOnClick === !1)
+        return;
+      n.onEnd(), n.destroy();
+      const h = await this._setupGraphicTransform3DOperation(this.updateGraphics.toArray(), e, a, !0);
+      f(h) || this._setUpdateOperationHandle(h, e);
+    } });
+    return c.push(...this._getHandlesForComponent(n, e), a.on("immediate-click", (h) => this._getCommonUpdateOperationClickHandlers(n, h, e), G.WIDGET), a.on("key-down", (h) => {
+      this._getCommonUpdateOperationKeyDownHandlers(n, h);
+    }, G.WIDGET)), n;
+  }
+  async _setupTransformOrReshape2DOperation(t, e, a, o) {
+    this.updateGraphics.addMany(t), await this._updateSpatialReference(t);
+    const i = e === "transform" ? await this._getBox(t, a, o) : await this._getReshape(t, a, o);
+    if (f(i))
+      return i;
+    const r = new T({ activeComponent: i, type: "update", onEnd: () => {
+      s.forEach((c) => c.remove()), p.forEach((c) => c.remove()), s = [], p = [], r.activeComponent && !r.activeComponent.destroyed && r.activeComponent.destroy(), this._internalGraphicsLayer.removeMany(this.updateGraphics.toArray());
+    }, undo: () => {
+      H(r, this.updateGraphics.toArray()), r.refreshComponent(), this._emitUndoEvent({ graphics: this.updateGraphics.toArray(), tool: r.tool });
+    }, redo: () => {
+      R(r, this.updateGraphics.toArray()), r.refreshComponent(), this._emitRedoEvent({ graphics: this.updateGraphics.toArray(), tool: r.tool });
+    }, addToSelection: async (c) => {
+      let n = r.activeComponent;
+      if ((n == null ? void 0 : n.type) === "reshape") {
+        const h = [...this.updateGraphics, c];
+        this.updateGraphics.removeAll(), r.onEnd(), r.destroy();
+        const l = await this._setupTransformOrReshape2DOperation(h, "transform", a, o);
+        if (f(l))
+          return;
+        this._setUpdateOperationHandle(l, a);
+      } else
+        this.updateGraphics.add(c), n.graphics = this.updateGraphics.toArray(), n.refresh(), r.resetHistory();
+      this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: [c], removed: [], type: "selection-change" }, type: "update" });
+    }, removeFromSelection: async (c) => {
+      const n = this.updateGraphics.indexOf(c);
+      r.history.undo.forEach((l) => l.updates.splice(n, 1)), r.history.redo.forEach((l) => l.updates.splice(n, 1)), this.updateGraphics.remove(c);
+      const h = this.updateGraphics.toArray();
+      if (h.length === 0)
+        r.complete();
+      else {
+        const l = h[0].geometry;
+        h.length !== 1 || l == null || l.type !== "point" && l.type !== "multipoint" ? r.activeComponent.graphics = h : r.toggleTool();
+      }
+      this.emit("update", { graphics: h, state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: [], removed: [c], type: "selection-change" }, type: "update" });
+    }, toggleTool: async () => {
+      var l;
+      if (this.updateGraphics.length > 1)
+        return;
+      const c = this.updateGraphics.at(0), n = c.geometry;
+      if (n != null && (r.tool === "reshape" && (n.type === "point" || n.type === "multipoint") || r.tool === "transform" && n.type === "extent"))
+        return;
+      let h = null;
+      r.tool === "transform" ? h = await this._getReshape([c], a, o) : r.tool === "reshape" && (h = await this._getBox([c], a, o)), f(h) || ((l = r.activeComponent) == null || l.destroy(), r.activeComponent = h, r.activeComponent && (s.forEach((y) => y.remove()), s = this._getHandlesForComponent(r, a)));
+    } });
+    let p = [o.on("immediate-click", (c) => this._getCommonUpdateOperationClickHandlers(r, c, a), G.WIDGET), o.on("key-down", (c) => {
+      if (this._getCommonUpdateOperationKeyDownHandlers(r, c), c.key === v.constraint && !c.repeat && r) {
+        const n = r.activeComponent;
+        n && n.type === "box" && (n.preserveAspectRatio = !n.preserveAspectRatio);
+      }
+    }, G.WIDGET), o.on("key-up", (c) => {
+      if (c.key === v.constraint && r) {
+        const n = r.activeComponent;
+        n && n.type === "box" && (n.preserveAspectRatio = !n.preserveAspectRatio);
+      }
+    }, G.WIDGET)], s = this._getHandlesForComponent(r, a);
+    return r;
+  }
+  async _getGraphicMover(t, e, a) {
+    const { enableMoveAllGraphics: o, highlightOptions: i } = e, r = await this._requireModule(import("../../views/draw/support/GraphicMover.js"));
+    return f(r) ? r : new r.module.default({ enableMoveAllGraphics: o, highlightsEnabled: !!(i != null && i.enabled), indicatorsEnabled: !1, graphics: t, view: a, callbacks: { onGraphicMoveStart: ({ dx: p, dy: s, graphic: c }) => {
+      this._displayGrabbingCursor(), this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { dx: p, dy: s, mover: c, type: "move-start" }, type: "update" });
+    }, onGraphicMove: ({ dx: p, dy: s, graphic: c }) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { dx: p, dy: s, mover: c, type: "move" }, type: "update" }), onGraphicMoveStop: ({ dx: p, dy: s, graphic: c }) => {
+      this._displayPointerCursor(), this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { dx: p, dy: s, mover: c, type: "move-stop" }, type: "update" });
+    }, onGraphicPointerOver: () => this._displayPointerCursor(), onGraphicPointerOut: () => this._displayDefaultCursor() } });
+  }
+  async _getBox(t, e, a) {
+    var n, h;
+    const { enableRotation: o, enableScaling: i, highlightOptions: r, preserveAspectRatio: p } = e, s = await this._requireModule(import("../../views/draw/support/Box.js"));
+    if (f(s))
+      return s;
+    const c = (h = (n = this.view) == null ? void 0 : n.inputManager) == null ? void 0 : h.isModifierKeyDown(v.constraint);
+    return new s.module.default({ graphics: t, enableRotation: o, enableScaling: i, highlightsEnabled: !!(r != null && r.enabled), preserveAspectRatio: !!p != !!c, layer: this._internalGraphicsLayer, view: a, sketchOptions: this.sketchOptions, callbacks: { onMoveStart: (l) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { ...l }, type: "update" }), onMove: (l) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { ...l }, type: "update" }), onMoveStop: (l) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { ...l }, type: "update" }), onScaleStart: (l) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { ...l }, type: "update" }), onScale: (l) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { ...l }, type: "update" }), onScaleStop: (l) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { ...l }, type: "update" }), onRotateStart: (l) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { ...l }, type: "update" }), onRotate: (l) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { ...l }, type: "update" }), onRotateStop: (l) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { ...l }, type: "update" }) } });
+  }
+  async _getReshape(t, e, a) {
+    var s, c, n;
+    const o = ((s = e.reshapeOptions) == null ? void 0 : s.edgeOperation) === "split", i = ((c = e.reshapeOptions) == null ? void 0 : c.shapeOperation) === "move", r = !!((n = e.highlightOptions) != null && n.enabled), p = await this._requireModule(import("../../views/draw/support/Reshape.js"));
+    return f(p) ? p : new p.module.default({ enableMidpoints: o, enableMovement: i, graphic: t[0], highlightsEnabled: r, layer: this._internalGraphicsLayer, snappingManager: this.snappingManager, sketchOptions: this.sketchOptions, view: a, callbacks: { onReshapeStart: (h) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { ...h }, type: "update" }), onReshape: (h) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { ...h }, type: "update" }), onReshapeStop: ({ mover: h, type: l }) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { mover: h, type: l }, type: "update" }), onMoveStart: ({ dx: h, dy: l, mover: y, type: _ }) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { dx: h, dy: l, mover: y, type: _ }, type: "update" }), onMove: ({ dx: h, dy: l, mover: y, type: _ }) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { dx: h, dy: l, mover: y, type: _ }, type: "update" }), onMoveStop: ({ dx: h, dy: l, mover: y, type: _ }) => this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { dx: h, dy: l, mover: y, type: _ }, type: "update" }), onVertexAdd: ({ added: h, type: l, vertices: y }) => {
+      const _ = h.map((O) => K(O.geometry));
+      this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { added: _, vertices: y, type: l }, type: "update" });
+    }, onVertexRemove: ({ removed: h, type: l, vertices: y }) => {
+      const _ = h.map((O) => K(O.geometry));
+      this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { removed: _, vertices: y, type: l }, type: "update" });
+    } } });
+  }
+  _getHandlesForComponent(t, e) {
+    const a = t.activeComponent;
+    if (!a)
+      return [];
+    switch (a.type) {
+      case "graphic-mover":
+        return [a.on("graphic-click", ({ graphic: o, viewEvent: i }) => {
+          var r;
+          (r = i.native) != null && r.shiftKey && (i.stopPropagation(), t.removeFromSelection(o));
+        }), a.on("graphic-move-start", (o) => t.addToHistory(b(o.allGraphics)))];
+      case "box":
+        return [a.on("graphic-click", (o) => this._onTransformOrReshape2DGraphicClick(t, e, o)), a.on("move-start", (o) => t.addToHistory(b(o.graphics))), a.on("rotate-start", (o) => t.addToHistory(b(o.graphics))), a.on("scale-start", (o) => t.addToHistory(b(o.graphics)))];
+      case "reshape":
+        return [a.on("graphic-click", (o) => this._onTransformOrReshape2DGraphicClick(t, e, o)), a.on("move-start", (o) => t.addToHistory(b([o.mover]))), a.on("reshape-start", (o) => t.addToHistory(b([o.graphic]))), a.on("vertex-add", (o) => t.addToHistory(b([o.oldGraphic]))), a.on("vertex-remove", (o) => t.addToHistory(b([o.oldGraphic])))];
+      case "move-3d":
+        return [a.on("graphic-move-start", (o) => {
+          t.addToHistory(b(o.allGraphics)), this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { dx: 0, dy: 0, mover: o.allGraphics.length > 0 ? o.allGraphics[0] : null, type: "move-start" }, type: "update" });
+        }), a.on("graphic-move", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { dx: o.dx, dy: o.dy, mover: o.allGraphics.length > 0 ? o.allGraphics[0] : null, type: "move" }, type: "update" });
+        }), a.on("graphic-move-stop", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { dx: 0, dy: 0, mover: o.allGraphics.length > 0 ? o.allGraphics[0] : null, type: "move-stop" }, type: "update" });
+        }), a.on("immediate-click", (o) => {
+          o.shiftKey ? this._toggleSelection([o.graphic], t, e) : t.toggleTool();
+        })];
+      case "transform-3d":
+        return [a.on("record-undo", ({ record: o }) => {
+          t.addToHistory({ updates: [o] });
+        }), a.on("graphic-translate-start", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { mover: o.graphic, dx: o.dxScreen, dy: o.dyScreen, type: "move-start" }, type: "update" });
+        }), a.on("graphic-translate-stop", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { mover: o.graphic, dx: o.dxScreen, dy: o.dyScreen, type: "move-stop" }, type: "update" });
+        }), a.on("graphic-rotate-start", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { mover: o.graphic, angle: o.angle, type: "rotate-start" }, type: "update" });
+        }), a.on("graphic-rotate-stop", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { mover: o.graphic, angle: o.angle, type: "rotate-stop" }, type: "update" });
+        }), a.on("graphic-scale-start", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { mover: o.graphic, xScale: o.xScale, yScale: o.yScale, type: "scale-start" }, type: "update" });
+        }), a.on("graphic-scale-stop", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { mover: o.graphic, xScale: o.xScale, yScale: o.yScale, type: "scale-stop" }, type: "update" });
+        }), a.on("graphic-translate", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { mover: o.graphic, dx: o.dxScreen, dy: o.dyScreen, type: "move" }, type: "update" });
+        }), a.on("graphic-rotate", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { mover: o.graphic, angle: o.angle, type: "rotate" }, type: "update" });
+        }), a.on("graphic-scale", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: { mover: o.graphic, xScale: o.xScale, yScale: o.yScale, type: "scale" }, type: "update" });
+        }), a.on("immediate-click", (o) => {
+          o.shiftKey ? this._toggleSelection([o.graphic], t, e) : t.toggleTool();
+        })];
+      case "reshape-3d":
+        return [a.on("reshape", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: o, type: "update" });
+        }), a.on("move", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: o, type: "update" });
+        }), a.on("vertex-add", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: o, type: "update" });
+        }), a.on("vertex-remove", (o) => {
+          this.emit("update", { graphics: this.updateGraphics.toArray(), state: "active", aborted: !1, tool: this.activeTool, toolEventInfo: o, type: "update" });
+        }), a.on("immediate-click", (o) => {
+          o.shiftKey ? this._toggleSelection([o.graphic], t, e) : t.toggleTool();
+        })];
+    }
+  }
+  _onTransformOrReshape2DGraphicClick(t, e, a) {
+    var r;
+    const { graphic: o, viewEvent: i } = a;
+    return (r = i.native) != null && r.shiftKey && o.layer === this.layer ? (i.stopPropagation(), t.removeFromSelection(o)) : e.toggleToolOnClick ? (i.stopPropagation(), t.toggleTool()) : void 0;
+  }
+  _setUpdateOperationHandle(t, e) {
+    var i;
+    this._operationHandle = t;
+    const a = (i = this.view) == null ? void 0 : i.map;
+    this._disablePopup(e);
+    const o = () => {
+      if (t === this._operationHandle) {
+        const r = this.updateGraphics.toArray(), p = this._operationHandle.tool;
+        this._operationHandle.destroy(), this._operationHandle = null, this._internalGraphicsLayer.removeMany(this.updateGraphics.toArray()), this.updateGraphics.removeAll(), a && a.remove(this._internalGraphicsLayer), this._restorePopup(e), this.emit("update", { graphics: r, state: "complete", aborted: t.cancelled, tool: p, toolEventInfo: null, type: "update" });
+      }
+    };
+    t.on("complete", o);
+  }
+  async _getCommonUpdateOperationClickHandlers(t, e, a) {
+    const o = $(e), i = await e.async(() => this._getFirstHit(o));
+    if (i == null)
+      return void t.complete();
+    if (e.native.shiftKey && this._toggleSelection([i.graphic], t, a))
+      return void e.stopPropagation();
+    this.updateGraphics.includes(i.graphic) ? e.stopPropagation() : t.complete();
+  }
+  _toggleSelection(t, e, a) {
+    const o = !!a.multipleSelectionEnabled;
+    return t.some((i) => i != null && !(!o || i.layer !== this.layer) && (this.updateGraphics.includes(i) ? e.removeFromSelection(i) : e.addToSelection(i), !0));
+  }
+  _getCommonUpdateOperationKeyDownHandlers(t, e) {
+    if (!t)
+      return;
+    const a = e.key;
+    a === v.undo && t.canUndo() ? (e.stopPropagation(), t.undo()) : a === v.redo && t.canRedo() ? (e.stopPropagation(), t.redo()) : a === v.cancel ? (e.stopPropagation(), t.cancel()) : this.allowDeleteKey && v.delete.includes(a) && this._onDeleteKey(e);
+  }
+  _onDeleteKey(t) {
+    var o;
+    if (!this._operationHandle || this._operationHandle.type !== "update")
+      return;
+    const e = this.activeComponent, a = this.updateGraphics.toArray();
+    e != null && e.type !== "reshape-3d" && (e.type !== "reshape" || a.length === 1 && ((o = a[0].geometry) == null ? void 0 : o.type) === "point") && (t.stopPropagation(), this.delete());
+  }
+  _removeDefaultLayer() {
+    var t, e;
+    this._internalGraphicsLayer && ((e = (t = this.view) == null ? void 0 : t.map) == null || e.remove(this._internalGraphicsLayer), this._internalGraphicsLayer = M(this._internalGraphicsLayer));
+  }
+  _isComponentGraphic(t) {
+    var a;
+    const { activeComponent: e } = this;
+    return !(!t || e == null) && (((a = t.attributes) == null ? void 0 : a.esriSketchTool) || e.type === "draw-2d" && e.graphic === t || (e.type === "box" || e.type === "reshape") && e.isUIGraphic(t));
+  }
+  _displayPointerCursor() {
+    var t;
+    (t = this.view) != null && t.container && this.view.cursor !== "pointer" && (this.view.cursor = "pointer");
+  }
+  _displayGrabbingCursor() {
+    var t;
+    (t = this.view) != null && t.container && this.view.cursor !== "grabbing" && (this.view.cursor = "grabbing");
+  }
+  _displayDefaultCursor() {
+    var t;
+    (t = this.view) != null && t.container && this.view.cursor !== null && (this.view.cursor = null);
+  }
+  _logError(t, e, a) {
+    X.getLogger(this).error(new J(t, e, a));
+  }
+  async _requireModule(t) {
+    const e = new AbortController();
+    this._moduleLoaderAbortController = e;
+    const a = await t;
+    return this._moduleLoaderAbortController !== e || e.signal.aborted ? { requireError: "aborted" } : { module: a };
+  }
+  _emitUndoEvent(t) {
+    this.emit("undo", { ...t, type: "undo" });
+  }
+  _emitRedoEvent(t) {
+    this.emit("redo", { ...t, type: "redo" });
+  }
+  _emitDeleteEvent(t) {
+    this.emit("delete", { ...t, type: "delete" });
+  }
+  get test() {
+    return { operationHandle: this._operationHandle, snappingManager: this.snappingManager, defaultUpdateOptions: S };
+  }
+  wait() {
+    return V(() => !this.updating);
+  }
+  _beginAsyncOperation() {
+    this._numUpdating += 1, this.notifyChange("updating");
+  }
+  _endAsyncOperation() {
+    this._numUpdating -= 1, this.notifyChange("updating");
+  }
+  _disablePopupEnabled(t) {
+    var e;
+    return ((e = this.view) == null ? void 0 : e.type) !== "3d" || this.updateOnGraphicClick || ((t == null ? void 0 : t.toggleToolOnClick) ?? !1);
+  }
+  _disablePopup(t) {
+    this._disablePopupEnabled(t) && this.view && this._originalPopupEnabled == null && (this._originalPopupEnabled = this.view.popupEnabled, this.view.popupEnabled = !1);
+  }
+  _restorePopup(t) {
+    this._disablePopupEnabled(t) && this.view && this._originalPopupEnabled != null && (this.view.popupEnabled = this._originalPopupEnabled, this._originalPopupEnabled = null);
+  }
+  async _waitViewReady() {
+    const t = this.view;
+    t ? (I(this._viewReadyAbortController), this._viewReadyAbortController = new AbortController(), await tt(V(() => t == null ? void 0 : t.ready), this._viewReadyAbortController.signal)) : this._logMissingView();
+  }
+  _logMissingView() {
+    this._logError("sketch:missing-property", z("view"));
+  }
+  _logMissingLayer() {
+    this._logError(Ot, z("layer"));
+  }
+};
+u([m()], d.prototype, "_defaultSnappingManager", void 0), u([m()], d.prototype, "updating", null), u([m()], d.prototype, "_operationHandle", void 0), u([m({ readOnly: !0 })], d.prototype, "activeTool", null), u([m()], d.prototype, "activeFillSymbol", void 0), u([m()], d.prototype, "activeLineSymbol", void 0), u([m()], d.prototype, "activeVertexSymbol", void 0), u([m()], d.prototype, "allowDeleteKey", void 0), u([m({ readOnly: !0 })], d.prototype, "createGraphic", null), u([m()], d.prototype, "defaultCreateOptions", null), u([m()], d.prototype, "defaultUpdateOptions", null), u([m({ type: ut, nonNullable: !0 })], d.prototype, "labelOptions", null), u([m()], d.prototype, "layer", void 0), u([m({ types: A })], d.prototype, "pointSymbol", void 0), u([m({ types: A })], d.prototype, "polygonSymbol", void 0), u([m({ types: A })], d.prototype, "polylineSymbol", void 0), u([m()], d.prototype, "meshSymbol", void 0), u([m({ type: B, nonNullable: !0 })], d.prototype, "snappingOptions", null), u([m()], d.prototype, "snappingManager", null), u([m({ readOnly: !0 })], d.prototype, "state", null), u([m({ type: yt, nonNullable: !0 })], d.prototype, "tooltipOptions", null), u([m({ readOnly: !0 })], d.prototype, "updateGraphics", void 0), u([m()], d.prototype, "updateOnGraphicClick", void 0), u([m({ type: mt, nonNullable: !0 })], d.prototype, "valueOptions", null), u([m({ types: A })], d.prototype, "vertexSymbol", void 0), u([m({ value: null })], d.prototype, "view", null), u([m({ constructOnly: !0, type: j })], d.prototype, "sketchOptions", void 0), d = u([ot("esri.widgets.Sketch.SketchViewModel")], d);
+const Ot = "sketch:missing-property", z = (t) => `Property '${t}' is missing on SketchViewModel.`;
+function Et(t) {
+  return t === "polygon" || t === "rectangle" || t === "circle";
+}
+function H(t, e) {
+  Y("undo", t.history.undo, t.history.redo, e);
+}
+function R(t, e) {
+  Y("redo", t.history.redo, t.history.undo, e);
+}
+function Y(t, e, a, o) {
+  const i = e.pop();
+  if (!i)
+    return;
+  const r = i.updates, p = [];
+  o.forEach((s, c) => {
+    const n = r[c];
+    n != null && ("geometry" in n && n.geometry != null && (p.push({ geometry: s.geometry }), s.geometry = n.geometry), "symbol" in n && n.symbol != null && (p.push({ symbol: s.symbol }), s.symbol = n.symbol), "undo" in n && (p.push(n), n[t](s)));
+  }), a.push({ updates: p });
+}
+function b(t) {
+  return { updates: t.map((e) => ({ geometry: e.geometry })) };
+}
+function f(t) {
+  return "requireError" in t && t.requireError === "aborted";
+}
+const de = d;
+export {
+  de as default
+};