@agrotools1/at-components 0.2.1 → 0.2.3

package/dist/DirectLineMeasurement3D-e9903136.js

@@ -0,0 +1,449 @@
+import { e as i, y as n, a$ as H, f_ as V, c as L, S as st, o as M, x as E, ad as R, P as C, b9 as x, dF as at, fG as Q, i6 as k, fR as ot, fU as F, fV as rt, fW as B, eQ as lt, fX as W, fY as ut } from "./index-01c737ed.js";
+import { c as dt } from "./Analysis-4b1d1fb5.js";
+import { t as pt, N as ht, e as ct, V as mt, g as gt, P as vt, x as yt, M as wt, d as _t, h as Pt, u as bt } from "./MeasurementWidgetContent-e4888ef2.js";
+import { h as ft, g as N, e as Mt, f as Dt, s as Lt, o as St, i as Vt, q as Ot, m as $t, u as Ct, O as xt, z as At, k as Ut, _ as Tt } from "./InteractiveAnalysisViewModel-b046fcb9.js";
+import { G as Ht, F as Et, P as Gt, D as zt } from "./colorUtils-54f4b662.js";
+import { b as It } from "./lineSegment-3aa941f5.js";
+import "vue";
+import "./vec42-36edeb73.js";
+import "./vec4f64-043e974c.js";
+import "./plane-3398eec1.js";
+import "./mat3f64-03233387.js";
+import "./mat4f64-cce69db4.js";
+import "./quatf64-bec1af25.js";
+import "./sphere-908cd9aa.js";
+import "./ObjectStack-10d91171.js";
+import "./projectVectorToVector-5163db7a.js";
+import "./projectPointToVector-7dc831a9.js";
+import "./elevationInfoUtils-5456a079.js";
+import "./unitConversionUtils-f0ebaf75.js";
+import "./lengthUtils-695e744c.js";
+import "./meshVertexSpaceUtils-6efe3dcc.js";
+import "./MeshLocalVertexSpace-00151564.js";
+import "./vec3-f79c600d.js";
+import "./Scheduler-eacc84bb.js";
+import "./RenderState-b244097f.js";
+import "./quantityUtils-5cd4cf90.js";
+import "./geometryEngineBase-527e8b63.js";
+import "./vec4f32-b2628ced.js";
+import "./Octree-78797046.js";
+import "./Util-002f5109.js";
+import "./triangle-8a3a2ba8.js";
+import "./DoubleArray-5076283e.js";
+import "./glUtil-8f8bce6b.js";
+import "./enums-2c166c09.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./InterleavedLayout-32973c8a.js";
+import "./BufferView-004ad517.js";
+import "./types-adba9034.js";
+import "./VertexArrayObject-07998745.js";
+import "./Texture-22a8cca5.js";
+import "./VertexAttribute-faad30bf.js";
+import "./VertexColor.glsl-e415cf02.js";
+import "./OrderIndependentTransparency-3eadfe42.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./BindType-5e76c8e1.js";
+import "./Indices-e6dc3b15.js";
+import "./doublePrecisionUtils-46e21550.js";
+import "./requestImageUtils-37d79281.js";
+import "./orientedBoundingBox-554ccdc6.js";
+import "./quat-a508aed3.js";
+import "./computeTranslationToOriginAndRotation-4876cb93.js";
+import "./BufferObject-cbd0168e.js";
+import "./axisAngleDegrees-32643b7c.js";
+import "./NestedMap-83f8e815.js";
+import "./floatRGBA-516d7961.js";
+import "./MemCache-a9232ec2.js";
+import "./vec3f32-304a6a9c.js";
+import "./FeatureFilter-8c5e44b1.js";
+import "./floorFilterUtils-936f7587.js";
+import "./layerViewUtils-052e603c.js";
+import "./geometryEngine-d3bb2fd6.js";
+import "./hydrated-0e1c7565.js";
+let f = class extends dt {
+  constructor(t) {
+    super(t), this.type = "direct-line-measurement", this.startPoint = null, this.endPoint = null, this.unit = null;
+  }
+  get requiredPropertiesForEditing() {
+    return [this.startPoint, this.endPoint];
+  }
+  clear() {
+    this.startPoint = null, this.endPoint = null;
+  }
+};
+i([n({ type: ["direct-line-measurement"] })], f.prototype, "type", void 0), i([n({ type: H })], f.prototype, "startPoint", void 0), i([n({ type: H })], f.prototype, "endPoint", void 0), i([n({ type: V, value: null })], f.prototype, "unit", void 0), i([n({ readOnly: !0 })], f.prototype, "requiredPropertiesForEditing", null), f = i([L("esri.analysis.DirectLineMeasurementAnalysis")], f);
+const X = f;
+var G;
+(function(t) {
+  t[t.Auto = 0] = "Auto", t[t.Euclidean = 1] = "Euclidean", t[t.Geodesic = 2] = "Geodesic";
+})(G || (G = {}));
+var O, q;
+(function(t) {
+  t[t.None = 0] = "None", t[t.Direct = 1] = "Direct", t[t.Triangle = 2] = "Triangle", t[t.ProjectedGeodesic = 3] = "ProjectedGeodesic";
+})(O || (O = {})), function(t) {
+  t[t.Auto = 0] = "Auto", t[t.AboveSegment = 1] = "AboveSegment", t[t.BelowSegment = 2] = "BelowSegment";
+}(q || (q = {}));
+var D;
+(function(t) {
+  t.Manipulators = "manipulators", t.AnalysisViewDestroyed = "analysis-view-destroyed", t.AnalysisView = "analysis-view";
+})(D || (D = {}));
+let d = class extends st {
+  constructor(t) {
+    super(t), this.cursorPoint = null, this._visible = !1, this._laserLine = null, this.laserLineEnabled = !0, this._lastDraggedHandle = null;
+  }
+  initialize() {
+    this._laserLine = new ft({ view: this.view, attached: !0, isDecoration: !0 }), this._updateVisibility(this._visible), this._connectToAnalysisView(), this.addHandles(M(() => this._params, ({ laserLineGlowColor: t, laserLineInnerColor: e, laserLineGlobalAlpha: a }) => {
+      const s = this._laserLine, l = s.style;
+      s.style = { ...l, innerColor: e, glowColor: t, globalAlpha: a };
+    }));
+  }
+  destroy() {
+    this._laserLine = E(this._laserLine);
+  }
+  get _params() {
+    const { accentColor: t } = this.view.effectiveTheme;
+    return { laserLineGlowColor: R.toUnitRGB(t), laserLineGlowWidth: 8, laserLineGlowFalloff: 8, laserLineInnerColor: R.toUnitRGB(Ht(t)), laserLineInnerWidth: 0.75, laserLineGlobalAlpha: 0.75 * t.a, handleColor: Et(t, 0.5), handleRadius: 5 };
+  }
+  get visible() {
+    return this._visible;
+  }
+  set visible(t) {
+    t ? this.show() : this.hide();
+  }
+  get testData() {
+    const t = this._laserLine.testData, e = this.analysisViewData.testData;
+    return { labels: e == null ? void 0 : e.labels, stripeLength: e == null ? void 0 : e.stripeLength, laserLineRenderer: { heightManifoldEnabled: t != null && t.heightManifoldEnabled, heightManifoldTarget: t != null ? t.heightManifoldTarget : null, pointDistanceEnabled: t != null && t.pointDistanceEnabled, pointDistanceOrigin: t != null ? t.pointDistanceOrigin : null, pointDistanceTarget: t != null ? t.pointDistanceTarget : null, lineVerticalPlaneEnabled: t != null && t.lineVerticalPlaneEnabled } };
+  }
+  get _cursorPosition() {
+    const t = x(), e = this.cursorPoint;
+    return e && this.view.renderCoordsHelper.toRenderCoords(e, t), t;
+  }
+  get _startPosition() {
+    const t = x(), e = this.analysis.startPoint;
+    return e && this.view.renderCoordsHelper.toRenderCoords(e, t), t;
+  }
+  get _endPosition() {
+    const t = x(), e = this.analysis.endPoint;
+    return e && this.view.renderCoordsHelper.toRenderCoords(e, t), t;
+  }
+  get _laserLineParams() {
+    const t = this._focusPosition, { active: e, lineState: a } = this.toolState, s = this.analysisViewData, l = this.laserLineEnabled && !!t && a !== "measured" && e;
+    if (!l || !this.visible || s == null || s.destroyed)
+      return { heightManifoldTarget: null, pointDistanceLine: null, lineVerticalPlaneSegment: null };
+    const r = s.actualVisualizedMeasurement, o = this.view.viewingMode !== "local" && l && !!this.analysis.startPoint && r === "geodesic", p = l && s.viewMode === O.Triangle;
+    return { heightManifoldTarget: r === "euclidean" ? t : null, pointDistanceLine: o ? this._pointDistanceLine : null, lineVerticalPlaneSegment: p ? It(this._startPosition, this._endPosition) : null };
+  }
+  get _focusPosition() {
+    const { lineState: t } = this.toolState, e = this.analysisViewData, a = e != null && !e.destroyed && e.measurementMode === G.Euclidean && e.viewMode === O.Direct;
+    switch (t) {
+      case "drawing":
+        return a ? this._startPosition : this.analysis.endPoint ? this._endPosition : this._startPosition;
+      case "editing":
+        return a ? this._lastDraggedHandle === "start" ? this._endPosition : this._startPosition : this._lastDraggedHandle === "start" ? this._startPosition : this._endPosition;
+      default:
+        return this.cursorPoint != null ? this._cursorPosition : null;
+    }
+  }
+  get _pointDistanceLine() {
+    return { origin: this.toolState.lineState === "drawing" || this._lastDraggedHandle === "end" ? this._startPosition : this._endPosition, target: this._focusPosition };
+  }
+  createManipulators() {
+    const t = this._params, { view: e } = this, a = () => {
+      const u = Mt(t.handleColor), b = [new Dt(Lt(u, 1, 32, 32))], _ = new N({ view: e, renderObjects: b });
+      return _.available = !1, _.radius = t.handleRadius, [_, u];
+    }, [s, l] = a(), [r, o] = a(), p = new N({ view: this.view });
+    p.available = !1, p.interactive = !1, this.analysis.startPoint != null && (s.location = this.analysis.startPoint, s.available = !0), this.analysis.endPoint != null && (r.location = this.analysis.endPoint, r.available = !0);
+    const m = () => {
+      let u = this._lastDraggedHandle;
+      s.grabbing && !r.grabbing && (u = "start"), r.grabbing && !s.grabbing && (u = "end"), s.grabbing || r.grabbing || (u = null), this._lastDraggedHandle = u;
+    }, P = s.events.on("grab-changed", m), w = r.events.on("grab-changed", m);
+    return this.addHandles([P, w, M(() => zt(this._params.handleColor), (u) => {
+      l.setParameters({ color: u }), o.setParameters({ color: u });
+    }, { equals: Gt })], D.Manipulators), { start: s, end: r, cursor: p };
+  }
+  show() {
+    this.destroyed || this._visible || this._updateVisibility(!0);
+  }
+  hide() {
+    !this.destroyed && this._visible && this._updateVisibility(!1);
+  }
+  _connectToAnalysisView() {
+    this.removeHandles(D.AnalysisView), this.addHandles([M(() => {
+      var t;
+      return (t = this.analysisViewData) == null ? void 0 : t.destroyed;
+    }, (t) => {
+      t && this.removeHandles(D.AnalysisView);
+    }, C), M(() => [this.toolState.lineState === "measured", this.analysisViewData], ([t, e]) => {
+      e == null || e.destroyed || (e.allowVisualElementsOrientationChange = !t);
+    }, C), M(() => this._laserLineParams, (t) => {
+      const e = this._laserLine;
+      e.heightManifoldTarget = t.heightManifoldTarget, e.pointDistanceLine = t.pointDistanceLine, e.lineVerticalPlaneSegment = t.lineVerticalPlaneSegment;
+    }, C)], D.AnalysisView);
+  }
+  _updateVisibility(t) {
+    this.initialized && (this._visible = t, t ? this._laserLine.style = { innerColor: this._params.laserLineInnerColor, innerWidth: this._params.laserLineInnerWidth, glowColor: this._params.laserLineGlowColor, glowWidth: this._params.laserLineGlowWidth, glowFalloff: this._params.laserLineGlowFalloff, globalAlpha: this._params.laserLineGlobalAlpha } : this.view.cursor = null, this._laserLine.visible = t);
+  }
+};
+i([n({ constructOnly: !0 })], d.prototype, "view", void 0), i([n()], d.prototype, "_params", null), i([n({ constructOnly: !0 })], d.prototype, "analysis", void 0), i([n({ constructOnly: !0 })], d.prototype, "analysisViewData", void 0), i([n()], d.prototype, "cursorPoint", void 0), i([n()], d.prototype, "toolState", void 0), i([n()], d.prototype, "visible", null), i([n()], d.prototype, "testData", null), i([n()], d.prototype, "_visible", void 0), i([n()], d.prototype, "_laserLine", void 0), i([n({ constructOnly: !0 })], d.prototype, "laserLineEnabled", void 0), i([n()], d.prototype, "_cursorPosition", null), i([n()], d.prototype, "_startPosition", null), i([n()], d.prototype, "_endPosition", null), i([n()], d.prototype, "_lastDraggedHandle", void 0), i([n()], d.prototype, "_laserLineParams", null), i([n()], d.prototype, "_focusPosition", null), i([n()], d.prototype, "_pointDistanceLine", null), d = i([L("esri.views.3d.interactive.measurementTools.directLineMeasurement3D.DirectLineMeasurement3DView")], d);
+let h = class extends St {
+  constructor(t) {
+    super(t), this._updatingHandles = new at(), this._emulatedDrag = null, this.lineState = "initial", this.startPointSurfaceLocation = null, this.endPointSurfaceLocation = null, this.cursorPointSurfaceLocation = null, this.startManipulator = null, this.endManipulator = null, this.cursorManipulator = null, this._getSnappingContext = pt((e) => new ct({ elevationInfo: { mode: "absolute-height", offset: 0 }, pointer: e, editGeometryOperations: new mt(new gt("point", vt(!0, !1, this.view.spatialReference))), visualizer: new xt() }));
+  }
+  initialize() {
+    const { view: t, analysis: e, analysisViewData: a, visible: s } = this;
+    this.measurementView = new d({ toolState: this, view: t, analysis: e, analysisViewData: a, visible: s });
+    const l = Vt(t);
+    this._snappingManagerResult = l, this.addHandles(l);
+    const { start: r, end: o, cursor: p } = this.measurementView.createManipulators(), m = (w, u, b) => yt(w, (_, J, S, z) => {
+      const I = Ut(_), K = this._snappingManager, Z = this._getSnappingContext(z), tt = this._updatingHandles, { lineState: et } = this;
+      S = S.next(I).next(wt(this, [b, u])).next((g) => {
+        if (u !== "cursorPoint") {
+          const v = this.analysis[u];
+          v != null && (_.location = v);
+        }
+        return g;
+      });
+      const it = At(this.view), nt = (g) => {
+        const v = it(g);
+        return v || this.lineState !== "drawing" && this.lineState !== "initial" || (this[u] = null, this[b] = null), v;
+      };
+      let $ = J.next(I).next(nt);
+      if (z !== "touch" || et === "editing") {
+        const { snappingStep: g, cancelSnapping: v } = Pt({ snappingManager: K, snappingContext: Z, updatingHandles: tt });
+        S = S.next(v), $ = $.next(...g);
+      }
+      $.next((g) => g.action !== "start" ? g : null).next((g) => {
+        const v = _t(g.mapEnd, new H());
+        this[u] = v, _.location = v, this[b] = this._surfaceLocation(v, g.surfaceType);
+      });
+    }), P = (w) => w.events.on("grab-changed", () => {
+      const u = r.grabbing || o.grabbing;
+      this.lineState = u ? "editing" : "measured";
+    });
+    this.addHandles([m(r, "startPoint", "startPointSurfaceLocation"), m(o, "endPoint", "endPointSurfaceLocation"), m(p, "cursorPoint", "cursorPointSurfaceLocation"), P(r), P(o)]), this.manipulators.add(r), this.manipulators.add(o), this.manipulators.add(p), this.startManipulator = r, this.endManipulator = o, this.cursorManipulator = p, this.addHandles(M(() => this.state, (w) => {
+      w === "measured" && this.finishToolCreation();
+    }, Q)), ht(this);
+  }
+  destroy() {
+    this._updatingHandles = E(this._updatingHandles), this.measurementView = E(this.measurementView);
+  }
+  get _snappingManager() {
+    return this._snappingManagerResult.snappingManager;
+  }
+  get state() {
+    const { analysis: t } = this;
+    if (t.startPoint == null && t.endPoint == null)
+      return "ready";
+    const { lineState: e } = this;
+    return this.validMeasurement && e !== "editing" && e !== "drawing" ? "measured" : "measuring";
+  }
+  get cursor() {
+    return this.state === "ready" || this.lineState === "drawing" ? "crosshair" : null;
+  }
+  get startPoint() {
+    return this.analysis.startPoint;
+  }
+  set startPoint(t) {
+    this.analysis.startPoint = t;
+  }
+  get endPoint() {
+    return this.analysis.endPoint;
+  }
+  set endPoint(t) {
+    this.analysis.endPoint = t;
+  }
+  get cursorPoint() {
+    return this.measurementView.cursorPoint;
+  }
+  set cursorPoint(t) {
+    this.measurementView.cursorPoint = t;
+  }
+  get snappingOptions() {
+    return this._snappingManager.options;
+  }
+  get validMeasurement() {
+    return this.analysis.startPoint != null && this.analysis.endPoint != null;
+  }
+  get updating() {
+    return this._updatingHandles.updating || this._snappingManager.updating;
+  }
+  onShow() {
+    this.measurementView.show(), this._updateManipulatorAvailability();
+  }
+  onHide() {
+    this.measurementView.hide();
+  }
+  onDeactivate() {
+    var t;
+    (t = this._emulatedDrag) == null || t.cancel(), this._emulatedDrag = null;
+  }
+  onInputEvent(t) {
+    switch (t.type) {
+      case "immediate-click":
+        this._handleImmediateClick(t);
+        break;
+      case "pointer-move":
+        this._handlePointerMove(t);
+    }
+    this._updateManipulatorAvailability();
+  }
+  _handlePointerMove(t) {
+    var p, m;
+    if (!this.active || this.view.navigating)
+      return;
+    const { pointerType: e } = t;
+    if (e !== "mouse")
+      return;
+    const a = k(t), { lineState: s, cursorManipulator: l, endManipulator: r } = this;
+    let o = !1;
+    this.cursorPoint == null && ((p = this._emulatedDrag) == null || p.cancel(), this._emulatedDrag = A(l, e, a), o = !0), s === "initial" && ((m = this._emulatedDrag) == null || m.update(a), o = !0), s === "drawing" && (r.events.emit("drag", { action: "update", start: a, screenPoint: a }), o = !0), o && t.stopPropagation();
+  }
+  _handleImmediateClick(t) {
+    var m, P, w, u, b;
+    if (!this.active || !Ot(t))
+      return;
+    const e = k(t), { pointerType: a } = t, { cursorManipulator: s, startManipulator: l, endManipulator: r, lineState: o } = this;
+    let p = !1;
+    switch (this.cursorPoint == null && ((m = this._emulatedDrag) == null || m.cancel(), this._emulatedDrag = A(s, a, e)), o) {
+      case "initial":
+        if ((P = this._emulatedDrag) == null || P.update(e), this.cursorPoint != null) {
+          (w = this._emulatedDrag) == null || w.end(e), this._emulatedDrag = null;
+          const { cursorPoint: _ } = this;
+          this.startPoint = _, this.startPointSurfaceLocation = this.cursorPointSurfaceLocation, l.location = _, l.interactive = !1, r.interactive = !1, this.lineState = "drawing", this._emulatedDrag = A(r, a, e), p = !0;
+        }
+        break;
+      case "drawing":
+        (u = this._emulatedDrag) == null || u.update(e), this.endPoint != null && ((b = this._emulatedDrag) == null || b.end(e), this._emulatedDrag = null, l.interactive = !0, r.interactive = !0, this.lineState = "measured", p = !0);
+    }
+    p && t.stopPropagation();
+  }
+  _surfaceLocation(t, e) {
+    return e === $t.GROUND ? "on-the-surface" : (t.z ?? 0) >= this._getElevation(t) ? "above-the-surface" : "below-the-surface";
+  }
+  _updateManipulatorAvailability() {
+    this.startManipulator.available = this.analysis.startPoint != null, this.endManipulator.available = this.analysis.endPoint != null;
+  }
+  _getElevation(t) {
+    return this.view.basemapTerrain.ready ? Ct(this.view.elevationProvider, t) ?? 0 : 0;
+  }
+  get test() {
+    return { snappingManager: this._snappingManager };
+  }
+};
+function A(t, e, a) {
+  return t.events.emit("drag", { action: "start", pointerType: e, start: a, screenPoint: a }), { update: (s) => t.events.emit("drag", { action: "update", start: s, screenPoint: s }), end: (s) => t.events.emit("drag", { action: "end", start: s, screenPoint: s }), cancel: () => t.events.emit("drag", { action: "cancel" }) };
+}
+i([n({ readOnly: !0 })], h.prototype, "state", null), i([n()], h.prototype, "lineState", void 0), i([n({ readOnly: !0 })], h.prototype, "cursor", null), i([n()], h.prototype, "startPoint", null), i([n()], h.prototype, "endPoint", null), i([n()], h.prototype, "cursorPoint", null), i([n({ constructOnly: !0 })], h.prototype, "analysis", void 0), i([n({ constructOnly: !0 })], h.prototype, "analysisViewData", void 0), i([n()], h.prototype, "measurementView", void 0), i([n({ constructOnly: !0 })], h.prototype, "view", void 0), i([n({ readOnly: !0 })], h.prototype, "validMeasurement", null), i([n({ value: null })], h.prototype, "startPointSurfaceLocation", void 0), i([n({ value: null })], h.prototype, "endPointSurfaceLocation", void 0), i([n({ value: null })], h.prototype, "cursorPointSurfaceLocation", void 0), i([n()], h.prototype, "updating", null), h = i([L("esri.views.3d.interactive.measurementTools.directLineMeasurement3D.DirectLineMeasurement3DTool")], h);
+const Rt = h;
+let y = class extends Tt {
+  constructor(t) {
+    super(t), this.analysis = null, this.supportedViewType = "3d", this.unsupportedErrorMessage = "DirectLineMeasurement3DViewModel is only supported in 3D views.", this._userUnit = null, this._userUnitOptions = null;
+  }
+  initialize() {
+    this.addHandles(M(() => ({ analysis: this.analysis, unit: this.unit }), ({ analysis: t, unit: e }) => {
+      t != null && (t.unit = e);
+    }, Q));
+  }
+  get state() {
+    return this.disabled || !this.ready ? "disabled" : this.tool == null ? "ready" : this.tool.state;
+  }
+  get measurement() {
+    var r;
+    const { tool: t } = this;
+    if (t == null)
+      return null;
+    const e = () => ({ text: null, state: "unavailable" }), a = (o) => ({ text: o, state: "available" }), { analysisViewData: s } = t, l = s.result != null;
+    return { mode: ((r = s.result) == null ? void 0 : r.mode) ?? "euclidean", directDistance: l && s.actualVisualizedMeasurement === "euclidean" ? a(s.directLabelText) : e(), horizontalDistance: l ? a(s.horizontalLabelText) : e(), verticalDistance: l ? a(s.verticalLabelText) : e() };
+  }
+  set unitOptions(t) {
+    this._userUnitOptions = t, this._set("unitOptions", this._filteredOrAllUnits(this._userUnitOptions));
+  }
+  get unitOptions() {
+    return this._filteredOrAllUnits(this._userUnitOptions);
+  }
+  set unit(t) {
+    this._userUnit = t ? this._findSelectableUnit(t, this._userUnit) : null;
+  }
+  get unit() {
+    return this._userUnit ? (this._userUnit = this._findSelectableUnit(this._userUnit, this.defaultUnit), this._userUnit) : this._findSelectableUnit(this.defaultUnit);
+  }
+  constructAnalysis() {
+    return new X();
+  }
+  constructTool() {
+    return new Rt({ view: this.view, analysis: this.analysis, analysisViewData: this.analysisView, visible: this.visible });
+  }
+  _findSelectableUnit(t, e) {
+    const a = this.unitOptions;
+    return a.includes(t) ? t : e ? this._findSelectableUnit(e) : a[0];
+  }
+  _filteredOrAllUnits(t) {
+    if (!t)
+      return V.slice();
+    const e = t.filter((a) => V.includes(a));
+    return e.length === 0 ? V.slice() : e;
+  }
+};
+i([n({ type: X })], y.prototype, "analysis", void 0), i([n({ readOnly: !0 })], y.prototype, "state", null), i([n({ readOnly: !0 })], y.prototype, "measurement", null), i([n()], y.prototype, "unitOptions", null), i([n()], y.prototype, "unit", null), i([n(ot)], y.prototype, "defaultUnit", void 0), i([n()], y.prototype, "_userUnit", void 0), i([n()], y.prototype, "_userUnitOptions", void 0), y = i([L("esri.widgets.DirectLineMeasurement3D.DirectLineMeasurement3DViewModel")], y);
+const Y = y, j = "esri-direct-line-measurement-3d", U = { base: j, newMeasurementButton: `${j}__clear-button`, widgetIcon: ut.measureLine };
+let c = class extends rt {
+  constructor(t, e) {
+    super(t, e), this.iconClass = U.widgetIcon, this.icon = null, this.messages = null, this.messagesCommon = null, this.viewModel = new Y();
+  }
+  get view() {
+    return this.viewModel.view;
+  }
+  set view(t) {
+    this.viewModel.view = t;
+  }
+  get visible() {
+    return this.viewModel.visible;
+  }
+  set visible(t) {
+    this.viewModel.visible = t;
+  }
+  get active() {
+    return this.viewModel.active;
+  }
+  get analysis() {
+    return this.viewModel.analysis;
+  }
+  set analysis(t) {
+    this.viewModel.analysis = t;
+  }
+  get label() {
+    var t;
+    return ((t = this.messages) == null ? void 0 : t.widgetLabel) ?? "";
+  }
+  set label(t) {
+    this._overrideIfSome("label", t);
+  }
+  get unitOptions() {
+    return this.viewModel.unitOptions;
+  }
+  set unitOptions(t) {
+    this.viewModel.unitOptions = t;
+  }
+  get unit() {
+    return this.viewModel.unit;
+  }
+  set unit(t) {
+    this.viewModel.unit = t;
+  }
+  render() {
+    const { messages: t, messagesCommon: e, unit: a, unitOptions: s, viewModel: l } = this, { active: r, measurement: o, state: p, supported: m } = l;
+    return B("div", { "aria-label": this.messages.widgetLabel, class: this.classes(U.base, W.widget, W.panel), key: this, role: "presentation" }, this.visible ? B(bt, { active: r, measurementItems: [{ key: "direct", title: t.direct, value: T(o == null ? void 0 : o.directDistance) }, { key: "horizontal", title: t.horizontal, value: T(o == null ? void 0 : o.horizontalDistance) }, { key: "vertical", title: t.vertical, value: T(o == null ? void 0 : o.verticalDistance) }], messages: { ...t, notApplicable: e == null ? void 0 : e.notApplicable }, newMeasurementButtonClass: U.newMeasurementButton, state: p, supported: m, unit: a, unitOptions: s, onNewMeasurementClick: () => {
+      lt(this.viewModel.start());
+    }, onUnitChange: (P) => {
+      this.unit = P;
+    } }) : null);
+  }
+};
+function T(t) {
+  return (t == null ? void 0 : t.state) === "available" ? t.text : null;
+}
+i([n()], c.prototype, "view", null), i([n()], c.prototype, "visible", null), i([n()], c.prototype, "active", null), i([n({ constructOnly: !0, nonNullable: !0 })], c.prototype, "analysis", null), i([n()], c.prototype, "iconClass", void 0), i([n()], c.prototype, "icon", void 0), i([n()], c.prototype, "label", null), i([n(), F("esri/widgets/DirectLineMeasurement3D/t9n/DirectLineMeasurement3D")], c.prototype, "messages", void 0), i([n(), F("esri/t9n/common")], c.prototype, "messagesCommon", void 0), i([n()], c.prototype, "uiStrings", void 0), i([n({ type: Y })], c.prototype, "viewModel", void 0), i([n()], c.prototype, "unitOptions", null), i([n()], c.prototype, "unit", null), c = i([L("esri.widgets.DirectLineMeasurement3D")], c);
+const Xe = c;
+export {
+  Xe as default
+};