@agrotools1/at-components 0.6.15 → 0.6.17

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

@@ -0,0 +1,164 @@
+import { _ as n } from "../../../../../chunks/tslib.es6.js";
+import b from "../../../../../core/Evented.js";
+import { makeHandle as M } from "../../../../../core/handleUtils.js";
+import { watch as p, initial as O } from "../../../../../core/reactiveUtils.js";
+import { property as r } from "../../../../../core/accessorSupport/decorators/property.js";
+import "../../../../../core/has.js";
+import "../../../../../core/Logger.js";
+import "../../../../../core/RandomLCG.js";
+import { subclass as E } from "../../../../../core/accessorSupport/decorators/subclass.js";
+import { containsXY as A } from "../../../../../geometry/support/aaBoundingRect.js";
+import { sm4d as x } from "../../../../../geometry/support/vectorStacks.js";
+import { calculateBoundedPlaneTranslateRotate as R, resizeNormal as S, resizeOutlineOnly as T } from "../../../analysis/Slice/sliceToolUtils.js";
+import { Manipulator3D as w } from "../../Manipulator3D.js";
+import { getGraphicAttachmentOrigin as G } from "../../manipulatorUtils.js";
+import { ManipulatorType as h } from "../ManipulatorType.js";
+import { canMoveZ as B } from "../manipulatorUtils.js";
+import { createVisualElements as D } from "../visualElementUtils.js";
+import { ExtentMove as H } from "./ExtentMove.js";
+import { ExtentRotate as k } from "./ExtentRotate.js";
+import { ExtentScale as U } from "./ExtentScale.js";
+import { TransformBounds as Z } from "./extentUtils.js";
+import { PreserveAspectRatio as C } from "./PreserveAspectRatio.js";
+import { OutlineVisualElement as $ } from "../../visualElements/OutlineVisualElement.js";
+import { GraphicState as I } from "../../../layers/graphics/GraphicState.js";
+import { InteractiveToolBase as z } from "../../../../interactive/InteractiveToolBase.js";
+import { EditGeometryOperations as N } from "../../../../interactive/editGeometry/EditGeometryOperations.js";
+import { applyInverse as m, apply as P } from "../../../../interactive/editGeometry/support/editPlaneUtils.js";
+import _ from "../../../../interactive/sketch/SketchOptions.js";
+import { Tooltip as V } from "../../../../interactive/tooltip/Tooltip.js";
+let s = class extends b.EventedMixin(z) {
+  constructor(t) {
+    super(t), this.enableZ = !0, this.enableScaling = !0, this.enableRotation = !0, this.sketchOptions = new _(), this._preserveAspectRatio = new C(), this.grabbing = !1, this.inputState = null, this._attachmentOrigin = null, this.type = "transform-3d", this._outlineVisualElement = null;
+  }
+  initialize() {
+    const { view: t, graphic: i } = this, e = this._graphicState = new I({ graphic: i }), o = i.geometry, l = this._editGeometryOperations = N.fromGeometry(o, t.state.viewingMode), d = this._bounds = new Z(this, () => this._updateManipulators(), l.data);
+    this._extentMove = new H(this, e, l, d), this._extentScale = new U(this, e, l, d, () => this._preserveAspectRatio.createDragEventPipelineStep()), this._extentRotate = new k(this, l, d), this.addHandles([p(() => this.enableZ, () => this._updateManipulatorAvailability(this._extentMove.moveZManipulator, h.TRANSLATE_Z)), p(() => this.enableScaling, () => this._extentScale.forEachManipulator((a) => this._updateManipulatorAvailability(a, h.SCALE))), p(() => this.enableRotation, () => this._updateManipulatorAvailability(this._extentRotate.rotateManipulator, h.ROTATE))]), this._updateAllManipulatorAvailability();
+    const c = D({ view: t, graphic: i, forEachManipulator: (a) => this._forEachManipulator(a), onManipulatorsChanged: () => M() });
+    if (c != null) {
+      const { visualElement: a } = c;
+      a instanceof $ && (this._outlineVisualElement = a, this.addHandles(a.events.on("attachment-origin-changed", () => this._bounds.updateDisplayBounds()))), this.addHandles(c);
+    }
+    this.addHandles([e.on("changed", () => this._onGeometryChanged()), p(() => e.displaying, () => this._updateAllManipulatorAvailability()), p(() => e.isDraped, () => this._graphicDrapedChanged(), O), p(() => {
+      var a;
+      return (a = t.pointsOfInterest) == null ? void 0 : a.centerOnSurfaceFrequent.location;
+    }, () => d.updateDisplayBounds()), t.trackGraphicState(e)]);
+    const v = (a) => {
+      this.addHandles(a.events.on("grab-changed", () => {
+        this.grabbing = a.grabbing, this._updateAllManipulatorAvailability();
+      }));
+    };
+    this._forEachManipulator(v);
+    const y = (a, f) => {
+      this.addHandles(a.events.on("immediate-click", (u) => {
+        f === h.TRANSLATE_XY && this.emit("immediate-click", { ...u, graphic: i }), u.stopPropagation();
+      }));
+    };
+    this._forEachManipulator(y), this._initializeTooltip(), this.finishToolCreation();
+  }
+  destroy() {
+    this._extentMove.destroy(), this._extentScale.destroy(), this._extentRotate.destroy(), this._editGeometryOperations.destroy(), this.tooltip.destroy(), this._set("view", null), this._set("graphic", null);
+  }
+  _initializeTooltip() {
+    const { view: t } = this, i = this.tooltip = new V({ view: t }), e = () => {
+      i.info = this._getUpdatedTooltipInfo();
+    };
+    this.addHandles([p(() => this.sketchOptions.tooltips.effectiveEnabled, e), this.on("graphic-translate-start", e), this.on("graphic-translate", e), this.on("graphic-translate-stop", () => {
+      this.tooltip.clear();
+    }), this.on("graphic-rotate-start", e), this.on("graphic-rotate", e), this.on("graphic-rotate-stop", e), this.on("graphic-scale-start", e), this.on("graphic-scale", e), this.on("graphic-scale-stop", e)]), this._forEachManipulator((o) => {
+      this.addHandles([o.events.on("focus-changed", e), o.events.on("grab-changed", e), o.events.on("drag", (l) => {
+        l.action === "cancel" ? this.tooltip.clear() : e();
+      })]);
+    });
+  }
+  _getUpdatedTooltipInfo() {
+    return this.sketchOptions.tooltips.effectiveEnabled ? this._extentMove.getUpdatedTooltipInfo() ?? this._extentScale.getUpdatedTooltipInfo() ?? this._extentRotate.getUpdatedTooltipInfo() : null;
+  }
+  _onGeometryChanged() {
+    this._bounds.updateDisplayBounds();
+  }
+  _graphicDrapedChanged() {
+    this.removeHandles(g), this._bounds.updateDisplayBounds(), this._graphicState.isDraped && this.addHandles(this.view.elevationProvider.on("elevation-change", (t) => {
+      this._attachmentOrigin != null && A(t.extent, this._attachmentOrigin.x, this._attachmentOrigin.y) && this._bounds.updateDisplayBounds();
+    }), g);
+  }
+  _updateManipulators() {
+    if (!this.visible)
+      return;
+    const t = this._bounds.displayBounds, i = R(t, x.get());
+    this._extentMove.updateManipulators(i, t), this._extentScale.updateManipulators(i, t), this._extentRotate.updateManipulators(i, t);
+  }
+  _updateAllManipulatorAvailability() {
+    this._forEachManipulator((t, i) => this._updateManipulatorAvailability(t, i));
+  }
+  _updateManipulatorAvailability(t, i) {
+    const e = this.grabbing && !t.grabbing;
+    if (t.interactive = !e, t instanceof w) {
+      const o = this._graphicState.displaying, l = this.enableZ && B(this.graphic);
+      switch (i) {
+        case h.ROTATE:
+          t.available = o && this.enableRotation;
+          break;
+        case h.SCALE:
+          t.available = o && (this.enableScaling || this.enableRotation || l), t.interactive = !e && this.enableScaling, t.state = this.enableScaling ? S : T;
+          break;
+        case h.TRANSLATE_Z:
+          t.available = o && l;
+          break;
+        default:
+          t.available = o;
+      }
+    }
+  }
+  _forEachManipulator(t) {
+    this._extentMove.forEachManipulator(t), this._extentScale.forEachManipulator(t), this._extentRotate.forEachManipulator(t);
+  }
+  get preserveAspectRatio() {
+    return this._preserveAspectRatio.enabled;
+  }
+  set preserveAspectRatio(t) {
+    this._preserveAspectRatio.enabled = t, this._set("preserveAspectRatio", t);
+  }
+  get attachmentOrigin() {
+    var e, o;
+    const t = this.graphic.geometry, i = this._graphicState.isDraped ? null : (e = this._outlineVisualElement) == null ? void 0 : e.attachmentOrigin;
+    return this._attachmentOrigin = i ?? G(this.view, this.graphic) ?? ((o = t == null ? void 0 : t.extent) == null ? void 0 : o.center), this._attachmentOrigin;
+  }
+  reset() {
+  }
+  cancel() {
+    if (this.canUndo) {
+      const t = this._editGeometryOperations.undo();
+      m(t, this._bounds.mapBounds), this.graphic.geometry = this._editGeometryOperations.data.geometry;
+    }
+    this.inputState = null;
+  }
+  get canUndo() {
+    return this._editGeometryOperations.canUndo;
+  }
+  undo() {
+    if (this.inputState != null)
+      this.view.activeTool = null;
+    else if (this.canUndo) {
+      const t = this._editGeometryOperations.undo();
+      m(t, this._bounds.mapBounds), this.graphic.geometry = this._editGeometryOperations.data.geometry;
+    }
+  }
+  get canRedo() {
+    return this._editGeometryOperations.canRedo;
+  }
+  redo() {
+    if (this.canRedo) {
+      const t = this._editGeometryOperations.redo();
+      P(t, this._bounds.mapBounds), this.graphic.geometry = this._editGeometryOperations.data.geometry;
+    }
+  }
+  get test() {
+    return { moveZManipulator: this._extentMove.moveZManipulator, resizeManipulators: this._extentScale.resizeManipulators, rotateManipulator: this._extentRotate.rotateManipulator };
+  }
+};
+n([r({ constructOnly: !0, nonNullable: !0 })], s.prototype, "view", void 0), n([r({ constructOnly: !0, nonNullable: !0 })], s.prototype, "graphic", void 0), n([r()], s.prototype, "enableZ", void 0), n([r()], s.prototype, "enableScaling", void 0), n([r()], s.prototype, "enableRotation", void 0), n([r({ constructOnly: !0, type: _ })], s.prototype, "sketchOptions", void 0), n([r()], s.prototype, "preserveAspectRatio", null), n([r()], s.prototype, "grabbing", void 0), n([r()], s.prototype, "inputState", void 0), n([r({ readOnly: !0 })], s.prototype, "type", void 0), n([r()], s.prototype, "tooltip", void 0), s = n([E("esri.views.3d.interactive.editingTools.transformGraphic.ExtentTransformTool")], s);
+const g = "draped-elevation-changes";
+export {
+  s as ExtentTransformTool
+};

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

@@ -0,0 +1,331 @@
+import { _ as b } from "../../../../../chunks/tslib.es6.js";
+import Mt from "../../../../../core/Accessor.js";
+import { multiplyOpacityToUnitRGBA as Tt } from "../../../../../core/colorUtils.js";
+import { cyclicalPI as vt } from "../../../../../core/Cyclical.js";
+import yt from "../../../../../core/Evented.js";
+import { clamp as Z, rad2deg as tt } from "../../../../../core/mathUtils.js";
+import { destroyMaybe as et } from "../../../../../core/maybe.js";
+import { createAngle as H, createLength as at } from "../../../../../core/quantityUtils.js";
+import { when as It, initial as B, watch as V } from "../../../../../core/reactiveUtils.js";
+import { addFrameTask as Rt } from "../../../../../core/scheduling.js";
+import { createScreenPointArray as wt } from "../../../../../core/screenUtils.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 bt } from "../../../../../core/accessorSupport/decorators/subclass.js";
+import { fromRotation as $t, fromScaling as At, multiply as Ot, scale as kt, rotate as it } from "../../../../../core/libs/gl-matrix-2/math/mat4.js";
+import { create as Pt } from "../../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { s as mt, f as x, l as ot, a as Ft, b as Et, g as Ct } from "../../../../../chunks/vec32.js";
+import { fromValues as q, clone as xt } from "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { fromPositionAndNormal as Lt, create as Ut, getNormal as ft } from "../../../../../geometry/support/plane.js";
+import { wrap as st, distance2 as rt } from "../../../../../geometry/support/ray.js";
+import { sm4d as J, sv3d as f } from "../../../../../geometry/support/vectorStacks.js";
+import { getGraphicEffectiveElevationInfo as zt } from "../../../../../support/elevationInfoUtils.js";
+import { Manipulator3D as Nt } from "../../Manipulator3D.js";
+import { calculateInputRotationTransform as jt } from "../../manipulatorUtils.js";
+import { RenderObject as M } from "../../RenderObject.js";
+import { screenToRenderPlane as Gt } from "../dragEventPipeline3D.js";
+import { ManipulatorType as Ht } from "../ManipulatorType.js";
+import { ringIndicatorDelayMs as Bt, ringThickness as K, rotateIndicatorDirectionBuffer as nt, scaleIndicatorDirectionBuffer as lt, rotateIndicatorArrowPlacementPercentage as ct, ringHeight as Q, rotateIndicatorArrowTipRadius as Vt, rotateIndicatorArrowTipLength as qt, indicatorThickness as O, dragThresholdPx as pt, ringRadius as C, rotateIndicatorArcLength as Jt, innerIndicatorRadius as Kt, outerIndicatorRadius as ht, scaleIndicatorOffset1 as dt, scaleIndicatorOffset2 as ut, ringResetAnimationSpeedFactor as Qt, geometrySegments as Wt, scaleIndicatorArcLength as Xt } from "../manipulations/config.js";
+import { CullFaceOptions as Yt } from "../../../webgl-engine/lib/basicInterfaces.js";
+import { createExtrudedTriangle as Zt, transformInPlace as te, createPathExtrusionGeometry as ee } from "../../../webgl-engine/lib/GeometryUtil.js";
+import { RenderOccludedFlag as ae } from "../../../webgl-engine/lib/Material.js";
+import { ColorMaterial as ie } from "../../../webgl-engine/materials/ColorMaterial.js";
+import { createManipulatorDragEventPipeline as oe } from "../../../../interactive/dragEventPipeline.js";
+import { ManipulatorStateCustomFlags as $, ManipulatorStateFlags as se } from "../../../../interactive/interfaces.js";
+import { Tooltip as re } from "../../../../interactive/tooltip/Tooltip.js";
+import { TransformRotateTooltipInfo as ne, TransformScaleTooltipInfo as le, TransformAbsoluteTooltipInfo as ce } from "../../../../interactive/tooltip/TransformTooltipInfos.js";
+var s;
+(function(t) {
+  t.ScaleIn = $.Custom2, t.ScaleOut = $.Custom3, t.RotateLeft = $.Custom4, t.RotateRight = $.Custom5, t.Unlocked = $.Custom7, t.DelayedFocused = $.Custom8, t.TouchInput = $.Custom12;
+})(s || (s = {}));
+let y = class extends Mt {
+  get angle() {
+    return this.adapter.angle;
+  }
+  get scale() {
+    return this.adapter.scale;
+  }
+  set location(t) {
+    this._ringManipulator.location = t;
+  }
+  set elevationAlignedLocation(t) {
+    this._ringManipulator.elevationAlignedLocation = t;
+  }
+  get grabbing() {
+    return this._ringManipulator.grabbing;
+  }
+  set interactive(t) {
+    this._ringManipulator.interactive = t;
+  }
+  get updating() {
+    return !!this._activeAnimation;
+  }
+  constructor(t) {
+    super(t), this.mode = null, this._scaleRotateDragData = null, this._activeAnimation = null, this._ringIndicatorDelayMs = Bt, this._absoluteTooltipInfo = null, this._scaleTooltipInfo = null, this._rotateTooltipInfo = null, this.events = new yt(), this.getFocused = () => this._ringManipulator.focused, this.getScale = () => {
+      var e;
+      return ((e = this._scaleRotateDragData) == null ? void 0 : e.mode) === "scale" ? this.adapter.scale : 1;
+    };
+  }
+  initialize() {
+    this._tooltip = new re({ view: this.tool.view }), this._createManipulator(), this._updateDragState(), this._updateManipulatorTransform(), this.addHandles([It(() => !this.sketchOptions.tooltips.effectiveEnabled, () => this._tooltip.clear(), B), V(() => {
+      const { adapter: t } = this, { info: e } = this._tooltip;
+      return e === this._absoluteTooltipInfo && this.getFocused() ? [e, t.size, t.orientationClockwise] : [null];
+    }, ([t]) => {
+      t && this._updateFocusTooltip();
+    })]);
+  }
+  destroy() {
+    var t;
+    (t = this._activeAnimation) == null || t.frameTask.remove(), this._activeAnimation = null, this.tool.manipulators.remove(this._ringManipulator), this._ringManipulator = null, this._tooltip = et(this._tooltip);
+  }
+  startAnimation(t) {
+    this.cancelActiveAnimation(), t.start();
+    const e = Rt({ update: ({ deltaTime: r }) => {
+      t.update(r) && this.cancelActiveAnimation();
+    } });
+    this._activeAnimation = { ...t, frameTask: e };
+  }
+  cancelActiveAnimation() {
+    var t;
+    (t = this._activeAnimation) == null || t.frameTask.remove(), this._activeAnimation = et(this._activeAnimation);
+  }
+  forEachManipulator(t) {
+    t(this._ringManipulator, Ht.SCALE_ROTATE);
+  }
+  _createManipulator() {
+    const t = this._createRingManipulator();
+    this._ringManipulator = t, this.tool.manipulators.add(t);
+    const e = this.tool.graphicState.graphic, r = oe(t, (a, i, p) => {
+      this._scaleRotateDragData = null;
+      const h = this.adapter.startInteraction(), o = { mode: "none", origin: xt(a.renderLocation), initialAngle: this.adapter.angle, angle: 0, angleDir: 0, scaleDir: 0 };
+      this._scaleRotateDragData = o, this._updateDragState();
+      const l = f.get();
+      this.tool.view.renderCoordsHelper.worldUpAtPosition(a.renderLocation, l), i.next(Gt(this.tool.view, Lt(a.renderLocation, l, Ut()))).next((c) => {
+        const u = ft(c.plane), g = jt(c.renderStart, c.renderEnd, o.origin, u), I = vt.shortestSignedDiff(o.angle, g);
+        o.angleDir = Z(o.angleDir + I, -nt, nt), o.angle = g;
+        const _ = pe(o, c), P = _ - this.adapter.scale;
+        if (o.scaleDir = Z(o.scaleDir + P, -lt, lt), this._onScaleChanged(), o.mode === "none") {
+          const R = this.mode || he(c, c.plane, o.origin, this.tool.view.state.camera);
+          if (R != null) {
+            switch (R) {
+              case "rotate":
+                this.tool.emit("graphic-rotate-start", { graphic: e, angle: 0 }), this.tool.emit("record-undo", { record: this.adapter.createUndoRecord() });
+                break;
+              case "scale":
+                this.tool.emit("graphic-scale-start", { graphic: e, xScale: 1, yScale: 1 }), this.tool.emit("record-undo", { record: this.adapter.createUndoRecord() });
+            }
+            o.mode = R;
+          }
+        }
+        switch (o.mode) {
+          case "rotate":
+            h.state.angle = o.initialAngle + g;
+            break;
+          case "scale":
+            h.state.scale = _, this._onScaleChanged();
+        }
+        switch (this._updateDragState(), this._updateManipulatorTransform(), c.action) {
+          case "start":
+          case "update":
+            switch (o.mode) {
+              case "rotate":
+                this.tool.emit("graphic-rotate", { graphic: e, angle: tt(o.angle) });
+                break;
+              case "scale":
+                this.tool.emit("graphic-scale", { graphic: e, xScale: _, yScale: _ });
+            }
+            break;
+          case "end":
+            switch (o.mode) {
+              case "rotate":
+                this.tool.emit("graphic-rotate-stop", { graphic: e, angle: tt(o.angle) });
+                break;
+              case "scale":
+                this.tool.emit("graphic-scale-stop", { graphic: e, xScale: _, yScale: _ });
+            }
+        }
+        return c.action === "end" && (this.startAnimation(gt(this, () => this._onScaleChanged())), this._scaleRotateDragData = null, this._updateDragState(), h.done()), c;
+      }).next(this._updateTooltipPipelineStep(o)), p.next(() => {
+        if (h.cancel(), this._scaleRotateDragData != null) {
+          switch (this._scaleRotateDragData.mode) {
+            case "none":
+              break;
+            case "rotate":
+              this.tool.emit("graphic-rotate-stop", { graphic: e, angle: 0 });
+              break;
+            case "scale":
+              this.tool.emit("graphic-scale-stop", { graphic: e, xScale: 1, yScale: 1 });
+          }
+          this.startAnimation(gt(this, () => this._onScaleChanged())), this._scaleRotateDragData = null, this._updateDragState();
+        }
+        this._updateFocusTooltip();
+      });
+    });
+    this.addHandles([r, t.events.on("focus-changed", (a) => {
+      a.action === "focus" ? this.startAnimation(de(this, () => this._updateDelayedFocusedState(), { delayMs: this._ringIndicatorDelayMs })) : this._updateDelayedFocusedState();
+    }), t.events.on("immediate-click", (a) => {
+      a.stopPropagation();
+    }), V(() => {
+      var a;
+      return (a = this.tool.graphicState) == null ? void 0 : a.displaying;
+    }, (a) => this._ringManipulator.available = a, B)]);
+  }
+  _updateTooltipPipelineStep(t) {
+    return (e) => {
+      const { sketchOptions: r } = this, { effectiveEnabled: a, visualVariables: i } = r.tooltips;
+      if (!a)
+        return e;
+      if (e.action === "end")
+        return this._updateFocusTooltip(), e;
+      const p = this._tooltip;
+      switch (t.mode) {
+        case "scale": {
+          p.info = this._scaleTooltipInfo ?? (this._scaleTooltipInfo = new le({ sketchOptions: r }));
+          const { size: h, scale: o } = this.adapter, l = i == null ? void 0 : i.size, c = p.info;
+          c.sketchOptions = r, c.scale = { value: o }, c.size = h != null ? at(h, "meters") : void 0, c.sizePrecision = U(l == null ? void 0 : l.valueType), c.sizeUnit = l == null ? void 0 : l.unit;
+          break;
+        }
+        case "rotate": {
+          p.info = this._rotateTooltipInfo ?? (this._rotateTooltipInfo = new ne({ sketchOptions: r }));
+          const { orientationClockwise: h, relativeAngleClockwise: o } = this.adapter, l = i == null ? void 0 : i.rotation, c = U(l == null ? void 0 : l.valueType), u = p.info;
+          u.sketchOptions = r, u.rotation = o != null ? H(o, "radians", "geographic") : void 0, u.rotationPrecision = c, u.rotationType = (l == null ? void 0 : l.rotationType) ?? "geographic", u.orientation = h != null ? H(h, "radians", "geographic") : void 0, u.orientationPrecision = c;
+          break;
+        }
+      }
+      return e;
+    };
+  }
+  _updateFocusTooltip() {
+    const { sketchOptions: t, _tooltip: e } = this, { effectiveEnabled: r, visualVariables: a } = t.tooltips;
+    if (r)
+      if (this.getFocused()) {
+        const i = a == null ? void 0 : a.rotation, p = a == null ? void 0 : a.size, h = this.mode, { size: o, orientationClockwise: l } = this.adapter, c = l != null && (h == null || h === "rotate"), u = o != null && (h == null || h === "scale");
+        e.info = this._absoluteTooltipInfo ?? (this._absoluteTooltipInfo = new ce({ sketchOptions: t }));
+        const g = e.info;
+        g.sketchOptions = t, g.orientation = c ? H(l, "radians", "geographic") : void 0, g.orientationPrecision = U(i == null ? void 0 : i.valueType), g.rotationType = (i == null ? void 0 : i.rotationType) ?? "geographic", g.size = u ? at(o, "meters") : void 0, g.sizeUnit = p == null ? void 0 : p.unit, g.sizePrecision = U(p == null ? void 0 : p.valueType);
+      } else
+        e.clear();
+  }
+  _onScaleChanged() {
+    this.events.emit("scale-changed"), this._updateManipulatorTransform();
+  }
+  _updateDelayedFocusedState() {
+    this._ringManipulator.updateStateEnabled(s.DelayedFocused, this.getFocused()), this._updateFocusTooltip();
+  }
+  _updateDragState() {
+    var t;
+    if (this._ringManipulator.updateStateEnabled(s.Unlocked, !(this._scaleRotateDragData != null && ((t = this._scaleRotateDragData) == null ? void 0 : t.mode) !== "none")), this._scaleRotateDragData != null)
+      switch (this._scaleRotateDragData.mode) {
+        case "rotate":
+          this._ringManipulator.updateStateEnabled(s.ScaleIn | s.ScaleOut, !1), this._ringManipulator.updateStateEnabled(s.RotateLeft, this._scaleRotateDragData.angleDir < 0), this._ringManipulator.updateStateEnabled(s.RotateRight, this._scaleRotateDragData.angleDir >= 0);
+          break;
+        case "scale":
+          this._ringManipulator.updateStateEnabled(s.RotateLeft | s.RotateRight, !1), this._ringManipulator.updateStateEnabled(s.ScaleIn, this._scaleRotateDragData.scaleDir < 0), this._ringManipulator.updateStateEnabled(s.ScaleOut, this._scaleRotateDragData.scaleDir >= 0);
+      }
+    else
+      this._ringManipulator.updateStateEnabled(s.ScaleIn | s.ScaleOut | s.RotateLeft | s.RotateRight, !1);
+  }
+  _updateManipulatorTransform() {
+    const t = $t(J.get(), this.adapter.angle, q(0, 0, 1));
+    if (t == null)
+      return;
+    const e = this.getScale(), r = At(J.get(), mt(f.get(), e, e, e));
+    this._ringManipulator.modelTransform = Ot(J.get(), r, t);
+  }
+  _createRingManipulator() {
+    const t = (n, S, D) => {
+      const T = [], v = Math.ceil(Wt * (S - n) / (2 * Math.PI));
+      for (let d = 0; d < v + 1; d++) {
+        const E = n + d * (S - n) / v;
+        T.push(q(D * Math.cos(E), D * Math.sin(E), 0));
+      }
+      return T;
+    }, e = (n) => t(0, 2 * Math.PI, n), r = (n) => [[-n / 2, 0], [n / 2, 0], [n / 2, Q / 2], [-n / 2, Q / 2]], a = this._createMaterial(1), i = (n, S, D = a) => ee(D, r(S), n, [], [], !1), p = e(C), h = i(p, K), o = { left: new Array(), right: new Array() }, l = [];
+    for (let n = 0; n < 2; n++) {
+      const S = n * Math.PI - Math.PI / 4, D = Math.PI / 2 - Jt, T = S + D, v = S + Math.PI / 2 - D, d = t(T, v, Kt), E = i(d, O);
+      l.push(d), l.push(t(T, v, ht - K / 2)), o.left.push(E), o.right.push(E.instantiate());
+      for (let G = 0; G < 2; G++) {
+        const X = G === 0, m = Pt();
+        if (X) {
+          kt(m, m, [1, -1, 1]), it(m, m, -T, [0, 0, 1]);
+          const w = Math.round(ct * (d.length - 1));
+          m[12] = d[w][0], m[13] = d[w][1], m[14] = d[w][2];
+        } else {
+          it(m, m, v, [0, 0, 1]);
+          const w = Math.round((1 - ct) * (d.length - 1));
+          m[12] = d[w][0], m[13] = d[w][1], m[14] = d[w][2];
+        }
+        const Y = Zt(a, qt, 0, Vt, Q);
+        te(Y, m), (X ? o.left : o.right).push(Y);
+      }
+    }
+    const c = [];
+    for (let n = 0; n < 2; n++) {
+      const S = n * Math.PI - Math.PI / 4, D = Math.PI / 2 - Xt, T = S + D, v = S + Math.PI / 2 - D, d = t(T, v, ht);
+      c.push(i(d, O));
+    }
+    const u = this._createMaterial(0.66), g = this._createMaterial(0.5), I = this._createMaterial(0.33), _ = e(C + dt), P = e(C + ut), R = i(_, O, u), z = i(P, O, I), N = e(C - dt), j = e(C - ut), _t = i(N, O, u), St = i(j, O, I);
+    let F = [new M(h, s.DelayedFocused), new M(h.instantiate({ material: g }), se.None)];
+    this.mode && this.mode !== "scale" || (F = F.concat([...c.map((n) => new M(n, s.DelayedFocused | s.Unlocked)), new M(R, s.DelayedFocused | s.ScaleIn), new M(z, s.DelayedFocused | s.ScaleIn), new M(_t, s.DelayedFocused | s.ScaleOut), new M(St, s.DelayedFocused | s.ScaleOut)])), this.mode && this.mode !== "rotate" || (F = F.concat([...o.right.map((n) => new M(n.instantiate(), s.DelayedFocused | s.Unlocked)), ...o.left.map((n) => new M(n, s.DelayedFocused | s.RotateLeft)), ...o.right.map((n) => new M(n, s.DelayedFocused | s.RotateRight))]));
+    const Dt = [p, ...l];
+    return new Nt({ view: this.tool.view, renderObjects: F, autoScaleRenderObjects: !1, worldOriented: !0, radius: K, focusMultiplier: 1, touchMultiplier: 1.5, elevationInfo: zt(this.tool.graphicState.graphic), collisionType: { type: "ribbon", paths: Dt, direction: q(0, 0, 1) } });
+  }
+  _createMaterial(t) {
+    const e = new ie({ cullFace: Yt.Back, renderOccluded: ae.Transparent, isDecoration: !0 });
+    return this.addHandles(V(() => ({ color: Tt(this.tool.view.effectiveTheme.accentColor, t) }), (r) => e.setParameters(r), B)), e;
+  }
+  get test() {
+    return { ringManipulator: this._ringManipulator, setRingIndicatorDelayMs: (t) => this._ringIndicatorDelayMs = t, tooltip: this._tooltip };
+  }
+};
+function pe(t, e) {
+  const r = x(f.get(), e.renderStart, t.origin), a = x(f.get(), e.renderEnd, t.origin), i = ot(r), p = ot(a);
+  return i === 0 ? 0 : p / i;
+}
+function he(t, e, r, a) {
+  const { renderStart: i, renderEnd: p } = t, h = L(i, a, f.get()), o = L(p, a, f.get());
+  if (Ft(h, o) < pt * pt)
+    return null;
+  const l = x(f.get(), i, r), c = Et(f.get(), l, ft(e)), u = i, g = Ct(f.get(), u, c), I = L(r, a, f.get()), _ = h, P = L(g, a, f.get()), R = x(f.get(), P, _), z = x(f.get(), h, I), N = st(_, R), j = st(I, z);
+  return rt(N, o) < rt(j, o) ? "rotate" : "scale";
+}
+function L(t, e, r) {
+  return e.projectToScreen(t, W), mt(r, W[0], W[1], 0);
+}
+var k;
+function gt(t, e) {
+  let r = null, a = 1;
+  const i = () => a;
+  return { start: () => {
+    a = t.getScale(), r = t.getScale, t.getScale = i, e();
+  }, update: (p) => (a += ((a + 1) / 2 - a) * Math.min(p * Qt, 1), e(), Math.abs(a - 1) < 0.01 ? k.STOP : k.CONTINUE), destroy: () => {
+    r && (t.getScale = r), e();
+  } };
+}
+function de(t, e, r) {
+  let a = 0, i = null;
+  const p = () => !1;
+  return { start: () => {
+    i = t.getFocused, t.getFocused = p, a = 0, e();
+  }, update: (h) => (a += h, !(i != null && i()) || a >= r.delayMs ? k.STOP : k.CONTINUE), destroy: () => {
+    i && (t.getFocused = i), e();
+  } };
+}
+function U(t) {
+  switch (t) {
+    case "integer":
+    case "long":
+      return 0;
+    default:
+      return null;
+  }
+}
+b([A({ constructOnly: !0 })], y.prototype, "tool", void 0), b([A({ constructOnly: !0 })], y.prototype, "adapter", void 0), b([A({ constructOnly: !0 })], y.prototype, "sketchOptions", void 0), b([A()], y.prototype, "mode", void 0), b([A()], y.prototype, "_activeAnimation", void 0), b([A()], y.prototype, "updating", null), y = b([bt("esri.views.3d.interactive.editingTools.transformGraphic.GraphicScaleRotateTransform")], y), function(t) {
+  t[t.CONTINUE = 0] = "CONTINUE", t[t.STOP = 1] = "STOP";
+}(k || (k = {}));
+const W = wt();
+export {
+  y as GraphicScaleRotateTransform
+};