@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/geometryUtils.js

@@ -0,0 +1,22 @@
+import { fromValues as p } from "../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { getEpsilon as f } from "../../../../core/libs/gl-matrix-2/math/common.js";
+function y(n) {
+  const o = u(n);
+  return p(Math.cos(o), Math.sin(o));
+}
+function u(n) {
+  if (n == null || n.type !== "polyline" && n.type !== "polygon")
+    return 0;
+  const o = n.type === "polyline" ? n.paths : n.rings, l = f();
+  for (const i of o)
+    for (let t = 0; t < i.length - 1; t++) {
+      const r = i[t], e = i[t + 1], s = r[0] - e[0], a = r[1] - e[1];
+      if (s * s + a * a > l)
+        return Math.atan2(e[1] - r[1], e[0] - r[0]);
+    }
+  return 0;
+}
+export {
+  y as mainAxis,
+  u as orientation
+};

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

@@ -0,0 +1,26 @@
+import "../../../../core/has.js";
+function S(e) {
+  switch (e) {
+    case P.SUPPORTED:
+      break;
+    case P.GRAPHICS_LAYER_MISSING:
+      return "not owned by a graphics layer";
+    case P.GEOMETRY_MISSING:
+      return "no geometry";
+    case P.GEOMETRY_TYPE_UNSUPPORTED:
+      return "the geometry type is not supported";
+    case P.ELEVATION_MODE_UNSUPPORTED:
+      return "the elevation mode is not supported";
+    case P.SYMBOL_TYPE_UNSUPPORTED:
+      return "the symbol type is not supported";
+  }
+  return "";
+}
+var P;
+(function(e) {
+  e[e.SUPPORTED = 0] = "SUPPORTED", e[e.GRAPHICS_LAYER_MISSING = 1] = "GRAPHICS_LAYER_MISSING", e[e.GEOMETRY_MISSING = 2] = "GEOMETRY_MISSING", e[e.GEOMETRY_TYPE_UNSUPPORTED = 3] = "GEOMETRY_TYPE_UNSUPPORTED", e[e.ELEVATION_MODE_UNSUPPORTED = 4] = "ELEVATION_MODE_UNSUPPORTED", e[e.SYMBOL_TYPE_UNSUPPORTED = 5] = "SYMBOL_TYPE_UNSUPPORTED";
+})(P || (P = {}));
+export {
+  P as SupportedGraphicResult,
+  S as isSupportedGraphicResultMessage
+};

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

@@ -0,0 +1,74 @@
+import { removeHandles as L, handlesGroup as E, destroyHandle as S, refHandle as P } from "../../../../core/handleUtils.js";
+import { deg2rad as x } from "../../../../core/mathUtils.js";
+import { watch as h, initial as f } from "../../../../core/reactiveUtils.js";
+import { signal as A } from "../../../../core/signal.js";
+import { s as X, g as H, h as Y } from "../../../../chunks/vec32.js";
+import { create as z } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { getGraphicEffectiveElevationInfo as C } from "../../../../support/elevationInfoUtils.js";
+import { Manipulator3D as R } from "../Manipulator3D.js";
+import { GrabbingState as D } from "./GrabbingState.js";
+import { ManipulatorState as j } from "./ManipulatorState.js";
+import { ManipulatorType as k } from "./ManipulatorType.js";
+import { Settings as O } from "./settings.js";
+import { ExtendedLineVisualElement as F } from "../visualElements/ExtendedLineVisualElement.js";
+import { LaserlineVisualElement as I } from "../visualElements/LaserlineVisualElement.js";
+import { OutlineVisualElement as N } from "../visualElements/OutlineVisualElement.js";
+import { GraphicState as W } from "../../layers/graphics/GraphicState.js";
+import { RenderOccludedFlag as Z } from "../../webgl-engine/lib/Material.js";
+function ue(e) {
+  const { view: t, graphic: n } = e, i = new W({ graphic: n }), a = U(e, i), l = [a, _(e, a.visualElement, i), t.maskOccludee(n), t.trackGraphicState(i)];
+  return { visualElement: a.visualElement, remove: () => L(l) };
+}
+function U(e, t) {
+  const { view: n, graphic: i } = e, a = new N({ view: n, geometry: b(i) ? i.geometry : null, elevationInfo: C(i), attached: !1, isDecoration: !0 }), l = new O({ getTheme: () => n.effectiveTheme }), s = () => {
+    a.attached = t.displaying;
+  }, w = E([h(() => l.visualElements.lineGraphics.outline, (o) => o.apply(a), f), h(() => l.visualElements.lineGraphics.shadowStyle, (o) => o.apply(a), f), h(() => t.displaying, s), h(() => t.isDraped, (o) => {
+    a.isDraped = o;
+  }), t.on("changed", () => a.geometry = b(i) ? i.geometry : null), S(a)]);
+  return s(), { visualElement: a, remove: () => w.remove() };
+}
+function _(e, t, n) {
+  const { graphic: i, view: a } = e, l = [], s = C(i), w = s.mode === "on-the-ground" || !s.offset && s.mode !== "absolute-height", o = new j(), d = new O({ getTheme: () => a.effectiveTheme }), v = d.visualElements, m = new F({ view: a, extensionType: v.zVerticalLine.extensionType, innerWidth: 1, attached: !1, writeDepthEnabled: !1, renderOccluded: Z.OccludeAndTransparent, isDecoration: !0 }), V = x(v.heightPlaneAngleCutoff), y = new I({ view: a, attached: !1, angleCutoff: V, isDecoration: !0 }), T = A(1);
+  l.push(h(() => ({ lineShadowStyle: d.visualElements.lineGraphics.shadowStyle, pointShadowStyle: d.visualElements.pointGraphics.shadowStyle, alpha: T.value }), ({ lineShadowStyle: r, pointShadowStyle: g, alpha: $ }) => {
+    r.apply(t, $), g.apply(m, $);
+  }, f));
+  const M = A(1);
+  l.push(h(() => ({ heightPlane: d.visualElements.heightPlane, alpha: M.value }), ({ heightPlane: r, alpha: g }) => r.apply(y, g), f));
+  const c = () => {
+    if (o.update(e), !n.displaying || w && (n.isDraped || !b(i) || !i.geometry.hasZ))
+      return t.laserlineEnabled = !1, m.attached = !1, void (y.attached = !1);
+    t.laserlineEnabled = !0;
+    const r = o.grabbingState & D.XY ? v.laserlineAlphaMultiplier : 1;
+    T.value = r;
+    const g = o.grabbingState & D.Z ? v.laserlineAlphaMultiplier : 1;
+    M.value = g, q(m, o), B(e, t, y, o);
+  };
+  l.push(h(() => d.visualElements.zVerticalLine, (r) => r.apply(m), f)), l.push(n.on("changed", c), h(() => n.displaying, c), t.events.on("attachment-origin-changed", c), S(m), S(y));
+  const u = [], G = () => {
+    L(u), u.length = 0, e.forEachManipulator((r) => u.push(r.events.on("grab-changed", c))), e.forEachManipulator((r) => u.push(r.events.on("select-changed", c))), c();
+  };
+  return G(), l.push(e.onManipulatorsChanged(G), P(() => E(u))), E(l);
+}
+function q(e, t) {
+  const n = t.numSelected === 1 ? t.firstSelected : t.numSelected > 1 && t.firstGrabbedXY != null ? t.firstGrabbedXY : null;
+  n != null ? (e.setStartEndFromWorldDownAtLocation(n.renderLocation), e.attached = !0) : e.attached = !1;
+}
+function B(e, t, n, i) {
+  if (i.numSelected > 0) {
+    X(p, 0, 0, 0);
+    let a = 0;
+    e.forEachManipulator((l, s) => {
+      s === k.TRANSLATE_XY && l.selected && l instanceof R && (H(p, p, l.renderLocation), a++);
+    }), a > 0 ? (n.heightManifoldTarget = Y(p, p, 1 / a), n.attached = !0) : n.attached = !1;
+  } else {
+    const a = t.attachmentOrigin;
+    a != null && e.view.renderCoordsHelper.toRenderCoords(a, p) ? (n.heightManifoldTarget = p, n.attached = !0) : n.attached = !1;
+  }
+}
+function b(e) {
+  return e.geometry != null && (e.geometry.type === "polygon" || e.geometry.type === "polyline");
+}
+const p = z();
+export {
+  ue as createVisualElements
+};

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

@@ -0,0 +1,53 @@
+import { Manipulator3D as o } from "../../Manipulator3D.js";
+class n {
+  constructor() {
+    this._available = !0;
+  }
+  set location(a) {
+    this._forEachManipulator3D((t) => t.location = a);
+  }
+  set elevationAlignedLocation(a) {
+    this._forEachManipulator3D((t) => t.elevationAlignedLocation = a);
+  }
+  set elevationInfo(a) {
+    this._forEachManipulator3D((t) => t.elevationInfo = a);
+  }
+  get renderLocation() {
+    let a;
+    return this._forEachManipulator3D((t) => {
+      a || (a = t.renderLocation);
+    }), a;
+  }
+  get available() {
+    return this._available;
+  }
+  set available(a) {
+    this._available = a, this._forEachManipulator3D((t) => t.available = a);
+  }
+  get hovering() {
+    return this.someManipulator((a) => a.hovering);
+  }
+  get grabbing() {
+    return this.someManipulator((a) => a.grabbing);
+  }
+  get dragging() {
+    return this.someManipulator((a) => a.dragging);
+  }
+  hasManipulator(a) {
+    return this.someManipulator((t) => t === a);
+  }
+  someManipulator(a) {
+    let t = !1;
+    return this.forEachManipulator((i) => {
+      !t && a(i) && (t = !0);
+    }), t;
+  }
+  _forEachManipulator3D(a) {
+    this.forEachManipulator((t, i) => {
+      t instanceof o && a(t, i);
+    });
+  }
+}
+export {
+  n as Manipulation
+};

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

@@ -0,0 +1,84 @@
+import d from "../../../../../core/Handles.js";
+import { handlesGroup as c } from "../../../../../core/handleUtils.js";
+import y from "../../../../../core/has.js";
+import { when as x } from "../../../../../core/reactiveUtils.js";
+import { ManipulatorType as h } from "../ManipulatorType.js";
+import { discRadiusSmall as v, discRadius as A } from "./config.js";
+import { Manipulation as _ } from "./Manipulation.js";
+import { MoveXYAxisManipulation as m } from "./MoveXYAxisManipulation.js";
+import { MoveXYDiscManipulation as f } from "./MoveXYDiscManipulation.js";
+import { MoveZManipulation as g } from "./MoveZManipulation.js";
+class I extends _ {
+  constructor(i) {
+    super(), this._handles = new d(), this._interactive = !0;
+    const { tool: a, view: n, snapToScene: e, radius: t } = i;
+    this._view = n, this.xyManipulation = new f({ tool: a, view: n, snapToScene: e, radius: t }), this.xyAxisManipulation = new m({ tool: a, view: n, radius: t }), this.zManipulation = new g({ tool: a, view: n, radius: t }), this.xyManipulation.available = i.xyAvailable, this.xyAxisManipulation.available = i.xyAxisAvailable, this.zManipulation.available = i.zAvailable, this._autoHideXYAxis(), this.forEachManipulator((s) => this._handles.add(s.events.on("grab-changed", () => this._updateManipulatorInteractivity())));
+  }
+  destroy() {
+    this._handles.destroy(), this.xyManipulation.destroy(), this.xyAxisManipulation.destroy(), this.zManipulation.destroy();
+  }
+  createGraphicDragPipeline(i, a, n) {
+    return c([this.xyManipulation.createGraphicDragPipeline((e, t, s, o, r) => i(l.XY, e, t, s, o, r), a, n), this.xyAxisManipulation.createGraphicDragPipeline((e, t, s, o, r) => i(l.XY_AXIS, e, t, s, o, r), a, n), this.zManipulation.createGraphicDragPipeline((e, t, s, o, r) => i(l.Z, e, t, s, o, r), a, n)]);
+  }
+  createDragPipeline(i, a, n, e) {
+    return c([this.xyManipulation.createDragPipeline((t, s, o, r, u) => i(l.XY, t, s, o, r, u), a, n, e), this.xyAxisManipulation.createDragPipeline((t, s, o, r, u) => i(l.XY_AXIS, t, s, o, r, u), a, n, e), this.zManipulation.createDragPipeline((t, s, o, r, u) => i(l.Z, t, s, o, r, u), n)]);
+  }
+  set snapToScene(i) {
+    this.xyManipulation.snapToScene = i;
+  }
+  set angle(i) {
+    this.xyAxisManipulation.angle = i;
+  }
+  set interactive(i) {
+    this._interactive !== i && (this._interactive = i, this._updateManipulatorInteractivity());
+  }
+  set radius(i) {
+    this.xyAxisManipulation.radius = i, this.xyManipulation.radius = i, this.zManipulation.radius = i;
+  }
+  set displayScale(i) {
+    this.xyManipulation.displayScale = i, this.xyAxisManipulation.displayScale = i;
+  }
+  forEachManipulator(i) {
+    this.xyManipulation.forEachManipulator((a) => i(a, h.TRANSLATE_XY)), this.xyAxisManipulation.forEachManipulator((a) => i(a, h.TRANSLATE_XY)), this.zManipulation.forEachManipulator((a) => i(a, h.TRANSLATE_Z));
+  }
+  get _xyAxisVisible() {
+    const i = this.xyManipulation.someManipulator((a) => a.focused) || this.xyAxisManipulation.someManipulator((a) => a.focused);
+    return this._view.inputManager && this._view.inputManager.latestPointerType === "touch" || i;
+  }
+  _autoHideXYAxis() {
+    const i = this.xyAxisManipulation, a = this.xyManipulation;
+    if (y("esri-mobile"))
+      return;
+    const n = [];
+    a.forEachManipulator((t) => n.push(t)), i.forEachManipulator((t) => n.push(t));
+    const e = () => {
+      const t = [];
+      this._xyAxisVisible || i.forEachManipulator((s) => t.push(s.disableDisplay())), this._handles.remove(M), this._handles.add(t, M);
+    };
+    for (const t of n)
+      this._handles.add(t.events.on("focus-changed", e));
+    this._view.inputManager && this._handles.add(x(() => {
+      var t;
+      return (t = this._view.inputManager) == null ? void 0 : t.latestPointerType;
+    }, e)), e();
+  }
+  _updateManipulatorInteractivity() {
+    const i = this.grabbing;
+    this.forEachManipulator((a) => {
+      a.interactive = !i && this._interactive || a.grabbing;
+    });
+  }
+  static radiusForSymbol(i) {
+    const a = i != null && i.type === "point-3d" && i.symbolLayers;
+    return a && a.some((n) => n.type === "icon") ? v : A;
+  }
+}
+const M = "disable-xy-axis-display";
+var l;
+(function(p) {
+  p[p.XY = 0] = "XY", p[p.XY_AXIS = 1] = "XY_AXIS", p[p.Z = 2] = "Z";
+})(l || (l = {}));
+export {
+  l as ManipulationType,
+  I as MoveManipulation
+};

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

@@ -0,0 +1,116 @@
+import $ from "../../../../../Color.js";
+import y from "../../../../../core/Evented.js";
+import I from "../../../../../core/Handles.js";
+import { handlesGroup as D } from "../../../../../core/handleUtils.js";
+import { destroyMaybe as S } from "../../../../../core/maybe.js";
+import { watch as x, initial as P } from "../../../../../core/reactiveUtils.js";
+import { fromTranslation as _, fromZRotation as R, multiply as m, fromRotation as E, fromScaling as O } from "../../../../../core/libs/gl-matrix-2/math/mat4.js";
+import { create as b } from "../../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { s as d } from "../../../../../chunks/vec32.js";
+import { fromValues as M } from "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { sv3d as f, sm4d as l } from "../../../../../geometry/support/vectorStacks.js";
+import { getGraphicEffectiveElevationInfo as L } from "../../../../../support/elevationInfoUtils.js";
+import { Manipulator3D as C } from "../../Manipulator3D.js";
+import { RenderObject as g } from "../../RenderObject.js";
+import { screenToMapXYAtLocation as F } from "../dragEventPipeline3D.js";
+import { ManipulatorType as w } from "../ManipulatorType.js";
+import { discRadius as A, discHeight as G, discTranslateArrowOffset as q, discTranslateArrowSize as X } from "./config.js";
+import { Manipulation as Y } from "./Manipulation.js";
+import { createGraphicMoveDragPipeline as j } from "./moveUtils.js";
+import { CullFaceOptions as B } from "../../../webgl-engine/lib/basicInterfaces.js";
+import { createExtrudedTriangle as N, transformInPlace as U } from "../../../webgl-engine/lib/GeometryUtil.js";
+import { RenderOccludedFlag as k } from "../../../webgl-engine/lib/Material.js";
+import { ColorMaterial as z } from "../../../webgl-engine/materials/ColorMaterial.js";
+import { createManipulatorDragEventPipeline as H, dragAtLocation as V, constrainToMapAxis as Z, addScreenDelta as J } from "../../../../interactive/dragEventPipeline.js";
+import { ManipulatorStateFlags as v } from "../../../../interactive/interfaces.js";
+class $a extends Y {
+  constructor(a) {
+    super(), this._handles = new I(), this._arrowManipulatorInfos = new Array(), this._angle = 0, this._scale = 1, this._radius = A, this._updateAfterDrag = !1, this.events = new y(), this._tool = a.tool, this._view = a.view, this._opaqueMaterial = this._createMaterial(), this._transparentMaterial = this._createMaterial(0.5), a.radius != null && (this._radius = a.radius), this._createManipulators(), this.forEachManipulator((t) => this._tool.manipulators.add(t));
+  }
+  set orthogonalAvailable(a) {
+    this._arrowManipulatorInfos.length >= 3 && (this._arrowManipulatorInfos[1].manipulator.available = a, this._arrowManipulatorInfos[3].manipulator.available = a);
+  }
+  destroy() {
+    this._handles = S(this._handles), this.forEachManipulator((a) => {
+      this._tool.manipulators.remove(a), a.destroy();
+    }), this._tool = null, this._view = null, this._arrowManipulatorInfos.length = 0;
+  }
+  forEachManipulator(a) {
+    for (const { manipulator: t } of this._arrowManipulatorInfos)
+      a(t, w.TRANSLATE_XY);
+  }
+  createGraphicDragPipeline(a, t, r) {
+    const i = t.graphic, e = L(i), s = i.geometry.spatialReference;
+    return j(i, r, (o) => this.createDragPipeline((p, n, u, h, c) => ({ steps: n, cancel: u } = a(p, n, u, h, c), o(p, n, u)), e, s, i));
+  }
+  createDragPipeline(a, t, r, i) {
+    return D(this._arrowManipulatorInfos.map(({ manipulator: e }, s) => H(e, (o, p, n, u, h) => {
+      const c = p.next((T) => ({ ...T, manipulatorType: w.TRANSLATE_XY })).next(V(this._view, o.elevationAlignedLocation)).next(F(this._view, o.elevationAlignedLocation, t, r, i)).next(Z(o.location, this.angle + (s + 1) * Math.PI * 0.5)).next(J());
+      a(o, c, n, u, h);
+    })));
+  }
+  get angle() {
+    return this._angle;
+  }
+  set angle(a) {
+    this._angle = a, this.dragging ? this._updateAfterDrag = !0 : this._updateManipulatorTransform();
+  }
+  get displayScale() {
+    return this._scale;
+  }
+  set displayScale(a) {
+    this._scale = a, this._updateManipulatorTransform();
+  }
+  get radius() {
+    return this._radius;
+  }
+  set radius(a) {
+    this._radius !== a && (this._radius = a, this._updateManipulators());
+  }
+  _updateManipulators() {
+    for (let a = 0; a < this._arrowManipulatorInfos.length; a++)
+      this._updateArrowManipulator(this._arrowManipulatorInfos[a], a);
+    this._updateManipulatorTransform();
+  }
+  _updateArrowManipulator({ manipulator: a, transform: t }, r) {
+    const i = this._radius / A, e = X * i, s = e * Math.sqrt(3) / 2, o = N(this._opaqueMaterial, s, e / 2, e / 2, G);
+    U(o, _(l.get(), d(f.get(), 0, -s / 3, 0))), a.renderObjects = [new g(o, v.Focused), new g(o.instantiate({ material: this._transparentMaterial }), v.Unfocused)], a.radius = s / 3 * 2 * 1.2;
+    const p = R(l.get(), r * Math.PI / 2), n = _(l.get(), d(f.get(), 0, q * i, 0));
+    m(t, p, n);
+  }
+  _createManipulators() {
+    for (let a = 0; a < 4; a++) {
+      const t = this._createArrowManipulator(a);
+      this._arrowManipulatorInfos.push(t);
+    }
+    this._updateManipulatorTransform();
+  }
+  _updateManipulatorTransform() {
+    const a = this.angle, t = E(l.get(), a, M(0, 0, 1));
+    if (t == null)
+      return;
+    const r = O(l.get(), d(f.get(), this.displayScale, this.displayScale, this.displayScale)), i = m(l.get(), r, t);
+    for (const e of this._arrowManipulatorInfos) {
+      const s = m(l.get(), i, e.transform);
+      e.manipulator.modelTransform = s;
+    }
+  }
+  _createArrowManipulator(a) {
+    const t = new C({ view: this._view, autoScaleRenderObjects: !1, worldOriented: !0, focusMultiplier: 1, touchMultiplier: 1, collisionType: { type: "disc", direction: M(0, 0, 1) } }), r = { manipulator: t, transform: b() };
+    return this._updateArrowManipulator(r, a), this._handles.add(t.events.on("drag", (i) => {
+      this._updateAfterDrag && i.action === "end" && !this.dragging && (this._updateManipulatorTransform(), this._updateAfterDrag = !1);
+    })), r;
+  }
+  _createMaterial(a = 1) {
+    const t = new z({ cullFace: B.Back, renderOccluded: k.Transparent, isDecoration: !0 });
+    return this._handles.add(x(() => $.toUnitRGBA(this._view.effectiveTheme.accentColor), (r) => {
+      r[3] *= a, t.setParameters({ color: r });
+    }, P)), t;
+  }
+  get test() {
+    return { arrowManipulators: this._arrowManipulatorInfos.map(({ manipulator: a }) => a) };
+  }
+}
+export {
+  $a as MoveXYAxisManipulation
+};

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

@@ -0,0 +1,90 @@
+import S from "../../../../../Color.js";
+import T from "../../../../../core/Handles.js";
+import { destroyMaybe as g } from "../../../../../core/maybe.js";
+import { watch as v, initial as y } from "../../../../../core/reactiveUtils.js";
+import { fromScaling as m } from "../../../../../core/libs/gl-matrix-2/math/mat4.js";
+import { create as w } from "../../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { s as $ } from "../../../../../chunks/vec32.js";
+import { fromValues as p } from "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { sv3d as D, sm4d as A } from "../../../../../geometry/support/vectorStacks.js";
+import { getGraphicEffectiveElevationInfo as R } from "../../../../../support/elevationInfoUtils.js";
+import { Manipulator3D as E } from "../../Manipulator3D.js";
+import { RenderObject as h } from "../../RenderObject.js";
+import { screenToMapXYAtLocation as P } from "../dragEventPipeline3D.js";
+import { ManipulatorType as _ } from "../ManipulatorType.js";
+import { discRadius as f, discCollisionRadius as x, geometrySegments as O, discHeight as b } from "./config.js";
+import { Manipulation as C } from "./Manipulation.js";
+import { createGraphicMoveDragPipeline as L } from "./moveUtils.js";
+import { SnapToScene as F } from "../snapping/SnapToScene.js";
+import { CullFaceOptions as G } from "../../../webgl-engine/lib/basicInterfaces.js";
+import { createCylinderGeometry as X } from "../../../webgl-engine/lib/GeometryUtil.js";
+import { RenderOccludedFlag as Y } from "../../../webgl-engine/lib/Material.js";
+import { ColorMaterial as j } from "../../../webgl-engine/materials/ColorMaterial.js";
+import { createManipulatorDragEventPipeline as B, dragAtLocation as N, addScreenDelta as U } from "../../../../interactive/dragEventPipeline.js";
+import { ManipulatorStateFlags as M } from "../../../../interactive/interfaces.js";
+class ha extends C {
+  constructor(a) {
+    super(), this._handles = new T(), this._snapToScene = new F(), this._scale = 1, this._radius = f, this._view = a.view, this._tool = a.tool, this._discMaterial = this._createMaterial(), this._discMaterialTransparent = this._createMaterial(0.5), a.snapToScene != null && (this.snapToScene = a.snapToScene), a.radius != null && (this._radius = a.radius), this._createManipulator(), this.forEachManipulator((t) => this._tool.manipulators.add(t));
+  }
+  destroy() {
+    this._handles = g(this._handles), this.forEachManipulator((a) => {
+      this._tool.manipulators.remove(a), a.destroy();
+    }), this._tool = null, this._view = null, this._manipulator = null;
+  }
+  forEachManipulator(a) {
+    a(this._manipulator, _.TRANSLATE_XY);
+  }
+  get displayScale() {
+    return this._scale;
+  }
+  set displayScale(a) {
+    this._scale = a, this._updateManipulatorTransform();
+  }
+  get snapToScene() {
+    return this._snapToScene.enabled;
+  }
+  set snapToScene(a) {
+    this._snapToScene.enabled = a;
+  }
+  get radius() {
+    return this._radius;
+  }
+  set radius(a) {
+    a !== this._radius && (this._radius = a, this._updateManipulator());
+  }
+  createGraphicDragPipeline(a, t, e) {
+    const i = t.graphic, r = R(i), s = i.geometry.spatialReference;
+    return L(i, e, (c) => this.createDragPipeline((l, o, n, u, d) => ({ steps: o, cancel: n } = a(l, o, n, u, d), c(l, o, n)), r, s, i));
+  }
+  createDragPipeline(a, t, e, i) {
+    const r = this._view;
+    return B(this._manipulator, (s, c, l, o, n) => {
+      const u = c.next(N(r, s.elevationAlignedLocation)).next(P(r, s.elevationAlignedLocation, t, e, i)).next(...this._snapToScene.createDragEventPipelineStep(r, t)).next((d) => ({ ...d, manipulatorType: _.TRANSLATE_XY })).next(U());
+      a(s, u, l, o, n);
+    });
+  }
+  _updateManipulatorTransform() {
+    const a = m(A.get(), $(D.get(), this.displayScale, this.displayScale, this.displayScale));
+    this._manipulator.modelTransform = a;
+  }
+  _createManipulator() {
+    const a = this._view;
+    this._manipulator = new E({ view: a, worldSized: !1, autoScaleRenderObjects: !1, focusMultiplier: 1, touchMultiplier: 1, collisionType: { type: "disc", direction: p(0, 0, 1) }, worldOriented: !0 }), this._updateManipulator();
+  }
+  _updateManipulator() {
+    const a = X(this._discMaterial, b, 1, O, p(0, 0, 1), p(0, 0, 0));
+    a.transformation = m(w(), p(this._radius, this._radius, this._radius)), this._manipulator.renderObjects = [new h(a, M.Focused), new h(a.instantiate({ material: this._discMaterialTransparent }), M.Unfocused)], this._manipulator.radius = x * (this._radius / f);
+  }
+  _createMaterial(a = 1) {
+    const t = new j({ cullFace: G.Back, renderOccluded: Y.Transparent, isDecoration: !0 });
+    return this._handles.add(v(() => S.toUnitRGBA(this._view.effectiveTheme.accentColor), (e) => {
+      e[3] *= a, t.setParameters({ color: e });
+    }, y)), t;
+  }
+  get test() {
+    return { discManipulator: this._manipulator };
+  }
+}
+export {
+  ha as MoveXYDiscManipulation
+};

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

@@ -0,0 +1,36 @@
+import { screenToMapXYForGraphic as h } from "../dragEventPipeline3D.js";
+import { ManipulatorType as c } from "../ManipulatorType.js";
+import { Manipulation as u } from "./Manipulation.js";
+import { createGraphicMoveDragPipeline as m } from "./moveUtils.js";
+import { createManipulatorDragEventPipeline as _, addMapDelta as g, addScreenDelta as M } from "../../../../interactive/dragEventPipeline.js";
+import { GraphicManipulator as v } from "../../../../interactive/GraphicManipulator.js";
+class y extends u {
+  constructor(a) {
+    super(), this._view = a.view, this._tool = a.tool, this._graphicState = a.graphicState, this._createManipulator(), this.forEachManipulator((t) => this._tool.manipulators.add(t));
+  }
+  destroy() {
+    this.forEachManipulator((a) => {
+      this._tool.manipulators.remove(a), a.destroy();
+    }), this._tool = null, this._view = null, this._manipulator = null, this._graphicState = null;
+  }
+  forEachManipulator(a) {
+    a(this._manipulator, c.TRANSLATE_XY);
+  }
+  createGraphicDragPipeline(a) {
+    return m(this._graphicState.graphic, a, (t) => this.createDragPipeline(t));
+  }
+  createDragPipeline(a) {
+    const t = this._view, i = this._graphicState.graphic, e = i.geometry != null ? i.geometry.spatialReference : null;
+    return _(this._manipulator, (o, p, n, s, r) => {
+      const l = p.next(h(r, t, i, e)).next(g()).next(M());
+      a(o, l, n, s, r);
+    });
+  }
+  _createManipulator() {
+    const a = this._view, t = this._graphicState.graphic;
+    this._manipulator = new v({ graphic: t, view: a, selectable: !0, cursor: "move" });
+  }
+}
+export {
+  y as MoveXYGraphicManipulation
+};

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

@@ -0,0 +1,96 @@
+import F from "../../../../../Color.js";
+import { darken as R } from "../../../../../core/colorUtils.js";
+import b from "../../../../../core/Evented.js";
+import { clamp as A } from "../../../../../core/mathUtils.js";
+import { removeMaybe as x } from "../../../../../core/maybe.js";
+import { watch as S } from "../../../../../core/reactiveUtils.js";
+import { translate as E, rotateX as H, scale as j } from "../../../../../core/libs/gl-matrix-2/math/mat4.js";
+import { create as G } from "../../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { o as L, f as Z, n as P, k as I, b as T, h as N } from "../../../../../chunks/vec32.js";
+import { create as y, fromValues as $ } from "../../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { Manipulator3D as W } from "../../Manipulator3D.js";
+import { createManipulatorMaterial as D } from "../../manipulatorUtils.js";
+import { RenderObject as m } from "../../RenderObject.js";
+import { screenToZConstrained as q } from "../dragEventPipeline3D.js";
+import { ManipulatorType as U } from "../ManipulatorType.js";
+import { Settings as B } from "../settings.js";
+import { discRadius as C } from "./config.js";
+import { Manipulation as V } from "./Manipulation.js";
+import { createGraphicMoveDragPipeline as X } from "./moveUtils.js";
+import { createTubeGeometry as J, createConeGeometry as K } from "../../../webgl-engine/lib/GeometryUtil.js";
+import { RenderOccludedFlag as k } from "../../../webgl-engine/lib/Material.js";
+import { createManipulatorDragEventPipeline as Q, addScreenDelta as Y } from "../../../../interactive/dragEventPipeline.js";
+import { ManipulatorStateFlags as u } from "../../../../interactive/interfaces.js";
+class Pe extends V {
+  constructor(e) {
+    super(), this._radius = C, this.events = new b(), this._tool = e.tool, this._view = e.view;
+    const a = new B({ getTheme: () => this._view.effectiveTheme });
+    this._settings = a, e.radius != null && (this._radius = e.radius);
+    const r = this._view.effectiveTheme.accentColor;
+    this._materials = { materialUnfocused: D(this._createDarkenedColor(r, 1, 0.25), k.Occlude), materialFocused: D(this._createDarkenedColor(r, 1, 0), k.Occlude), materialOccludedUnfocused: D(this._createDarkenedColor(r, 0.7, 0), a.zManipulator.renderOccluded), materialOccludedFocused: D(this._createDarkenedColor(r, 0.85, 0), a.zManipulator.renderOccluded) }, this._themeHandle = S(() => this._view.effectiveTheme.accentColor, (t) => {
+      const o = this._createDarkenedColor(t, 1, 0.25), s = this._createDarkenedColor(t, 1, 0), l = this._createDarkenedColor(t, 0.7, 0), i = this._createDarkenedColor(t, 0.85, 0), { materialUnfocused: n, materialFocused: c, materialOccludedUnfocused: f, materialOccludedFocused: d } = this._materials;
+      n.setParameters({ color: o }), c.setParameters({ color: s }), f.setParameters({ color: l }), d.setParameters({ color: i });
+    }), this._createManipulator(), this.forEachManipulator((t) => this._tool.manipulators.add(t));
+  }
+  destroy() {
+    this._themeHandle = x(this._themeHandle), this._manipulator.applyObjectTransform = te, this.forEachManipulator((e) => {
+      this._tool.manipulators.remove(e), e.destroy();
+    });
+  }
+  forEachManipulator(e) {
+    e(this._manipulator, U.TRANSLATE_Z);
+  }
+  createGraphicDragPipeline(e, a, r) {
+    const t = a.graphic.geometry.spatialReference;
+    return X(a.graphic, r, (o) => this.createDragPipeline((s, l, i, n, c) => ({ steps: l, cancel: i } = e(s, l, i, n, c), o(s, l, i)), t));
+  }
+  createDragPipeline(e, a) {
+    const r = this._view;
+    return Q(this._manipulator, (t, o, s, l, i) => {
+      const n = o.next((c) => ({ ...c, manipulatorType: U.TRANSLATE_Z })).next(q(r, t.renderLocation, a)).next(Y());
+      e(t, n, s, l, i);
+    });
+  }
+  get radius() {
+    return this._radius;
+  }
+  set radius(e) {
+    e !== this._radius && (this._radius = e, this._updateManipulator());
+  }
+  _updateManipulator() {
+    const e = this._settings, a = this._radius / C, r = e.zManipulator.height * a, t = e.zManipulator.coneHeight * a, o = e.zManipulator.coneWidth * a, s = e.zManipulator.width * a, l = [$(0, 0, 0), $(0, 0, r)], i = [$(0, 0, 0), $(0, 0, r + t)], n = (v) => {
+      const h = G();
+      if (E(h, h, [0, 0, r]), H(h, h, Math.PI / 2), v) {
+        const O = 1 + 2 * v / o;
+        j(h, h, [O, O, O]);
+      }
+      return h;
+    }, c = n(0), { materialUnfocused: f, materialFocused: d, materialOccludedUnfocused: _, materialOccludedFocused: g } = this._materials, M = J(f, l, s / 2, 16, !1), p = K(f, t, o / 2, 16, !1);
+    p.transformation = c, this._manipulator.renderObjects = [new m(p, u.Unfocused), new m(M, u.Unfocused), new m(p.instantiate({ material: d }), u.Focused), new m(M.instantiate({ material: d }), u.Focused), new m(p.instantiate({ material: _ }), u.Unfocused), new m(M.instantiate({ material: _ }), u.Unfocused), new m(p.instantiate({ material: g }), u.Focused), new m(M.instantiate({ material: g }), u.Focused)], this._manipulator.radius = s / 2 + 2, this._manipulator.collisionType = { type: "line", paths: [i] };
+  }
+  _createManipulator() {
+    const e = this._view, a = new W({ view: e, autoScaleRenderObjects: !1, worldSized: !1, selectable: !1, cursor: "ns-resize", elevationInfo: this.elevationInfo, worldOriented: !0, collisionPriority: 1.6 });
+    a.applyObjectTransform = (r) => {
+      const t = e.state.camera, o = z;
+      e.renderCoordsHelper.toRenderCoords(this._manipulator.elevationAlignedLocation, o);
+      const s = L(t.eye, o), l = t.computeRenderPixelSizeAtDist(s), i = Z(w, o, t.eye);
+      P(i, i);
+      const n = ee;
+      e.renderCoordsHelper.worldUpAtPosition(z, n);
+      const c = Math.abs(I(i, n)), f = T(w, i, n), d = T(w, f, n), _ = A(c, 0.01, 1), g = 1 - Math.sqrt(1 - _ * _) / _ / t.fullWidth, M = this._settings, p = this._radius / C, v = M.zManipulator.width * p;
+      N(d, P(d, d), (1 / g - 1) * s + l * v), r[12] -= w[0], r[13] -= w[1], r[14] -= w[2];
+    }, this._manipulator = a, this._updateManipulator();
+  }
+  _createDarkenedColor(e, a, r) {
+    const t = R(e, r);
+    return t.a *= a, F.toUnitRGBA(t);
+  }
+  get test() {
+    return { manipulator: this._manipulator };
+  }
+}
+const z = y(), w = y(), ee = y(), te = () => {
+};
+export {
+  Pe as MoveZManipulation
+};

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

@@ -0,0 +1,29 @@
+const s = 128, r = 70, i = 80, e = 0.02, t = 54, n = 100, o = Math.ceil(46.666666666666664), a = 160, c = 0.5, d = 24, l = 9, g = a + 30, h = a + 53, I = 60, f = 23, u = 5 * Math.PI / 12, A = 1 * Math.PI / 3, R = 10, T = 0.2, m = 30, w = 53, P = 0.2, p = 0.3, M = 200, S = 3, k = 1e6;
+export {
+  k as alignArrowsScaleThreshold,
+  i as discCollisionRadius,
+  e as discHeight,
+  r as discRadius,
+  o as discRadiusSmall,
+  n as discTranslateArrowOffset,
+  t as discTranslateArrowSize,
+  R as dragThresholdPx,
+  s as geometrySegments,
+  l as indicatorThickness,
+  g as innerIndicatorRadius,
+  h as outerIndicatorRadius,
+  c as ringHeight,
+  M as ringIndicatorDelayMs,
+  a as ringRadius,
+  S as ringResetAnimationSpeedFactor,
+  d as ringThickness,
+  u as rotateIndicatorArcLength,
+  T as rotateIndicatorArrowPlacementPercentage,
+  I as rotateIndicatorArrowTipLength,
+  f as rotateIndicatorArrowTipRadius,
+  p as rotateIndicatorDirectionBuffer,
+  A as scaleIndicatorArcLength,
+  P as scaleIndicatorDirectionBuffer,
+  m as scaleIndicatorOffset1,
+  w as scaleIndicatorOffset2
+};