@agrotools1/at-components 0.3.4 → 0.3.5-5

package/dist/FeatureLayer-f1a17cbb.js

@@ -0,0 +1,693 @@
+import { fy as z, hg as Z, W as f, b3 as U, b0 as H, c$ as B, aO as K, s as _, fJ as L, e as o, hh as X, z as R, c3 as Y, y as n, c as E, V as M, S as ee, bj as te, bR as re, k as ie, bO as se, ba as I, cT as oe, d1 as x, fB as P, fN as ae, bL as ne, h1 as le, dE as ue, q as pe, by as de, U as ye, cf as ce, c5 as y, hi as he, c1 as me, c2 as $, bz as D, w as fe, ei as ge, a_ as be, hj as we } from "./index-4ead5b97.js";
+import "./UniqueValueRenderer-cc2c9298.js";
+import { o as ve, a as Fe, u as Se } from "./jsonUtils-fbd6d2d1.js";
+import { m as Te } from "./MultiOriginJSONSupport-66a73b5d.js";
+import { I as _e, m as Ie, a as G, b as Ee, c as $e, C as De, y as je, p as Oe } from "./commonProperties-c36fc1b2.js";
+import { y as Ce } from "./FormTemplate-8281e66a.js";
+import { i as Me } from "./editsZScale-adebaa6e.js";
+import { t as A } from "./queryZScale-201978da.js";
+import { d as V } from "./FeatureSet-a2d35655.js";
+import { i as qe } from "./APIKeyMixin-ee07543b.js";
+import { l as Le } from "./ArcGISService-16ef592c.js";
+import { n as Re } from "./BlendLayer-f24275a8.js";
+import { e as xe } from "./CustomParametersMixin-949de3be.js";
+import { F as Pe } from "./EditBusLayer-b3dc1330.js";
+import { p as Ge } from "./FeatureEffectLayer-bdca70b7.js";
+import { D as Ae } from "./FeatureLayerBase-85c25451.js";
+import { c as Ne } from "./FeatureReductionLayer-949cfff9.js";
+import { u as Je } from "./OperationalLayer-2e935984.js";
+import { c as Ve } from "./OrderedLayer-63abe7dc.js";
+import { j as ke } from "./PortalLayer-15420854.js";
+import { f as Qe } from "./RefreshableLayer-f99ea584.js";
+import { t as We } from "./ScaleRangeLayer-6b36cfd2.js";
+import { f as ze } from "./TemporalLayer-52d34fa2.js";
+import { Q as Ze, T as Ue, R as He, M as Be, D as Ke, m as Xe, w as Ye, b as et, g as tt, x as rt, j as it, I as st, q as ot, F as at, A as nt, O as lt, P as ut, E as pt, S as dt, f as N } from "./featureLayerUtils-f9a404fc.js";
+import { p as k } from "./FeatureTemplate-33f1511c.js";
+import { n as Q } from "./FeatureType-03d8bfc6.js";
+import { s as yt } from "./fieldProperties-917b162f.js";
+import { C as ct } from "./LabelClass-fd78b96b.js";
+import { i as j } from "./labelingInfo-419c11be.js";
+import { a as ht } from "./serviceCapabilitiesUtils-98603a14.js";
+import { d as mt } from "./TimeInfo-8ce5e779.js";
+import { e as ft } from "./versionUtils-d824fad7.js";
+import { t as gt } from "./styleUtils-a42848e6.js";
+import { S as F } from "./TopFeaturesQuery-92ff83cb.js";
+import { p as bt } from "./popupUtils-3e3652c3.js";
+import { A as S } from "./interfaces-fac3cfda.js";
+import "vue";
+import "./ColorStop-6fd09765.js";
+import "./diffUtils-f967bb01.js";
+import "./colorRamps-fedcdeb0.js";
+import "./sizeVariableUtils-a1b694d8.js";
+import "./visualVariableUtils-88773652.js";
+import "./lengthUtils-21f99608.js";
+import "./jsonUtils-0c0893e4.js";
+import "./styleUtils-b62393b9.js";
+import "./LRUCache-7a6c25d0.js";
+import "./MemCache-cfd09d4d.js";
+import "./Version-df01af53.js";
+import "./FieldsIndex-cddb2b35.js";
+import "./UnknownTimeZone-6d259a58.js";
+import "./OverrideHelper-212a5126.js";
+import "./colorUtils-b3dcdea1.js";
+import "./vec42-689e76ac.js";
+import "./vec4f64-043e974c.js";
+import "./utils-b1ab6c91.js";
+import "./quantizationUtils-2be4bff3.js";
+import "./heatmapUtils-ae60011e.js";
+import "./ElevationInfo-c194d5f5.js";
+import "./unitConversionUtils-c6c847c9.js";
+import "./jsonUtils-2a454e30.js";
+import "./parser-bab9c2ce.js";
+import "./FeatureEffect-c51c2425.js";
+import "./FeatureFilter-9a11227d.js";
+import "./LayerFloorInfo-43dec126.js";
+import "./FeatureReductionSelection-2b7de4bb.js";
+import "./MD5-1b5ec1c3.js";
+import "./OrderByInfo-b7d114ac.js";
+import "./portalItemUtils-9fe0753b.js";
+import "./AttachmentQuery-14f4ec29.js";
+import "./RelationshipQuery-292ab835.js";
+import "./labelUtils-31fc2428.js";
+import "./defaults-9d551b4c.js";
+import "./defaultsJSON-ba17aa15.js";
+let wt = 0, g = class extends z.LoadableMixin(Z(M)) {
+  constructor(e) {
+    super(e), this._idToClientGraphic = null, this.type = "memory";
+  }
+  load(e) {
+    const t = e != null ? e.signal : null;
+    return this.addResolvingPromise(this._startWorker(t)), Promise.resolve(this);
+  }
+  destroy() {
+    var e;
+    (e = this._connection) == null || e.close(), this._connection = null;
+  }
+  get _workerGeometryType() {
+    var t;
+    const e = (t = this.layer) == null ? void 0 : t.geometryType;
+    return e ? this._geometryTypeRequiresClientGraphicMapping(e) ? "polygon" : e : null;
+  }
+  applyEdits(e) {
+    return this.load().then(() => this._applyEdits(e));
+  }
+  openPorts() {
+    return this.load().then(() => this._connection.openPorts());
+  }
+  async queryFeatures(e, t = {}) {
+    await this.load(t);
+    const r = await this._connection.invoke("queryFeatures", e ? e.toJSON() : null, t);
+    A(e, this.layer.spatialReference, r);
+    const i = V.fromJSON(r);
+    if (!this._requiresClientGraphicMapping())
+      return i;
+    const s = this.layer.objectIdField;
+    for (const l of i.features) {
+      const u = l.attributes[s], c = this._idToClientGraphic.get(u);
+      c && (l.geometry = c.geometry);
+    }
+    return i.geometryType = this.layer.geometryType, i;
+  }
+  async queryFeaturesJSON(e, t = {}) {
+    if (this._requiresClientGraphicMapping())
+      throw new f("query-features-json:unsupported", "Cannot query in JSON format for client only geometry types (mesh and extent)");
+    await this.load(t);
+    const r = await this._connection.invoke("queryFeatures", e ? e.toJSON() : null, t);
+    return A(e, this.layer.spatialReference, r), r;
+  }
+  queryFeatureCount(e, t = {}) {
+    return this.load(t).then(() => this._connection.invoke("queryFeatureCount", e ? e.toJSON() : null, t));
+  }
+  queryObjectIds(e, t = {}) {
+    return this.load(t).then(() => this._connection.invoke("queryObjectIds", e ? e.toJSON() : null, t));
+  }
+  queryExtent(e, t = {}) {
+    return this.load(t).then(() => this._connection.invoke("queryExtent", e ? e.toJSON() : null, t)).then((r) => ({ count: r.count, extent: U.fromJSON(r.extent) }));
+  }
+  querySnapping(e, t = {}) {
+    return this.load(t).then(() => this._connection.invoke("querySnapping", e, t));
+  }
+  async _applyEdits(e) {
+    if (!this._connection)
+      throw new f("feature-layer-source:edit-failure", "Memory source not loaded");
+    const t = this.layer.objectIdField;
+    let r = null;
+    const i = [], s = [];
+    await Promise.all([this._prepareClientMapping(e.addFeatures, null), this._prepareClientMapping(e.updateFeatures, null)]);
+    const l = (p) => "objectId" in p && p.objectId != null ? p.objectId : "attributes" in p && p.attributes[t] != null ? p.attributes[t] : null;
+    if (e.addFeatures && (r = this._prepareAddFeatures(e.addFeatures)), e.deleteFeatures)
+      for (const p of e.deleteFeatures) {
+        const m = l(p);
+        m != null && i.push(m);
+      }
+    const u = e.updateFeatures && this._idToClientGraphic ? /* @__PURE__ */ new Map() : null;
+    if (e.updateFeatures) {
+      for (const p of e.updateFeatures)
+        if (s.push(this._serializeFeature(p)), u) {
+          const m = l(p);
+          m != null && u.set(m, p);
+        }
+    }
+    Me(r ? r.features : null, s, this.layer.spatialReference);
+    const { fullExtent: c, featureEditResults: d } = await this._connection.invoke("applyEdits", { adds: r ? r.features : [], updates: s, deletes: i });
+    return this.fullExtent = c, r && r.finish(d.uidToObjectId), this._updateClientGraphicIds(u, d), this._createEditsResult(d);
+  }
+  async _prepareClientMapping(e, t) {
+    if (this._layerOrSourceGeometryType !== "mesh" || e == null)
+      return;
+    const r = [];
+    for (const { geometry: i } of e)
+      i == null || i.type !== "mesh" || i.hasExtent || i.loaded || r.push(i.load({ signal: t }));
+    r.length && await Promise.all(r);
+  }
+  _updateClientGraphicIds(e, t) {
+    if (this._idToClientGraphic) {
+      if (e)
+        for (const r of t.updateResults) {
+          if (!r.success)
+            continue;
+          const i = e.get(r.objectId);
+          i != null && this._addIdToClientGraphic(i);
+        }
+      for (const r of t.deleteResults)
+        r.success && this._idToClientGraphic.delete(r.objectId);
+    }
+  }
+  _createEditsResult(e) {
+    return { addFeatureResults: e.addResults ? e.addResults.map(this._createFeatureEditResult, this) : [], updateFeatureResults: e.updateResults ? e.updateResults.map(this._createFeatureEditResult, this) : [], deleteFeatureResults: e.deleteResults ? e.deleteResults.map(this._createFeatureEditResult, this) : [], addAttachmentResults: [], updateAttachmentResults: [], deleteAttachmentResults: [] };
+  }
+  _createFeatureEditResult(e) {
+    const t = e.success === !0 ? null : e.error || { code: void 0, description: void 0 };
+    return { objectId: e.objectId, globalId: e.globalId, error: t ? new f("feature-layer-source:edit-failure", t.description, { code: t.code }) : null };
+  }
+  _prepareAddFeatures(e) {
+    const t = /* @__PURE__ */ new Map(), r = new Array(e.length);
+    let i = null;
+    for (let l = 0; l < e.length; l++) {
+      const u = e[l], c = this._serializeFeature(u);
+      i || u.geometry == null || (i = u.geometry.type), r[l] = c, t.set(`${c.uid}`, u);
+    }
+    const s = this;
+    return { features: r, inferredGeometryType: i, finish(l) {
+      const u = s.sourceJSON.objectIdField;
+      for (const c in l) {
+        const d = l[c], p = t.get(c);
+        p && (p.attributes || (p.attributes = {}), d === -1 ? delete p.attributes[u] : p.attributes[u] = d, s._addIdToClientGraphic(p));
+      }
+    } };
+  }
+  _addIdToClientGraphic(e) {
+    var i;
+    if (!this._idToClientGraphic)
+      return;
+    const t = this.sourceJSON.objectIdField, r = (i = e.attributes) == null ? void 0 : i[t];
+    r != null && this._idToClientGraphic.set(r, e);
+  }
+  get _layerOrSourceGeometryType() {
+    var e, t;
+    return ((e = this.layer) == null ? void 0 : e.geometryType) ?? ((t = this.sourceJSON) == null ? void 0 : t.geometryType);
+  }
+  _requiresClientGraphicMapping() {
+    return this._geometryTypeRequiresClientGraphicMapping(this._layerOrSourceGeometryType);
+  }
+  _geometryRequiresClientGraphicMapping(e) {
+    return this._geometryTypeRequiresClientGraphicMapping(e.type);
+  }
+  _geometryTypeRequiresClientGraphicMapping(e) {
+    return e === "mesh" || e === "multipatch" || e === "extent";
+  }
+  _serializeFeature(e) {
+    const { attributes: t } = e, r = this._geometryForSerialization(e), i = (wt++).toString();
+    return r ? { uid: i, geometry: r.toJSON(), attributes: t } : { uid: i, attributes: t };
+  }
+  _geometryForSerialization(e) {
+    const { geometry: t } = e;
+    return t == null ? null : this._geometryRequiresClientGraphicMapping(t) ? t.extent ? H.fromExtent(t.extent) : null : t;
+  }
+  async _startWorker(e) {
+    this._connection = await B("MemorySourceWorker", { strategy: K("feature-layers-workers") ? "dedicated" : "local", signal: e, registryTarget: this });
+    const { fields: t, spatialReference: r, objectIdField: i, hasM: s, hasZ: l, timeInfo: u, dateFieldsTimeZone: c } = this.layer, d = this.layer.originOf("spatialReference") === "defaults";
+    await this._prepareClientMapping(this.items, e);
+    const p = this._prepareAddFeatures(this.items);
+    this.addHandles(this.on("before-changes", (w) => {
+      _.getLogger(this).error("Source modifications will not propagate after layer has been loaded. Please use .applyEdits() instead"), w.preventDefault();
+    }));
+    const m = { features: p.features, fields: t == null ? void 0 : t.map((w) => w.toJSON()), geometryType: L.toJSON(this._workerGeometryType), hasM: this._layerOrSourceGeometryType !== "mesh" && s, hasZ: this._layerOrSourceGeometryType === "mesh" || l, objectIdField: i, spatialReference: d ? null : r && r.toJSON(), timeInfo: (u == null ? void 0 : u.toJSON()) ?? null, dateFieldsTimeZone: c }, b = await this._connection.invoke("load", m, { signal: e });
+    for (const w of b.warnings)
+      _.getLogger(this.layer).warn("#load()", `${w.message} (title: '${this.layer.title || "no title"}', id: '${this.layer.id ?? "no id"}')`, { warning: w });
+    b.featureErrors.length && _.getLogger(this.layer).warn("#load()", `Encountered ${b.featureErrors.length} validation errors while loading features. (title: '${this.layer.title || "no title"}', id: '${this.layer.id ?? "no id"}')`, { errors: b.featureErrors });
+    const q = b.layerDefinition;
+    this._geometryTypeRequiresClientGraphicMapping(p.inferredGeometryType) && (q.geometryType = L.toJSON(p.inferredGeometryType)), this.sourceJSON = q, this._requiresClientGraphicMapping() && (this._idToClientGraphic = /* @__PURE__ */ new Map()), p.finish(b.assignedObjectIds);
+  }
+};
+o([X({ Type: R, ensureType: Y(R) })], g.prototype, "itemType", void 0), o([n()], g.prototype, "type", void 0), o([n({ constructOnly: !0 })], g.prototype, "layer", void 0), o([n({ readOnly: !0 })], g.prototype, "_workerGeometryType", null), o([n()], g.prototype, "sourceJSON", void 0), g = o([E("esri.layers.graphics.sources.MemorySource")], g);
+let v = class extends ee {
+  constructor() {
+    super(...arguments), this.updating = !1, this.status = "unknown";
+  }
+};
+o([n()], v.prototype, "updating", void 0), o([n()], v.prototype, "status", void 0), v = o([E("esri.layers.support.PublishingInfo")], v);
+const vt = v, W = "esri.layers.mixins.PublishableLayer", Ft = Symbol(W), St = (e) => {
+  var t;
+  let r = class extends e {
+    constructor() {
+      super(...arguments), this[t] = !0;
+    }
+    get publishingInfo() {
+      if (this.destroyed)
+        return null;
+      const i = this._get("publishingInfo");
+      if (i)
+        return i;
+      const s = new vt();
+      return this._checkPublishingStatus(s), s;
+    }
+    _checkPublishingStatus(i) {
+      let u = 0;
+      const c = async (p) => {
+        let m;
+        i.updating = !0;
+        try {
+          m = await this.fetchPublishingStatus();
+        } catch {
+          m = "unavailable";
+        }
+        m !== "published" && m !== "unavailable" || (i.status === "publishing" && this.refresh(), d.remove()), i.status = m, i.updating = !1, d.removed || (u = setTimeout(c, p, p + 125));
+      }, d = { removed: !1, remove() {
+        this.removed = !0, clearTimeout(u);
+      } };
+      this.when().catch(() => d.remove()), c(250), this.addHandles(d);
+    }
+  };
+  return t = Ft, o([n({ readOnly: !0, clonable: !1 })], r.prototype, "publishingInfo", null), r = o([E(W)], r), r;
+}, h = "FeatureLayer";
+function T(e, t) {
+  return new f("layer:unsupported", `Layer (${e.title}, ${e.id}) of type '${e.declaredClass}' ${t}`, { layer: e });
+}
+function J(e) {
+  return e && e instanceof M;
+}
+const O = yt();
+function C(e, t, r) {
+  const i = !!(r != null && r.writeLayerSchema);
+  return { enabled: i, ignoreOrigin: i };
+}
+let a = class extends Ae(Ne(Ge(St(Pe(Re(Ve(ze(We(Qe(Le(Je(ke(Te(xe(qe(te(be))))))))))))))))) {
+  constructor(...e) {
+    super(...e), this.charts = null, this.copyright = null, this.displayField = null, this.dynamicDataSource = null, this.fields = null, this.fieldsIndex = null, this.formTemplate = null, this.fullExtent = null, this.geometryType = null, this.hasM = void 0, this.hasZ = void 0, this.infoFor3D = null, this.isTable = !1, this.labelsVisible = !0, this.labelingInfo = null, this.legendEnabled = !0, this.objectIdField = null, this.outFields = null, this.path = null, this.popupEnabled = !0, this.popupTemplate = null, this.resourceInfo = null, this.screenSizePerspectiveEnabled = !0, this.spatialReference = re.WGS84, this.subtypeCode = null, this.templates = null, this.timeInfo = null, this.title = null, this.sublayerTitleMode = "item-title", this.type = "feature", this.typeIdField = null, this.types = null, this.visible = !0, this._debouncedSaveOperations = ie(async (t, r, i) => {
+      const { save: s, saveAs: l } = await import("./featureLayerUtils-6fd62a19.js");
+      switch (t) {
+        case S.SAVE:
+          return s(this, r);
+        case S.SAVE_AS:
+          return l(this, i, r);
+      }
+    });
+  }
+  destroy() {
+    var e;
+    (e = this.source) == null || e.destroy();
+  }
+  normalizeCtorArgs(e, t) {
+    return typeof e == "string" ? { url: e, ...t } : e;
+  }
+  load(e) {
+    var i;
+    const t = e != null ? e.signal : null;
+    if ((i = this.portalItem) != null && i.loaded && this.source)
+      return this.addResolvingPromise(this.createGraphicsSource(t).then((s) => this.initLayerProperties(s))), Promise.resolve(this);
+    const r = this.loadFromPortal({ supportedTypes: ["Feature Service", "Feature Collection", "Scene Service"] }, e).catch(se).then(async () => {
+      if (this.url && this.layerId == null && /FeatureServer|MapServer\/*$/i.test(this.url)) {
+        const s = await this._fetchFirstValidLayerId(t);
+        s != null && (this.layerId = s);
+      }
+      if (!this.url && !this._hasMemorySource())
+        throw new f("feature-layer:missing-url-or-source", "Feature layer must be created with either a url or a source");
+      return this.initLayerProperties(await this.createGraphicsSource(t));
+    }).then(() => Ze(this, "load", e));
+    return this.addResolvingPromise(r), Promise.resolve(this);
+  }
+  readCapabilities(e, t) {
+    return t = t.layerDefinition || t, ht(t, this.url);
+  }
+  get createQueryVersion() {
+    return this.commitProperty("definitionExpression"), this.commitProperty("dynamicDataSource"), this.commitProperty("timeExtent"), this.commitProperty("timeOffset"), this.commitProperty("geometryType"), this.commitProperty("gdbVersion"), this.commitProperty("historicMoment"), this.commitProperty("returnZ"), this.commitProperty("capabilities"), this.commitProperty("returnM"), (this._get("createQueryVersion") ?? 0) + 1;
+  }
+  get editingEnabled() {
+    var e;
+    return !(this.loaded && !((e = this.capabilities) != null && e.operations.supportsEditing)) && (this._isOverridden("editingEnabled") ? this._get("editingEnabled") : this._hasMemorySource() || this.userHasEditingPrivileges);
+  }
+  set editingEnabled(e) {
+    this._overrideIfSome("editingEnabled", e);
+  }
+  readEditingEnabled(e, t) {
+    return this._readEditingEnabled(t, !1);
+  }
+  readEditingEnabledFromWebMap(e, t, r) {
+    return this._readEditingEnabled(t, !0, r);
+  }
+  writeEditingEnabled(e, t) {
+    this._writeEditingEnabled(e, t, !1);
+  }
+  writeEditingEnabledToWebMap(e, t, r, i) {
+    this._writeEditingEnabled(e, t, !0, i);
+  }
+  get effectiveEditingEnabled() {
+    return Ue(this);
+  }
+  readIsTable(e, t) {
+    return (t = (t == null ? void 0 : t.layerDefinition) ?? t).type === "Table" || !t.geometryType;
+  }
+  writeIsTable(e, t, r, i) {
+    i != null && i.writeLayerSchema && I(r, e ? "Table" : "Feature Layer", t);
+  }
+  readGlobalIdField(e, t) {
+    return He(t.layerDefinition || t);
+  }
+  readObjectIdField(e, t) {
+    return Be(t.layerDefinition || t);
+  }
+  get parsedUrl() {
+    const e = oe(this.url);
+    return e != null && (this.dynamicDataSource != null ? e.path = x(e.path, "dynamicLayer") : this.layerId != null && (e.path = x(e.path, this.layerId.toString()))), e;
+  }
+  get defaultPopupTemplate() {
+    return this.createPopupTemplate();
+  }
+  set renderer(e) {
+    P(e, this.fieldsIndex), this._set("renderer", e);
+  }
+  readRenderer(e, t, r) {
+    var s;
+    t = t.layerDefinition || t;
+    const i = (s = t.drawingInfo) == null ? void 0 : s.renderer;
+    if (i) {
+      const l = ve(i, t, r) ?? void 0;
+      return l || _.getLogger(this).error("Failed to create renderer", { rendererDefinition: t.drawingInfo.renderer, layer: this, context: r }), l;
+    }
+    return Ke(t, r);
+  }
+  set source(e) {
+    const t = this._get("source");
+    t !== e && (J(t) && this._resetMemorySource(t), J(e) && this._initMemorySource(e), this._set("source", e));
+  }
+  castSource(e) {
+    return e ? Array.isArray(e) || e instanceof M ? new g({ layer: this, items: e }) : e : null;
+  }
+  readSource(e, t) {
+    const r = V.fromJSON(t.featureSet);
+    return new g({ layer: this, items: (r == null ? void 0 : r.features) ?? [] });
+  }
+  readTemplates(e, t) {
+    const r = t.editFieldsInfo, i = r == null ? void 0 : r.creatorField, s = r == null ? void 0 : r.editorField;
+    return e = e == null ? void 0 : e.map((l) => k.fromJSON(l)), this._fixTemplates(e, i), this._fixTemplates(e, s), e;
+  }
+  readTitle(e, t) {
+    var s, l, u;
+    const r = ((s = t.layerDefinition) == null ? void 0 : s.name) ?? t.name, i = t.title || ((l = t.layerDefinition) == null ? void 0 : l.title);
+    if (r) {
+      const c = (u = this.portalItem) == null ? void 0 : u.title;
+      if (this.sublayerTitleMode === "item-title")
+        return this.url ? ae(this.url, r) : r;
+      let d = r;
+      if (!d && this.url) {
+        const p = ne(this.url);
+        p != null && (d = p.title);
+      }
+      return d ? (this.sublayerTitleMode === "item-title-and-service-name" && c && c !== d && (d = c + " - " + d), le(d)) : void 0;
+    }
+    if (this.sublayerTitleMode === "item-title" && i)
+      return i;
+  }
+  readTitleFromWebMap(e, t) {
+    var r;
+    return t.title || ((r = t.layerDefinition) == null ? void 0 : r.name);
+  }
+  readTypeIdField(e, t) {
+    let r = (t = t.layerDefinition || t).typeIdField;
+    if (r && t.fields) {
+      r = r.toLowerCase();
+      const i = t.fields.find((s) => s.name.toLowerCase() === r);
+      i && (r = i.name);
+    }
+    return r;
+  }
+  readTypes(e, t) {
+    e = (t = t.layerDefinition || t).types;
+    const r = t.editFieldsInfo, i = r == null ? void 0 : r.creatorField, s = r == null ? void 0 : r.editorField;
+    return e == null ? void 0 : e.map((l) => (l = Q.fromJSON(l), this._fixTemplates(l.templates, i), this._fixTemplates(l.templates, s), l));
+  }
+  readVisible(e, t) {
+    var r;
+    return ((r = t.layerDefinition) == null ? void 0 : r.defaultVisibility) != null ? !!t.layerDefinition.defaultVisibility : t.visibility != null ? !!t.visibility : void 0;
+  }
+  async addAttachment(e, t) {
+    return Xe(this, e, t, h);
+  }
+  async updateAttachment(e, t, r) {
+    return Ye(this, e, t, r, h);
+  }
+  async applyEdits(e, t) {
+    return et(this, e, t);
+  }
+  async uploadAssets(e, t) {
+    return tt(this, e, t);
+  }
+  on(e, t) {
+    return super.on(e, t);
+  }
+  createPopupTemplate(e) {
+    return bt(this, e);
+  }
+  async createGraphicsSource(e) {
+    if (this._hasMemorySource() && this.source)
+      return this.source.load({ signal: e });
+    const { default: t } = await ue(import("./FeatureLayerSource-8d9419ca.js"), e);
+    return new t({ layer: this }).load({ signal: e });
+  }
+  createQuery() {
+    const e = rt(this);
+    e.dynamicDataSource = this.dynamicDataSource;
+    const t = this.subtypeCode != null ? `${this.subtypeField} = ${this.subtypeCode}` : null, r = pe(this.definitionExpression, t);
+    return e.where = r || "1=1", e;
+  }
+  async deleteAttachments(e, t) {
+    return it(this, e, t, h);
+  }
+  async fetchRecomputedExtents(e) {
+    return st(this, e, h);
+  }
+  getFeatureType(e) {
+    const { typeIdField: t, types: r } = this;
+    if (!t || !e)
+      return null;
+    const i = e.attributes ? e.attributes[t] : void 0;
+    if (i == null)
+      return null;
+    let s = null;
+    return r == null || r.some((l) => {
+      const { id: u } = l;
+      return u != null && (u.toString() === i.toString() && (s = l), !!s);
+    }), s;
+  }
+  getFieldDomain(e, t) {
+    const r = t == null ? void 0 : t.feature, i = this.getFeatureType(r);
+    if (i) {
+      const s = i.domains && i.domains[e];
+      if (s && s.type !== "inherited")
+        return s;
+    }
+    return this._getLayerDomain(e);
+  }
+  getField(e) {
+    return this.fieldsIndex.get(e);
+  }
+  async queryAttachments(e, t) {
+    return ot(this, e, t, h);
+  }
+  async queryFeatures(e, t) {
+    const r = await this.load(), i = await r.source.queryFeatures(de.from(e) ?? r.createQuery(), t);
+    if (i != null && i.features)
+      for (const s of i.features)
+        s.layer = s.sourceLayer = r;
+    return i;
+  }
+  async queryObjectIds(e, t) {
+    return at(this, e, t, h);
+  }
+  async queryFeatureCount(e, t) {
+    return nt(this, e, t, h);
+  }
+  async queryExtent(e, t) {
+    return lt(this, e, t, h);
+  }
+  async queryRelatedFeatures(e, t) {
+    return ut(this, e, t, h);
+  }
+  async queryRelatedFeaturesCount(e, t) {
+    return pt(this, e, t, h);
+  }
+  async queryTopFeatures(e, t) {
+    var l;
+    const { source: r, capabilities: i } = await this.load();
+    if (!r.queryTopFeatures || !((l = i == null ? void 0 : i.query) != null && l.supportsTopFeaturesQuery))
+      throw new f(h, "Layer source does not support queryTopFeatures capability");
+    const s = await r.queryTopFeatures(F.from(e), t);
+    if (s != null && s.features)
+      for (const u of s.features)
+        u.layer = u.sourceLayer = this;
+    return s;
+  }
+  async queryTopObjectIds(e, t) {
+    const { source: r, capabilities: i } = await this.load();
+    if (!r.queryTopObjectIds || !(i != null && i.query.supportsTopFeaturesQuery))
+      throw new f(h, "Layer source does not support queryTopObjectIds capability");
+    return r.queryTopObjectIds(F.from(e), t);
+  }
+  async queryTopFeaturesExtent(e, t) {
+    var s;
+    const { source: r, capabilities: i } = await this.load();
+    if (!r.queryTopExtents || !((s = i == null ? void 0 : i.query) != null && s.supportsTopFeaturesQuery))
+      throw new f(h, "Layer source does not support queryTopExtents capability");
+    return r.queryTopExtents(F.from(e), t);
+  }
+  async queryTopFeatureCount(e, t) {
+    var s;
+    const { source: r, capabilities: i } = await this.load();
+    if (!r.queryTopCount || !((s = i == null ? void 0 : i.query) != null && s.supportsTopFeaturesQuery))
+      throw new f(h, "Layer source does not support queryFeatureCount capability");
+    return r.queryTopCount(F.from(e), t);
+  }
+  read(e, t) {
+    const r = e.featureCollection;
+    if ((r || e.type === "Feature Collection") && (this.resourceInfo = e), r) {
+      const i = r.layers;
+      i && i.length === 1 && (super.read(i[0], t), r.showLegend != null && super.read({ showLegend: r.showLegend }, t));
+    }
+    super.read(e, t), t && t.origin === "service" && (this.revert(["objectIdField", "fields", "timeInfo", "dateFieldsTimeZone"], "service"), this.spatialReference || this.revert(["spatialReference"], "service"));
+  }
+  write(e, t) {
+    t = { ...t, origin: (t == null ? void 0 : t.origin) ?? void 0, writeLayerSchema: (t == null ? void 0 : t.writeLayerSchema) ?? this._hasMemorySource() };
+    const { origin: r, layerContainerType: i, messages: s } = t;
+    if (this.dynamicDataSource)
+      return s == null || s.push(T(this, "using a dynamic data source cannot be written to web scenes, web maps and feature service items")), null;
+    if (this.isTable) {
+      if ((r === "web-map" || r === "web-scene") && i !== "tables")
+        return s == null || s.push(T(this, `a table source can only be written to tables, not ${i}`)), null;
+      if (this._hasMemorySource())
+        return s == null || s.push(T(this, "using an in-memory table source cannot be written to web scenes and web maps")), null;
+    } else if (this.loaded && (r === "web-map" || r === "web-scene") && i === "tables")
+      return s == null || s.push(T(this, "using a non-table source cannot be written to tables in web maps or web scenes")), null;
+    return super.write(e, t);
+  }
+  clone() {
+    if (this._hasMemorySource())
+      throw new f(h, `FeatureLayer (title: ${this.title}, id: ${this.id}) created using in-memory source cannot be cloned`);
+    return super.clone();
+  }
+  serviceSupportsSpatialReference(e) {
+    var t;
+    return !!this.loaded && (((t = this.source) == null ? void 0 : t.type) === "memory" || ft(this, e));
+  }
+  async save(e) {
+    return this._debouncedSaveOperations(S.SAVE, e);
+  }
+  async saveAs(e, t) {
+    return this._debouncedSaveOperations(S.SAVE_AS, t, e);
+  }
+  _readEditingEnabled(e, t, r) {
+    var s;
+    let i = (s = e.layerDefinition) == null ? void 0 : s.capabilities;
+    return i ? this._hasEditingCapability(i) : (i = e.capabilities, t && (r == null ? void 0 : r.origin) === "web-map" && !this._hasMemorySource() && i ? this._hasEditingCapability(i) : void 0);
+  }
+  _hasEditingCapability(e) {
+    return e.toLowerCase().split(",").map((t) => t.trim()).includes("editing");
+  }
+  _writeEditingEnabled(e, t, r, i) {
+    var s, l;
+    if (!e) {
+      const u = (l = (s = this.capabilities) == null ? void 0 : s.operations) != null && l.supportsSync ? "Query,Sync" : "Query";
+      I("layerDefinition.capabilities", u, t), r && !(i != null && i.writeLayerSchema) && (t.capabilities = u);
+    }
+  }
+  _getLayerDomain(e) {
+    const t = this.fieldsIndex.get(e);
+    return t ? t.domain : null;
+  }
+  _fetchFirstValidLayerId(e) {
+    return ye(this.url, { query: { f: "json", ...this.customParameters, token: this.apiKey }, responseType: "json", signal: e }).then((t) => {
+      const r = t.data;
+      if (r)
+        return this.findFirstValidLayerId(r);
+    });
+  }
+  async initLayerProperties(e) {
+    var t;
+    return this._set("source", e), e.sourceJSON && (this.sourceJSON = e.sourceJSON, this.read(e.sourceJSON, { origin: "service", portalItem: this.portalItem, portal: (t = this.portalItem) == null ? void 0 : t.portal, url: this.parsedUrl })), this._verifySource(), this._verifyFields(), P(this.renderer, this.fieldsIndex), ce(this.timeInfo, this.fieldsIndex), gt(this, { origin: "service" });
+  }
+  async hasDataChanged() {
+    return dt(this);
+  }
+  async fetchPublishingStatus() {
+    const e = this.source;
+    return e != null && e.fetchPublishingStatus ? e.fetchPublishingStatus() : "unavailable";
+  }
+  _verifyFields() {
+    var t, r;
+    const e = ((t = this.parsedUrl) == null ? void 0 : t.path) ?? "undefined";
+    this.objectIdField || console.log("FeatureLayer: 'objectIdField' property is not defined (url: " + e + ")"), this.isTable || this._hasMemorySource() || e.search(/\/FeatureServer\//i) !== -1 || (r = this.fields) != null && r.some((i) => i.type === "geometry") || console.log("FeatureLayer: unable to find field of type 'geometry' in the layer 'fields' list. If you are using a map service layer, features will not have geometry (url: " + e + ")");
+  }
+  _fixTemplates(e, t) {
+    e && e.forEach((r) => {
+      var s;
+      const i = (s = r.prototype) == null ? void 0 : s.attributes;
+      i && t && delete i[t];
+    });
+  }
+  _verifySource() {
+    if (this._hasMemorySource()) {
+      if (this.url)
+        throw new f("feature-layer:mixed-source-and-url", "FeatureLayer cannot be created with both an in-memory source and a url");
+    } else if (!this.url)
+      throw new f("feature-layer:source-or-url-required", "FeatureLayer requires either a url, a valid portal item or a source");
+  }
+  _initMemorySource(e) {
+    e.forEach((t) => {
+      t.layer = this, t.sourceLayer = this;
+    }), this.addHandles([e.on("after-add", (t) => {
+      t.item.layer = this, t.item.sourceLayer = this;
+    }), e.on("after-remove", (t) => {
+      t.item.layer = null, t.item.sourceLayer = null;
+    })], "fl-source");
+  }
+  _resetMemorySource(e) {
+    e.forEach((t) => {
+      t.layer = null, t.sourceLayer = null;
+    }), this.removeHandles("fl-source");
+  }
+  _hasMemorySource() {
+    return !(this.url || !this.source);
+  }
+  findFirstValidLayerId(e) {
+    return Array.isArray(e.layers) && e.layers.length > 0 ? e.layers[0].id : Array.isArray(e.tables) && e.tables.length > 0 ? e.tables[0].id : void 0;
+  }
+};
+o([y("service", "capabilities")], a.prototype, "readCapabilities", null), o([n({ json: { origins: { "web-scene": { write: !1 } }, write: !0 } })], a.prototype, "charts", void 0), o([n({ readOnly: !0 })], a.prototype, "createQueryVersion", null), o([n({ json: { read: { source: "layerDefinition.copyrightText" } } })], a.prototype, "copyright", void 0), o([n({ json: { read: { source: "layerDefinition.displayField" } } })], a.prototype, "displayField", void 0), o([n({ types: he, readOnly: !0 })], a.prototype, "defaultSymbol", void 0), o([n({ type: me })], a.prototype, "dynamicDataSource", void 0), o([n({ type: Boolean })], a.prototype, "editingEnabled", null), o([y(["portal-item", "web-scene"], "editingEnabled", ["layerDefinition.capabilities"])], a.prototype, "readEditingEnabled", null), o([y("web-map", "editingEnabled", ["capabilities", "layerDefinition.capabilities"])], a.prototype, "readEditingEnabledFromWebMap", null), o([$(["portal-item", "web-scene"], "editingEnabled", { "layerDefinition.capabilities": { type: String } })], a.prototype, "writeEditingEnabled", null), o([$("web-map", "editingEnabled", { capabilities: { type: String }, "layerDefinition.capabilities": { type: String } })], a.prototype, "writeEditingEnabledToWebMap", null), o([n({ readOnly: !0 })], a.prototype, "effectiveEditingEnabled", null), o([n({ ...O.fields, json: { read: { source: "layerDefinition.fields" }, origins: { service: { name: "fields" }, "web-map": { write: { target: "layerDefinition.fields", overridePolicy: C } } } } })], a.prototype, "fields", void 0), o([n(O.fieldsIndex)], a.prototype, "fieldsIndex", void 0), o([n({ type: Ce, json: { name: "formInfo", write: !0, origins: { "web-scene": { read: !1, write: !1 } } } })], a.prototype, "formTemplate", void 0), o([n({ json: { read: { source: "layerDefinition.extent" } } })], a.prototype, "fullExtent", void 0), o([n({ json: { origins: { "web-map": { write: { target: "layerDefinition.geometryType", overridePolicy: C, writer(e, t, r) {
+  const i = e ? N.toJSON(e) : null;
+  i && I(r, i, t);
+} } } }, read: { source: "layerDefinition.geometryType", reader: N.read } } })], a.prototype, "geometryType", void 0), o([n({ json: { read: { source: "layerDefinition.hasM" } } })], a.prototype, "hasM", void 0), o([n({ json: { read: { source: "layerDefinition.hasZ" } } })], a.prototype, "hasZ", void 0), o([n(_e)], a.prototype, "id", void 0), o([n({ readOnly: !0, json: { origins: { service: { read: !0 } }, read: !1 } })], a.prototype, "infoFor3D", void 0), o([n({ json: { origins: { "web-map": { write: { target: "layerDefinition.type" } } } } })], a.prototype, "isTable", void 0), o([y("service", "isTable", ["type", "geometryType"]), y("isTable", ["layerDefinition.type", "layerDefinition.geometryType"])], a.prototype, "readIsTable", null), o([$("web-map", "isTable")], a.prototype, "writeIsTable", null), o([n(Ie)], a.prototype, "labelsVisible", void 0), o([n({ type: [ct], json: { origins: { service: { name: "drawingInfo.labelingInfo", read: j, write: !1 }, "web-scene": { name: "layerDefinition.drawingInfo.labelingInfo", read: j, write: { enabled: !0, layerContainerTypes: G } } }, name: "layerDefinition.drawingInfo.labelingInfo", read: j, write: !0 } })], a.prototype, "labelingInfo", void 0), o([n((() => {
+  const e = D(Ee);
+  return e.json.origins["portal-item"] = { write: { target: "layerDefinition.drawingInfo.transparency", writer(t, r, i) {
+    I(i, we(t), r);
+  } } }, e;
+})())], a.prototype, "opacity", void 0), o([n($e)], a.prototype, "legendEnabled", void 0), o([n({ type: ["show", "hide"], json: (() => {
+  const e = D(De.json);
+  return e.origins["portal-item"] = { read: !1, write: !1 }, e;
+})() })], a.prototype, "listMode", void 0), o([y("globalIdField", ["layerDefinition.globalIdField", "layerDefinition.fields"])], a.prototype, "readGlobalIdField", null), o([n({ json: { origins: { "web-map": { write: { target: "layerDefinition.objectIdField", overridePolicy: C } } } } })], a.prototype, "objectIdField", void 0), o([y("objectIdField", ["layerDefinition.objectIdField", "layerDefinition.fields"])], a.prototype, "readObjectIdField", null), o([n({ value: "ArcGISFeatureLayer", type: ["ArcGISFeatureLayer"] })], a.prototype, "operationalLayerType", void 0), o([n(O.outFields)], a.prototype, "outFields", void 0), o([n({ readOnly: !0 })], a.prototype, "parsedUrl", null), o([n({ type: String, json: { origins: { "web-scene": { read: !0, write: !0 } }, read: !1 } })], a.prototype, "path", void 0), o([n(je)], a.prototype, "popupEnabled", void 0), o([n({ type: fe, json: { name: "popupInfo", write: !0 } })], a.prototype, "popupTemplate", void 0), o([n({ readOnly: !0 })], a.prototype, "defaultPopupTemplate", null), o([n({ types: Fe, json: { origins: { service: { write: { target: "drawingInfo.renderer", enabled: !1 } }, "web-scene": { types: Se, name: "layerDefinition.drawingInfo.renderer", write: { layerContainerTypes: G, overridePolicy: (e, t, r) => ({ ignoreOrigin: r == null ? void 0 : r.writeLayerSchema }) } } }, write: { target: "layerDefinition.drawingInfo.renderer", overridePolicy: (e, t, r) => ({ ignoreOrigin: r == null ? void 0 : r.writeLayerSchema }) } } })], a.prototype, "renderer", null), o([y("service", "renderer", ["drawingInfo.renderer", "defaultSymbol"]), y("renderer", ["layerDefinition.drawingInfo.renderer", "layerDefinition.defaultSymbol"])], a.prototype, "readRenderer", null), o([n()], a.prototype, "resourceInfo", void 0), o([n((() => {
+  const e = D(Oe);
+  return e.json.origins["portal-item"] = { read: !1, write: !1 }, e;
+})())], a.prototype, "screenSizePerspectiveEnabled", void 0), o([n({ clonable: !1 })], a.prototype, "source", null), o([ge("source")], a.prototype, "castSource", null), o([y("portal-item", "source", ["featureSet"]), y("web-map", "source", ["featureSet"])], a.prototype, "readSource", null), o([n({ json: { read: { source: "layerDefinition.extent.spatialReference" } } })], a.prototype, "spatialReference", void 0), o([n({ type: Number })], a.prototype, "subtypeCode", void 0), o([n({ type: [k] })], a.prototype, "templates", void 0), o([y("templates", ["editFieldsInfo", "creatorField", "editorField", "templates"])], a.prototype, "readTemplates", null), o([n({ type: mt })], a.prototype, "timeInfo", void 0), o([n()], a.prototype, "title", void 0), o([y("service", "title", ["name"]), y("portal-item", "title", ["layerDefinition.title", "layerDefinition.name", "title"])], a.prototype, "readTitle", null), o([y("web-map", "title", ["layerDefinition.name", "title"])], a.prototype, "readTitleFromWebMap", null), o([n({ type: String })], a.prototype, "sublayerTitleMode", void 0), o([n({ json: { read: !1 } })], a.prototype, "type", void 0), o([n({ type: String })], a.prototype, "typeIdField", void 0), o([y("service", "typeIdField"), y("typeIdField", ["layerDefinition.typeIdField"])], a.prototype, "readTypeIdField", null), o([n({ type: [Q] })], a.prototype, "types", void 0), o([y("service", "types", ["types"]), y("types", ["layerDefinition.types"])], a.prototype, "readTypes", null), o([n({ type: Boolean, json: { origins: { "portal-item": { write: { target: "layerDefinition.defaultVisibility" } } } } })], a.prototype, "visible", void 0), o([y("portal-item", "visible", ["visibility", "layerDefinition.defaultVisibility"])], a.prototype, "readVisible", null), a = o([E("esri.layers.FeatureLayer")], a);
+const Vr = a;
+export {
+  Vr as default
+};