@agrotools1/at-components 0.6.15 → 0.6.17

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/DOMContainer.js

@@ -5,13 +5,13 @@ import { on as b } from "../core/events.js";
 import z from "../core/has.js";
 import M from "../core/Logger.js";
 import { destroyMaybe as R, removeMaybe as T } from "../core/maybe.js";
-import { watch as d, initial as g, whenOnce as k } from "../core/reactiveUtils.js";
+import { watch as d, initial as g, whenOnce as $ } from "../core/reactiveUtils.js";
 import { addFrameTask as _ } from "../core/scheduling.js";
 import { property as r } from "../core/accessorSupport/decorators/property.js";
 import "../core/RandomLCG.js";
-import { subclass as q } from "../core/accessorSupport/decorators/subclass.js";
+import { subclass as k } from "../core/accessorSupport/decorators/subclass.js";
 import v from "./overlay/ViewOverlay.js";
-import { onLocaleChange as $ } from "../intl/locale.js";
+import { onLocaleChange as q } from "../intl/locale.js";
 import { fetchMessageBundle as I } from "../intl/messages.js";
 const m = [0, 0];
 function A(h) {
@@ -38,10 +38,10 @@ const u = 16, c = 750, D = 512, E = 2, Q = (h) => {
     }
     initialize() {
       const e = z("mac"), s = async () => {
-        e && (await k(() => this.ready), this.messagesCommon = await I("esri/t9n/common").catch(() => {
+        e && (await $(() => this.ready), this.messagesCommon = await I("esri/t9n/common").catch(() => {
         }));
       };
-      s(), this.addHandles([d(() => this.ui, (t, i) => this._handleUIChange(t, i), g), this.on("focus", () => this.notifyChange("focused")), this.on("blur", () => this.notifyChange("focused")), $(s), d(() => [this.surface, this.messagesCommon], () => {
+      s(), this.addHandles([d(() => this.ui, (t, i) => this._handleUIChange(t, i), g), this.on("focus", () => this.notifyChange("focused")), this.on("blur", () => this.notifyChange("focused")), q(s), d(() => [this.surface, this.messagesCommon], () => {
         var t, i, a;
         e && ((a = this.surface) == null || a.setAttribute("aria-label", ((i = (t = this.messagesCommon) == null ? void 0 : t.ariaLabels) == null ? void 0 : i.navigationMacVoiceOver) ?? ""));
       })]);
@@ -131,7 +131,7 @@ const u = 16, c = 750, D = 512, E = 2, Q = (h) => {
     forceDOMReadyCycle() {
     }
   };
-  return o([r()], n.prototype, "container", null), o([r({ readOnly: !0 })], n.prototype, "focused", null), o([r({ readOnly: !0 })], n.prototype, "height", void 0), o([r()], n.prototype, "messagesCommon", void 0), o([r({ type: v })], n.prototype, "overlay", void 0), o([r({ readOnly: !0 })], n.prototype, "position", void 0), o([r({ readOnly: !0 })], n.prototype, "resizing", void 0), o([r({ readOnly: !0 })], n.prototype, "root", void 0), o([r({ value: null, readOnly: !0 })], n.prototype, "size", null), o([r({ readOnly: !0 })], n.prototype, "surface", void 0), o([r({ readOnly: !0 })], n.prototype, "suspended", void 0), o([r()], n.prototype, "ui", void 0), o([r({ readOnly: !0 })], n.prototype, "userContent", void 0), o([r({ readOnly: !0 })], n.prototype, "width", void 0), o([r()], n.prototype, "widthBreakpoint", void 0), n = o([q("esri.views.DOMContainer")], n), n;
+  return o([r()], n.prototype, "container", null), o([r({ readOnly: !0 })], n.prototype, "focused", null), o([r({ readOnly: !0 })], n.prototype, "height", void 0), o([r()], n.prototype, "messagesCommon", void 0), o([r({ type: v })], n.prototype, "overlay", void 0), o([r({ readOnly: !0 })], n.prototype, "position", void 0), o([r({ readOnly: !0 })], n.prototype, "resizing", void 0), o([r({ readOnly: !0 })], n.prototype, "root", void 0), o([r({ value: null, readOnly: !0 })], n.prototype, "size", null), o([r({ readOnly: !0 })], n.prototype, "surface", void 0), o([r({ readOnly: !0 })], n.prototype, "suspended", void 0), o([r()], n.prototype, "ui", void 0), o([r({ readOnly: !0 })], n.prototype, "userContent", void 0), o([r({ readOnly: !0 })], n.prototype, "width", void 0), o([r()], n.prototype, "widthBreakpoint", void 0), n = o([k("esri.views.DOMContainer")], n), n;
 };
 export {
   Q as DOMContainer

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

@@ -0,0 +1,397 @@
+import { _ as n } from "../../chunks/tslib.es6.js";
+import U from "../../Graphic.js";
+import Z from "../../core/Evented.js";
+import { makeHandle as O } from "../../core/handleUtils.js";
+import { destroyMaybe as x } from "../../core/maybe.js";
+import { createLength as L, zeroMeters as f, zeroSquareMeters as I, zeroDegreesGeographic as $, valueInUnit as F } from "../../core/quantityUtils.js";
+import { watch as q, syncAndInitial as B } from "../../core/reactiveUtils.js";
+import { getMetersPerVerticalUnitForSR as S } from "../../core/unitUtils.js";
+import { property as a } from "../../core/accessorSupport/decorators/property.js";
+import "../../core/has.js";
+import "../../core/Logger.js";
+import "../../core/RandomLCG.js";
+import { subclass as K } from "../../core/accessorSupport/decorators/subclass.js";
+import N from "../../layers/GraphicsLayer.js";
+import { pointEquals as X } from "../../layers/graphics/dehydratedFeatureComparison.js";
+import { absoluteHeightElevationInfo as j, getConvertedElevationFromXYZ as J } from "../../support/elevationInfoUtils.js";
+import { createCircle as z, createEllipse as Q, createSquare as D, createRectangle as W, createPolygon as Y, createPolyline as P, createMultipoint as ee } from "./support/createUtils.js";
+import { getDrawHelpMessage as k } from "./support/helpMessageUtils.js";
+import { createViewAlignedCoordinateSystem as te } from "./support/surfaceCoordinateSystems.js";
+import { InteractiveToolBase as oe } from "../interactive/InteractiveToolBase.js";
+import { tooltipKeys as ie } from "../interactive/keybindings.js";
+import R from "../interactive/sketch/SketchOptions.js";
+import { getConstraintContext as M } from "../interactive/tooltip/constraintUtils.js";
+import { DrawPointTooltipInfo as re, DrawPolylineTooltipInfo as ne, DrawPolygonTooltipInfo as ae, DrawMeshTooltipInfo as se, DrawRectangleTooltipInfo as le, DrawCircleTooltipInfo as ce } from "../interactive/tooltip/DrawTooltipInfos.js";
+import { Tooltip as pe } from "../interactive/tooltip/Tooltip.js";
+import { directionForVertices as ue } from "../support/angularMeasurementUtils.js";
+import { autoArea2D as H } from "../support/automaticAreaMeasurementUtils.js";
+import { autoLength2D as he, autoDistanceBetweenPoints2D as _ } from "../support/automaticLengthMeasurementUtils.js";
+import { elevationFromPoint as de, elevationFromZ as me } from "../support/euclideanLengthMeasurementUtils.js";
+import { autorun as A } from "../../core/accessorSupport/trackingUtils.js";
+class ye {
+  constructor() {
+    this.committedVertices = null, this.cursorVertex = null, this.full = null, this.outline = null, this.cursorEdge = null, this.circle = null, this.rectangle = null;
+  }
+}
+let r = class extends Z.EventedMixin(oe) {
+  constructor(e) {
+    super(e), this._graphic = null, this._createOperationGeometry = null, this.defaultZ = 0, this.directionOptions = null, this.geometryType = null, this.hasZ = !0, this.geometryToPlace = null, this.mode = null, this.snappingManager = null, this.snapToScene = !1, this.sketchOptions = new R();
+  }
+  initialize() {
+    this.internalGraphicsLayer = new N({ listMode: "hide", internal: !0 }), this.view.map.layers.add(this.internalGraphicsLayer);
+    const e = this.drawOperation = this.makeDrawOperation(), { sketchOptions: t } = this, o = this.view.type;
+    this.tooltipInfos = { point: new re({ sketchOptions: t, viewType: o }), polyline: new ne({ sketchOptions: t, viewType: o }), polygon: new ae({ sketchOptions: t, viewType: o }), mesh: new se({ sketchOptions: t, viewType: o }), rectangle: new le({ sketchOptions: t }), circle: new ce({ sketchOptions: t }) }, this.tooltip = new pe({ view: this.view }), this._initializeConstraints(), this.addHandles([e.on("vertex-add", (i) => this.onVertexAdd(i)), e.on("vertex-remove", (i) => this.onVertexRemove(i)), e.on("vertex-update", (i) => this.onVertexUpdate(i)), e.on("cursor-update", (i) => this.onCursorUpdate(i)), e.on("cursor-remove", () => this._updateGraphic()), e.on("complete", (i) => this.onComplete(i)), q(() => this.cursor, (i) => e.cursor = i, B), A(() => this._updateTooltipInfo()), A(() => {
+      e.constraintZ = this._constraintZ;
+    })]), this.finishToolCreation();
+  }
+  destroy() {
+    this.drawOperation = x(this.drawOperation), this.tooltip = x(this.tooltip), this._destroyAllVisualizations(), this.view.map.remove(this.internalGraphicsLayer), this.internalGraphicsLayer = x(this.internalGraphicsLayer), this._set("view", null);
+  }
+  get _defaultElevation() {
+    const e = S(this.drawOperation.coordinateHelper.spatialReference);
+    return L(this.defaultZ * e, "meters");
+  }
+  get _inputModeAvailable() {
+    var o;
+    const { inputEnabled: e, visibleElements: t } = this.sketchOptions.tooltips;
+    return e && ((o = this.activeTooltipInfo) == null ? void 0 : o.editableFields.some((i) => t[i.name] === !0)) === !0;
+  }
+  get canRedo() {
+    return this.drawOperation.canRedo;
+  }
+  get canUndo() {
+    return this.drawOperation.canUndo;
+  }
+  set centered(e) {
+    this._set("centered", e), this._updateGraphic();
+  }
+  get cursor() {
+    return this._get("cursor");
+  }
+  set cursor(e) {
+    this._set("cursor", e);
+  }
+  set enabled(e) {
+    this.drawOperation.interactive = e, this._set("enabled", e);
+  }
+  set forceUniformSize(e) {
+    this._set("forceUniformSize", e), this._updateGraphic();
+  }
+  get graphic() {
+    return this._graphic;
+  }
+  set graphicSymbol(e) {
+    this._set("graphicSymbol", e), this._graphic != null && (this._graphic.symbol = e);
+  }
+  get updating() {
+    var e;
+    return ((e = this.drawOperation) == null ? void 0 : e.updating) ?? !1;
+  }
+  completeCreateOperation() {
+    this.drawOperation.complete();
+  }
+  onInputEvent(e) {
+    if (!this.destroyed)
+      return e.type === "key-down" && e.key === ie.enterInputMode && this._inputModeAvailable ? (this.tooltip.enterInputMode(), void e.stopPropagation()) : void this.drawOperation.onInputEvent(e);
+  }
+  redo() {
+    this.drawOperation.redo();
+  }
+  reset() {
+  }
+  undo() {
+    this.drawOperation.undo(), this.drawOperation.numCommittedVertices === 0 && this._initializeConstraints();
+  }
+  _destroyAllVisualizations() {
+    this.removeHandles(m.outline), this.removeHandles(m.regularVertices), this.removeHandles(m.activeVertex), this.removeHandles(m.activeEdge), this.removeHandles(C);
+  }
+  _createOrUpdateGraphic(e) {
+    if (this._graphic != null)
+      return this.updateGraphicGeometry(e), this._graphic;
+    const t = new U({ ...this.graphicProperties, symbol: this.graphicSymbol });
+    return this._graphic = t, this.updateGraphicGeometry(e), this.internalGraphicsLayer.add(t), this.addHandles(this.initializeGraphic(t)), this.notifyChange("graphic"), this.addHandles(O(() => {
+      this.internalGraphicsLayer.remove(t), this._graphic === t && (this._graphic = null);
+    }), C), t;
+  }
+  updateGraphicGeometry(e) {
+    this._graphic.geometry = e;
+  }
+  _getCreateOperationGeometry(e = { operationComplete: !1 }) {
+    var G, b;
+    if (this.drawOperation == null)
+      return;
+    const { coordinateHelper: t, view: o, visualizationCursorVertex: i, lastVertex: l, committedVertices: c, geometryIncludingUncommittedVertices: u, numCommittedVertices: h } = this.drawOperation;
+    if (!(h > 0 || i != null))
+      return;
+    const s = e.operationComplete ? c : u, d = s.length, y = i != null ? t.pointToArray(i) : null, v = o.spatialReference, T = o.type === "3d" && o.viewingMode === "global", p = new ye();
+    p.committedVertices = c, p.cursorVertex = y;
+    const { geometryType: V } = this;
+    switch (V) {
+      case "point":
+      case "mesh":
+        p.full = t.arrayToPoint(s[0]);
+        break;
+      case "multipoint":
+        p.full = d > 0 ? ee(s, v) : null;
+        break;
+      case "polyline":
+      case "polygon":
+        d > 0 && (p.full = V === "polygon" ? Y([s], v, T, !0) : P([s], v, T), p.cursorEdge = y != null && l && !X(i, l) ? P([[y, t.pointToArray(l)]], v, T) : null, p.outline = d > 1 ? p.full : null);
+        break;
+      case "circle":
+      case "rectangle": {
+        if (p.committedVertices = p.cursorVertex = null, !d)
+          break;
+        const g = te(o, s[0]), w = s[0], E = g.makeMapPoint(w[0] + ve * o.resolution, w[1]);
+        V === "circle" ? d === 1 && e.operationComplete ? p.circle = z([w, E], g, !0) : d === 2 && (this.forceUniformSize ? p.circle = z(s, g, this.centered) : p.rectangle = Q(s, g, this.centered)) : d === 1 && e.operationComplete ? p.rectangle = D([w, E], g, !0) : d === 2 && (p.rectangle = this.forceUniformSize ? D(s, g, this.centered) : W(s, g, this.centered)), p.full = p.circle != null ? p.circle.geometry : (G = p.rectangle) == null ? void 0 : G.geometry, p.outline = ((b = p.full) == null ? void 0 : b.type) === "polygon" ? p.full : null;
+        break;
+      }
+      default:
+        return null;
+    }
+    return p;
+  }
+  initializeGraphic(e) {
+    return O();
+  }
+  onComplete(e) {
+    if (!this.drawOperation)
+      return;
+    this._updateGraphic();
+    let t = null;
+    if (this.drawOperation.isCompleted) {
+      const o = this._getCreateOperationGeometry({ operationComplete: !0 });
+      o != null && (t = this._createOrUpdateGraphic(o.full));
+    }
+    this._createOperationGeometry = null, this.emit("complete", { graphic: t, ...e });
+  }
+  onCursorUpdate(e) {
+    this._updateGraphic(), this.emit("cursor-update", e);
+  }
+  onDeactivate() {
+    const { drawOperation: e } = this;
+    e && (e.isCompleted || e.cancel());
+  }
+  onOutlineChanged(e) {
+    return O();
+  }
+  onCursorEdgeChanged(e) {
+    return O();
+  }
+  onVertexAdd(e) {
+    var t;
+    this._updateGraphic(), this._unlockConstraintsOnVertexAddOrRemove(), this._lockElevationOnVertexAdd((t = e.vertices.at(0)) == null ? void 0 : t.coordinates), this.emit("vertex-add", e);
+  }
+  onVertexRemove(e) {
+    this._updateGraphic(), this._unlockConstraintsOnVertexAddOrRemove(), this.emit("vertex-remove", e);
+  }
+  onVertexUpdate(e) {
+    this._updateGraphic(), this.emit("vertex-update", e);
+  }
+  _updateGraphic() {
+    const e = this._getCreateOperationGeometry();
+    this._createOperationGeometry = e, e != null ? (e.cursorEdge != null ? this.addHandles(this.onCursorEdgeChanged(e.cursorEdge), m.activeEdge) : this.removeHandles(m.activeEdge), e.outline != null ? this.addHandles(this.onOutlineChanged(e.outline), m.outline) : this.removeHandles(m.outline), e.committedVertices != null ? this.addHandles(this.onRegularVerticesChanged(e.committedVertices), m.regularVertices) : this.removeHandles(m.regularVertices), e.cursorVertex != null ? this.addHandles(this.onActiveVertexChanged(e.cursorVertex), m.activeVertex) : this.removeHandles(m.activeVertex), e.full != null ? this._createOrUpdateGraphic(e.full) : this.removeHandles(C)) : this._destroyAllVisualizations();
+  }
+  get activeTooltipInfo() {
+    var c;
+    const { drawOperation: e, graphic: t, view: o } = this;
+    if (!e)
+      return null;
+    const i = this.tooltipInfos, l = (c = t == null ? void 0 : t.geometry) == null ? void 0 : c.type;
+    switch (this.geometryType) {
+      case "point":
+        return o.type === "2d" && this.defaultZ === 0 ? null : l === "point" ? i.point : null;
+      case "polyline":
+        return l === "polyline" ? i.polyline : null;
+      case "polygon":
+        return l === "polygon" ? i.polygon : null;
+      case "rectangle":
+        return l === "polygon" ? i.rectangle : null;
+      case "circle":
+        return l === "polygon" ? i.circle : null;
+      case "mesh":
+        return l === "mesh" ? i.mesh : null;
+      default:
+        return null;
+    }
+  }
+  _updateTooltipInfo() {
+    const { activeTooltipInfo: e, tooltip: t, sketchOptions: o } = this;
+    switch (e == null ? void 0 : e.type) {
+      case "draw-point":
+        this._updateDrawPointTooltipInfo(e);
+        break;
+      case "draw-polyline":
+        this._updateDrawPolylineTooltipInfo(e);
+        break;
+      case "draw-polygon":
+        this._updateDrawPolygonTooltipInfo(e);
+        break;
+      case "draw-rectangle":
+        this._updateDrawRectangleTooltipInfo(e);
+        break;
+      case "draw-circle":
+        this._updateDrawCircleTooltipInfo(e);
+        break;
+      case "draw-mesh":
+        this.updateDrawMeshTooltipInfo(e);
+    }
+    t.view = this.view, t.info = o.tooltips.effectiveEnabled ? e : null;
+  }
+  _updateDrawPointTooltipInfo(e) {
+    const { drawOperation: t, graphic: o, view: i, sketchOptions: l } = this, { coordinateHelper: c, cursorVertex: u } = t;
+    if (e.sketchOptions = l, e.viewType = i.type, e.helpMessage = k("point", o == null ? void 0 : o.geometry), this.updateElevation(e.elevation), !u)
+      return void (t.constraintInfo = void 0);
+    const h = M(u, i, c.spatialReference, this._constraintElevationInfo, c.hasZ(), l.values.effectiveDirectionMode);
+    t.constraintInfo = { context: h, distance: null, direction: null, elevation: e.elevation.committed };
+  }
+  _updateDrawPolylineTooltipInfo(e) {
+    const t = this._createOperationGeometry, o = t != null ? t.full : null;
+    if ((o == null ? void 0 : o.type) !== "polyline")
+      return;
+    this._updatePolylineOrPolygonCommon(e);
+    const i = he(o);
+    e.totalLength.actual = i ?? f, e.sketchOptions = this.sketchOptions, e.viewType = this.view.type, e.helpMessage = k("polyline", o);
+  }
+  _updateDrawPolygonTooltipInfo(e) {
+    const t = this._createOperationGeometry, o = t != null ? t.full : null;
+    if ((o == null ? void 0 : o.type) !== "polygon")
+      return;
+    this._updatePolylineOrPolygonCommon(e);
+    const i = H(o);
+    e.area.actual = i ?? I, e.sketchOptions = this.sketchOptions, e.viewType = this.view.type, e.helpMessage = k("polygon", o);
+  }
+  _updatePolylineOrPolygonCommon(e) {
+    const { view: t, drawOperation: o, sketchOptions: i } = this, { coordinateHelper: l, cursorVertex: c, lastVertex: u, secondToLastVertex: h } = o, s = i.values.effectiveDirectionMode, d = u && c ? _(u, c) : null;
+    if (e.distance.actual = d ?? f, e.distance.readOnly = u == null, e.direction.actual = null, e.direction.readOnly = !0, u && c && (s === "absolute" || h)) {
+      const v = ue(h, u, c, s);
+      e.direction.actual = v ?? $, e.direction.readOnly = !1;
+    }
+    this.updateElevation(e.elevation);
+    const y = c ?? u;
+    if (y) {
+      const v = M(y, t, l.spatialReference, this._constraintElevationInfo, l.hasZ(), s);
+      o.constraintInfo = { context: v, distance: e.distance.committed, direction: e.direction.committed, elevation: e.elevation.committed };
+    } else
+      o.constraintInfo = void 0;
+  }
+  updateDrawMeshTooltipInfo(e) {
+  }
+  _updateDrawRectangleTooltipInfo(e) {
+    e.sketchOptions = this.sketchOptions, e.xSize = this._xSize ?? f, e.ySize = this._ySize ?? f, e.area = this._fullGeometryArea ?? I;
+  }
+  _updateDrawCircleTooltipInfo(e) {
+    const { forceUniformSize: t } = this;
+    e.sketchOptions = this.sketchOptions, e.radius = t ? this._circleRadius ?? f : null, e.xSize = t ? null : this._xSize ?? f, e.ySize = t ? null : this._ySize ?? f, e.area = this._fullGeometryArea ?? I;
+  }
+  get _circleRadius() {
+    var t;
+    const e = this._createOperationGeometry;
+    return ((t = e == null ? void 0 : e.circle) == null ? void 0 : t.center) != null && e.circle.edge != null ? _(e.circle.center, e.circle.edge) : null;
+  }
+  get _xSize() {
+    var t, o;
+    const e = (o = (t = this._createOperationGeometry) == null ? void 0 : t.rectangle) == null ? void 0 : o.midpoints;
+    return e != null ? _(e.left, e.right) : null;
+  }
+  get _ySize() {
+    var t, o;
+    const e = (o = (t = this._createOperationGeometry) == null ? void 0 : t.rectangle) == null ? void 0 : o.midpoints;
+    return e != null ? _(e.top, e.bottom) : null;
+  }
+  get _fullGeometryArea() {
+    var t;
+    const e = (t = this._createOperationGeometry) == null ? void 0 : t.full;
+    return (e == null ? void 0 : e.type) !== "polygon" ? null : H(e);
+  }
+  updateElevation(e) {
+    const { drawOperation: t } = this, o = (t == null ? void 0 : t.cursorVertex) ?? (t == null ? void 0 : t.lastVertex);
+    e.actual = de(o) ?? this._defaultElevation, e.visible = this.view.type === "3d" && this.hasZ, e.readOnly = !1;
+  }
+  get _constraintElevationInfo() {
+    var e;
+    return ((e = this.drawOperation) == null ? void 0 : e.elevationInfo) ?? j;
+  }
+  get _constraintZ() {
+    const { geometryType: e } = this;
+    switch (e) {
+      case "point":
+      case "mesh":
+      case "polyline":
+      case "polygon": {
+        const t = this.tooltipInfos[e].elevation.committed;
+        if (!t)
+          return;
+        const o = this.drawOperation.coordinateHelper.spatialReference;
+        return F(t, "meters") / S(o);
+      }
+      default:
+        return;
+    }
+  }
+  _initializeConstraints() {
+    const { directionOptions: e, drawOperation: t, geometryType: o, tooltipInfos: i, sketchOptions: l } = this, c = (h) => {
+      var y;
+      const s = (y = t.elevationInfo) == null ? void 0 : y.mode, d = i[h].elevation;
+      s === "relative-to-ground" || s === "relative-to-scene" || s === "on-the-ground" ? d.lock(this._defaultElevation) : d.unlock();
+    }, u = (h) => {
+      if (e) {
+        const s = i[h].direction;
+        s.committed = e.angle, s.unlockOnVertexPlacement = !1, l.values.directionMode = e.mode;
+      }
+    };
+    switch (o) {
+      case "polygon":
+      case "polyline":
+        c(o), u(o);
+        break;
+      case "point":
+      case "mesh":
+        c(o);
+    }
+  }
+  _lockElevationOnVertexAdd(e) {
+    const { activeTooltipInfo: t, drawOperation: o, view: i } = this, l = this._constraintElevationInfo;
+    if (i.type === "2d" || !e || l.mode !== "absolute-height" || (o == null ? void 0 : o.numCommittedVertices) !== 1 || !t || t.type !== "draw-polyline" && t.type !== "draw-polygon" || t.elevation.locked)
+      return;
+    const [c, u, h] = e, s = this._getConvertedVertexElevation(c, u, h, l);
+    s != null && t.elevation.lock(s);
+  }
+  _unlockConstraintsOnVertexAddOrRemove() {
+    var e;
+    (e = this.activeTooltipInfo) == null || e.allFields.forEach((t) => {
+      t.unlockOnVertexPlacement && t.unlock();
+    });
+  }
+  _getConvertedVertexElevation(e, t, o, i) {
+    const { view: l, drawOperation: c } = this;
+    if (l.type !== "3d" || !c)
+      return;
+    const { spatialReference: u } = c.coordinateHelper;
+    o ?? (o = 0);
+    const h = c.elevationInfo, s = J(l, e, t, o, u, h, i);
+    return me(s, u) ?? this._defaultElevation;
+  }
+};
+n([a()], r.prototype, "_createOperationGeometry", void 0), n([a()], r.prototype, "_defaultElevation", null), n([a()], r.prototype, "_inputModeAvailable", null), n([a({ value: !0 })], r.prototype, "centered", null), n([a()], r.prototype, "cursor", null), n([a({ nonNullable: !0 })], r.prototype, "defaultZ", void 0), n([a({ constructOnly: !0 })], r.prototype, "directionOptions", void 0), n([a()], r.prototype, "drawOperation", void 0), n([a({ value: !0 })], r.prototype, "enabled", null), n([a({ value: !0 })], r.prototype, "forceUniformSize", null), n([a({ constructOnly: !0 })], r.prototype, "geometryType", void 0), n([a()], r.prototype, "graphic", null), n([a({ constructOnly: !0 })], r.prototype, "graphicProperties", void 0), n([a()], r.prototype, "graphicSymbol", null), n([a({ constructOnly: !0 })], r.prototype, "hasZ", void 0), n([a({ constructOnly: !0 })], r.prototype, "geometryToPlace", void 0), n([a({ constructOnly: !0 })], r.prototype, "mode", void 0), n([a()], r.prototype, "snappingManager", void 0), n([a()], r.prototype, "snapToScene", void 0), n([a()], r.prototype, "tooltip", void 0), n([a()], r.prototype, "tooltipInfos", void 0), n([a({ constructOnly: !0, type: R })], r.prototype, "sketchOptions", void 0), n([a({ readOnly: !0 })], r.prototype, "updating", null), n([a({ constructOnly: !0, nonNullable: !0 })], r.prototype, "view", void 0), n([a()], r.prototype, "activeTooltipInfo", null), n([a()], r.prototype, "_circleRadius", null), n([a()], r.prototype, "_xSize", null), n([a()], r.prototype, "_ySize", null), n([a()], r.prototype, "_fullGeometryArea", null), n([a()], r.prototype, "_constraintElevationInfo", null), n([a()], r.prototype, "_constraintZ", null), r = n([K("esri.views.draw.DrawGraphicTool")], r);
+const C = Symbol("create-operation-graphic"), m = { outline: Symbol("outline-visual"), regularVertices: Symbol("regular-vertices-visual"), activeVertex: Symbol("active-vertex-visual"), activeEdge: Symbol("active-edge-visual") };
+function Ne(e) {
+  switch (e) {
+    case "point":
+    case "polyline":
+    case "polygon":
+    case "multipoint":
+      return e;
+    case "circle":
+    case "rectangle":
+      return "segment";
+    case "mesh":
+      return "point";
+  }
+}
+const ve = 48;
+export {
+  ye as CreateOperationGeometry,
+  r as DrawGraphicTool,
+  Ne as geometryTypeToDrawOperationGeometryType
+};

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

@@ -2,7 +2,7 @@ import { _ as s } from "../../chunks/tslib.es6.js";
 import H from "../../core/Accessor.js";
 import G from "../../core/Evented.js";
 import { clone as V } from "../../core/lang.js";
-import { equalsMaybe as Z, destroyMaybe as v } from "../../core/maybe.js";
+import { destroyMaybe as v, equalsMaybe as Z } from "../../core/maybe.js";
 import { memoize as w } from "../../core/memoize.js";
 import { ignoreAbortErrors as O } from "../../core/promiseUtils.js";
 import { watch as _, syncAndInitial as M } from "../../core/reactiveUtils.js";

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

@@ -0,0 +1,126 @@
+import { _ as o } from "../../chunks/tslib.es6.js";
+import v from "../../core/Evented.js";
+import { makeHandle as f } from "../../core/handleUtils.js";
+import { destroyMaybe as T } from "../../core/maybe.js";
+import { property as i } from "../../core/accessorSupport/decorators/property.js";
+import "../../core/has.js";
+import "../../core/Logger.js";
+import "../../core/RandomLCG.js";
+import { subclass as O } from "../../core/accessorSupport/decorators/subclass.js";
+import { IDENTITY as _ } from "../../core/libs/gl-matrix-2/factories/mat2df64.js";
+import { DrawOperation as I } from "./DrawOperation.js";
+import { ScreenDrawSurface as y } from "./drawSurfaces.js";
+import { createCircle as S, createSquare as D, createEllipse as b, createRectangle as V } from "./support/createUtils.js";
+import { AffineCoordinateSystem as $ } from "./support/surfaceCoordinateSystems.js";
+import { InteractiveToolBase as x } from "../interactive/InteractiveToolBase.js";
+import C from "../overlay/OutlineOverlayItem.js";
+let t = class extends v.EventedMixin(x) {
+  constructor(e) {
+    super(e), this._overlayItem = void 0, this.geometryType = null, this.mode = null, this.type = "draw-screen";
+  }
+  initialize() {
+    this.drawOperation = this._makeDrawOperation();
+    const e = (r) => this.drawOperation.on(r, (a) => {
+      this._updateVisuals(), this.emit(r, a);
+    });
+    this.addHandles([e("vertex-add"), e("vertex-remove"), e("vertex-update"), e("cursor-update"), e("complete")]), this.finishToolCreation();
+  }
+  destroy() {
+    this.drawOperation = T(this.drawOperation), this._set("view", null);
+  }
+  get canRedo() {
+    return this.drawOperation.canRedo;
+  }
+  get canUndo() {
+    return this.drawOperation.canUndo;
+  }
+  set centeredToggled(e) {
+    this._set("centeredToggled", e), this._updateVisuals();
+  }
+  set enabled(e) {
+    this.drawOperation.interactive = e, this._set("enabled", e);
+  }
+  set uniformSizeToggled(e) {
+    this._set("uniformSizeToggled", e), this._updateVisuals();
+  }
+  get updating() {
+    var e;
+    return ((e = this.drawOperation) == null ? void 0 : e.updating) ?? !1;
+  }
+  get cursor() {
+    return this.geometryType === "point" ? "default" : "crosshair";
+  }
+  completeCreateOperation() {
+    this.drawOperation.complete();
+  }
+  onInputEvent(e) {
+    this.destroyed || this.drawOperation.onInputEvent(e);
+  }
+  redo() {
+    this.drawOperation.redo();
+  }
+  undo() {
+    this.drawOperation.undo();
+  }
+  reset() {
+  }
+  _makeDrawOperation() {
+    const { view: e } = this;
+    return new I({ view: e, manipulators: this.manipulators, geometryType: k(this.geometryType), drawingMode: this.mode, hasZ: !1, defaultZ: 0, snapToSceneEnabled: !1, drawSurface: new y(), hasM: !1, snappingManager: null, snappingVisualizer: null, graphic: null, cursor: this.cursor });
+  }
+  get coordinates() {
+    var c, m, u;
+    const { drawOperation: e } = this;
+    if (!(e != null && e.geometryIncludingUncommittedVertices.length))
+      return [];
+    const { coordinateHelper: r } = e, a = e.committableVertex, s = e.committedVertices.slice();
+    a != null && s.push(r.pointToArray(a));
+    const d = s.length;
+    switch (this.geometryType) {
+      case "circle":
+      case "rectangle": {
+        const p = new $(_, y.spatialReference), h = this.geometryType === "circle" ? S : D, g = this.geometryType === "circle" ? b : V;
+        if (d === 1 && e.isCompleted) {
+          const n = s[0], l = p.makeMapPoint(n[0] + z, n[1]);
+          return ((c = h([n, l], p, !0)) == null ? void 0 : c.geometry.rings[0]) ?? [];
+        }
+        if (d === 2) {
+          const n = this.geometryType !== "rectangle", l = this.centeredToggled !== n, w = this.geometryType !== "rectangle";
+          return (this.uniformSizeToggled !== w ? (m = h(s, p, l)) == null ? void 0 : m.geometry.rings[0] : (u = g(s, p, l)) == null ? void 0 : u.geometry.rings[0]) ?? [];
+        }
+        return [];
+      }
+    }
+    return s;
+  }
+  _updateVisuals() {
+    var e;
+    if (!this._overlayItem) {
+      const r = new C({ strokeDash: [5], strokeDashColor: [255, 255, 255, 255] });
+      (e = this.view.overlay) == null || e.addItem(r), this.addHandles(f(() => {
+        var a;
+        (a = this.view.overlay) == null || a.removeItem(r), r == null || r.destroy(), this._overlayItem = void 0;
+      })), this._overlayItem = r;
+    }
+    this._overlayItem.coordinates = this.coordinates;
+  }
+  onDeactivate() {
+    this.drawOperation.isCompleted || this.drawOperation.cancel();
+  }
+};
+function k(e) {
+  switch (e) {
+    case "polygon":
+    case "point":
+      return e;
+    case "circle":
+    case "rectangle":
+      return "segment";
+  }
+}
+o([i({ value: !1 })], t.prototype, "centeredToggled", null), o([i()], t.prototype, "drawOperation", void 0), o([i({ value: !0 })], t.prototype, "enabled", null), o([i({ value: !1 })], t.prototype, "uniformSizeToggled", null), o([i({ constructOnly: !0 })], t.prototype, "geometryType", void 0), o([i({ constructOnly: !0 })], t.prototype, "mode", void 0), o([i({ readOnly: !0 })], t.prototype, "type", void 0), o([i({ readOnly: !0 })], t.prototype, "updating", null), o([i({ constructOnly: !0, nonNullable: !0 })], t.prototype, "view", void 0), o([i()], t.prototype, "cursor", null), t = o([O("esri.views.draw.DrawScreenTool")], t);
+const z = 48;
+export {
+  t as DrawScreenTool,
+  k as geometryTypeToDrawOperationGeometryType
+};