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

@@ -0,0 +1,25 @@
+import { dragGraphic as o, resetGraphic as p } from "../../../../interactive/dragEventPipeline.js";
+function l(e, s, c) {
+  const n = (r, t) => s({ action: r, graphic: e, dxScreen: t.screenDeltaX, dyScreen: t.screenDeltaY });
+  return c((r, t, i) => (t.next((a) => (a.action === "start" && n("start", a), a)).next(o(e)).next((a) => {
+    switch (a.action) {
+      case "start":
+      case "update":
+        (a.translationX || a.translationY || a.translationZ) && n("update", a);
+        break;
+      case "end":
+        n("end", a);
+    }
+    return a;
+  }), { steps: t, cancel: i = i.next(p(e)).next((a) => (n("end", { screenDeltaX: 0, screenDeltaY: 0 }), a)) }));
+}
+function d(e) {
+  if ((e == null ? void 0 : e.axis) == null)
+    return 1;
+  const { mapStart: s, mapEnd: c, axis: n } = e, r = [c.x - s.x, c.y - s.y];
+  return r[0] * n[0] + r[1] * n[1] > 0 ? 1 : -1;
+}
+export {
+  d as axisConstrainedDragSign,
+  l as createGraphicMoveDragPipeline
+};

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

@@ -0,0 +1,7 @@
+import { getGraphicEffectiveElevationInfo as n } from "../../../../support/elevationInfoUtils.js";
+function r(o, e = n(o)) {
+  return e.mode !== "on-the-ground" && !(o.geometry == null || !o.geometry.hasZ);
+}
+export {
+  r as canMoveZ
+};

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

@@ -0,0 +1,34 @@
+import { makeHandle as m } from "../../../../core/handleUtils.js";
+import { watch as p, syncAndInitial as l } from "../../../../core/reactiveUtils.js";
+import { isRelativeVertexSpace as d } from "../../../../geometry/support/meshVertexSpaceUtils.js";
+import { equals as h } from "../../../../geometry/support/spatialReferenceUtils.js";
+import { MeshTransformUpdateAction as c } from "../../../../layers/graphics/sources/interfaces.js";
+import { ViewingMode as o } from "../../../ViewingMode.js";
+function F(a, e) {
+  const { graphic: t } = a;
+  return [p(() => a.displaying, (r) => {
+    r ? g(t, e) : i(t, e);
+  }, { ...l }), m(() => i(t, e))];
+}
+function g(a, e) {
+  const { geometry: t } = a;
+  f(t, e) && a.notifyMeshTransformChanged({ action: c.EnableFastUpdates });
+}
+function i(a, e) {
+  const { geometry: t } = a;
+  f(t, e) && a.notifyMeshTransformChanged({ action: c.DisableFastUpdates });
+}
+function f(a, { state: { viewingMode: e }, spatialReference: t }) {
+  if ((a == null ? void 0 : a.type) !== "mesh")
+    return !1;
+  const { vertexSpace: r, spatialReference: s } = a;
+  if (!d(r))
+    return !1;
+  const { type: n } = r;
+  return e === o.Global && n === "local" || e === o.Local && h(t, s) && n === "georeferenced" && !s.isGeographic;
+}
+export {
+  F as meshTransformFastUpdateHandles,
+  i as tryDisableMeshTransformFastUpdates,
+  g as tryEnableMeshTransformFastUpdates
+};

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

@@ -0,0 +1,256 @@
+import { _ as d } from "../../../../../chunks/tslib.es6.js";
+import H from "../../../../../core/Collection.js";
+import D from "../../../../../core/Evented.js";
+import { makeHandle as O } from "../../../../../core/handleUtils.js";
+import { destroyMaybe as y } from "../../../../../core/maybe.js";
+import { zeroMeters as T, scale as X } from "../../../../../core/quantityUtils.js";
+import { watch as w, syncAndInitial as Y } from "../../../../../core/reactiveUtils.js";
+import { property as g } from "../../../../../core/accessorSupport/decorators/property.js";
+import "../../../../../core/has.js";
+import "../../../../../core/Logger.js";
+import "../../../../../core/RandomLCG.js";
+import { subclass as k } from "../../../../../core/accessorSupport/decorators/subclass.js";
+import { UpdatingHandles as A } from "../../../../../core/support/UpdatingHandles.js";
+import { makeDehydratedPoint as P } from "../../../../../layers/graphics/dehydratedPoint.js";
+import { getGraphicEffectiveElevationInfo as I, getConvertedElevation as z } from "../../../../../support/elevationInfoUtils.js";
+import { getGraphicAttachmentOrigin as R } from "../../manipulatorUtils.js";
+import { SnappingVisualizer3D as Z } from "../../SnappingVisualizer3D.js";
+import { orientation as V } from "../geometryUtils.js";
+import { SupportedGraphicResult as F } from "../isSupportedGraphicUtils.js";
+import { canMoveZ as C } from "../manipulatorUtils.js";
+import { meshTransformFastUpdateHandles as U } from "../meshFastUpdateUtils.js";
+import { createVisualElements as B } from "../visualElementUtils.js";
+import { discRadius as N } from "../manipulations/config.js";
+import { ManipulationType as m, MoveManipulation as G } from "../manipulations/MoveManipulation.js";
+import { axisConstrainedDragSign as q } from "../manipulations/moveUtils.js";
+import { MoveXYGraphicManipulation as L } from "../manipulations/MoveXYGraphicManipulation.js";
+import { isSupportedGraphic as j } from "./isSupportedGraphic.js";
+import { OutlineVisualElement as b } from "../../visualElements/OutlineVisualElement.js";
+import { GraphicState as J } from "../../../layers/graphics/GraphicState.js";
+import { dragGraphicMany as K, resetGraphicMany as Q } from "../../../../interactive/dragEventPipeline.js";
+import { InteractiveToolBase as W } from "../../../../interactive/InteractiveToolBase.js";
+import { EditGeometryOperations as tt } from "../../../../interactive/editGeometry/EditGeometryOperations.js";
+import $ from "../../../../interactive/sketch/SketchOptions.js";
+import { SnappingContext as it } from "../../../../interactive/snapping/SnappingContext.js";
+import { createSnapDragEventPipelineStep as et } from "../../../../interactive/snapping/SnappingDragPipelineStep.js";
+import { Tooltip as at } from "../../../../interactive/tooltip/Tooltip.js";
+import { TranslateGraphicZTooltipInfo as ot, TranslateGraphicXYTooltipInfo as nt, TranslateGraphicTooltipInfo as st } from "../../../../interactive/tooltip/TranslateTooltipInfos.js";
+import { autoDistanceBetweenPoints2D as x } from "../../../../support/automaticLengthMeasurementUtils.js";
+import { verticalSignedDistanceBetweenPoints as rt } from "../../../../support/euclideanLengthMeasurementUtils.js";
+class pt {
+  constructor(t) {
+    this.allGraphics = t, this.type = "graphic-move-start";
+  }
+}
+class lt {
+  constructor(t, e, a) {
+    this.dx = t, this.dy = e, this.allGraphics = a, this.type = "graphic-move";
+  }
+}
+class E {
+  constructor(t) {
+    this.allGraphics = t, this.type = "graphic-move-stop";
+  }
+}
+const c = "manipulators";
+let u = class extends D.EventedMixin(W) {
+  constructor(i) {
+    super(i), this._infos = /* @__PURE__ */ new Map(), this.graphics = new H(), this.enableZ = !0, this.sketchOptions = new $(), this.type = "move-3d", this.tooltip = null, this._updatingHandles = new A(), this._moveManipulation = null, this._latestTooltipInfo = null, this._translateGraphicTooltipInfo = null, this._translateGraphicXYTooltipInfo = null, this._translateGraphicZTooltipInfo = null;
+  }
+  initialize() {
+    const { view: i } = this;
+    this.addHandles([this.graphics.on("change", (e) => {
+      e.removed.forEach((a) => this.removeHandles(a)), this._updateGraphicInfos(e), this._setupFastTransformUpdates(e.added), this._refreshManipulators();
+    }), w(() => this.sketchOptions.tooltips.effectiveEnabled, (e) => {
+      this.tooltip = e ? new at({ info: this._latestTooltipInfo, view: i }) : y(this.tooltip);
+    }, Y)]);
+    const t = this.graphics.toArray();
+    this._updateGraphicInfos({ added: t, removed: [] }), this._setupFastTransformUpdates(t), this._refreshManipulators(), this.finishToolCreation();
+  }
+  destroy() {
+    this.tooltip = y(this.tooltip), this._moveManipulation = y(this._moveManipulation), this._set("view", null), this._updatingHandles.destroy();
+  }
+  get updating() {
+    return this._updatingHandles.updating;
+  }
+  reset() {
+  }
+  _updateGraphicInfos({ added: i, removed: t }) {
+    var e;
+    for (const a of i) {
+      if (j(a) !== F.SUPPORTED)
+        continue;
+      const o = new ht(a), n = this.view.trackGraphicState(o.state);
+      this._infos.set(o.graphic, { info: o, handle: n });
+    }
+    for (const a of t)
+      (e = this._infos.get(a)) == null || e.handle.remove(), this._infos.delete(a);
+  }
+  _setupFastTransformUpdates(i) {
+    const { view: t } = this;
+    for (const e of i) {
+      const { info: a } = this._infos.get(e);
+      this.addHandles(U(a.state, t), e);
+    }
+  }
+  _refreshManipulators() {
+    if (this.removeHandles(c), this._moveManipulation = y(this._moveManipulation), this.manipulators.removeAll(), this._infos.size === 0)
+      return;
+    const i = Array.from(this._infos.values(), ({ info: t }) => t);
+    this._createManipulators(i), this._createVisualElements(i), this._updateMoveManipulation(i);
+  }
+  _createManipulators(i) {
+    for (const t of i) {
+      const e = t.state;
+      t.manipulationXY = new L({ tool: this, view: this.view, graphicState: e }), t.manipulationXY.forEachManipulator((a) => this.addHandles([a.events.on("immediate-click", (o) => {
+        this.emit("immediate-click", { ...o, graphic: e.graphic }), o.stopPropagation();
+      }), a.events.on("grab-changed", ({ action: o }) => {
+        o === "start" ? this._showTooltip(m.XY) : this._hideTooltip();
+      })], c)), this.addHandles(t.manipulationXY.createDragPipeline((a, o, n, s) => this._buildDragEventPipeline(i, m.XY, a, o, n, s)), c);
+    }
+    this._createMoveManipulation(i);
+  }
+  _createMoveManipulation(i) {
+    const t = new G({ tool: this, view: this.view, snapToScene: !1, xyAvailable: !0, xyAxisAvailable: !0, zAvailable: !0, radius: i.length === 1 ? G.radiusForSymbol(i[0].graphic.symbol) : N });
+    this._moveManipulation = t, t.elevationInfo = { mode: "absolute-height", offset: 0 }, t.forEachManipulator((n) => {
+      this.addHandles(n.events.on("immediate-click", (s) => {
+        t.zManipulation.hasManipulator(n) || this.graphics.length !== 1 || this.emit("immediate-click", { ...s, graphic: this.graphics.at(0) }), s.stopPropagation();
+      }), c);
+    });
+    const e = (n) => (s) => {
+      this.addHandles([s.events.on("focus-changed", ({ action: p }) => {
+        p === "focus" ? this._showTooltip(n) : this._hideTooltip();
+      }), s.events.on("grab-changed", () => {
+        this._latestTooltipInfo && (this._latestTooltipInfo.distance = T);
+      })], c);
+    };
+    this._moveManipulation.xyManipulation.forEachManipulator(e(m.XY)), this._moveManipulation.xyAxisManipulation.forEachManipulator(e(m.XY_AXIS)), this._moveManipulation.zManipulation.forEachManipulator(e(m.Z));
+    const a = () => this._updateMoveManipulation(i);
+    for (const n of i)
+      this.addHandles([n.state.on("changed", a), w(() => n.state.displaying, a)], c);
+    const o = i[i.length - 1];
+    this.addHandles(o.state.on("changed", () => this._updateMoveManipulationAngle(o)), c), this.addHandles(t.createDragPipeline((n, s, p, l, h) => this._buildDragEventPipeline(i, n, s, p, l, h), I(o.graphic), o.graphic.geometry.spatialReference, o.graphic), c), this._updateMoveManipulationAngle(o);
+  }
+  _createVisualElements(i) {
+    for (const t of i) {
+      const e = t.graphic, a = B({ view: this.view, graphic: e, forEachManipulator: (o) => {
+        var n, s;
+        (n = t.manipulationXY) == null || n.forEachManipulator(o), (s = this._moveManipulation) == null || s.forEachManipulator(o);
+      }, onManipulatorsChanged: () => O() });
+      a != null && (t.geometryRepresentation = a.visualElement, t.geometryRepresentation instanceof b && this.addHandles([t.geometryRepresentation.events.on("attachment-origin-changed", () => {
+        t.state.isDraped || this._updateMoveManipulation(i);
+      }), w(() => t.state.isDraped, () => this._updateMoveManipulation(i))], c), this.addHandles(a, c));
+    }
+  }
+  _updateMoveManipulationAngle(i) {
+    this._moveManipulation && (this._moveManipulation.angle = V(i.graphic.geometry));
+  }
+  _updateMoveManipulation(i) {
+    const t = P(0, 0, 0, this.view.spatialReference);
+    let e = 0, a = !1;
+    const o = this._moveManipulation;
+    if (o) {
+      for (const n of i) {
+        if (!n.state.displaying)
+          continue;
+        const s = n.state.graphic;
+        this.enableZ && C(s) && (a = !0);
+        const p = n.geometryRepresentation instanceof b && !n.state.isDraped ? n.geometryRepresentation.attachmentOrigin : R(this.view, s);
+        if (p != null) {
+          const { x: l, y: h, z: v } = p;
+          t.x += l, t.y += h, v && (t.z ?? (t.z = 0), t.z += v), e++;
+        }
+      }
+      e > 0 ? (t.x /= e, t.y /= e, t.z ?? (t.z = 0), t.z /= e, o.location = t, o.xyManipulation.available = !0, o.xyAxisManipulation.available = !0, o.zManipulation.available = a) : o.available = !1;
+    }
+  }
+  _buildDragEventPipeline(i, t, e, a, o, n) {
+    const s = [], p = [];
+    let l = null, h = null;
+    const v = () => {
+      for (const r of s)
+        r.dragging = !1;
+      s.length = 0, p.length = 0, l = null, h = null, this._moveManipulation && (this._moveManipulation.interactive = !0);
+    };
+    if (i.length === 1 && t === m.XY) {
+      const r = i[0].graphic;
+      ({ steps: a, cancel: o } = this._buildSnappingPipelineSteps(r, I(r), a, o, n));
+    }
+    return o = o.next((r) => h == null ? void 0 : h(r)).next(() => (this.emit("graphic-move-stop", new E(p)), this.destroyed || v(), null)), { steps: a = a.next((r) => {
+      var _, M;
+      if (r.action === "start") {
+        s.length = 0, p.length = 0;
+        for (const f of i)
+          f.dragging || !((_ = f.manipulationXY) != null && _.hasManipulator(e)) && ((M = f.manipulationXY) != null && M.grabbing) || (s.push(f), p.push(f.graphic), f.dragging = !0);
+        if (p.length !== 0 && (this._moveManipulation && (this._moveManipulation.interactive = !1), l = K(p), h = Q(p), this.emit("graphic-move-start", new pt(p)), this.destroyed))
+          return null;
+      }
+      return p.length !== 0 ? r : null;
+    }).next((r) => l == null ? void 0 : l(r)).next((r) => (this._updateMoveTooltip(t, r), r)).next((r) => {
+      switch (r.action) {
+        case "start":
+        case "update":
+          if (r.translationX || r.translationY || r.translationZ) {
+            const _ = this.view.toScreen(r.mapStart), M = this.view.toScreen(r.mapEnd), f = M.x - _.x, S = M.y - _.y;
+            if (this.emit("graphic-move", new lt(f, S, p)), this.destroyed)
+              return null;
+          }
+          break;
+        case "end":
+          if (this.emit("graphic-move-stop", new E(p)), this.destroyed)
+            return null;
+          v();
+      }
+      return null;
+    }), cancel: o };
+  }
+  _showTooltip(i) {
+    this._updateMoveTooltip(i), this._latestTooltipInfo && (this._latestTooltipInfo.distance = T);
+  }
+  _hideTooltip() {
+    var i;
+    (i = this.tooltip) == null || i.clear(), this._latestTooltipInfo = null;
+  }
+  _updateMoveTooltip(i, t) {
+    const { sketchOptions: e, tooltip: a } = this;
+    switch (i) {
+      case m.XY:
+        this._latestTooltipInfo = this._translateGraphicTooltipInfo ?? (this._translateGraphicTooltipInfo = new st({ sketchOptions: e })), this._updateMoveTooltipDistance(this._latestTooltipInfo, t, (o, n) => x(o, n));
+        break;
+      case m.XY_AXIS:
+        this._latestTooltipInfo = this._translateGraphicXYTooltipInfo ?? (this._translateGraphicXYTooltipInfo = new nt({ sketchOptions: e })), this._updateMoveTooltipDistance(this._latestTooltipInfo, t, (o, n) => X(x(o, n), q(t)));
+        break;
+      case m.Z:
+        this._latestTooltipInfo = this._translateGraphicZTooltipInfo ?? (this._translateGraphicZTooltipInfo = new ot({ sketchOptions: e })), this._updateMoveTooltipDistance(this._latestTooltipInfo, t, rt);
+    }
+    this._latestTooltipInfo.sketchOptions = e, a && (a.info = this._latestTooltipInfo);
+  }
+  _updateMoveTooltipDistance(i, t, e) {
+    if (t == null || t.action === "end")
+      return;
+    const { mapStart: a, mapEnd: o } = t, n = e(a, o);
+    i.distance = n ?? T;
+  }
+  _buildSnappingPipelineSteps(i, t, e, a, o) {
+    const n = i.geometry;
+    if (n == null || n.type !== "point" && n.type !== "mesh")
+      return { steps: e, cancel: a };
+    const s = (n.type === "point" ? n : n.anchor).clone(), p = new it({ elevationInfo: t, pointer: o, editGeometryOperations: tt.fromGeometry(s, this.view.state.viewingMode), visualizer: new Z(), excludeFeature: i }), l = this.snappingManager, { snappingStep: h, cancelSnapping: v } = et({ snappingContext: p, snappingManager: l, updatingHandles: this._updatingHandles });
+    return a = a.next(v), { steps: e = e.next((r) => (s.z = z(this.view, s, I(i), { mode: "absolute-height", offset: 0 }), { ...r, snapOrigin: p.coordinateHelper.pointToVector(s) })).next(...h), cancel: a };
+  }
+};
+d([g({ constructOnly: !0, nonNullable: !0 })], u.prototype, "view", void 0), d([g()], u.prototype, "graphics", void 0), d([g({ constructOnly: !0, nonNullable: !0 })], u.prototype, "enableZ", void 0), d([g({ constructOnly: !0, type: $ })], u.prototype, "sketchOptions", void 0), d([g({ constructOnly: !0 })], u.prototype, "snappingManager", void 0), d([g()], u.prototype, "type", void 0), d([g()], u.prototype, "updating", null), d([g()], u.prototype, "tooltip", void 0), u = d([k("esri.views.3d.interactive.editingTools.graphicMove3D.GraphicMoveTool")], u);
+class ht {
+  constructor(t) {
+    this.geometryRepresentation = null, this.manipulationXY = null, this.dragging = !1, this.state = new J({ graphic: t });
+  }
+  get graphic() {
+    return this.state.graphic;
+  }
+}
+export {
+  lt as GraphicMoveEvent,
+  pt as GraphicMoveStartEvent,
+  E as GraphicMoveStopEvent,
+  u as GraphicMoveTool
+};

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

@@ -0,0 +1,23 @@
+import "../../../../../core/has.js";
+import { getGraphicEffectiveElevationMode as a, hasGraphicFeatureExpressionInfo as p } from "../../../../../support/elevationInfoUtils.js";
+import { SupportedGraphicResult as r } from "../isSupportedGraphicUtils.js";
+function n(e) {
+  var t;
+  if (((t = e.layer) == null ? void 0 : t.type) !== "graphics")
+    return r.GRAPHICS_LAYER_MISSING;
+  if (e.geometry == null)
+    return r.GEOMETRY_MISSING;
+  switch (e.geometry.type) {
+    case "polygon":
+    case "point":
+    case "polyline":
+    case "mesh":
+      break;
+    default:
+      return r.GEOMETRY_TYPE_UNSUPPORTED;
+  }
+  return a(e) !== "on-the-ground" && p(e) ? r.ELEVATION_MODE_UNSUPPORTED : r.SUPPORTED;
+}
+export {
+  n as isSupportedGraphic
+};

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

@@ -0,0 +1,94 @@
+import { removeHandles as z, destroyHandle as v, refHandle as O } from "../../../../core/handleUtils.js";
+import { deg2rad as W } from "../../../../core/mathUtils.js";
+import { watch as d, initial as w } from "../../../../core/reactiveUtils.js";
+import { signal as V } from "../../../../core/signal.js";
+import { s as j } from "../../../../chunks/vec32.js";
+import { create as B } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { projectPointToVector as F } from "../../../../geometry/projection/projectPointToVector.js";
+import { projectVectorToVector as b } from "../../../../geometry/projection/projectVectorToVector.js";
+import { create as U, empty as X, getMin as Y } from "../../../../geometry/support/aaBoundingBox.js";
+import { containsXY as Z } from "../../../../geometry/support/aaBoundingRect.js";
+import { getGraphicEffectiveElevationInfo as L } from "../../../../support/elevationInfoUtils.js";
+import { GrabbingState as A } from "./GrabbingState.js";
+import { ManipulatorState as k } from "./ManipulatorState.js";
+import { Settings as M } from "./settings.js";
+import { ExtendedLineVisualElement as N } from "../visualElements/ExtendedLineVisualElement.js";
+import { LaserlineVisualElement as C } from "../visualElements/LaserlineVisualElement.js";
+import { PointVisualElement as q } from "../visualElements/PointVisualElement.js";
+import { evaluateElevationAlignmentAtPoint as J } from "../../layers/graphics/elevationAlignmentUtils.js";
+import { ElevationContext as K } from "../../layers/graphics/ElevationContext.js";
+import { GraphicState as Q } from "../../layers/graphics/GraphicState.js";
+import { RenderOccludedFlag as _ } from "../../webgl-engine/lib/Material.js";
+function be(n) {
+  const { view: e, graphic: a } = n, r = new Q({ graphic: a }), t = [], s = te(n, r, t);
+  return ee(n, r, t, s), t.push(e.trackGraphicState(r)), { visualElement: s, remove: () => z(t) };
+}
+function ee(n, e, a, r) {
+  const { view: t, graphic: s } = n, i = new M({ getTheme: () => t.effectiveTheme }), h = new N({ view: t, extensionType: i.visualElements.zVerticalLine.extensionType, innerWidth: 1, attached: !1, writeDepthEnabled: !1, renderOccluded: _.OccludeAndTransparent, isDecoration: !0 });
+  a.push(d(() => i.visualElements.zVerticalLine, (o) => o.apply(h), w));
+  const c = new C({ view: t, intersectsLineInfinite: !0, attached: !1, isDecoration: !0 }), p = W(i.visualElements.heightPlaneAngleCutoff), u = new C({ view: t, attached: !1, angleCutoff: p, isDecoration: !0 }), f = L(n.graphic), x = K.fromElevationInfo(f), R = f.mode === "on-the-ground" || !f.offset && f.mode !== "absolute-height", y = new k(), P = V(1);
+  a.push(d(() => ({ heightPlane: i.visualElements.heightPlane, alpha: P.value }), ({ heightPlane: o, alpha: m }) => o.apply(u, m), w));
+  const $ = V(1);
+  a.push(d(() => ({ shadowStyle: i.visualElements.pointGraphics.shadowStyle, alpha: $.value }), ({ shadowStyle: o, alpha: m }) => o.apply(c, m), w));
+  const g = () => {
+    y.update(n);
+    const o = E(s), m = R && (e.isDraped || o == null || !o.hasZ);
+    let D = !0;
+    if (m || o == null)
+      D = !1;
+    else {
+      const I = J(o, t.elevationProvider, x, t.renderCoordsHelper);
+      j(l, o.x, o.y, I), b(l, o.spatialReference, l, t.renderCoordsHelper.spatialReference), h.setStartEndFromWorldDownAtLocation(l), c.intersectsWorldUpAtLocation = l;
+    }
+    const G = y.grabbingState & A.Z ? i.visualElements.laserlineAlphaMultiplier : 1;
+    P.value = G;
+    const S = X(oe);
+    !m && e.displaying && r.calculateMapBounds(S) && b(Y(S, l), t.spatialReference, l, t.renderCoordsHelper.spatialReference) ? (u.heightManifoldTarget = l, u.attached = !0) : u.attached = !1;
+    const H = y.grabbingState & A.XY ? i.visualElements.laserlineAlphaMultiplier : 1;
+    $.value = H;
+    const T = D && e.displaying && !m;
+    c.attached = T, h.attached = T;
+  };
+  a.push(d(() => [e.displaying, e.isDraped], g), e.on("changed", g)), n.forEachManipulator((o) => {
+    a.push(o.events.on("grab-changed", g));
+  }), a.push(v(c)), a.push(v(h)), a.push(v(u)), g();
+}
+function te(n, e, a) {
+  const { view: r, graphic: t } = n, s = new q({ view: r, geometry: E(t), elevationInfo: L(t), isDecoration: !0 });
+  return ae(n, s, e, a), a.push(v(s)), s;
+}
+function E(n) {
+  const e = n.geometry;
+  return e == null ? null : e.type === "point" ? e : e.type === "mesh" ? e.anchor.clone() : null;
+}
+function ae(n, e, a, r) {
+  const t = () => {
+    e.attached = a.displaying;
+  }, s = new M({ getTheme: () => n.view.effectiveTheme });
+  ne(n, e, a, r), s.visualElements.pointGraphics.outline.apply(e), r.push(d(() => a.displaying, t, w));
+}
+function ne(n, e, a, r) {
+  const { view: t, graphic: s } = n;
+  let i = null;
+  const h = (p) => {
+    i != null && (i.remove(), i = null), a.isDraped && p != null && (i = ie(t, p, () => {
+      e.geometry = p;
+    }));
+  }, c = () => {
+    const p = E(s);
+    h(p), e.geometry = p;
+  };
+  r.push(a.on("changed", c), O(() => i)), c();
+}
+function ie(n, e, a) {
+  const r = n.elevationProvider.spatialReference;
+  F(e, l, r);
+  const t = l[0], s = l[1];
+  return n.elevationProvider.on("elevation-change", (i) => {
+    Z(i.extent, t, s) && a();
+  });
+}
+const l = B(), oe = U();
+export {
+  be as createVisualElements
+};

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

@@ -0,0 +1,93 @@
+import { _ as n } from "../../../../../chunks/tslib.es6.js";
+import s from "../../../../../core/Evented.js";
+import { destroyMaybe as h } from "../../../../../core/maybe.js";
+import { watch as r, syncAndInitial as l, sync as c } from "../../../../../core/reactiveUtils.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 d } from "../../../../../core/accessorSupport/decorators/subclass.js";
+import { SupportedGraphicResult as y } from "../isSupportedGraphicUtils.js";
+import { geometryOfSupportedGraphic as m, isSupportedGraphic as u } from "./isSupportedGraphic.js";
+import { ReshapeOperation as g } from "./ReshapeOperation.js";
+import { InteractiveToolBase as _ } from "../../../../interactive/InteractiveToolBase.js";
+import p from "../../../../interactive/sketch/SketchOptions.js";
+let o = class extends s.EventedMixin(_) {
+  constructor(e) {
+    super(e), this._internalGeometryUpdate = !1, this.enableZShape = !0, this.enableZVertex = !0, this.enableMoveGraphic = !0, this.enableMidpoints = !0, this.enableEdgeOffset = !1, this.type = "reshape-3d", this.sketchOptions = new p(), this.snappingManager = null, this.automaticManipulatorSelection = !1;
+  }
+  initialize() {
+    const e = this._reshapeOperation = new g({ tool: this });
+    this.addHandles([e.on("reshape", (t) => {
+      t.type === "reshape" && this._onReshapeGeometryChanged(), this.emit("reshape", t);
+    }), e.on("move", (t) => {
+      t.type === "move" && this._onReshapeGeometryChanged(), this.emit("move", t);
+    }), e.on("vertex-add", (t) => {
+      this._onReshapeGeometryChanged(), this.emit("vertex-add", t);
+    }), e.on("vertex-remove", (t) => {
+      this._onReshapeGeometryChanged(), this.emit("vertex-remove", t);
+    }), e.on("immediate-click", (t) => this.emit("immediate-click", t)), this.view.on("pointer-down", ["Shift"], (t) => t.stopPropagation()), r(() => this.graphic, () => this._updateGraphic(), l)]), this.finishToolCreation();
+  }
+  destroy() {
+    this._reshapeOperation = h(this._reshapeOperation);
+  }
+  get updating() {
+    var e;
+    return ((e = this._reshapeOperation) == null ? void 0 : e.updating) ?? !1;
+  }
+  _updateGeometry() {
+    const e = m(this.graphic);
+    this._reshapeOperation.inputGeometry = e != null ? e.clone() : null;
+  }
+  _updateGraphic() {
+    if (this.removeHandles("onGraphicGeometryChange"), this._updateGeometry(), u(this.graphic) !== y.SUPPORTED)
+      return;
+    const e = r(() => {
+      var t;
+      return (t = this.graphic) == null ? void 0 : t.geometry;
+    }, () => {
+      this._internalGeometryUpdate === !1 && this._updateGeometry();
+    }, c);
+    this.addHandles(e, "onGraphicGeometryChange");
+  }
+  onManipulatorSelectionChanged() {
+    this._reshapeOperation && this._reshapeOperation.onManipulatorSelectionChanged();
+  }
+  _updateGeometryInternally(e) {
+    this._internalGeometryUpdate = !0;
+    const { graphic: t } = this, { geometry: i } = t;
+    (i == null ? void 0 : i.type) === "mesh" && e.type === "point" ? (t.geometry = i.centerAt(e), t.notifyGeometryChanged()) : t.geometry = e, this._internalGeometryUpdate = !1;
+  }
+  _onReshapeGeometryChanged() {
+    const { outputGeometry: e } = this._reshapeOperation;
+    this.graphic != null && e && this._updateGeometryInternally(e.clone());
+  }
+  get canUndo() {
+    return this._reshapeOperation.canUndo ?? !1;
+  }
+  undo() {
+    this.snappingManager != null && this.snappingManager.doneSnapping();
+    const e = this._reshapeOperation.undo(), { outputGeometry: t } = this._reshapeOperation;
+    e && t && this._updateGeometryInternally(t.clone());
+  }
+  get canRedo() {
+    return this._reshapeOperation.canRedo ?? !1;
+  }
+  redo() {
+    this.snappingManager != null && this.snappingManager.doneSnapping();
+    const e = this._reshapeOperation.redo(), { outputGeometry: t } = this._reshapeOperation;
+    e && t && this._updateGeometryInternally(t.clone());
+  }
+  onInputEvent(e) {
+    e.type !== "key-down" || e.key !== "Delete" && e.key !== "Backspace" || this._reshapeOperation.removeSelectedVertices();
+  }
+  reset() {
+  }
+  get test() {
+    return { snappingManager: this.snappingManager, reshapeOperation: this._reshapeOperation };
+  }
+};
+n([a()], o.prototype, "_reshapeOperation", void 0), n([a({ constructOnly: !0, nonNullable: !0 })], o.prototype, "view", void 0), n([a({ constructOnly: !0 })], o.prototype, "graphic", void 0), n([a({ constructOnly: !0, nonNullable: !0 })], o.prototype, "enableZShape", void 0), n([a({ constructOnly: !0, nonNullable: !0 })], o.prototype, "enableZVertex", void 0), n([a({ constructOnly: !0, nonNullable: !0 })], o.prototype, "enableMoveGraphic", void 0), n([a({ constructOnly: !0, nonNullable: !0 })], o.prototype, "enableMidpoints", void 0), n([a({ constructOnly: !0, nonNullable: !0 })], o.prototype, "enableEdgeOffset", void 0), n([a()], o.prototype, "type", void 0), n([a({ constructOnly: !0, type: p })], o.prototype, "sketchOptions", void 0), n([a({ constructOnly: !0 })], o.prototype, "snappingManager", void 0), n([a()], o.prototype, "updating", null), n([a()], o.prototype, "automaticManipulatorSelection", void 0), o = n([d("esri.views.3d.interactive.editingTools.graphicReshape3D.GraphicReshapeTool")], o);
+export {
+  o as GraphicReshapeTool
+};