@agrotools1/at-components 0.2.3 → 0.2.5

package/dist/AGraphicContainer-d82e96aa.js

@@ -0,0 +1,109 @@
+import { fd as p, Q as O, g1 as D, f6 as I, fb as V, f7 as $, f8 as w, g2 as z, f9 as C, x as E } from "./index-6ebf29c1.js";
+import { i as L, r as N } from "./TechniqueInstance-397b7dc2.js";
+import { i as T, N as F } from "./Container-f931e682.js";
+import { h } from "./FeatureCommandQueue-4e426066.js";
+import { r as P } from "./UpdateTracking2D-23c8ff3f.js";
+import { r as k } from "./vec3f32-304a6a9c.js";
+import { b as U } from "./LabelMetric-ee740bd1.js";
+import { h as v } from "./BufferObject-22d914df.js";
+import { R as x, E as W, C as M, F as b } from "./enums-2c166c09.js";
+import { o as H } from "./VertexArrayObject-08a9d938.js";
+let q = 0;
+function c(f, e, t) {
+  return new L(P(q++), f, f.meshWriter.name, e, t);
+}
+const d = { geometry: { visualVariableColor: null, visualVariableOpacity: null, visualVariableSizeMinMaxValue: null, visualVariableSizeScaleStops: null, visualVariableSizeStops: null, visualVariableSizeUnitValue: null, visualVariableRotation: null } };
+class j {
+  constructor() {
+    this.instances = { fill: c(h.fill, d, { zoomRange: !0 }), marker: c(h.marker, d, { zoomRange: !0 }), line: c(h.line, d, { zoomRange: !0 }), text: c(h.text, d, { zoomRange: !0, referenceSymbol: !1, clipAngle: !1 }), complexFill: c(h.complexFill, d, { zoomRange: !0 }), texturedLine: c(h.texturedLine, d, { zoomRange: !0 }) }, this._instancesById = Object.values(this.instances).reduce((e, t) => (e.set(t.instanceId, t), e), /* @__PURE__ */ new Map());
+  }
+  getInstance(e) {
+    return this._instancesById.get(e);
+  }
+}
+const G = Math.PI / 180, Y = 4;
+class Q extends T {
+  constructor(e) {
+    super(), this._program = null, this._vao = null, this._vertexBuffer = null, this._indexBuffer = null, this._dvsMat3 = p(), this._localOrigin = { x: 0, y: 0 }, this._getBounds = e;
+  }
+  destroy() {
+    this._vao && (this._vao.dispose(), this._vao = null, this._vertexBuffer = null, this._indexBuffer = null), this._program = O(this._program);
+  }
+  doRender(e) {
+    const { context: t } = e, s = this._getBounds();
+    if (s.length < 1)
+      return;
+    this._createShaderProgram(t), this._updateMatricesAndLocalOrigin(e), this._updateBufferData(t, s), t.setBlendingEnabled(!0), t.setDepthTestEnabled(!1), t.setStencilWriteMask(0), t.setStencilTestEnabled(!1), t.setBlendFunction(x.ONE, x.ONE_MINUS_SRC_ALPHA), t.setColorMask(!0, !0, !0, !0);
+    const r = this._program;
+    t.bindVAO(this._vao), t.useProgram(r), r.setUniformMatrix3fv("u_dvsMat3", this._dvsMat3), t.gl.lineWidth(1), t.drawElements(W.LINES, 8 * s.length, M.UNSIGNED_INT, 0), t.bindVAO();
+  }
+  _createTransforms() {
+    return { displayViewScreenMat3: p() };
+  }
+  _createShaderProgram(e) {
+    if (this._program)
+      return;
+    const t = `precision highp float;
+        uniform mat3 u_dvsMat3;
+
+        attribute vec2 a_position;
+
+        void main() {
+          mediump vec3 pos = u_dvsMat3 * vec3(a_position, 1.0);
+          gl_Position = vec4(pos.xy, 0.0, 1.0);
+        }`, s = `precision mediump float;
+      void main() {
+        gl_FragColor = vec4(0.75, 0.0, 0.0, 0.75);
+      }`;
+    this._program = e.programCache.acquire(t, s, y().attributes);
+  }
+  _updateMatricesAndLocalOrigin(e) {
+    const { state: t } = e, { displayMat3: s, size: r, resolution: _, pixelRatio: a, rotation: o, viewpoint: i } = t, l = G * o, { x: n, y: R } = i.targetGeometry, B = D(n, t.spatialReference);
+    this._localOrigin.x = B, this._localOrigin.y = R;
+    const g = a * r[0], m = a * r[1], S = _ * g, A = _ * m, u = I(this._dvsMat3);
+    V(u, u, s), $(u, u, w(g / 2, m / 2)), z(u, u, k(r[0] / S, -m / A, 1)), C(u, u, -l);
+  }
+  _updateBufferData(e, t) {
+    const { x: s, y: r } = this._localOrigin, _ = 2 * Y * t.length, a = new Float32Array(_), o = new Uint32Array(8 * t.length);
+    let i = 0, l = 0;
+    for (const n of t)
+      n && (a[2 * i] = n[0] - s, a[2 * i + 1] = n[1] - r, a[2 * i + 2] = n[0] - s, a[2 * i + 3] = n[3] - r, a[2 * i + 4] = n[2] - s, a[2 * i + 5] = n[3] - r, a[2 * i + 6] = n[2] - s, a[2 * i + 7] = n[1] - r, o[l] = i + 0, o[l + 1] = i + 3, o[l + 2] = i + 3, o[l + 3] = i + 2, o[l + 4] = i + 2, o[l + 5] = i + 1, o[l + 6] = i + 1, o[l + 7] = i + 0, i += 4, l += 8);
+    if (this._vertexBuffer ? this._vertexBuffer.setData(a.buffer) : this._vertexBuffer = v.createVertex(e, b.DYNAMIC_DRAW, a.buffer), this._indexBuffer ? this._indexBuffer.setData(o) : this._indexBuffer = v.createIndex(e, b.DYNAMIC_DRAW, o), !this._vao) {
+      const n = y();
+      this._vao = new H(e, n.attributes, n.bufferLayouts, { geometry: this._vertexBuffer }, this._indexBuffer);
+    }
+  }
+}
+const y = () => U("bounds", { geometry: [{ location: 0, name: "a_position", count: 2, type: M.FLOAT }] });
+class ae extends N {
+  constructor(e) {
+    super(e), this._instanceStore = new j(), this.checkHighlight = () => !0;
+  }
+  destroy() {
+    super.destroy(), this._boundsRenderer = E(this._boundsRenderer);
+  }
+  get instanceStore() {
+    return this._instanceStore;
+  }
+  enableRenderingBounds(e) {
+    this._boundsRenderer = new Q(e), this.requestRender();
+  }
+  get hasHighlight() {
+    return this.checkHighlight();
+  }
+  onTileData(e, t) {
+    e.onMessage(t), this.contains(e) || this.addChild(e), this.requestRender();
+  }
+  _renderChildren(e, t) {
+    e.selection = t;
+    for (const s of this.children) {
+      if (!s.visible)
+        continue;
+      const r = s.getDisplayList(e.drawPhase, this._instanceStore, F.STRICT_ORDER);
+      r == null || r.render(e);
+    }
+  }
+}
+export {
+  ae as i
+};

package/dist/APIKeyMixin-2ee64e59.js

@@ -0,0 +1,19 @@
+import { e as r, y as s, c as p } from "./index-6ebf29c1.js";
+function a(t) {
+  return "portalItem" in t;
+}
+const y = (t) => {
+  let i = class extends t {
+    get apiKey() {
+      var e;
+      return this._isOverridden("apiKey") ? this._get("apiKey") : a(this) ? (e = this.portalItem) == null ? void 0 : e.apiKey : null;
+    }
+    set apiKey(e) {
+      e != null ? this._override("apiKey", e) : (this._clearOverride("apiKey"), this.clear("apiKey", "user"));
+    }
+  };
+  return r([s({ type: String })], i.prototype, "apiKey", null), i = r([p("esri.layers.mixins.APIKeyMixin")], i), i;
+};
+export {
+  y as i
+};

package/dist/Analysis-449f84c5.js

@@ -0,0 +1,31 @@
+import { bi as a, bj as r, bk as l, B as o, e as s, y as i, c as p, S as c } from "./index-6ebf29c1.js";
+let y = 0, t = class extends a(r(l(c))) {
+  constructor(n) {
+    super(n), this.id = `${Date.now().toString(16)}-analysis-${y++}`, this.title = null;
+  }
+  get parent() {
+    return this._get("parent");
+  }
+  set parent(n) {
+    const e = this.parent;
+    if (e != null)
+      switch (e.type) {
+        case "line-of-sight":
+        case "dimension":
+          e.releaseAnalysis(this);
+          break;
+        case "2d":
+        case "3d":
+          e.analyses.includes(this) && e.analyses.remove(this);
+      }
+    this._set("parent", n);
+  }
+  get isEditable() {
+    return this.requiredPropertiesForEditing.every(o);
+  }
+};
+s([i({ type: String, constructOnly: !0, clonable: !1 })], t.prototype, "id", void 0), s([i({ type: String })], t.prototype, "title", void 0), s([i({ clonable: !1, value: null })], t.prototype, "parent", null), s([i({ readOnly: !0 })], t.prototype, "isEditable", null), t = s([p("esri.analysis.Analysis")], t);
+const u = t;
+export {
+  u as c
+};

package/dist/ArcGISCachedService-a838709f.js

@@ -0,0 +1,47 @@
+import { e as t, y as a, c5 as m, bR as x, cZ as y, c as S } from "./index-6ebf29c1.js";
+import { e as I } from "./TileInfoTilemapCache-3e97ab02.js";
+import { T as O } from "./TilemapCache-36e3c4b7.js";
+const T = (h) => {
+  let l = class extends h {
+    constructor() {
+      super(...arguments), this.copyright = null, this.minScale = 0, this.maxScale = 0, this.spatialReference = null, this.tileInfo = null, this.tilemapCache = null;
+    }
+    destroy() {
+      var i, e;
+      (e = (i = this.tilemapCache) == null ? void 0 : i.destroy) == null || e.call(i);
+    }
+    readMinScale(i, e) {
+      return e.minLOD != null && e.maxLOD != null ? i : 0;
+    }
+    readMaxScale(i, e) {
+      return e.minLOD != null && e.maxLOD != null ? i : 0;
+    }
+    get supportsBlankTile() {
+      return this.version >= 10.2;
+    }
+    readTilemapCache(i, e, f) {
+      var u;
+      const v = (u = e.capabilities) == null ? void 0 : u.includes("Tilemap");
+      let { minLOD: n, maxLOD: o, minScale: c, maxScale: p } = e;
+      if (n == null && o == null && c !== 0 && p !== 0) {
+        const r = (s) => Math.round(1e4 * s) / 1e4;
+        c = r(c || e.tileInfo.lods[0].scale), p = r(p || e.tileInfo.lods[e.tileInfo.lods.length - 1].scale);
+        for (const s of e.tileInfo.lods) {
+          const d = r(s.scale);
+          n = d >= c ? s.level : n, o = d >= p ? s.level : o;
+        }
+      }
+      if (v)
+        return new O({ layer: this, minLOD: n, maxLOD: o });
+      if (e.tileInfo) {
+        const r = new y();
+        return r.read(e.tileInfo, f), new I(r, n, o);
+      }
+      return null;
+    }
+  };
+  return t([a({ json: { read: { source: "copyrightText" } } })], l.prototype, "copyright", void 0), t([a()], l.prototype, "minScale", void 0), t([m("service", "minScale")], l.prototype, "readMinScale", null), t([a()], l.prototype, "maxScale", void 0), t([m("service", "maxScale")], l.prototype, "readMaxScale", null), t([a({ type: x })], l.prototype, "spatialReference", void 0), t([a({ readOnly: !0 })], l.prototype, "supportsBlankTile", null), t([a({ type: y })], l.prototype, "tileInfo", void 0), t([a()], l.prototype, "tilemapCache", void 0), t([m("service", "tilemapCache", ["capabilities", "tileInfo"])], l.prototype, "readTilemapCache", null), t([a()], l.prototype, "version", void 0), l = t([S("esri.layers.mixins.ArcGISCachedService")], l), l;
+};
+export {
+  T as p
+};

package/dist/ArcGISService-7e5e8710.js

@@ -0,0 +1,25 @@
+import { e as i, y as s, c as r, bL as n, c8 as u, s as o } from "./index-6ebf29c1.js";
+const h = (l) => {
+  let e = class extends l {
+    get title() {
+      if (this._get("title") && this.originOf("title") !== "defaults")
+        return this._get("title");
+      if (this.url) {
+        const t = n(this.url);
+        if (t != null && t.title)
+          return t.title;
+      }
+      return this._get("title") || "";
+    }
+    set title(t) {
+      this._set("title", t);
+    }
+    set url(t) {
+      this._set("url", u(t, o.getLogger(this)));
+    }
+  };
+  return i([s()], e.prototype, "title", null), i([s({ type: String })], e.prototype, "url", null), e = i([r("esri.layers.mixins.ArcGISService")], e), e;
+};
+export {
+  h as l
+};

package/dist/AreaMeasurement2D-971dad40.js

@@ -0,0 +1,405 @@
+import { e as a, y as o, c as U, fO as R, fP as J, o as $, P as q, x as A, cB as K, a$ as W, z as M, ab as Z, aa as F, ac as ee, fQ as te, a9 as z, b1 as I, bT as v, bR as L, b0 as se, j as V, fR as ie, fS as re, s as ae, fT as S, fH as ne, cC as oe, fU as T, fV as le, fW as j, eQ as ue, fX as B, fY as me } from "./index-6ebf29c1.js";
+import { R as G, G as ce, q as he } from "./colorUtils-6d5e716b.js";
+import { g as H, $ as pe, j as de, d as ve, D as ye } from "./unitFormatUtils-e75be0c3.js";
+import { geodesicDensify as D, planarLength as E, simplify as b, geodesicLength as fe, geodesicArea as we, planarArea as ge } from "./geometryEngine-e18a460d.js";
+import { l as _e, x as be, w as C, R as g, v as O, a as k, b as $e, S as Le, p as Me, u as Ae } from "./MeasurementWidgetContent-82971f95.js";
+import { h as N } from "./GraphicsLayer-a30f80da.js";
+import { l as Se, S as Te } from "./GraphicManipulator-797ae6c6.js";
+import "vue";
+import "./vec42-27060a00.js";
+import "./vec4f64-043e974c.js";
+import "./ByteSizeUnit-90df2840.js";
+import "./quantityUtils-b64583f9.js";
+import "./geometryEngineBase-d653892b.js";
+import "./hydrated-36edecd6.js";
+import "./plane-84e27261.js";
+import "./mat3f64-03233387.js";
+import "./mat4f64-cce69db4.js";
+import "./quatf64-bec1af25.js";
+import "./sphere-418b76df.js";
+import "./ObjectStack-424092a9.js";
+import "./projectVectorToVector-b7e757a1.js";
+import "./projectPointToVector-1f1d1dc7.js";
+import "./elevationInfoUtils-c1caf596.js";
+import "./unitConversionUtils-c1bfd22b.js";
+import "./lengthUtils-6a89d855.js";
+import "./meshVertexSpaceUtils-c9b69510.js";
+import "./MeshLocalVertexSpace-6fe3a662.js";
+import "./vec3-61daf837.js";
+import "./Scheduler-b3c40220.js";
+import "./RenderState-b244097f.js";
+import "./BlendLayer-246e4998.js";
+import "./jsonUtils-09f69988.js";
+import "./parser-7a76caf9.js";
+import "./ScaleRangeLayer-ab226dbd.js";
+import "./ElevationInfo-234040e3.js";
+import "./enums-fa8f05ab.js";
+import "./SnappingOperation-be595c42.js";
+import "./diffUtils-54c1c039.js";
+import "./quat-5502b70d.js";
+import "./defaults-b7c93d2a.js";
+import "./defaultsJSON-ba17aa15.js";
+import "./drapedUtils-166cd4c2.js";
+const y = 1e5;
+let f = class extends _e {
+  constructor(e) {
+    super(e), this._drawActive = !1, this._measurementLayer = new N({ internal: !0, listMode: "hide", visible: !1 }), this._manipulatorLayer = new N({ internal: !0, listMode: "hide", visible: !1 }), this._vertices = [], this.geodesicDistanceThreshold = null, this.measurement = null, this.measurementLabel = null;
+  }
+  initialize() {
+    R("esri/core/t9n/Units").then((t) => {
+      this.messages = t;
+    }), this.addHandles(J(async () => {
+      this.messages = await R("esri/core/t9n/Units");
+    }));
+    const e = this.view;
+    this._draw = new Se({ view: e }), e.map.addMany([this._measurementLayer, this._manipulatorLayer]), e.focus(), this.addHandles([$(() => [this.unit, this.geodesicDistanceThreshold, this.messages], () => {
+      this._updateGraphics();
+    }, q), $(() => [this.view.effectiveTheme.accentColor, this.view.effectiveTheme.textColor], () => {
+      if (!this._vertices.length)
+        return;
+      const t = this._vertices.map(({ coord: i }) => i);
+      for (const { handle: i } of this._vertices)
+        i.remove();
+      this._vertices = [], this._measurementLayer.removeAll(), this._manipulatorLayer.removeAll(), this.manipulators.removeAll(), this._updateSketch(t);
+    })]);
+  }
+  destroy() {
+    const { map: e } = this.view;
+    this._draw.view = null, this._draw = A(this._draw), e.removeMany([this._measurementLayer, this._manipulatorLayer]), this._measurementLayer.removeAll(), this._manipulatorLayer.removeAll(), this._set("measurement", null), this._set("measurementLabel", null), this._measurementLayer = A(this._measurementLayer), this._manipulatorLayer = A(this._manipulatorLayer), this._resetVertices();
+  }
+  get cursor() {
+    return this._drawActive ? "crosshair" : null;
+  }
+  set editable(e) {
+    this._set("editable", e), e || this._draw.reset();
+  }
+  onActivate() {
+    this._drawActive || this._vertices.length !== 0 || this._startSketch();
+  }
+  onShow() {
+    this._measurementLayer.visible = !0, this._manipulatorLayer.visible = !0;
+  }
+  onHide() {
+    this._measurementLayer.visible = !1, this._manipulatorLayer.visible = !1;
+  }
+  reset() {
+    this.manipulators.removeAll(), this._resetVertices(), this._measurementLayer.removeAll(), this._manipulatorLayer.removeAll(), this._set("measurement", null), this._set("measurementLabel", null), this._draw.reset(), this._drawActive = !1;
+  }
+  _resetVertices() {
+    for (const { handle: e } of this._vertices)
+      e.remove();
+    this._vertices = [];
+  }
+  _startSketch() {
+    this._drawActive = !0;
+    const e = this._draw.create("polyline", { mode: "click" });
+    e.on(["vertex-add", "vertex-update", "vertex-remove", "cursor-update", "undo", "redo"], (t) => this._updateSketch(t.vertices)), e.on("draw-complete", () => this._stopSketch());
+  }
+  _stopSketch() {
+    if (this._vertices.length < 3)
+      return this.reset(), void this._startSketch();
+    this.manipulators.forEach(({ manipulator: e }) => {
+      e.interactive = !0;
+    }), this._drawActive = !1, this.finishToolCreation();
+  }
+  _updateSketch(e) {
+    const t = this.view.spatialReference;
+    if (t && (!X(t) || K())) {
+      for (; this._vertices.length > e.length; ) {
+        const { handle: i, manipulator: r } = this._vertices.pop();
+        i.remove(), this.manipulators.remove(r);
+      }
+      for (let i = this._vertices.length; i < e.length; i++) {
+        const [r, u] = e[i], l = De(new W({ x: r, y: u, spatialReference: t }), this.view, this._manipulatorLayer);
+        this.manipulators.add(l);
+        const m = be(l, (n, s) => {
+          s.next($e(this.view)).next(Le(n.graphic)).next(() => {
+            const c = n.graphic.geometry;
+            this._vertices[i].coord = [c.x, c.y], this._updateGraphics();
+          });
+        });
+        this._vertices.push({ manipulator: l, coord: [r, u], handle: m });
+      }
+      if (this._vertices.length) {
+        const i = this._vertices.length - 1, r = this._vertices[i], [u, l] = e[i];
+        r.coord[0] === u && r.coord[1] === l || (r.coord = [u, l], r.manipulator.graphic.geometry = new W({ x: u, y: l, spatialReference: t }));
+        const m = this._drawActive ? this._vertices[i].manipulator : null;
+        this.manipulators.forEach(({ manipulator: n }) => {
+          n.interactive = m == null || n !== m;
+        });
+      }
+      this._updateGraphics();
+    }
+  }
+  _updateGraphics() {
+    if (this._vertices.length < 2)
+      return void this._measurementLayer.removeAll();
+    const e = Oe(this._vertices.map(({ coord: d }) => d), this.view.spatialReference, this.geodesicDistanceThreshold);
+    if (!e)
+      return;
+    const { measurement: t, fillGeometry: i, outlineGeometry: r } = e;
+    this._set("measurement", t);
+    const u = t ? xe(this.messages, t, this.unit) : null;
+    if (this._set("measurementLabel", u), !i && !r)
+      return;
+    let l, m, n;
+    const { graphics: s } = this._measurementLayer, c = s.length === 3, { effectiveTheme: h } = this.view;
+    c ? (l = s.at(0), m = s.at(1), n = s.at(2)) : (l = new M({ symbol: new Z({ color: G(h.accentColor, 0.3), outline: null }) }), m = new M({ symbol: new F({ color: h.accentColor, width: 2 }) }), n = new M({ symbol: new ee({ color: h.textColor, font: new te({ size: 14, family: "sans-serif" }), haloColor: G(ce(h.textColor, he.Low), 0.5), haloSize: 2 }) }), s.removeAll(), s.addMany([l, m, n])), l.geometry = i, m.geometry = r, n.geometry = i == null ? void 0 : i.centroid, n.symbol.text = (u == null ? void 0 : u.area) ?? "";
+  }
+};
+function De(e, t, i) {
+  const u = { style: "circle", color: G(t.effectiveTheme.accentColor, 0.5), outline: { type: "simple-line", width: 0 } }, l = new z({ ...u, size: 8 }), m = new z({ ...u, size: 1.5 * 8 }), n = new M({ geometry: e, symbol: l });
+  return new Te({ view: t, layer: i, graphic: n, focusedSymbol: m });
+}
+function Oe(e, t, i) {
+  if (e.length === 2) {
+    const c = new I({ paths: e, spatialReference: t });
+    let h;
+    if (t != null && t.isGeographic)
+      if (C(t))
+        h = g(c, y);
+      else {
+        const d = v(c, L.WGS84), _ = g(d, y);
+        h = v(_, t);
+      }
+    else if (t != null && t.isWebMercator)
+      h = D(c, y, "meters");
+    else if (E(c, "meters") >= P(i)) {
+      const d = v(c, L.WGS84), _ = g(d, y);
+      h = v(_, t);
+    } else
+      h = c;
+    return { measurement: null, fillGeometry: null, outlineGeometry: h };
+  }
+  e.push(e[0]);
+  const r = new I({ paths: [e], spatialReference: t }), u = new se({ rings: [e], spatialReference: t });
+  let l, m, n = null, s = null;
+  if (t != null && t.isGeographic)
+    if (C(t)) {
+      if (n = g(r, y), s = g(u, y), s = b(s), !s)
+        return null;
+      l = O([r], "meters")[0], m = k([s], "square-meters")[0];
+    } else {
+      const c = L.WGS84, h = v(r, c), d = v(u, c);
+      if (n = g(h, y), s = g(d, y), s = b(s), !s)
+        return null;
+      l = O([h], "meters")[0], m = k([s], "square-meters")[0], n = v(n, t), s = v(s, t);
+    }
+  else if (t != null && t.isWebMercator) {
+    if (n = D(r, y, "meters"), s = D(u, y, "meters"), s = b(s), !s)
+      return null;
+    l = fe(r, "meters"), m = we(s, "square-meters");
+  } else {
+    const c = E(r, "meters");
+    if (c >= P(i)) {
+      const h = L.WGS84, d = v(r, h), _ = v(u, h);
+      if (n = g(d, y), s = g(_, y), s = b(s), !s)
+        return null;
+      l = O([d], "meters")[0], m = k([s], "square-meters")[0], n = v(n, t), s = v(s, t);
+    } else {
+      if (n = r, s = b(u), !s)
+        return null;
+      l = c, m = ge(s, "square-meters");
+    }
+  }
+  return { measurement: { geometry: s, area: m, perimeter: l }, fillGeometry: s, outlineGeometry: n };
+}
+function ke(e) {
+  return e != null;
+}
+function X(e) {
+  if (!e)
+    return !1;
+  const { isGeographic: t, isWebMercator: i, isWGS84: r } = e;
+  return t && !r && !C(e) || !t && !i;
+}
+function xe(e, t, i) {
+  if (!t || !e)
+    return null;
+  const r = { area: null, perimeter: null }, { area: u, perimeter: l } = t;
+  switch (i) {
+    case "metric":
+      r.area = de(e, u, "square-meters");
+      break;
+    case "imperial":
+      r.area = pe(e, u, "square-meters");
+      break;
+    default: {
+      const n = V(u, "square-meters", i);
+      r.area = H(e, n, i);
+      break;
+    }
+  }
+  const m = qe(i);
+  if (m)
+    switch (m) {
+      case "metric":
+        r.perimeter = ye(e, l, "meters");
+        break;
+      case "imperial":
+        r.perimeter = ve(e, l, "meters");
+        break;
+      default: {
+        const n = V(l, "meters", m);
+        r.perimeter = H(e, n, m);
+        break;
+      }
+    }
+  else
+    r.perimeter = "";
+  return r;
+}
+function qe(e) {
+  switch (e) {
+    case "metric":
+    case "ares":
+    case "hectares":
+      return "metric";
+    case "imperial":
+    case "acres":
+      return "imperial";
+    case "square-inches":
+      return "inches";
+    case "square-feet":
+      return "feet";
+    case "square-yards":
+      return "yards";
+    case "square-miles":
+      return "miles";
+    case "square-us-feet":
+      return "us-feet";
+    case "square-meters":
+      return "meters";
+    case "square-kilometers":
+      return "kilometers";
+    case "square-millimeters":
+      return "millimeters";
+    case "square-centimeters":
+      return "centimeters";
+    case "square-decimeters":
+      return "decimeters";
+    default:
+      return null;
+  }
+}
+function P(e) {
+  return e ?? 1 / 0;
+}
+a([o()], f.prototype, "_drawActive", void 0), a([o({ readOnly: !0 })], f.prototype, "cursor", null), a([o({ value: !0 })], f.prototype, "editable", null), a([o({ type: Number })], f.prototype, "geodesicDistanceThreshold", void 0), a([o({ readOnly: !0 })], f.prototype, "measurement", void 0), a([o({ readOnly: !0 })], f.prototype, "measurementLabel", void 0), a([o()], f.prototype, "messages", void 0), a([o()], f.prototype, "unit", void 0), a([o({ constructOnly: !0 })], f.prototype, "view", void 0), f = a([U("esri.widgets.AreaMeasurement2D.AreaMeasurement2DTool")], f);
+let w = class extends Me {
+  constructor(e) {
+    super(e), this.supportedViewType = "2d", this.unsupportedErrorMessage = "AreaMeasurement2DViewModel is only supported in 2D views.";
+  }
+  initialize() {
+    this.addHandles([$(() => {
+      var e;
+      return (e = this.view) == null ? void 0 : e.spatialReference;
+    }, () => this.clear()), $(() => this.unit, (e) => {
+      this.tool != null && (this.tool.unit = e);
+    }, q), $(() => this.geodesicDistanceThreshold, (e) => {
+      this.tool != null && (this.tool.geodesicDistanceThreshold = e);
+    }, q)]);
+  }
+  get geodesicDistanceThreshold() {
+    return this._get("geodesicDistanceThreshold");
+  }
+  set geodesicDistanceThreshold(e) {
+    re(ae.getLogger(this), "geodesicDistanceThreshold", { version: "4.29", warnOnce: !0 }), this._set("geodesicDistanceThreshold", e);
+  }
+  get measurement() {
+    return this.tool != null ? this.tool.measurement : null;
+  }
+  get measurementLabel() {
+    return this.tool != null ? this.tool.measurementLabel : null;
+  }
+  get state() {
+    var e;
+    return this.disabled || this.view == null || !ke(this.view.spatialReference) ? "disabled" : (e = this.tool) != null && e.measurement ? this.tool.active ? "measuring" : "measured" : "ready";
+  }
+  get unit() {
+    return this._validateUnit(this.defaultUnit);
+  }
+  set unit(e) {
+    this._overrideIfSome("unit", this._validateUnit(e));
+  }
+  get unitOptions() {
+    return S;
+  }
+  set unitOptions(e) {
+    this._overrideIfSome("unitOptions", this._validateUnits(e));
+  }
+  async start() {
+    const e = this.view;
+    e != null && (await ne(() => e.ready), X(e.spatialReference) && await oe()), this.createTool({ interactive: !0 });
+  }
+  clear() {
+    this.removeTool();
+  }
+  constructTool() {
+    return new f({ view: this.view, visible: this.visible, geodesicDistanceThreshold: this.geodesicDistanceThreshold, unit: this.unit });
+  }
+  _validateUnit(e) {
+    const { unitOptions: t, defaultUnit: i } = this;
+    return e != null && t.includes(e) ? e : t.includes(i) ? i : t.length > 0 ? t[0] : i;
+  }
+  _validateUnits(e) {
+    if (e == null)
+      return [];
+    const t = e.filter((i) => S.includes(i));
+    return t.length === 0 ? S.slice() : t;
+  }
+};
+a([o(ie)], w.prototype, "defaultUnit", void 0), a([o()], w.prototype, "geodesicDistanceThreshold", null), a([o({ readOnly: !0 })], w.prototype, "measurement", null), a([o({ readOnly: !0 })], w.prototype, "measurementLabel", null), a([o({ readOnly: !0 })], w.prototype, "state", null), a([o({ type: String })], w.prototype, "unit", null), a([o({ type: [String] })], w.prototype, "unitOptions", null), w = a([U("esri.widgets.AreaMeasurement2D.AreaMeasurement2DViewModel")], w);
+const Y = w, Q = "esri-area-measurement-2d", x = { base: Q, newMeasurementButton: `${Q}__clear-button`, widgetIcon: me.measureArea };
+let p = class extends le {
+  constructor(e, t) {
+    super(e, t), this.iconClass = x.widgetIcon, this.icon = null, this.messages = null, this.messagesUnits = null, this.messagesCommon = null, this.viewModel = new Y();
+  }
+  get active() {
+    return this.viewModel.active;
+  }
+  get label() {
+    var e;
+    return ((e = this.messages) == null ? void 0 : e.widgetLabel) ?? "";
+  }
+  set label(e) {
+    this._overrideIfSome("label", e);
+  }
+  get unit() {
+    return this.viewModel.unit;
+  }
+  set unit(e) {
+    this.viewModel.unit = e;
+  }
+  get unitOptions() {
+    return this.viewModel.unitOptions;
+  }
+  set unitOptions(e) {
+    this.viewModel.unitOptions = e;
+  }
+  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;
+  }
+  render() {
+    const { messages: e, messagesCommon: t, messagesUnits: i, unit: r, unitOptions: u, viewModel: l, visible: m } = this, { active: n, measurementLabel: s, state: c, supported: h } = l;
+    return j("div", { "aria-label": e.widgetLabel, class: this.classes(x.base, B.widget, B.panel), key: this, role: "presentation" }, m ? j(Ae, { active: n, measurementItems: [{ key: "area", title: i == null ? void 0 : i.measures.area, value: s == null ? void 0 : s.area }, { key: "perimeter", title: e.perimeter, value: s == null ? void 0 : s.perimeter }], messages: { ...e, notApplicable: t.notApplicable }, newMeasurementButtonClass: x.newMeasurementButton, state: c, supported: h, unit: r, unitOptions: u, onNewMeasurementClick: () => {
+      ue(l.start());
+    }, onUnitChange: (d) => {
+      this.unit = d;
+    } }) : null);
+  }
+};
+a([o({ readOnly: !0 })], p.prototype, "active", null), a([o()], p.prototype, "iconClass", void 0), a([o()], p.prototype, "icon", void 0), a([o()], p.prototype, "label", null), a([o(), T("esri/widgets/AreaMeasurement2D/t9n/AreaMeasurement2D")], p.prototype, "messages", void 0), a([o(), T("esri/core/t9n/Units")], p.prototype, "messagesUnits", void 0), a([o(), T("esri/t9n/common")], p.prototype, "messagesCommon", void 0), a([o()], p.prototype, "uiStrings", void 0), a([o()], p.prototype, "unit", null), a([o()], p.prototype, "unitOptions", null), a([o()], p.prototype, "view", null), a([o({ type: Y })], p.prototype, "viewModel", void 0), a([o({ type: Boolean })], p.prototype, "visible", null), p = a([U("esri.widgets.AreaMeasurement2D")], p);
+const bt = p;
+export {
+  bt as default
+};