@agrotools1/at-components 0.2.4 → 0.2.5

package/dist/DistanceMeasurement2D-a6cf62b6.js

@@ -0,0 +1,303 @@
+import { e as i, y as r, c as T, fO as x, fP as j, o as y, P as D, x as f, a$ as A, z as S, fZ as N, ac as q, fQ as F, a9 as R, b1 as Q, bT as g, bR as U, j as X, fR as Y, fS as Z, s as J, f_ as b, fH as K, cC as ee, fU as k, fV as te, fW as I, eQ as ie, fX as z, fY as se } from "./index-6ebf29c1.js";
+import { G as B, R as H, q as re } from "./colorUtils-6d5e716b.js";
+import { g as oe, d as ne, D as ae } from "./unitFormatUtils-e75be0c3.js";
+import { geodesicLength as le, geodesicDensify as he, planarLength as ce } from "./geometryEngine-e18a460d.js";
+import { l as me, x as ue, w as W, v as M, R as L, b as pe, S as de, p as ve, u as ye } from "./MeasurementWidgetContent-82971f95.js";
+import { h as G } from "./GraphicsLayer-a30f80da.js";
+import { l as ge, S as we } 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 w = 1e5;
+let u = class extends me {
+  constructor(e) {
+    super(e), this._drawActive = !1, this._measurementLayer = new G({ internal: !0, listMode: "hide", visible: !1 }), this._manipulatorLayer = new G({ internal: !0, listMode: "hide", visible: !1 }), this._vertices = [], this.geodesicDistanceThreshold = null, this.measurement = null, this.measurementLabel = null;
+  }
+  initialize() {
+    x("esri/core/t9n/Units").then((t) => {
+      this.messages = t;
+    }), this.addHandles(j(async () => {
+      this.messages = await x("esri/core/t9n/Units");
+    }));
+    const e = this.view;
+    this._draw = new ge({ view: e }), e.map.addMany([this._measurementLayer, this._manipulatorLayer]), e.focus(), this.addHandles([y(() => [this.unit, this.geodesicDistanceThreshold, this.messages], () => {
+      this._updatePolylines();
+    }, D), y(() => [this.view.effectiveTheme.accentColor, this.view.effectiveTheme.textColor], () => {
+      if (!this._vertices.length)
+        return;
+      const t = this._vertices.map(({ coord: s }) => s);
+      for (const { handle: s } of this._vertices)
+        s.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 = f(this._draw), e.removeMany([this._measurementLayer, this._manipulatorLayer]), this._measurementLayer.removeAll(), this._manipulatorLayer.removeAll(), this._set("measurement", null), this._set("measurementLabel", null), this._measurementLayer = f(this._measurementLayer), this._manipulatorLayer = f(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;
+  }
+  _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() {
+    this.manipulators.forEach(({ manipulator: e }) => {
+      e.interactive = !0;
+    }), this._drawActive = !1, this.finishToolCreation();
+  }
+  _updateSketch(e) {
+    const { spatialReference: t } = this.view;
+    for (; this._vertices.length > e.length; ) {
+      const { handle: o, manipulator: m } = this._vertices.pop();
+      o.remove(), this.manipulators.remove(m);
+    }
+    for (let o = this._vertices.length; o < e.length; o++) {
+      const [m, d] = e[o], v = _e(new A({ x: m, y: d, spatialReference: t }), this.view, this._manipulatorLayer);
+      this.manipulators.add(v);
+      const _ = ue(v, (C, V) => {
+        V.next(pe(this.view)).next(de(C.graphic)).next(() => {
+          const O = C.graphic.geometry;
+          this._vertices[o].coord = [O.x, O.y], this._updatePolylines();
+        });
+      });
+      this._vertices.push({ manipulator: v, coord: [m, d], handle: _ });
+    }
+    const s = this._vertices.length - 1, n = this._vertices[s], [l, a] = e[s];
+    n.coord[0] === l && n.coord[1] === a || (n.coord = [l, a], n.manipulator.graphic.geometry = new A({ x: l, y: a, spatialReference: t }));
+    const h = this._drawActive ? this._vertices[s].manipulator : null;
+    this.manipulators.forEach(({ manipulator: o }) => {
+      o.interactive = h == null || o !== h;
+    }), this._updatePolylines();
+  }
+  _updatePolylines() {
+    var v;
+    if (this._vertices.length < 2)
+      return void this._measurementLayer.removeAll();
+    const e = this._vertices.map(({ coord: _ }) => _), { measurement: t, drawing: s, original: n } = fe(e, this.view.spatialReference, this.geodesicDistanceThreshold);
+    this._set("measurement", t);
+    const l = Le(this.messages, t, this.unit);
+    let a, h;
+    this._set("measurementLabel", l);
+    const { graphics: o } = this._measurementLayer, m = o.length === 2, { effectiveTheme: d } = this.view;
+    m ? (a = o.at(0), h = o.at(1)) : (a = new S({ symbol: new N({ data: { type: "CIMSymbolReference", symbol: { type: "CIMLineSymbol", symbolLayers: [{ type: "CIMSolidStroke", effects: [{ type: "CIMGeometricEffectDashes", dashTemplate: [14, 12], lineDashEnding: "FullGap", controlPointEnding: "NoConstraint" }], enable: !0, capStyle: "Butt", joinStyle: "Round", width: 3.5, color: B(d.accentColor).toArray() }, { type: "CIMSolidStroke", enable: !0, capStyle: "Butt", joinStyle: "Round", width: 5, color: d.accentColor.toArray() }] } } }) }), h = new S({ symbol: new q({ color: d.textColor, haloColor: H(B(d.textColor, re.Low), 0.5), haloSize: 2, font: new F({ size: 14, family: "sans-serif" }) }) }), o.removeAll(), o.addMany([a, h])), a.geometry = s, h.geometry = (v = n.extent) == null ? void 0 : v.center, h.symbol.text = l;
+  }
+};
+function _e(e, t, s) {
+  const n = H(t.effectiveTheme.accentColor, 0.5), l = { type: "simple-line", width: 0 }, a = 8, h = new R({ style: "circle", color: n, size: a, outline: l }), o = new R({ style: "circle", color: n, size: 1.5 * a, outline: l }), m = new S({ geometry: e, symbol: h });
+  return new we({ view: t, layer: s, graphic: m, focusedSymbol: o });
+}
+function fe(e, t, s) {
+  const n = new Q({ paths: [e], spatialReference: t });
+  let l, a;
+  if (t.isGeographic)
+    if (W(t))
+      l = M([n], "meters")[0], a = L(n, w);
+    else {
+      const h = g(n, U.WGS84), o = L(h, w);
+      l = M([h], "meters")[0], a = g(o, t);
+    }
+  else if (t.isWebMercator)
+    l = le(n, "meters"), a = he(n, w, "meters");
+  else {
+    const h = ce(n, "meters");
+    if (s != null && h >= s) {
+      const o = g(n, U.WGS84), m = L(o, w);
+      l = M([o], "meters")[0], a = g(m, t);
+    } else
+      l = h, a = n;
+  }
+  return { measurement: { geometry: a, length: l }, original: n, drawing: a };
+}
+function be(e) {
+  return e != null;
+}
+function Me(e) {
+  if (!e)
+    return !1;
+  const { isGeographic: t, isWebMercator: s, isWGS84: n } = e;
+  return t && !n && !W(e) || !t && !s;
+}
+function Le(e, t, s) {
+  if (!t || !e)
+    return "";
+  switch (s) {
+    case "metric":
+      return ae(e, t.length, "meters");
+    case "imperial":
+      return ne(e, t.length, "meters");
+    default:
+      return oe(e, X(t.length, "meters", s), s);
+  }
+}
+i([r()], u.prototype, "_drawActive", void 0), i([r({ readOnly: !0 })], u.prototype, "cursor", null), i([r({ value: !0 })], u.prototype, "editable", null), i([r({ type: Number })], u.prototype, "geodesicDistanceThreshold", void 0), i([r({ readOnly: !0 })], u.prototype, "measurement", void 0), i([r({ readOnly: !0 })], u.prototype, "measurementLabel", void 0), i([r()], u.prototype, "messages", void 0), i([r()], u.prototype, "unit", void 0), i([r({ constructOnly: !0 })], u.prototype, "view", void 0), u = i([T("esri.widgets.DistanceMeasurement2D.DistanceMeasurement2DTool")], u);
+let p = class extends ve {
+  constructor(e) {
+    super(e), this.supportedViewType = "2d", this.unsupportedErrorMessage = "DistanceMeasurement2DViewModel is only supported in 2D views.";
+  }
+  initialize() {
+    this.addHandles([y(() => {
+      var e;
+      return (e = this.view) == null ? void 0 : e.spatialReference;
+    }, () => this.clear()), y(() => this.unit, (e) => {
+      this.tool != null && (this.tool.unit = e);
+    }, D), y(() => this.geodesicDistanceThreshold, (e) => {
+      this.tool != null && (this.tool.geodesicDistanceThreshold = e);
+    }, D)]);
+  }
+  get geodesicDistanceThreshold() {
+    return this._get("geodesicDistanceThreshold");
+  }
+  set geodesicDistanceThreshold(e) {
+    Z(J.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 || !be((e = this.view) == null ? void 0 : e.spatialReference) ? "disabled" : this.tool != null && this.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 b;
+  }
+  set unitOptions(e) {
+    this._overrideIfSome("unitOptions", this._validateUnits(e));
+  }
+  async start() {
+    const e = this.view;
+    e != null && (await K(() => e.ready), Me(e.spatialReference) && await ee()), this.createTool({ interactive: !0 });
+  }
+  clear() {
+    this.removeTool();
+  }
+  constructTool() {
+    return new u({ view: this.view, visible: this.visible, geodesicDistanceThreshold: this.geodesicDistanceThreshold, unit: this.unit });
+  }
+  _validateUnit(e) {
+    const { unitOptions: t, defaultUnit: s } = this;
+    return e != null && t.includes(e) ? e : t.includes(s) ? s : t.length > 0 ? t[0] : s;
+  }
+  _validateUnits(e) {
+    if (e == null)
+      return [];
+    const t = e.filter((s) => b.includes(s));
+    return t.length === 0 ? b.slice() : t;
+  }
+};
+i([r(Y)], p.prototype, "defaultUnit", void 0), i([r()], p.prototype, "geodesicDistanceThreshold", null), i([r({ readOnly: !0 })], p.prototype, "measurement", null), i([r({ readOnly: !0 })], p.prototype, "measurementLabel", null), i([r({ readOnly: !0 })], p.prototype, "state", null), i([r({ type: String })], p.prototype, "unit", null), i([r({ type: [String] })], p.prototype, "unitOptions", null), p = i([T("esri.widgets.DistanceMeasurement2D.DistanceMeasurement2DViewModel")], p);
+const E = p, P = "esri-distance-measurement-2d", $ = { base: P, newMeasurementButton: `${P}__clear-button`, widgetIcon: se.measureLine };
+let c = class extends te {
+  constructor(e, t) {
+    super(e, t), this.iconClass = $.widgetIcon, this.icon = null, this.messages = null, this.messagesCommon = null, this.viewModel = new E();
+  }
+  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, unit: s, unitOptions: n, viewModel: l } = this, { active: a, measurementLabel: h, state: o, supported: m } = l;
+    return I("div", { "aria-label": this.messages.widgetLabel, class: this.classes($.base, z.widget, z.panel), key: this, role: "presentation" }, this.visible ? I(ye, { active: a, measurementItems: [{ key: "distance", title: e.distance, value: h }], messages: { ...e, notApplicable: t.notApplicable }, newMeasurementButtonClass: $.newMeasurementButton, state: o, supported: m, unit: s, unitOptions: n, onNewMeasurementClick: () => {
+      ie(this.viewModel.start());
+    }, onUnitChange: (d) => {
+      this.unit = d;
+    } }) : null);
+  }
+};
+i([r({ readOnly: !0 })], c.prototype, "active", null), i([r()], c.prototype, "iconClass", void 0), i([r()], c.prototype, "icon", void 0), i([r()], c.prototype, "label", null), i([r()], c.prototype, "uiStrings", void 0), i([r(), k("esri/widgets/DistanceMeasurement2D/t9n/DistanceMeasurement2D")], c.prototype, "messages", void 0), i([r(), k("esri/t9n/common")], c.prototype, "messagesCommon", void 0), i([r()], c.prototype, "unit", null), i([r()], c.prototype, "unitOptions", null), i([r()], c.prototype, "view", null), i([r({ type: E })], c.prototype, "viewModel", void 0), i([r({ type: Boolean })], c.prototype, "visible", null), c = i([T("esri.widgets.DistanceMeasurement2D")], c);
+const ut = c;
+export {
+  ut as default
+};

package/dist/DoubleArray-bb8ff0fb.js

@@ -0,0 +1,25 @@
+import { bs as t, bt as n } from "./index-6ebf29c1.js";
+function y(r, a = !1) {
+  return r <= t ? a ? new Array(r).fill(0) : new Array(r) : new Float64Array(r);
+}
+function u(r) {
+  return (n(r) ? r.length : r.byteLength / 8) <= t ? Array.from(r) : new Float64Array(r);
+}
+function i(r, a, e) {
+  return Array.isArray(r) ? r.slice(a, a + e) : r.subarray(a, a + e);
+}
+function A(r, a) {
+  for (let e = 0; e < a.length; ++e)
+    r[e] = a[e];
+  return r;
+}
+function f(r) {
+  return Array.isArray(r) ? new Float64Array(r) : r;
+}
+export {
+  i as a,
+  u as e,
+  A as o,
+  y as t,
+  f as y
+};

package/dist/Dropdown/Filter/test.mocks.d.ts

@@ -1,5 +1,5 @@
 import type { DropdownListItem } from "../Dropdown.core";
-import type { DropdownList } from "./Dropdown.Filter";
+import type { DropdownList } from "./Dropdown.filter";
 declare const dropdownFilter: DropdownListItem[];
 declare const dropdownFilterTextArray: DropdownListItem[];
 declare const dropdownFilterSeparator: DropdownList[];

package/dist/Dropdown/List/test.mocks.d.ts

@@ -1,4 +1,4 @@
-import type { DropdownListItem } from "./Dropdown.List";
+import type { DropdownListItem } from "./Dropdown.list";
 declare const renderList: DropdownListItem[];
 declare const renderItemText: DropdownListItem[];
 declare const renderIconLeft: DropdownListItem[];

package/dist/EdgeProcessingWorker-c5511714.js

@@ -0,0 +1,63 @@
+import { u as a } from "./workerHelper-d8d5f17b.js";
+import { f as p, u as c, a as u, I as d, d as f, m as g } from "./edgeProcessing-1a2c4169.js";
+import "./InterleavedLayout-9490090b.js";
+import "./BufferView-5272765e.js";
+import "./index-6ebf29c1.js";
+import "vue";
+import "./vec42-27060a00.js";
+import "./types-adba9034.js";
+import "./Util-2ba07f64.js";
+import "./vec4f64-043e974c.js";
+import "./deduplicate-16f30199.js";
+import "./Indices-f0dca4b5.js";
+import "./VertexAttribute-faad30bf.js";
+import "./glUtil-8f8bce6b.js";
+import "./enums-2c166c09.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+class q {
+  async extract(t) {
+    const e = o(t), r = p(e), n = [e.data.buffer];
+    return { result: m(r, n), transferList: n };
+  }
+  async extractComponentsEdgeLocations(t) {
+    const e = o(t), r = c(e.data, e.skipDeduplicate, e.indices, e.indicesLength), n = u(r, D, l), s = [];
+    return { result: a(n.regular.instancesData, s), transferList: s };
+  }
+  async extractEdgeLocations(t) {
+    const e = o(t), r = c(e.data, e.skipDeduplicate, e.indices, e.indicesLength), n = u(r, w, l), s = [];
+    return { result: a(n.regular.instancesData, s), transferList: s };
+  }
+}
+function o(i) {
+  return { data: d.createView(i.dataBuffer), indices: i.indicesType === "Uint32Array" ? new Uint32Array(i.indices) : i.indicesType === "Uint16Array" ? new Uint16Array(i.indices) : i.indices, indicesLength: i.indicesLength, writerSettings: i.writerSettings, skipDeduplicate: i.skipDeduplicate };
+}
+function m(i, t) {
+  return t.push(i.regular.lodInfo.lengths.buffer), t.push(i.silhouette.lodInfo.lengths.buffer), { regular: { instancesData: a(i.regular.instancesData, t), lodInfo: { lengths: i.regular.lodInfo.lengths.buffer } }, silhouette: { instancesData: a(i.silhouette.instancesData, t), lodInfo: { lengths: i.silhouette.lodInfo.lengths.buffer } }, averageEdgeLength: i.averageEdgeLength };
+}
+class h {
+  allocate(t) {
+    return f.createBuffer(t);
+  }
+  trim(t, e) {
+    return t.slice(0, e);
+  }
+  write(t, e, r) {
+    t.position0.setVec(e, r.position0), t.position1.setVec(e, r.position1);
+  }
+}
+class L {
+  allocate(t) {
+    return g.createBuffer(t);
+  }
+  trim(t, e) {
+    return t.slice(0, e);
+  }
+  write(t, e, r) {
+    t.position0.setVec(e, r.position0), t.position1.setVec(e, r.position1), t.componentIndex.set(e, r.componentIndex);
+  }
+}
+const w = new h(), D = new L(), l = { allocate: () => null, write: () => {
+}, trim: () => null };
+export {
+  q as default
+};

package/dist/EditBusLayer-513ca203.js

@@ -0,0 +1,107 @@
+import { eM as H, U as L, dc as R, e as x, c as k, dO as T, bz as p } from "./index-6ebf29c1.js";
+const _ = H(), w = /* @__PURE__ */ new Map(), $ = /* @__PURE__ */ new Map();
+async function N(e, i, d) {
+  if (!e || !d)
+    return !1;
+  if (!i)
+    return !0;
+  const r = new URL(e).host;
+  let t = w.get(r);
+  if (!t) {
+    const n = e.replace(/\/FeatureServer/i, "/VersionManagementServer").replace(/\/\d*$/, "");
+    t = (await L(n, { responseType: "json", query: { f: "json" } })).data.defaultVersionName;
+  }
+  return t === i;
+}
+async function O(e, i, d = !1) {
+  var n, a;
+  if (!e || !i)
+    return !0;
+  const r = e.replace(/\/FeatureServer/i, "/VersionManagementServer").replace(/\/\d*$/, ""), t = (n = $.get(r)) == null ? void 0 : n.entries();
+  if (t) {
+    for (const [l, c] of t)
+      if (c.name === i) {
+        const u = !((a = c.stack) != null && a.hasForwardEdits());
+        if (!u && d) {
+          const [{ deleteForwardEdits: m }, { default: h }] = await Promise.all([import("./deleteForwardEdits-f31f885d.js"), import("./DeleteForwardEditsParameters-8b5196fa.js")]);
+          return m(r, l, new h({ sessionId: _, moment: c.moment }));
+        }
+        return u;
+      }
+  }
+  return !0;
+}
+function W(e, i) {
+  var t;
+  if (!e)
+    return !1;
+  const d = e.replace(/\/FeatureServer/i, "/VersionManagementServer").replace(/\/\d*$/, ""), r = (t = $.get(d)) == null ? void 0 : t.entries();
+  if (r) {
+    for (const [n, a] of r)
+      if (a.name === i)
+        return a.lockType === "edit";
+  }
+  return !1;
+}
+const g = new R.EventEmitter();
+function q(e) {
+  return g.on("apply-edits", new WeakRef(e));
+}
+function z(e) {
+  return g.on("update-moment", new WeakRef(e));
+}
+function P(e, i, d = null, r = !1) {
+  const t = T();
+  return r = i == null || r, g.emit("apply-edits", { serviceUrl: e, layerId: i, gdbVersion: d, mayReceiveServiceEdits: r, result: t.promise }), t;
+}
+const V = "esri.layers.mixins.EditBusLayer", A = Symbol(V);
+function C(e) {
+  return e != null && typeof e == "object" && A in e;
+}
+function f(e) {
+  return e != null && typeof e == "object" && "gdbVersion" in e;
+}
+function F(e, i, d) {
+  const r = new URL(e).host, t = w.get(r), n = (a) => !a || a === t;
+  return n(i) && n(d) || i === d;
+}
+const D = (e) => {
+  var i;
+  let d = class extends e {
+    constructor(...r) {
+      super(...r), this[i] = !0, this._applyEditsHandler = (t) => {
+        const { serviceUrl: n, layerId: a, gdbVersion: l, mayReceiveServiceEdits: c, result: u } = t, m = n === this.url, h = a != null && this.layerId != null && a === this.layerId, E = f(this), S = f(this) && F(n, l, this.gdbVersion);
+        if (!m || E && !S || !h && !c)
+          return;
+        const U = u.then((s) => {
+          var y;
+          if (h && (s.addedFeatures.length || s.updatedFeatures.length || s.deletedFeatures.length || s.addedAttachments.length || s.updatedAttachments.length || s.deletedAttachments.length))
+            return this.emit("edits", p(s)), s;
+          const I = (y = s.editedFeatures) == null ? void 0 : y.find(({ layerId: b }) => b === this.layerId);
+          if (I) {
+            const { adds: b, updates: M, deletes: v } = I.editedFeatures, j = { edits: null, addedAttachments: [], deletedAttachments: [], updatedAttachments: [], addedFeatures: b ? b.map(({ attributes: o }) => ({ objectId: this.objectIdField && o[this.objectIdField], globalId: this.globalIdField && o[this.globalIdField] })) : [], deletedFeatures: v ? v.map(({ attributes: o }) => ({ objectId: this.objectIdField && o[this.objectIdField], globalId: this.globalIdField && o[this.globalIdField] })) : [], updatedFeatures: M ? M.map(({ current: { attributes: o } }) => ({ objectId: this.objectIdField && o[this.objectIdField], globalId: this.globalIdField && o[this.globalIdField] })) : [], editedFeatures: p(s.editedFeatures), exceededTransferLimit: !1, historicMoment: p(s.historicMoment) };
+            return this.emit("edits", j), j;
+          }
+          return { edits: null, addedAttachments: [], deletedAttachments: [], updatedAttachments: [], addedFeatures: [], deletedFeatures: [], updatedFeatures: [], editedFeatures: p(s.editedFeatures), exceededTransferLimit: !1, historicMoment: p(s.historicMoment) };
+        }).then((s) => ("historicMoment" in this && this.historicMoment !== s.historicMoment && W(n, l) && (this.historicMoment = s.historicMoment), s));
+        this.emit("apply-edits", { result: U });
+      }, this._updateMomentHandler = (t) => {
+        const { serviceUrl: n, gdbVersion: a, moment: l } = t, c = n === this.url, u = f(this), m = f(this) && F(n, a, this.gdbVersion), h = f(this) && !F(n, this.gdbVersion, null);
+        c && u && m && h && "historicMoment" in this && this.historicMoment !== l && (this.historicMoment = l);
+      }, this.when().then(() => {
+        this.addHandles(q(this._applyEditsHandler)), "historicMoment" in this && this.addHandles(z(this._updateMomentHandler));
+      }, () => {
+      });
+    }
+  };
+  return i = A, d = x([k(V)], d), d;
+};
+export {
+  D as F,
+  N as a,
+  W as c,
+  P as h,
+  O as i,
+  C as p,
+  _ as t
+};

package/dist/ElevationInfo-234040e3.js

@@ -0,0 +1,56 @@
+import { e as s, y as r, bx as l, eI as y, c as d, eJ as c, bu as m, c5 as E, c2 as v, eK as I } from "./index-6ebf29c1.js";
+import { o as w } from "./unitConversionUtils-c1bfd22b.js";
+var u;
+let i = u = class extends l {
+  constructor(e) {
+    super(e);
+  }
+  async collectRequiredFields(e, t) {
+    return y(e, t, this.expression);
+  }
+  clone() {
+    return new u({ expression: this.expression, title: this.title });
+  }
+  equals(e) {
+    return this.expression === e.expression && this.title === e.title;
+  }
+};
+s([r({ type: String, json: { write: !0 } })], i.prototype, "expression", void 0), s([r({ type: String, json: { write: !0 } })], i.prototype, "title", void 0), i = u = s([d("esri.layers.support.FeatureExpressionInfo")], i);
+const a = i;
+var p;
+const n = c()({ onTheGround: "on-the-ground", relativeToGround: "relative-to-ground", relativeToScene: "relative-to-scene", absoluteHeight: "absolute-height" }), f = new m({ foot: "feet", kilometer: "kilometers", meter: "meters", mile: "miles", "us-foot": "us-feet", yard: "yards" });
+let o = p = class extends l {
+  constructor(e) {
+    super(e), this.offset = null;
+  }
+  readFeatureExpressionInfo(e, t) {
+    return e ?? (t.featureExpression && t.featureExpression.value === 0 ? { expression: "0" } : void 0);
+  }
+  writeFeatureExpressionInfo(e, t, x, h) {
+    t[x] = e.write({}, h), e.expression === "0" && (t.featureExpression = { value: 0 });
+  }
+  get mode() {
+    const { offset: e, featureExpressionInfo: t } = this;
+    return this._isOverridden("mode") ? this._get("mode") : e != null || t ? "relative-to-ground" : "on-the-ground";
+  }
+  set mode(e) {
+    this._override("mode", e);
+  }
+  set unit(e) {
+    this._set("unit", e);
+  }
+  write(e, t) {
+    return this.offset || this.mode || this.featureExpressionInfo || this.unit ? super.write(e, t) : null;
+  }
+  clone() {
+    return new p({ mode: this.mode, offset: this.offset, featureExpressionInfo: this.featureExpressionInfo ? this.featureExpressionInfo.clone() : void 0, unit: this.unit });
+  }
+  equals(e) {
+    return this.mode === e.mode && this.offset === e.offset && this.unit === e.unit && I(this.featureExpressionInfo, e.featureExpressionInfo);
+  }
+};
+s([r({ type: a, json: { write: !0 } })], o.prototype, "featureExpressionInfo", void 0), s([E("featureExpressionInfo", ["featureExpressionInfo", "featureExpression"])], o.prototype, "readFeatureExpressionInfo", null), s([v("featureExpressionInfo", { featureExpressionInfo: { type: a }, "featureExpression.value": { type: [0] } })], o.prototype, "writeFeatureExpressionInfo", null), s([r({ type: n.apiValues, nonNullable: !0, json: { type: n.jsonValues, read: n.read, write: { writer: n.write, isRequired: !0 } } })], o.prototype, "mode", null), s([r({ type: Number, json: { write: !0 } })], o.prototype, "offset", void 0), s([r({ type: w, json: { type: String, read: f.read, write: f.write } })], o.prototype, "unit", null), o = p = s([d("esri.layers.support.ElevationInfo")], o);
+const b = o;
+export {
+  b as h
+};