@agrotools1/at-components 0.3.2 → 0.3.4-5

package/dist/AreaMeasurement3D-cac5c660.js

@@ -0,0 +1,488 @@
+import { e as a, y as n, b0 as Q, fT as M, c as f, s as X, dN as Y, b9 as $, x as w, i5 as J, a$ as P, he as Z, o as _, eD as tt, ad as A, dF as et, fG as S, eQ as x, i6 as C, fR as it, fU as b, fV as st, fW as L, fX as U, fY as at } from "./index-a3d05a4e.js";
+import { c as nt } from "./Analysis-0faeda0c.js";
+import { i as q, t as ot, d as v, N as rt, e as lt, V as pt, g as ht, P as ut, x as dt, h as gt, u as mt } from "./MeasurementWidgetContent-e2f7712f.js";
+import { T as ct, t as _t, e as H, f as k, s as T, g as E, h as yt, o as wt, i as vt, q as I, O as Mt, z as ft, k as Vt, _ as bt } from "./InteractiveAnalysisViewModel-7f97091f.js";
+import { F as R, I as Dt, G as Pt } from "./colorUtils-80904254.js";
+import { p as St } from "./SnappingOperation-cc14dbd9.js";
+import "vue";
+import "./vec42-1ca3a15b.js";
+import "./vec4f64-043e974c.js";
+import "./plane-7439f515.js";
+import "./mat3f64-03233387.js";
+import "./mat4f64-cce69db4.js";
+import "./quatf64-bec1af25.js";
+import "./sphere-4b51c308.js";
+import "./ObjectStack-2dcbe343.js";
+import "./projectVectorToVector-dc4f9075.js";
+import "./projectPointToVector-1d44e9e0.js";
+import "./elevationInfoUtils-1d1e5962.js";
+import "./unitConversionUtils-1f174f0a.js";
+import "./lengthUtils-2f2cfc0b.js";
+import "./meshVertexSpaceUtils-91f680d6.js";
+import "./MeshLocalVertexSpace-2a137632.js";
+import "./vec3-1254a687.js";
+import "./Scheduler-cad9ed50.js";
+import "./RenderState-b244097f.js";
+import "./quantityUtils-8fb2344b.js";
+import "./geometryEngineBase-f4b5ba37.js";
+import "./vec4f32-b2628ced.js";
+import "./Octree-4cefe4d0.js";
+import "./Util-cdfa8555.js";
+import "./lineSegment-738773c9.js";
+import "./triangle-0862aaaa.js";
+import "./DoubleArray-831931a7.js";
+import "./glUtil-8f8bce6b.js";
+import "./enums-2c166c09.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./InterleavedLayout-6b6c63b3.js";
+import "./BufferView-68dc0cfa.js";
+import "./types-adba9034.js";
+import "./VertexArrayObject-d100959c.js";
+import "./Texture-a9913471.js";
+import "./VertexAttribute-faad30bf.js";
+import "./VertexColor.glsl-39d73de9.js";
+import "./OrderIndependentTransparency-3eadfe42.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./BindType-5e76c8e1.js";
+import "./Indices-47421f35.js";
+import "./doublePrecisionUtils-46e21550.js";
+import "./requestImageUtils-27feb4bc.js";
+import "./orientedBoundingBox-dcadfac1.js";
+import "./quat-21571234.js";
+import "./computeTranslationToOriginAndRotation-afe53590.js";
+import "./BufferObject-e3e67b62.js";
+import "./axisAngleDegrees-541e21e5.js";
+import "./NestedMap-83f8e815.js";
+import "./floatRGBA-db3504b8.js";
+import "./MemCache-edc290a8.js";
+import "./vec3f32-304a6a9c.js";
+import "./FeatureFilter-e04ef24c.js";
+import "./floorFilterUtils-936f7587.js";
+import "./layerViewUtils-052e603c.js";
+import "./geometryEngine-2e792902.js";
+import "./hydrated-ffe82711.js";
+let c = class extends nt {
+  constructor(t) {
+    super(t), this.type = "area-measurement", this.unit = null;
+  }
+  set geometry(t) {
+    t != null ? (t.rings.length > 1 && X.getLogger(this).warn("Measuring polygons with multiple rings is not supported."), this._set("geometry", t.clone())) : this._set("geometry", null);
+  }
+  get requiredPropertiesForEditing() {
+    if (this.geometry != null && this.geometry.rings.length === 1) {
+      const t = this.geometry.rings[0];
+      if (t.length <= 2 || !Y(t[0], t[t.length - 1]))
+        return [null];
+    }
+    return [this.geometry];
+  }
+  clear() {
+    this.geometry = null;
+  }
+};
+a([n({ type: ["area-measurement"] })], c.prototype, "type", void 0), a([n({ value: null, type: Q })], c.prototype, "geometry", null), a([n({ type: M, value: null })], c.prototype, "unit", void 0), a([n({ readOnly: !0 })], c.prototype, "requiredPropertiesForEditing", null), c = a([f("esri.analysis.AreaMeasurementAnalysis")], c);
+const B = c;
+class xt {
+  constructor(t, i = null) {
+    this.screenPoint = t, this.result = i;
+  }
+}
+let Ot = class {
+  constructor(t, i) {
+    this.scenePoint = t, this.mapPoint = i;
+  }
+};
+function $t(e) {
+  const t = ct(e);
+  return t.options.store = _t.MIN, t.options.hud = !1, t;
+}
+class At {
+  constructor(t) {
+    this.vertexManipulators = [], this._destroyed = !1, this._isManipulatorsOwner = !0, this._visible = !0, this._listenerHandles = null, this._tempHandlePosition = $();
+    const { analysisViewData: i, manipulators: s, toolState: r, view: o, visible: l } = t;
+    this._analysisViewData = i, this._toolState = r, s != null ? (this._manipulators = s, this._isManipulatorsOwner = !1) : this._manipulators = new q(), this._view = o, this._intersector = $t(o.state.viewingMode);
+    const p = H(this._handleColor), d = [new k(T(p, 1, 32, 32))], m = new E({ view: o, renderObjects: d });
+    m.available = !1, m.radius = z, m.interactive = !1, this._manipulators.add(m), this._cursorManipulator = m, this._cursorManipulatorMaterial = p, this._laserLine = new yt({ view: o, attached: !0, style: { glowWidth: Lt, glowFalloff: Ut, innerWidth: Ht }, isDecoration: !0 }), this._updateVisibility(l ?? !0);
+  }
+  destroy() {
+    this._listenerHandles = w(this._listenerHandles), this._isManipulatorsOwner ? this._manipulators = w(this._manipulators) : this._manipulators = null, this._laserLine = w(this._laserLine), this._destroyed = !0;
+  }
+  get destroyed() {
+    return this._destroyed;
+  }
+  get visible() {
+    return this._visible;
+  }
+  set visible(t) {
+    t ? this.show() : this.hide();
+  }
+  get testData() {
+    const t = this._laserLine.testData;
+    return { laserLineRenderer: t != null ? { heightManifoldEnabled: t.heightManifoldEnabled, heightManifoldTarget: t.heightManifoldTarget, pointDistanceEnabled: t.pointDistanceEnabled, pointDistanceOrigin: t.pointDistanceOrigin, pointDistanceTarget: t.pointDistanceTarget, lineVerticalPlaneEnabled: t.lineVerticalPlaneEnabled } : { heightManifoldEnabled: !1, heightManifoldTarget: null, pointDistanceEnabled: !1, pointDistanceOrigin: null, pointDistanceTarget: null, lineVerticalPlaneEnabled: !1 } };
+  }
+  show() {
+    this._setVisibility(!0);
+  }
+  hide() {
+    this._setVisibility(!1);
+  }
+  _setVisibility(t) {
+    this._destroyed || this._visible === t || this._updateVisibility(t);
+  }
+  _updateVisibility(t) {
+    this._visible = t, this._laserLine.visible = t, t ? (this._initializeListeners(), this._updateAll()) : (this._destroyListeners(), this.vertexManipulators.forEach(({ manipulator: i }) => this._removeVertexManipulator(i)), this.vertexManipulators = [], this._view.cursor = null);
+  }
+  vertexHandleAt(t, i) {
+    const s = this._manipulators.intersect(t, i);
+    return s == null ? void 0 : s.metadata;
+  }
+  pick(t) {
+    const i = this._view.spatialReference, s = J(t.screenPoint);
+    this._view.sceneIntersectionHelper.intersectToolIntersectorScreen(s, this._intersector);
+    const r = this._intersector.results.min, o = $();
+    if (!r.getIntersectionPoint(o))
+      return null;
+    const l = this._view.renderCoordsHelper.fromRenderCoords(o, new P({ spatialReference: i }));
+    return l == null ? null : new Ot(o, l);
+  }
+  _updateAll() {
+    this._visible && (this._updateVertexManipulators(), this._updateLaserLine());
+  }
+  _createVertexManipulator() {
+    const t = H(this._handleColor), i = [new k(T(t, 1, 32, 32))], s = new E({ view: this._view, renderObjects: i });
+    return s.radius = z, this._manipulators.add(s), { manipulator: s, material: t };
+  }
+  _removeVertexManipulator(t) {
+    this._manipulators.remove(t);
+  }
+  _updateVertexManipulators() {
+    const { viewData: t } = this._analysisViewData, i = this._analysisViewData.path ? this._analysisViewData.path.vertices : [], s = this.vertexManipulators;
+    Ct(s, i.length, () => this._createVertexManipulator(), ({ manipulator: r }) => this._removeVertexManipulator(r)), s.forEach(({ manipulator: r }, o) => {
+      r.metadata = i[o], r.renderLocation = t.positionsRenderCoords[o], r.cursor = o === 0 && this._toolState.polygonState === "drawing" ? "crosshair" : null;
+    }), this._toolState.polygonState === "drawing" && this._analysisViewData.stagedPoint != null ? (this._cursorManipulator.available = !0, this._cursorManipulator.location = this._analysisViewData.stagedPoint) : this._cursorManipulator.available = !1;
+  }
+  get _handleColor() {
+    return R(this._view.effectiveTheme.accentColor, 0.5);
+  }
+  _getFocusPoint() {
+    const { lastDraggedVertex: t } = this._analysisViewData;
+    switch (this._toolState.polygonState) {
+      case "drawing":
+        return this._analysisViewData.stagedPoint != null ? this._analysisViewData.stagedPoint : t != null ? this._analysisViewData.path.getVertexPositionAsPoint(t) : this._analysisViewData.path.lastPoint;
+      case "editing":
+        return t != null ? this._analysisViewData.path.getVertexPositionAsPoint(t) : null;
+      default:
+        return this._analysisViewData.stagedPoint;
+    }
+  }
+  _updateLaserLine() {
+    const t = this._toolState.polygonState !== "measured" && this._toolState.active, i = this._getFocusPoint();
+    if (t && i != null) {
+      const s = this._tempHandlePosition;
+      this._view.renderCoordsHelper.toRenderCoords(i, s), this._laserLine.heightManifoldTarget = s;
+    } else
+      this._laserLine.heightManifoldTarget = null;
+  }
+  _initializeListeners() {
+    this._listenerHandles = new Z(), this._listenerHandles.add([_(() => this._toolState.polygonState, () => this._updateLaserLine()), _(() => this._analysisViewData.viewData, () => this._updateAll(), tt), _(() => ({ lastDraggedVertex: this._analysisViewData.lastDraggedVertex, cursorPoint: this._analysisViewData.stagedPoint }), () => this._updateLaserLine()), _(() => this._toolState.active, () => this._updateAll()), _(() => this._view.effectiveTheme.accentColor, (t) => {
+      const i = R(t, 0.5);
+      for (const { material: d } of this.vertexManipulators)
+        d.setParameters({ color: i });
+      this._cursorManipulatorMaterial.setParameters({ color: i });
+      const s = A.toUnitRGB(t), r = A.toUnitRGB(Pt(t)), o = 0.75 * t.a, l = this._laserLine, p = l.style;
+      l.style = { ...p, glowColor: s, innerColor: r, globalAlpha: o };
+    }, { initial: !0, equals: Dt })]);
+  }
+  _destroyListeners() {
+    this._listenerHandles = w(this._listenerHandles);
+  }
+}
+function Ct(e, t, i, s) {
+  for (; e.length < t; )
+    e.push(i());
+  if (s)
+    for (; e.length > t; )
+      s(e.pop());
+  else
+    e.length = t;
+}
+const Lt = 8, Ut = 8, Ht = 1, z = 5;
+let u = class extends wt {
+  constructor(e) {
+    super(e), this._updatingHandles = new et(), this.polygonState = "initial", this.manipulators = new q(), this._getSnappingContext = ot((t) => new lt({ elevationInfo: { mode: "absolute-height", offset: 0 }, pointer: t, editGeometryOperations: new pt(new ht("point", ut(!0, !1, this.view.spatialReference))), visualizer: new Mt() }));
+  }
+  initialize() {
+    const { view: e, analysisViewData: t, manipulators: i, visible: s } = this;
+    this.measurementView = new At({ view: e, analysisViewData: t, toolState: this, manipulators: i, visible: s });
+    const r = vt(e);
+    this._snappingManagerResult = r, this.addHandles(r), this._snappingOperation = new St({ view: e }), this._updatingHandles.add(() => this.stagedPoint, (o) => {
+      this.analysisViewData.stagedPoint = o != null ? v(o, new P()) : null;
+    }, S), rt(this, () => {
+      const o = this.view.inputManager.latestPointerType ?? "mouse", l = this._getSnappingContext(o);
+      this._updatingHandles.addPromise(x(this._snappingOperation.snapAgainNearPreviousMapPoint(this._snappingManager, l)));
+    }), this._setupManipulators(), this.addHandles([_(() => this.state, (o) => {
+      o === "measured" && this.finishToolCreation();
+    }, S), this.analysisViewData.path.on("change", () => {
+      const o = this.analysisViewData.path;
+      this.polygonState !== "initial" || o.isEmptyPolygon || (o.isValidPolygon ? this.polygonState = "measured" : this.polygonState = "drawing");
+    })]);
+  }
+  destroy() {
+    this.measurementView.destroy(), this._set("measurementView", null), this._updatingHandles = w(this._updatingHandles);
+  }
+  get _snappingManager() {
+    return this._snappingManagerResult.snappingManager;
+  }
+  get state() {
+    return this.analysisViewData.path.numVertices === 0 ? "ready" : this.analysisViewData.path.isValidPolygon && this.polygonState !== "editing" ? "measured" : "measuring";
+  }
+  get cursor() {
+    return this.state === "ready" || this.polygonState === "drawing" ? "crosshair" : null;
+  }
+  get updating() {
+    return this._updatingHandles.updating || this._snappingManager.updating;
+  }
+  get stagedPoint() {
+    return this._snappingOperation.stagedPoint;
+  }
+  set stagedPoint(e) {
+    this._snappingOperation.stagedPoint = e;
+  }
+  get snappingOptions() {
+    return this._snappingManager.options;
+  }
+  finishMeasurement() {
+    const { path: e } = this.analysisViewData;
+    e.numVertices < 3 ? (e.clear(), this.polygonState = "initial") : (e.close(), this.polygonState = "measured"), this._resetSnappingState();
+  }
+  onShow() {
+    this.measurementView.show();
+  }
+  onHide() {
+    this.measurementView.hide();
+  }
+  onDeactivate() {
+    this._resetSnappingState();
+  }
+  onInputEvent(e) {
+    switch (e.type) {
+      case "immediate-double-click":
+        this._handleImmediateDoubleClick(e);
+        break;
+      case "immediate-click":
+        this._handleImmediateClick(e);
+        break;
+      case "pointer-move":
+        this._handlePointerMove(e);
+        break;
+      case "drag":
+        this._handleDrag(e);
+        break;
+      case "key-down":
+        this._handleKeyDown(e);
+    }
+  }
+  _setupManipulators() {
+    const e = (i) => i.events.on("grab-changed", () => {
+      if (this.analysisViewData.path.isValidPolygon) {
+        const s = this.manipulators.some((r) => r.manipulator.grabbing);
+        this.polygonState = s ? "editing" : "measured";
+      }
+    }), t = (i) => {
+      this.addHandles([dt(i, (s, r, o, l) => {
+        const p = Vt(s), d = s.metadata, m = this._snappingManager, V = this._getSnappingContext(l), j = this._updatingHandles, { snappingStep: W, cancelSnapping: K } = gt({ snappingManager: m, snappingContext: V, updatingHandles: j });
+        o = o.next(p).next((y) => (this.analysisViewData.lastDraggedVertex = null, this.analysisViewData.path.setVertexPosition(d, O), s.location = O, y)).next(K), r.next(p).next(ft(this.view)).next(...W).next((y) => {
+          s.location = y.mapEnd, this.analysisViewData.lastDraggedVertex = y.action === "end" ? null : d, this.analysisViewData.path.setVertexPosition(d, v(y.mapEnd));
+        });
+        const O = v(this.analysisViewData.path.getVertexPositionAsPoint(d));
+      }), e(i)], i);
+    };
+    this.manipulators.forEach(({ manipulator: i }) => {
+      t(i);
+    }), this.addHandles([this.manipulators.on("after-add", ({ item: { manipulator: i } }) => {
+      t(i);
+    }), this.manipulators.on("after-remove", ({ item: { manipulator: i } }) => this.removeHandles(i))]);
+  }
+  _handleImmediateDoubleClick(e) {
+    I(e) && (this.polygonState === "drawing" && this.finishMeasurement(), e.stopPropagation());
+  }
+  _handleDrag(e) {
+    this.polygonState === "editing" && e.stopPropagation();
+  }
+  _handleImmediateClick(e) {
+    if (!I(e))
+      return;
+    const t = C(e), { pointerType: i } = e;
+    if (this.active)
+      switch (this.polygonState) {
+        case "initial":
+          if (this._addVertexAt(t, i))
+            return this.stagedPoint = null, this.polygonState = "drawing", void e.stopPropagation();
+          break;
+        case "drawing": {
+          const s = this.measurementView.vertexHandleAt(t, i);
+          if (s == null) {
+            if (this._addVertexAt(t, i))
+              return this.stagedPoint = null, void e.stopPropagation();
+          } else
+            s.index === 0 && (this.finishMeasurement(), e.stopPropagation());
+          break;
+        }
+      }
+    e.pointerType === "mouse" && this._hoverAt(t);
+  }
+  _handlePointerMove(e) {
+    if (e.pointerType === "mouse") {
+      const t = C(e);
+      this._hoverAt(t);
+    }
+  }
+  _handleKeyDown(e) {
+    const { path: t } = this.analysisViewData;
+    e.key === "Enter" && this.polygonState === "drawing" && t.numVertices >= 3 && (this.stagedPoint = null, this.finishMeasurement(), e.stopPropagation());
+  }
+  _hoverAt(e) {
+    const { polygonState: t } = this;
+    if (this.active && (t === "initial" || t === "drawing")) {
+      const i = this._pick(e);
+      if ((i == null ? void 0 : i.mapPoint) != null) {
+        const s = this._getSnappingContext("mouse");
+        this._updatingHandles.addPromise(x(this._snappingOperation.snap({ point: i.mapPoint }, this._snappingManager, s)));
+      }
+    } else
+      this.stagedPoint = null;
+  }
+  _addVertexAt(e, t) {
+    const i = this._pick(e);
+    if ((i == null ? void 0 : i.mapPoint) != null) {
+      const { mapPoint: s } = i, r = this._getSnappingContext(t), o = this._snappingOperation.update({ point: s }, this._snappingManager, r), l = v(o, new P());
+      return this.analysisViewData.path.add(l), !0;
+    }
+    return !1;
+  }
+  _pick(e) {
+    const t = new xt(e);
+    return this.measurementView.pick(t);
+  }
+  _resetSnappingState() {
+    this._snappingManager.doneSnapping(), this._snappingOperation.abort(), this._snappingOperation.stagedPoint = null;
+  }
+  get test() {
+    return { snappingManager: this._snappingManager };
+  }
+};
+a([n({ readOnly: !0 })], u.prototype, "state", null), a([n()], u.prototype, "polygonState", void 0), a([n({ readOnly: !0 })], u.prototype, "cursor", null), a([n()], u.prototype, "measurementView", void 0), a([n({ constructOnly: !0 })], u.prototype, "view", void 0), a([n({ constructOnly: !0 })], u.prototype, "analysis", void 0), a([n({ constructOnly: !0 })], u.prototype, "analysisViewData", void 0), a([n({ readOnly: !0 })], u.prototype, "manipulators", void 0), a([n()], u.prototype, "updating", null), a([n()], u.prototype, "stagedPoint", null), a([n()], u.prototype, "snappingOptions", null), u = a([f("esri.views.3d.interactive.measurementTools.areaMeasurement3D.AreaMeasurement3DTool")], u);
+const kt = u;
+let g = class extends bt {
+  constructor(e) {
+    super(e), this.analysis = null, this.supportedViewType = "3d", this.unsupportedErrorMessage = "AreaMeasurement3DViewModel is only supported in 3D views.", this._userUnitOptions = null, this._userUnit = null;
+  }
+  initialize() {
+    this.addHandles(_(() => ({ analysis: this.analysis, unit: this.unit }), ({ analysis: e, unit: t }) => {
+      e != null && (e.unit = t);
+    }, S));
+  }
+  get state() {
+    return this.disabled || !this.ready ? "disabled" : this.tool == null ? "ready" : this.tool.state;
+  }
+  get measurement() {
+    if (this.tool == null || this.disabled || this.tool.destroyed)
+      return null;
+    const { analysisView: e } = this;
+    if (e == null)
+      return null;
+    const t = e.analysisVisualization, i = t.viewData, s = i.measurementData, r = s.validMeasurement, o = i.mode === "euclidean", l = (o ? s.intersectingSegments : s.geodesicIntersectingSegments).size === 0, p = l ? r ? "available" : "unavailable" : "invalid";
+    return { mode: o ? "euclidean" : "geodesic", area: { text: l && r ? t.areaLabel : null, state: p }, perimeterLength: { text: l && r ? t.perimeterLengthLabel : null, state: p } };
+  }
+  set unitOptions(e) {
+    this._userUnitOptions = e, this._set("unitOptions", this._filteredOrAllUnits(this._userUnitOptions));
+  }
+  get unitOptions() {
+    return this._filteredOrAllUnits(this._userUnitOptions);
+  }
+  set unit(e) {
+    this._userUnit = e ? this._findSelectableUnit(e, this._userUnit) : null;
+  }
+  get unit() {
+    return this._userUnit != null ? (this._userUnit = this._findSelectableUnit(this._userUnit, this.defaultUnit), this._userUnit) : this._findSelectableUnit(this.defaultUnit);
+  }
+  constructAnalysis() {
+    return new B();
+  }
+  constructTool() {
+    return new kt({ view: this.view, analysis: this.analysis, analysisViewData: this.analysisView, visible: this.visible });
+  }
+  _findSelectableUnit(e, t) {
+    const { unitOptions: i } = this;
+    return i.includes(e) ? e : t != null ? this._findSelectableUnit(t) : i[0];
+  }
+  _filteredOrAllUnits(e) {
+    if (e == null)
+      return M.slice();
+    const t = e.filter((i) => M.includes(i));
+    return t.length === 0 ? M.slice() : t;
+  }
+};
+a([n({ type: B })], g.prototype, "analysis", void 0), a([n({ readOnly: !0 })], g.prototype, "state", null), a([n({ readOnly: !0 })], g.prototype, "measurement", null), a([n()], g.prototype, "unitOptions", null), a([n()], g.prototype, "unit", null), a([n(it)], g.prototype, "defaultUnit", void 0), a([n()], g.prototype, "_userUnit", void 0), g = a([f("esri.widgets.AreaMeasurement3D.AreaMeasurement3DViewModel")], g);
+const G = g, F = "esri-area-measurement-3d", D = { base: F, newMeasurementButton: `${F}__clear-button`, widgetIcon: at.measureArea };
+let h = class extends st {
+  constructor(e, t) {
+    super(e, t), this.iconClass = D.widgetIcon, this.icon = null, this.messages = null, this.messagesCommon = null, this.messagesUnits = null, this.viewModel = new G();
+  }
+  get view() {
+    return this.viewModel.view;
+  }
+  set view(e) {
+    this.viewModel.view = e;
+  }
+  get visible() {
+    return this.viewModel.visible;
+  }
+  set visible(e) {
+    this.viewModel.visible = e;
+  }
+  get active() {
+    return this.viewModel.active;
+  }
+  get analysis() {
+    return this.viewModel.analysis;
+  }
+  set analysis(e) {
+    this.viewModel.analysis = e;
+  }
+  get label() {
+    var e;
+    return ((e = this.messages) == null ? void 0 : e.widgetLabel) ?? "";
+  }
+  set label(e) {
+    this._overrideIfSome("label", e);
+  }
+  get unitOptions() {
+    return this.viewModel.unitOptions;
+  }
+  set unitOptions(e) {
+    this.viewModel.unitOptions = e;
+  }
+  get unit() {
+    return this.viewModel.unit;
+  }
+  set unit(e) {
+    this.viewModel.unit = e;
+  }
+  render() {
+    const { messages: e, messagesCommon: t, messagesUnits: i, unit: s, unitOptions: r, viewModel: o } = this, { active: l, measurement: p, state: d, supported: m } = o;
+    return L("div", { "aria-label": this.messages.widgetLabel, class: this.classes(D.base, U.widget, U.panel), key: this, role: "presentation" }, this.visible ? L(mt, { active: l, measurementItems: [{ key: "direct", title: i.measures.area, value: N(p == null ? void 0 : p.area) }, { key: "perimeter", title: e.perimeterLength, value: N(p == null ? void 0 : p.perimeterLength) }], messages: { ...e, notApplicable: t.notApplicable }, newMeasurementButtonClass: D.newMeasurementButton, state: d, supported: m, unit: s, unitOptions: r, onNewMeasurementClick: () => {
+      x(this.viewModel.start());
+    }, onUnitChange: (V) => {
+      this.unit = V;
+    } }) : null);
+  }
+};
+function N(e) {
+  return (e == null ? void 0 : e.state) === "available" ? e.text : null;
+}
+a([n()], h.prototype, "view", null), a([n()], h.prototype, "visible", null), a([n()], h.prototype, "active", null), a([n({ constructOnly: !0, nonNullable: !0 })], h.prototype, "analysis", null), a([n()], h.prototype, "iconClass", void 0), a([n()], h.prototype, "icon", void 0), a([n()], h.prototype, "label", null), a([n(), b("esri/widgets/AreaMeasurement3D/t9n/AreaMeasurement3D")], h.prototype, "messages", void 0), a([n(), b("esri/t9n/common")], h.prototype, "messagesCommon", void 0), a([n(), b("esri/core/t9n/Units")], h.prototype, "messagesUnits", void 0), a([n()], h.prototype, "uiStrings", void 0), a([n({ type: G })], h.prototype, "viewModel", void 0), a([n()], h.prototype, "unitOptions", null), a([n()], h.prototype, "unit", null), h = a([f("esri.widgets.AreaMeasurement3D")], h);
+const We = h;
+export {
+  We as default
+};

package/dist/AttachmentInfo-b6b59871.js

@@ -0,0 +1,34 @@
+import { e as o, y as e, ea as s, c as u, bx as f } from "./index-a3d05a4e.js";
+function y(n) {
+  const { exifInfo: r, exifName: a, tagName: i } = n;
+  if (!r || !a || !i)
+    return null;
+  const l = r.find((p) => p.name === a);
+  return l ? c({ tagName: i, tags: l.tags }) : null;
+}
+function c(n) {
+  const { tagName: r, tags: a } = n;
+  if (!a || !r)
+    return null;
+  const i = a.find((l) => l.name === r);
+  return (i == null ? void 0 : i.value) || null;
+}
+var d;
+const m = { 1: { id: 1, rotation: 0, mirrored: !1 }, 2: { id: 2, rotation: 0, mirrored: !0 }, 3: { id: 3, rotation: 180, mirrored: !1 }, 4: { id: 4, rotation: 180, mirrored: !0 }, 5: { id: 5, rotation: -90, mirrored: !0 }, 6: { id: 6, rotation: 90, mirrored: !1 }, 7: { id: 7, rotation: 90, mirrored: !0 }, 8: { id: 8, rotation: -90, mirrored: !1 } };
+let t = d = class extends f {
+  constructor(n) {
+    super(n), this.contentType = null, this.exifInfo = null, this.id = null, this.globalId = null, this.keywords = null, this.name = null, this.parentGlobalId = null, this.parentObjectId = null, this.size = null, this.url = null;
+  }
+  get orientationInfo() {
+    const { exifInfo: n } = this, r = y({ exifName: "Exif IFD0", tagName: "Orientation", exifInfo: n });
+    return m[r] || null;
+  }
+  clone() {
+    return new d({ contentType: this.contentType, exifInfo: this.exifInfo, id: this.id, globalId: this.globalId, keywords: this.keywords, name: this.name, parentGlobalId: this.parentGlobalId, parentObjectId: this.parentObjectId, size: this.size, url: this.url });
+  }
+};
+o([e({ type: String })], t.prototype, "contentType", void 0), o([e()], t.prototype, "exifInfo", void 0), o([e({ readOnly: !0 })], t.prototype, "orientationInfo", null), o([e({ type: s })], t.prototype, "id", void 0), o([e({ type: String })], t.prototype, "globalId", void 0), o([e({ type: String })], t.prototype, "keywords", void 0), o([e({ type: String })], t.prototype, "name", void 0), o([e({ json: { read: !1 } })], t.prototype, "parentGlobalId", void 0), o([e({ json: { read: !1 } })], t.prototype, "parentObjectId", void 0), o([e({ type: s })], t.prototype, "size", void 0), o([e({ json: { read: !1 } })], t.prototype, "url", void 0), t = d = o([u("esri.layers.support.AttachmentInfo")], t);
+const h = t;
+export {
+  h as a
+};

package/dist/AttachmentQuery-0eb145ac.js

@@ -0,0 +1,18 @@
+import { e, y as s, c2 as n, c as a, c3 as p, bx as h, bz as u } from "./index-a3d05a4e.js";
+var r;
+let t = r = class extends h {
+  constructor(o) {
+    super(o), this.attachmentTypes = null, this.attachmentsWhere = null, this.cacheHint = void 0, this.keywords = null, this.globalIds = null, this.name = null, this.num = null, this.objectIds = null, this.returnMetadata = !1, this.size = null, this.start = null, this.where = null;
+  }
+  writeStart(o, i) {
+    i.resultOffset = this.start, i.resultRecordCount = this.num || 10;
+  }
+  clone() {
+    return new r(u({ attachmentTypes: this.attachmentTypes, attachmentsWhere: this.attachmentsWhere, cacheHint: this.cacheHint, keywords: this.keywords, where: this.where, globalIds: this.globalIds, name: this.name, num: this.num, objectIds: this.objectIds, returnMetadata: this.returnMetadata, size: this.size, start: this.start }));
+  }
+};
+e([s({ type: [String], json: { write: !0 } })], t.prototype, "attachmentTypes", void 0), e([s({ type: String, json: { read: { source: "attachmentsDefinitionExpression" }, write: { target: "attachmentsDefinitionExpression" } } })], t.prototype, "attachmentsWhere", void 0), e([s({ type: Boolean, json: { write: !0 } })], t.prototype, "cacheHint", void 0), e([s({ type: [String], json: { write: !0 } })], t.prototype, "keywords", void 0), e([s({ type: [Number], json: { write: !0 } })], t.prototype, "globalIds", void 0), e([s({ json: { write: !0 } })], t.prototype, "name", void 0), e([s({ type: Number, json: { read: { source: "resultRecordCount" } } })], t.prototype, "num", void 0), e([s({ type: [Number], json: { write: !0 } })], t.prototype, "objectIds", void 0), e([s({ type: Boolean, json: { default: !1, write: !0 } })], t.prototype, "returnMetadata", void 0), e([s({ type: [Number], json: { write: !0 } })], t.prototype, "size", void 0), e([s({ type: Number, json: { read: { source: "resultOffset" } } })], t.prototype, "start", void 0), e([n("start"), n("num")], t.prototype, "writeStart", null), e([s({ type: String, json: { read: { source: "definitionExpression" }, write: { target: "definitionExpression" } } })], t.prototype, "where", void 0), t = r = e([a("esri.rest.support.AttachmentQuery")], t), t.from = p(t);
+const l = t;
+export {
+  l as c
+};