@agrotools1/at-components 0.6.16 → 0.6.17

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/interactive/editingTools/reshapeGraphic/edgeOffsetUtils.js

@@ -0,0 +1,39 @@
+import { createRenderScreenPointArray3 as c } from "../../../../../core/screenUtils.js";
+import { fromValues as p } from "../../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { b as f, E as u, p as g, f as R } from "../../../../../chunks/vec32.js";
+import { create as a } from "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { getNormal as m, fromPositionAndNormal as C, create as E } from "../../../../../geometry/support/plane.js";
+import { makeDehydratedPoint as x } from "../../../../../layers/graphics/dehydratedPoint.js";
+import { PlaneType as i, OffsetEdgeVertex as O } from "../../../../interactive/editGeometry/operations/OffsetEdgeVertex.js";
+function Y(o, e, n) {
+  const t = n.mode === "on-the-ground" ? i.XY : i.XYZ;
+  return new O(o, t, e, 0);
+}
+function A(o, e, n) {
+  const t = a();
+  if (!o.renderCoordsHelper.toRenderCoords(e, t))
+    return null;
+  const r = l(o, e, m(n.plane)), s = l(o, e, n.edgeDirection);
+  if (r == null || s == null)
+    return null;
+  const d = f(a(), r, s);
+  return C(t, d, E());
+}
+function l(o, e, n) {
+  const t = x(e.x + n[0], e.y + n[1], e.z + n[2], e.spatialReference), r = a(), s = a();
+  return o.renderCoordsHelper.toRenderCoords(e, r) && o.renderCoordsHelper.toRenderCoords(t, s) ? u(s, r, s) : null;
+}
+function D(o, e, n) {
+  const t = m(o), r = u(a(), e, n), s = f(a(), r, t), d = f(a(), r, s);
+  return p(r[0], r[1], r[2], 0, s[0], s[1], s[2], 0, d[0], d[1], d[2], 0, 0, 0, 0, 1);
+}
+function N(o, e, n) {
+  const t = n.projectToRenderScreen(o, c()), r = n.projectToRenderScreen(e, c());
+  return t != null && r != null ? g(R(t, t, r)) : 0;
+}
+export {
+  A as createEdgeOffsetIntersectionPlane,
+  Y as createEdgeOffsetOperation,
+  D as edgeOffsetRotationMatrix,
+  N as screenEdgeLengthSquared
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/interactive/editingTools/reshapeGraphic/isSupportedGraphic.js

@@ -0,0 +1,25 @@
+import l from "../../../../../geometry/Circle.js";
+import { getGraphicEffectiveElevationMode as i, hasGraphicFeatureExpressionInfo as p } from "../../../../../support/elevationInfoUtils.js";
+import { SupportedGraphicResult as r } from "../isSupportedGraphicUtils.js";
+function E(e) {
+  return n(e).result;
+}
+function c(e) {
+  return n(e).geometry;
+}
+function n(e) {
+  var u;
+  if (((u = e.layer) == null ? void 0 : u.type) !== "graphics")
+    return { result: r.GRAPHICS_LAYER_MISSING, geometry: null };
+  const { geometry: o } = e;
+  if (o == null)
+    return { result: r.GEOMETRY_MISSING, geometry: null };
+  if (i(e) !== "on-the-ground" && p(e))
+    return { result: r.ELEVATION_MODE_UNSUPPORTED, geometry: null };
+  const t = o.type;
+  return t !== "point" && t !== "mesh" && t !== "polyline" && (t !== "polygon" || e.geometry instanceof l) ? { result: r.GEOMETRY_TYPE_UNSUPPORTED, geometry: null } : { result: r.SUPPORTED, geometry: o };
+}
+export {
+  c as geometryOfSupportedGraphic,
+  E as isSupportedGraphic
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/interactive/editingTools/settings.js

@@ -0,0 +1,124 @@
+import { _ as n } from "../../../../chunks/tslib.es6.js";
+import o from "../../../../Color.js";
+import w from "../../../../core/Accessor.js";
+import { getContrast as O, desaturate as m, multiplyOpacity as p, unitRGBAFromColor as s } from "../../../../core/colorUtils.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 y } from "../../../../core/accessorSupport/decorators/subclass.js";
+import { ExtensionType as C } from "../visualElements/ExtendedLineVisualElement.js";
+import { RenderOccludedFlag as r } from "../../webgl-engine/lib/Material.js";
+import { createStipplePatternSimple as A } from "../../webgl-engine/materials/lineStippleUtils.js";
+const c = 0.3;
+function h(l, t) {
+  t && Object.assign(l, t);
+}
+class W {
+  constructor(t) {
+    this.height = 90, this.coneHeight = 40, this.coneWidth = 23, this.width = 3, this.renderOccluded = r.Opaque, this.color = t.accent;
+  }
+}
+class u {
+  constructor({ colors: t, ...e }) {
+    this.size = 11, this.outlineSize = 1, this.collisionPadding = 9, this.color = t.accent, this.outlineColor = t.outline, this.renderOccluded = r.Opaque, this.hoverOutlineColor = t.selectedOutline, h(this, e);
+  }
+  applyColor(t) {
+    this._apply(this.color, t);
+  }
+  applyOutline(t) {
+    this._apply(this.outlineColor, t);
+  }
+  applyHoverOutline(t) {
+    this._apply(this.hoverOutlineColor, t);
+  }
+  _apply(t, e) {
+    e.setParameters({ color: s(t), renderOccluded: this.renderOccluded });
+  }
+}
+class S {
+  constructor({ colors: t, ...e }) {
+    this.size = 40, this.height = 0.2, this.offset = 0.25, this.collisionPadding = 2, this.renderOccluded = r.Transparent, this.minSquaredEdgeLength = 900, this.color = p(t.accent, 0.5), this.hoverColor = t.accent, h(this, e);
+  }
+  applyColor(t) {
+    this._apply(this.color, t);
+  }
+  applyHover(t) {
+    this._apply(this.hoverColor, t);
+  }
+  _apply(t, e) {
+    e.setParameters({ color: s(t), renderOccluded: this.renderOccluded });
+  }
+}
+class z {
+  constructor(t) {
+    this.vertex = new u({ colors: t, color: t.accent, outlineColor: t.outline }), this.edge = new u({ colors: t, color: m(p(t.accent, 2 / 3), 0.5), outlineColor: p(t.outline, 0.5), size: 8, collisionPadding: 8 }), this.selected = new u({ colors: t, color: t.selected, outlineColor: t.outline }), this.edgeOffset = new S({ colors: t });
+  }
+}
+class f {
+  constructor({ colors: t, ...e }) {
+    this.width = 1.5, this.stipplePattern = A(3.3), this.falloff = 0, this.innerWidth = 1.5, this.renderOccluded = r.OccludeAndTransparent, this.color = t.selected, this.stippleOffColor = t.outline, this.innerColor = t.selected, h(this, e);
+  }
+  apply(t) {
+    t.color = s(this.color), t.width = this.width, t.stipplePattern = this.stipplePattern, t.stippleOffColor = s(this.stippleOffColor), t.falloff = this.falloff, t.innerWidth = this.innerWidth, t.innerColor = s(this.innerColor), t.renderOccluded = this.renderOccluded;
+  }
+}
+class b {
+  constructor({ colors: t, ...e }) {
+    this.size = 4, this.outlineSize = 1, this.shape = "square", this.color = t.selected, this.outlineColor = t.outline, h(this, e);
+  }
+  apply(t) {
+    t.color = s(this.color), t.size = this.size, t.outlineSize = this.outlineSize, t.outlineColor = s(this.outlineColor), t.primitive = this.shape;
+  }
+}
+class d {
+  constructor({ colors: t, ...e }) {
+    this.innerWidth = 1, this.glowWidth = 8, this.glowFalloff = 8, this.globalAlpha = c, this.globalAlphaContrastBoost = 1.5, this.radius = 3, this.innerColor = t.selected, this.glowColor = t.accent, this.heightFillColor = t.accent, h(this, e);
+  }
+  apply(t, e = 1) {
+    const g = { glowColor: o.toUnitRGB(this.glowColor), glowFalloff: this.glowFalloff, glowWidth: this.glowWidth, innerColor: o.toUnitRGB(this.innerColor), innerWidth: this.innerWidth, globalAlpha: this.globalAlpha * e * this.glowColor.a, globalAlphaContrastBoost: this.globalAlphaContrastBoost, intersectsLineRadius: this.radius };
+    "style" in t ? t.style = g : t.laserlineStyle = g;
+  }
+}
+class v {
+  constructor(t) {
+    this.outline = new f({ colors: t, color: t.stippleOff, renderOccluded: r.OccludeAndTransparentStencil, stippleOffColor: t.stippleOn, innerWidth: 0 }), this.staged = new f({ colors: t, color: t.stippleOn, renderOccluded: r.OccludeAndTransparentStencil, innerColor: t.stagedSolid, stippleOffColor: t.stippleOff }), this.shadowStyle = new d({ colors: t, globalAlpha: c, glowColor: t.accent, glowFalloff: 8, glowWidth: 8, innerColor: t.selected, innerWidth: 1 });
+  }
+}
+class P {
+  constructor(t) {
+    this.outline = new b({ colors: t, color: t.selected, outlineColor: t.outline, outlineSize: 1, shape: "circle", size: 4 }), this.shadowStyle = new d({ colors: t, globalAlpha: c, glowColor: t.accent, glowFalloff: 1.5, glowWidth: 6, innerColor: t.selected, innerWidth: 1, radius: 2 });
+  }
+}
+class F extends f {
+  constructor({ colors: t, ...e }) {
+    super({ colors: t }), this.extensionType = C.GROUND_RAY, h(this, e);
+  }
+}
+class T {
+  constructor(t) {
+    this.laserlineAlphaMultiplier = 1.5, this.heightPlaneAngleCutoff = 20, this.lineGraphics = new v(t), this.pointGraphics = new P(t), this.heightPlane = new d({ colors: t, globalAlpha: c, glowColor: t.accent, glowFalloff: 8, glowWidth: 8, innerColor: t.selected, innerWidth: 1 }), this.heightBox = new d({ colors: t, globalAlpha: c, glowColor: t.accent, glowFalloff: 8, glowWidth: 8, innerColor: t.selected, innerWidth: 0, heightFillColor: t.accent }), this.zVerticalLine = new F({ colors: t, color: p(t.accent, 5 * c / 3), falloff: 2, innerColor: p(t.selected, 0), renderOccluded: r.OccludeAndTransparent, stipplePattern: null, width: 5, extensionType: C.GROUND_RAY });
+  }
+}
+let i = class extends w {
+  constructor(t) {
+    super(t);
+  }
+  get colors() {
+    const t = this.getTheme().accentColor, e = t.a;
+    return { accent: t, contrast: O(t), selected: o.fromArray([255, 255, 255, e]), selectedOutline: o.fromArray([255, 255, 255, e]), staged: o.fromArray([12, 207, 255, e]), stagedSolid: o.fromArray([12, 207, 255, 1]), outline: o.fromArray([0, 0, 0, 0.5 * e]), stippleOn: o.fromArray([255, 255, 255, 1]), stippleOff: o.fromArray([0, 0, 0, 0.5]) };
+  }
+  get visualElements() {
+    return new T(this.colors);
+  }
+  get manipulators() {
+    return new z(this.colors);
+  }
+  get zManipulator() {
+    return new W(this.colors);
+  }
+};
+n([a()], i.prototype, "colors", null), n([a()], i.prototype, "visualElements", null), n([a()], i.prototype, "manipulators", null), n([a()], i.prototype, "zManipulator", null), n([a()], i.prototype, "getTheme", void 0), i = n([y("esri.views.3d.interactive.editingTools.settings.Settings")], i);
+export {
+  i as Settings
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/interactive/editingTools/snapping/SnapToScene.js

@@ -0,0 +1,38 @@
+import { getZForElevationMode as i } from "../../../../../support/elevationInfoUtils.js";
+import { EventPipeline as l } from "../../../../interactive/dragEventPipeline.js";
+class h {
+  constructor() {
+    this._view = null, this._elevationInfo = null, this._lastDragEvent = null, this._next = null, this._enabled = !1;
+  }
+  get enabled() {
+    return this._enabled;
+  }
+  set enabled(t) {
+    if (this._enabled !== t && this._lastDragEvent != null && this._next != null) {
+      const n = this._lastDragEvent.mapEnd, a = this._snap(this._lastDragEvent.screenEnd);
+      if (a != null) {
+        const e = { action: "update", mapStart: this._lastDragEvent.mapStart, mapEnd: t === !0 ? a : n, screenStart: this._lastDragEvent.screenEnd, screenEnd: this._lastDragEvent.screenEnd };
+        this._next.execute(e);
+      }
+    }
+    this._enabled = t;
+  }
+  _snap(t) {
+    const n = this._view != null ? this._view.toMap(t, { exclude: [] }) : null;
+    return n != null && this._view != null && (n.z = i(n, this._view, this._elevationInfo)), n;
+  }
+  createDragEventPipelineStep(t, n) {
+    this._view = t, this._elevationInfo = n, this._lastDragEvent = null;
+    const a = new l();
+    return this._next = a, [(e) => {
+      if (this._lastDragEvent = e.action !== "end" ? { ...e } : null, this._enabled) {
+        const s = this._snap(e.screenEnd);
+        return s != null ? { action: e.action, mapStart: e.mapStart, mapEnd: s, screenStart: e.screenStart, screenEnd: e.screenEnd } : null;
+      }
+      return { action: e.action, mapStart: e.mapStart, mapEnd: e.mapEnd, screenStart: e.screenStart, screenEnd: e.screenEnd };
+    }, a];
+  }
+}
+export {
+  h as SnapToScene
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/interactive/editingTools/transformGraphic/ExtentMove.js

@@ -0,0 +1,108 @@
+import { zeroMeters as s } from "../../../../../core/quantityUtils.js";
+import { rotateZ as l } from "../../../../../core/libs/gl-matrix-2/math/mat4.js";
+import { f as c } from "../../../../../chunks/vec32.js";
+import { clone as m } from "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { sm4d as h, sv3d as u } from "../../../../../geometry/support/vectorStacks.js";
+import { ShiftManipulator as d, OffsetMode as v } from "../../../analysis/Slice/ShiftManipulator.js";
+import { IsShiftEdgeOnScreenFlag as f } from "../../../analysis/Slice/sliceToolUtils.js";
+import { screenToZConstrained as g } from "../dragEventPipeline3D.js";
+import { ManipulatorType as _ } from "../ManipulatorType.js";
+import { MoveXYGraphicManipulation as M } from "../manipulations/MoveXYGraphicManipulation.js";
+import { createManipulatorDragEventPipeline as S, addMapDelta as y, addScreenDelta as T } from "../../../../interactive/dragEventPipeline.js";
+import { AccumulationBehavior as p } from "../../../../interactive/editGeometry/interfaces.js";
+import { apply as G } from "../../../../interactive/editGeometry/support/editPlaneUtils.js";
+import { TranslateGraphicTooltipInfo as Z, TranslateGraphicZTooltipInfo as D } from "../../../../interactive/tooltip/TranslateTooltipInfos.js";
+import { autoDistance2D as X } from "../../../../support/automaticLengthMeasurementUtils.js";
+import { verticalSignedDistance as Y } from "../../../../support/euclideanLengthMeasurementUtils.js";
+class $ {
+  constructor(a, o, e, i) {
+    this._tool = a, this._graphicState = o, this._editGeometryOperations = e, this._bounds = i, this._moveXYTooltipInfo = null, this._moveZTooltipInfo = null;
+    const r = this._tool, t = r.view;
+    this.moveXYGraphicManipulation = new M({ view: t, tool: r, graphicState: this._graphicState }), r.addHandles(this._createMoveXYGraphicDragPipeline()), this.moveZManipulator = new d(t, v.CENTER_ON_CALLOUT), this.moveZManipulator.state |= f, r.manipulators.add(this.moveZManipulator), r.addHandles([this._createMoveZDragPipeline()]), r.addHandles([r.on("graphic-translate-stop", () => {
+      this._moveXYTooltipInfo = null, this._moveZTooltipInfo = null;
+    })]);
+  }
+  destroy() {
+    this.moveXYGraphicManipulation.destroy(), this._tool.manipulators.remove(this.moveZManipulator), this.moveZManipulator.destroy();
+  }
+  forEachManipulator(a) {
+    this.moveXYGraphicManipulation.forEachManipulator(a), a(this.moveZManipulator, _.TRANSLATE_Z);
+  }
+  updateManipulators(a, o) {
+    const e = this.moveZManipulator, i = l(h.get(), a, Math.PI);
+    i[12] = 0, i[13] = 0, i[14] = 0, e.modelTransform = i, e.renderLocation = c(u.get(), o.origin, o.basis1);
+  }
+  getUpdatedTooltipInfo() {
+    return this.moveXYGraphicManipulation.grabbing || this.moveXYGraphicManipulation.dragging ? this._computeMoveXYTooltipInfo() : this.moveZManipulator.focused ? this._computeMoveZTooltipInfo() : null;
+  }
+  _computeMoveXYTooltipInfo() {
+    const a = this._tool, o = this._moveXYTooltipInfo ?? (this._moveXYTooltipInfo = new Z({ sketchOptions: a.sketchOptions }));
+    if (this.moveXYGraphicManipulation.dragging) {
+      const e = this._bounds, i = e.mapBoundsStart.origin, r = e.mapBounds.origin, { renderSpatialReference: t } = a.view;
+      if (!t)
+        return null;
+      const n = X(i, r, t);
+      if (n == null)
+        return null;
+      o.distance = n;
+    } else
+      o.distance = s;
+    return o;
+  }
+  _computeMoveZTooltipInfo() {
+    const a = this._tool, o = this._moveZTooltipInfo ?? (this._moveZTooltipInfo = new D({ sketchOptions: a.sketchOptions }));
+    if (this.moveZManipulator.dragging) {
+      const e = this._bounds, i = e.mapBoundsStart.origin, r = e.mapBounds.origin, { renderSpatialReference: t } = a.view;
+      if (!t)
+        return null;
+      const n = Y(i, r, t);
+      if (n == null)
+        return null;
+      o.distance = n;
+    } else
+      o.distance = s;
+    return o;
+  }
+  _createMoveXYGraphicDragPipeline() {
+    return this.moveXYGraphicManipulation.createDragPipeline((a, o, e) => this._applyGraphicMoveSteps(o, e));
+  }
+  _createMoveZDragPipeline() {
+    const a = this._editGeometryOperations.data.spatialReference;
+    return S(this.moveZManipulator, (o, e, i) => {
+      const r = m(o.renderLocation), t = e.next(g(this._tool.view, r, a)).next(T());
+      this._applyGraphicMoveSteps(t, i);
+    });
+  }
+  _applyGraphicMoveSteps(a, o) {
+    const e = this._tool, i = e.graphic, r = a.next((t) => (t.action === "start" && (e.inputState = { type: "move" }, this._bounds.backupMapBounds(), e.emit("graphic-translate-start", { graphic: i, dxScreen: t.screenDeltaX, dyScreen: t.screenDeltaY })), t)).next(y()).next(this._moveDragUpdateGeometry()).next((t) => {
+      const n = { graphic: i, dxScreen: t.screenDeltaX, dyScreen: t.screenDeltaY };
+      switch (t.action) {
+        case "start":
+        case "update":
+          (t.mapEnd.x - t.mapStart.x || t.mapEnd.y - t.mapStart.y || (t.mapEnd.z ?? 0) - (t.mapStart.z ?? 0)) && e.emit("graphic-translate", n);
+          break;
+        case "end":
+          e.inputState = null, e.emit("graphic-translate-stop", n);
+      }
+      return t;
+    });
+    return o.next(() => {
+      e.inputState != null && e.emit("graphic-translate-stop", { graphic: i, dxScreen: 0, dyScreen: 0 }), e.cancel();
+    }), r;
+  }
+  _moveDragUpdateGeometry() {
+    const a = this._tool;
+    return (o) => {
+      if (a.inputState == null || a.inputState.type !== "move")
+        return o;
+      const e = [];
+      for (const t of this._editGeometryOperations.data.components)
+        e.push(...t.vertices);
+      const i = o.action === "start" ? p.NEW_STEP : p.ACCUMULATE_STEPS, r = this._editGeometryOperations.moveVertices(e, o.mapDeltaX, o.mapDeltaY, o.mapDeltaZ, i);
+      return G(r, this._bounds.mapBounds), a.graphic.geometry = this._editGeometryOperations.data.geometry, o;
+    };
+  }
+}
+export {
+  $ as ExtentMove
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/interactive/editingTools/transformGraphic/ExtentRotate.js

@@ -0,0 +1,96 @@
+import { rad2deg as m } from "../../../../../core/mathUtils.js";
+import { rotateX as u } from "../../../../../core/libs/gl-matrix-2/math/mat4.js";
+import { g as d, c as h } from "../../../../../chunks/vec32.js";
+import { create as g } from "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { c as _ } from "../../../../../chunks/boundedPlane.js";
+import { create as f, intersectRay as A, getNormal as R } from "../../../../../geometry/support/plane.js";
+import { sm4d as T, sv3d as l } from "../../../../../geometry/support/vectorStacks.js";
+import { getRotateHeadingTexture as M } from "../../../analysis/images/Factory.js";
+import { RotateManipulator as y } from "../../../analysis/Slice/RotateManipulator.js";
+import { createRotatePlane as P, RotationAxis as x } from "../../../analysis/Slice/sliceToolUtils.js";
+import { calculateInputRotationTransform as E } from "../../manipulatorUtils.js";
+import { screenToRenderPlane as b } from "../dragEventPipeline3D.js";
+import { ManipulatorType as v } from "../ManipulatorType.js";
+import { fromScreenNormalized as S } from "../../../support/geometryUtils/ray.js";
+import { createManipulatorDragEventPipeline as B } from "../../../../interactive/dragEventPipeline.js";
+import { AccumulationBehavior as c } from "../../../../interactive/editGeometry/interfaces.js";
+import { AccumulationType as G } from "../../../../interactive/editGeometry/operations/UpdateVertices.js";
+import { apply as I } from "../../../../interactive/editGeometry/support/editPlaneUtils.js";
+import { ExtentRotateTooltipInfo as w } from "../../../../interactive/tooltip/ExtentTooltipInfos.js";
+class Y {
+  constructor(o, t, a) {
+    var i;
+    this._tool = o, this._editGeometryOperations = t, this._bounds = a, this._rotateTooltipInfo = null, this._startAngle = 0, this._endAngle = 0;
+    const e = this._tool, n = e.view, s = !((i = n._stage) != null && i.renderView.renderingContext.driverTest.svgPremultipliesAlpha.result);
+    this.rotateManipulator = new y(n, (r, p) => M(n.textures, { accentColor: r, contrastColor: p, preMultiplyAlpha: s })), e.addHandles([this.rotateManipulator.events.on("grab-changed", (r) => this._onRotateGrab(r)), this._createRotateDragPipeline(this.rotateManipulator)]), e.manipulators.add(this.rotateManipulator), e.addHandles([e.on("graphic-rotate-start", (r) => {
+      this._startAngle = r.angle;
+    }), e.on("graphic-rotate", (r) => {
+      this._endAngle = r.angle;
+    }), e.on("graphic-rotate-stop", () => {
+      this._startAngle = 0, this._endAngle = 0;
+    })]);
+  }
+  destroy() {
+    this._tool.manipulators.remove(this.rotateManipulator), this.rotateManipulator.destroy();
+  }
+  forEachManipulator(o) {
+    o(this.rotateManipulator, v.ROTATE);
+  }
+  updateManipulators(o, t) {
+    const a = this._bounds.mapBounds.plane[2] < 0 ? Math.PI : 0, e = u(T.get(), o, a);
+    e[12] = 0, e[13] = 0, e[14] = 0, this.rotateManipulator.modelTransform = e, this.rotateManipulator.renderLocation = d(l.get(), t.origin, t.basis1);
+  }
+  getUpdatedTooltipInfo() {
+    return this.rotateManipulator.focused ? this._computeRotateTooltipInfo() : null;
+  }
+  _computeRotateTooltipInfo() {
+    const o = this._rotateTooltipInfo ?? (this._rotateTooltipInfo = new w({ sketchOptions: this._tool.sketchOptions }));
+    return o.angle = this._startAngle - this._endAngle, o;
+  }
+  _onRotateGrab({ action: o, screenPoint: t }) {
+    const a = this._tool, e = this._bounds;
+    if (o !== "start" || !t)
+      return;
+    const n = P(e.displayBounds, a.view.renderCoordsHelper, x.HEADING, f()), s = S(a.view.state.camera, t);
+    A(n, s, l.get()) && (e.backupMapBounds(), a.inputState = { type: "rotate", rotatePlane: n });
+  }
+  _createRotateDragPipeline(o) {
+    const t = this._tool, a = t.graphic;
+    return B(o, (e, n, s) => {
+      const i = t.inputState;
+      i != null && (n.next((r) => (r.action === "start" && t.emit("graphic-rotate-start", { graphic: a, angle: 0 }), r)).next(b(t.view, i.rotatePlane)).next(this._rotateDragRenderPlaneToRotate(i)).next(this._rotateDragUpdateGeometry()).next((r) => {
+        const p = { graphic: a, angle: m(r.rotateAngle) };
+        switch (r.action) {
+          case "start":
+          case "update":
+            t.emit("graphic-rotate", p);
+            break;
+          case "end":
+            t.inputState = null, t.emit("graphic-rotate-stop", p);
+        }
+        return r;
+      }), s.next(() => {
+        t.inputState != null && t.emit("graphic-rotate-stop", { graphic: a, angle: 0 }), t.cancel();
+      }));
+    });
+  }
+  _rotateDragRenderPlaneToRotate(o) {
+    return (t) => {
+      const a = R(o.rotatePlane), e = E(t.renderStart, t.renderEnd, this._bounds.displayBounds.origin, a);
+      return { ...t, rotateAxis: a, rotateAngle: e };
+    };
+  }
+  _rotateDragUpdateGeometry() {
+    const o = this._tool, t = this._bounds;
+    return (a) => {
+      const e = h(g(), t.mapBoundsStart.origin), n = [];
+      for (const r of this._editGeometryOperations.data.components)
+        n.push(...r.vertices);
+      const s = a.action === "start" ? c.NEW_STEP : c.ACCUMULATE_STEPS, i = this._editGeometryOperations.rotateVertices(n, e, a.rotateAngle, s, G.REPLACE);
+      return _(t.mapBoundsStart, t.mapBounds), I(i, t.mapBounds), o.graphic.geometry = this._editGeometryOperations.data.geometry, a;
+    };
+  }
+}
+export {
+  Y as ExtentRotate
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/interactive/editingTools/transformGraphic/ExtentScale.js

@@ -0,0 +1,138 @@
+import { set as p, normalize as A } from "../../../../../core/libs/gl-matrix-2/math/vec2.js";
+import { create as z } from "../../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { c as y, r as u, f as x, l as I, k as M } from "../../../../../chunks/vec32.js";
+import { create as G } from "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { a as H, c as B } from "../../../../../chunks/boundedPlane.js";
+import { intersectRay as O } from "../../../../../geometry/support/plane.js";
+import { sv3d as m } from "../../../../../geometry/support/vectorStacks.js";
+import { ResizeManipulator as w } from "../../../analysis/Slice/ResizeManipulator.js";
+import { updateResizeHandle as N, isDiagonalResizeHandle as U, calculateDiagonalResizeHandleScale as E } from "../../../analysis/Slice/sliceToolUtils.js";
+import { screenToRenderPlane as k } from "../dragEventPipeline3D.js";
+import { ManipulatorType as C } from "../ManipulatorType.js";
+import { mapPlaneAutoSize2D as b } from "./extentUtils.js";
+import { fromScreenNormalized as F } from "../../../support/geometryUtils/ray.js";
+import { createManipulatorDragEventPipeline as L } from "../../../../interactive/dragEventPipeline.js";
+import { AccumulationBehavior as v } from "../../../../interactive/editGeometry/interfaces.js";
+import { AccumulationType as Z } from "../../../../interactive/editGeometry/operations/UpdateVertices.js";
+import { apply as $ } from "../../../../interactive/editGeometry/support/editPlaneUtils.js";
+import { ExtentScaleTooltipInfo as V } from "../../../../interactive/tooltip/ExtentTooltipInfos.js";
+class ht {
+  get zMax() {
+    if (!this._zMaxDirty)
+      return this._zMax;
+    const i = this._editGeometryOperations.data;
+    if (i.geometry.hasZ) {
+      const e = i.coordinateHelper;
+      this._zMax = Number.NEGATIVE_INFINITY;
+      for (const t of i.components)
+        for (const a of t.vertices) {
+          const o = e.getZ(a.pos) ?? 0;
+          this._zMax = Math.max(o, this._zMax);
+        }
+    } else
+      this._zMax = 0;
+    return this._zMaxDirty = !1, this._zMax;
+  }
+  constructor(i, e, t, a, o) {
+    this._tool = i, this._graphicState = e, this._editGeometryOperations = t, this._bounds = a, this._preserveAspectRatioStep = o, this._resizeHandles = [{ direction: [1, 0] }, { direction: [1, 1] }, { direction: [0, 1] }, { direction: [-1, 1] }, { direction: [-1, 0] }, { direction: [-1, -1] }, { direction: [0, -1] }, { direction: [1, -1] }], this._scaleTooltipInfo = null, this._displayBoundsStart = H(), this._displayBoundsMarginStart = 0, this._startScale = z(), this._endScale = z(), this._sizeStart = null, this._zMax = 0, this._zMaxDirty = !0;
+    const r = this._tool, n = r.view;
+    this.resizeManipulators = this._resizeHandles.map((s) => {
+      const c = new w(n, s);
+      return r.addHandles([c.events.on("grab-changed", (S) => this._onResizeGrab(S)), this._createResizeDragPipeline(c, s)]), c;
+    }), r.manipulators.addMany(this.resizeManipulators), r.addHandles([r.on("graphic-scale-start", (s) => {
+      p(this._startScale, s.xScale, s.yScale), p(this._endScale, s.xScale, s.yScale);
+    }), r.on("graphic-scale", (s) => {
+      p(this._endScale, s.xScale, s.yScale);
+    }), r.on("graphic-scale-stop", () => {
+      p(this._startScale, 0, 0), p(this._endScale, 0, 0);
+    }), this._graphicState.on("changed", () => {
+      var s;
+      ((s = r.inputState) == null ? void 0 : s.type) !== "resize" && (this._zMaxDirty = !0);
+    })]);
+  }
+  destroy() {
+    this.forEachManipulator((i) => {
+      this._tool.manipulators.remove(i), i.destroy();
+    });
+  }
+  forEachManipulator(i) {
+    this.resizeManipulators.forEach((e) => i(e, C.SCALE));
+  }
+  updateManipulators(i, e) {
+    this.resizeManipulators.forEach((t, a) => {
+      N(t, this._resizeHandles[a], i, e);
+    });
+  }
+  getUpdatedTooltipInfo() {
+    return this.resizeManipulators.some((i) => i.focused) ? this._computeScaleTooltipInfo() : null;
+  }
+  _computeScaleTooltipInfo() {
+    const i = this._tool, e = this._scaleTooltipInfo ?? (this._scaleTooltipInfo = new V({ sketchOptions: i.sketchOptions })), t = i.graphic.geometry;
+    if (t == null)
+      return null;
+    const a = b(this._bounds.mapBounds, this.zMax, t.spatialReference);
+    return a == null ? null : (e.xSize = a.xSize, e.ySize = a.ySize, this._sizeStart != null && this.resizeManipulators.some((o) => o.dragging) ? (e.xScale = a.xSize.value / this._sizeStart.xSize.value, e.yScale = a.ySize.value / this._sizeStart.ySize.value) : (e.xScale = 1, e.yScale = 1), e);
+  }
+  _onResizeGrab({ action: i, screenPoint: e }) {
+    const t = this._tool, a = this._bounds;
+    if (i !== "start" || !e || !t.graphic.geometry)
+      return;
+    const o = F(t.view.state.camera, e);
+    O(a.displayBounds.plane, o, m.get()) && (a.backupMapBounds(), B(a.displayBounds, this._displayBoundsStart), this._displayBoundsMarginStart = a.displayBoundsMargin, this._sizeStart = b(a.mapBoundsStart, this.zMax, t.graphic.geometry.spatialReference), t.inputState = { type: "resize" });
+  }
+  _createResizeDragPipeline(i, e) {
+    const t = this._tool, a = t.graphic;
+    return L(i, (o, r, n) => {
+      t.inputState != null && (r.next((s) => (s.action === "start" && t.emit("graphic-scale-start", { graphic: a, xScale: 1, yScale: 1 }), s)).next(k(t.view, this._displayBoundsStart.plane)).next((s) => ({ ...s, handle: e })).next(this._resizeDragRenderPlaneToFactors()).next(...this._preserveAspectRatioStep()).next(this._resizeDragUpdateGeometry()).next((s) => {
+        const c = { graphic: a, xScale: s.factor1, yScale: s.factor2 };
+        switch (s.action) {
+          case "start":
+          case "update":
+            t.emit("graphic-scale", c);
+            break;
+          case "end":
+            t.inputState = null, t.emit("graphic-scale-stop", c);
+        }
+        return s;
+      }), n.next(() => {
+        t.inputState != null && t.emit("graphic-scale-stop", { graphic: a, xScale: 1, yScale: 1 }), t.cancel();
+      }));
+    });
+  }
+  _resizeDragRenderPlaneToFactors() {
+    const i = this._bounds;
+    return (e) => {
+      const t = this._displayBoundsStart, a = e.handle.direction, o = i.displayBoundsMargin, r = this._displayBoundsMarginStart, n = y(m.get(), t.origin);
+      u(n, n, t.basis1, -a[0]), u(n, n, t.basis2, -a[1]);
+      const s = x(m.get(), e.renderEnd, n), c = x(m.get(), e.renderStart, n), S = U(e.handle), T = E(t), D = E(i.displayBounds) / T, f = (_, g) => {
+        if (_ === 0)
+          return 1;
+        let l = I(g), h = 0.5 * _ * M(g, s) / l;
+        const d = h < 0 ? -1 : 1;
+        S && (h += (l - 0.5 * _ * M(g, c) / l) * d * D);
+        const P = l < 1.5 * r ? 1 : R;
+        return l = Math.max(l - r, R), d > 0 && (h -= o), d * Math.max(d * (h / l), P);
+      };
+      return { ...e, factor1: f(a[0], t.basis1), factor2: f(a[1], t.basis2) };
+    };
+  }
+  _resizeDragUpdateGeometry() {
+    const i = this._tool, e = this._bounds;
+    return (t) => {
+      const a = y(G(), e.mapBoundsStart.origin);
+      u(a, a, e.mapBoundsStart.basis1, -t.handle.direction[0]), u(a, a, e.mapBoundsStart.basis2, -t.handle.direction[1]);
+      const o = p(z(), e.mapBoundsStart.basis1[0], e.mapBoundsStart.basis1[1]);
+      A(o, o);
+      const r = [];
+      for (const c of this._editGeometryOperations.data.components)
+        r.push(...c.vertices);
+      const n = t.action === "start" ? v.NEW_STEP : v.ACCUMULATE_STEPS, s = this._editGeometryOperations.scaleVertices(r, a, o, t.factor1, t.factor2, n, Z.REPLACE);
+      return B(e.mapBoundsStart, e.mapBounds), $(s, e.mapBounds), i.graphic.geometry = this._editGeometryOperations.data.geometry, t;
+    };
+  }
+}
+const R = 1e-6;
+export {
+  ht as ExtentScale,
+  R as scaleEpsilon
+};