@agrotools1/at-components 0.3.4-5 → 0.3.5

package/dist/GeoJSONSourceWorker-4571c9d5.js

@@ -0,0 +1,247 @@
+import { dg as _, W as I, dh as C, $ as Q, di as v, a0 as Z, dj as A, i as G, s as P, G as M, U as N, dk as R } from "./index-a8d87ec0.js";
+import { o as z, r as U, e as B, n as J, t as L } from "./featureConversionUtils-8fd0a407.js";
+import { m as W } from "./FeatureStore-9d48217b.js";
+import { x as E, j as b } from "./timeSupport-3ddd7e4b.js";
+import { $ as H } from "./QueryEngine-ca1511e3.js";
+import { I as V, N as K, E as Y } from "./geojson-33ba4718.js";
+import { o as X, a as ee, i as te } from "./clientSideDefaults-366deb67.js";
+import { j as ie, p as T, d as w, f as F, y as $ } from "./sourceUtils-5aee3b16.js";
+import { Z as k } from "./FieldsIndex-7d8f3589.js";
+import "vue";
+import "./OptimizedGeometry-3b808152.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./BoundsStore-030e1112.js";
+import "./PooledRBush-df73bc2a.js";
+import "./json-5febf88a.js";
+import "./MemCache-1532e921.js";
+import "./LRUCache-948c7d75.js";
+import "./WhereClause-a8fc45da.js";
+import "./TimeOnly-bb600899.js";
+import "./UnknownTimeZone-e62caf07.js";
+import "./QueryEngineCapabilities-0d8477a2.js";
+import "./quantizationUtils-4616cce9.js";
+import "./utils-e582955c.js";
+import "./heatmapUtils-582b52e1.js";
+import "./vec42-d5675dd5.js";
+import "./vec4f64-043e974c.js";
+import "./utils-283fbef1.js";
+import "./utils-cffde1b1.js";
+import "./ClassBreaksDefinition-0f6902fe.js";
+import "./Scheduler-e3ad50f2.js";
+import "./RenderState-b244097f.js";
+import "./date-1c28c6a5.js";
+import "./defaultsJSON-ba17aa15.js";
+const se = { hasAttachments: !1, capabilities: "query, editing, create, delete, update", useStandardizedQueries: !0, supportsCoordinatesQuantization: !0, supportsReturningQueryGeometry: !0, advancedQueryCapabilities: { supportsQueryAttachments: !1, supportsStatistics: !0, supportsPercentileStatistics: !0, supportsReturningGeometryCentroid: !0, supportsQueryWithDistance: !0, supportsDistinct: !0, supportsReturningQueryExtent: !0, supportsReturningGeometryProperties: !1, supportsHavingClause: !0, supportsOrderBy: !0, supportsPagination: !0, supportsQueryWithResultType: !1, supportsSqlExpression: !0, supportsDisjointSpatialRel: !0 } };
+class Ae {
+  constructor() {
+    this._queryEngine = null, this._snapshotFeatures = async (e) => {
+      const t = await this._fetch(e);
+      return this._createFeatures(t);
+    };
+  }
+  destroy() {
+    var e;
+    (e = this._queryEngine) == null || e.destroy(), this._queryEngine = this._createDefaultAttributes = null;
+  }
+  async load(e, t = {}) {
+    this._loadOptions = { url: e.url, customParameters: e.customParameters };
+    const r = [], [i] = await Promise.all([e.url ? this._fetch(t == null ? void 0 : t.signal) : null, this._checkProjection(e.spatialReference)]), s = V(i, { geometryType: e.geometryType }), o = e.fields || s.fields || [], d = e.hasZ != null ? e.hasZ : s.hasZ, p = s.geometryType;
+    let m = e.objectIdField || s.objectIdFieldName || "__OBJECTID";
+    const h = e.spatialReference || _;
+    let n = e.timeInfo;
+    o === s.fields && s.unknownFields.length > 0 && r.push({ name: "geojson-layer:unknown-field-types", message: "Some fields types couldn't be inferred from the features and were dropped", details: { unknownFields: s.unknownFields } });
+    const l = new k(o);
+    let u = l.get(m);
+    u ? (u.type !== "esriFieldTypeString" && (u.type = "esriFieldTypeOID"), u.editable = !1, u.nullable = !1, m = u.name) : (u = { alias: m, name: m, type: s.objectIdFieldType === "string" ? "esriFieldTypeString" : "esriFieldTypeOID", editable: !1, nullable: !1 }, o.unshift(u));
+    const y = {};
+    for (const a of o) {
+      if (a.name == null && (a.name = a.alias), a.alias == null && (a.alias = a.name), !a.name)
+        throw new I("geojson-layer:invalid-field-name", "field name is missing", { field: a });
+      if (!C.jsonValues.includes(a.type))
+        throw new I("geojson-layer:invalid-field-type", `invalid type for field "${a.name}"`, { field: a });
+      if (a.name !== u.name) {
+        const g = Q(a);
+        g !== void 0 && (y[a.name] = g);
+      }
+      a.length == null && (a.length = v(a));
+    }
+    if (n) {
+      if (n.startTimeField) {
+        const a = l.get(n.startTimeField);
+        a ? (n.startTimeField = a.name, a.type = "esriFieldTypeDate") : n.startTimeField = null;
+      }
+      if (n.endTimeField) {
+        const a = l.get(n.endTimeField);
+        a ? (n.endTimeField = a.name, a.type = "esriFieldTypeDate") : n.endTimeField = null;
+      }
+      if (n.trackIdField) {
+        const a = l.get(n.trackIdField);
+        a ? n.trackIdField = a.name : (n.trackIdField = null, r.push({ name: "geojson-layer:invalid-timeInfo-trackIdField", message: "trackIdField is missing", details: { timeInfo: n } }));
+      }
+      n.startTimeField || n.endTimeField || (r.push({ name: "geojson-layer:invalid-timeInfo", message: "startTimeField and endTimeField are missing", details: { timeInfo: n } }), n = null);
+    }
+    const c = p ? X(p) : void 0, j = l.dateFields.length ? { timeZoneIANA: Z } : null, f = { warnings: r, featureErrors: [], layerDefinition: { ...se, drawingInfo: c ?? void 0, templates: ee(y), extent: void 0, geometryType: p, objectIdField: m, fields: o, hasZ: !!d, timeInfo: n, dateFieldsTimeReference: j } };
+    this._queryEngine = new H({ fieldsIndex: k.fromLayerJSON({ fields: o, timeInfo: n, dateFieldsTimeReference: j }), geometryType: p, hasM: !1, hasZ: d, objectIdField: m, spatialReference: h, timeInfo: n, featureStore: new W({ geometryType: p, hasM: !1, hasZ: d }), cacheSpatialQueries: !0 });
+    const q = this._queryEngine.fieldsIndex.requiredFields.indexOf(u);
+    q > -1 && this._queryEngine.fieldsIndex.requiredFields.splice(q, 1), this._createDefaultAttributes = te(y, m);
+    const x = await this._createFeatures(i);
+    this._objectIdGenerator = this._createObjectIdGenerator(this._queryEngine, x);
+    const O = this._normalizeFeatures(x, f.featureErrors);
+    this._queryEngine.featureStore.addMany(O);
+    const { fullExtent: D, timeExtent: S } = await this._queryEngine.fetchRecomputedExtents();
+    if (f.layerDefinition.extent = D, S) {
+      const { start: a, end: g } = S;
+      f.layerDefinition.timeInfo.timeExtent = [a, g];
+    }
+    return f;
+  }
+  async applyEdits(e) {
+    const { spatialReference: t, geometryType: r } = this._queryEngine;
+    return await Promise.all([ie(t, r), E(e.adds, t), E(e.updates, t)]), await this._waitSnapshotComplete(), this._applyEdits(e);
+  }
+  async queryFeatures(e = {}, t = {}) {
+    return await this._waitSnapshotComplete(), this._queryEngine.executeQuery(e, t.signal);
+  }
+  async queryFeatureCount(e = {}, t = {}) {
+    return await this._waitSnapshotComplete(), this._queryEngine.executeQueryForCount(e, t.signal);
+  }
+  async queryObjectIds(e = {}, t = {}) {
+    return await this._waitSnapshotComplete(), this._queryEngine.executeQueryForIds(e, t.signal);
+  }
+  async queryExtent(e = {}, t = {}) {
+    return await this._waitSnapshotComplete(), this._queryEngine.executeQueryForExtent(e, t.signal);
+  }
+  async querySnapping(e, t = {}) {
+    return await this._waitSnapshotComplete(), this._queryEngine.executeQueryForSnapping(e, t.signal);
+  }
+  async refresh(e) {
+    var i;
+    this._loadOptions.customParameters = e, (i = this._snapshotTask) == null || i.abort(), this._snapshotTask = A(this._snapshotFeatures), this._snapshotTask.promise.then((s) => {
+      this._queryEngine.featureStore.clear(), this._objectIdGenerator = this._createObjectIdGenerator(this._queryEngine, s);
+      const o = this._normalizeFeatures(s);
+      o && this._queryEngine.featureStore.addMany(o);
+    }, (s) => {
+      this._queryEngine.featureStore.clear(), G(s) || P.getLogger("esri.layers.GeoJSONLayer").error(new I("geojson-layer:refresh", "An error occurred during refresh", { error: s }));
+    }), await this._waitSnapshotComplete();
+    const { fullExtent: t, timeExtent: r } = await this._queryEngine.fetchRecomputedExtents();
+    return { extent: t, timeExtent: r };
+  }
+  async _createFeatures(e) {
+    if (e == null)
+      return [];
+    const { geometryType: t, hasZ: r, objectIdField: i } = this._queryEngine, s = K(e, { geometryType: t, hasZ: r, objectIdField: i });
+    if (!M(this._queryEngine.spatialReference, _))
+      for (const o of s)
+        o.geometry != null && (o.geometry = z(b(U(o.geometry, this._queryEngine.geometryType, this._queryEngine.hasZ, !1), _, this._queryEngine.spatialReference)));
+    return s;
+  }
+  async _waitSnapshotComplete() {
+    if (this._snapshotTask && !this._snapshotTask.finished) {
+      try {
+        await this._snapshotTask.promise;
+      } catch {
+      }
+      return this._waitSnapshotComplete();
+    }
+  }
+  async _fetch(e) {
+    const { url: t, customParameters: r } = this._loadOptions, i = (await N(t, { responseType: "json", query: { ...r }, signal: e })).data;
+    return Y(i), i;
+  }
+  _normalizeFeatures(e, t) {
+    const { objectIdField: r, fieldsIndex: i } = this._queryEngine, s = [];
+    for (const o of e) {
+      const d = this._createDefaultAttributes(), p = T(i, d, o.attributes, !0);
+      p ? t == null || t.push(p) : (this._assignObjectId(d, o.attributes, !0), o.attributes = d, o.objectId = d[r], s.push(o));
+    }
+    return s;
+  }
+  async _applyEdits(e) {
+    const { adds: t, updates: r, deletes: i } = e, s = { addResults: [], deleteResults: [], updateResults: [], uidToObjectId: {} };
+    if (t != null && t.length && this._applyAddEdits(s, t), r != null && r.length && this._applyUpdateEdits(s, r), i == null ? void 0 : i.length) {
+      for (const p of i)
+        s.deleteResults.push(w(p));
+      this._queryEngine.featureStore.removeManyById(i);
+    }
+    const { fullExtent: o, timeExtent: d } = await this._queryEngine.fetchRecomputedExtents();
+    return { extent: o, timeExtent: d, featureEditResults: s };
+  }
+  _applyAddEdits(e, t) {
+    const { addResults: r } = e, { geometryType: i, hasM: s, hasZ: o, objectIdField: d, spatialReference: p, featureStore: m, fieldsIndex: h } = this._queryEngine, n = [];
+    for (const l of t) {
+      if (l.geometry && i !== R(l.geometry)) {
+        r.push(F("Incorrect geometry type."));
+        continue;
+      }
+      const u = this._createDefaultAttributes(), y = T(h, u, l.attributes);
+      if (y)
+        r.push(y);
+      else {
+        if (this._assignObjectId(u, l.attributes), l.attributes = u, l.uid != null) {
+          const c = l.attributes[d];
+          e.uidToObjectId[l.uid] = c;
+        }
+        if (l.geometry != null) {
+          const c = l.geometry.spatialReference ?? p;
+          l.geometry = b($(l.geometry, c), c, p);
+        }
+        n.push(l), r.push(w(l.attributes[d]));
+      }
+    }
+    m.addMany(B([], n, i, o, s, d));
+  }
+  _applyUpdateEdits({ updateResults: e }, t) {
+    const { geometryType: r, hasM: i, hasZ: s, objectIdField: o, spatialReference: d, featureStore: p, fieldsIndex: m } = this._queryEngine;
+    for (const h of t) {
+      const { attributes: n, geometry: l } = h, u = n == null ? void 0 : n[o];
+      if (u == null) {
+        e.push(F(`Identifier field ${o} missing`));
+        continue;
+      }
+      if (!p.has(u)) {
+        e.push(F(`Feature with object id ${u} missing`));
+        continue;
+      }
+      const y = J(p.getFeature(u), r, s, i);
+      if (l != null) {
+        if (r !== R(l)) {
+          e.push(F("Incorrect geometry type."));
+          continue;
+        }
+        const c = l.spatialReference ?? d;
+        y.geometry = b($(l, c), c, d);
+      }
+      if (n) {
+        const c = T(m, y.attributes, n);
+        if (c) {
+          e.push(c);
+          continue;
+        }
+      }
+      p.add(L(y, r, s, i, o)), e.push(w(u));
+    }
+  }
+  _createObjectIdGenerator(e, t) {
+    const r = e.fieldsIndex.get(e.objectIdField);
+    if (r.type === "esriFieldTypeString")
+      return () => r.name + "-" + Date.now().toString(16);
+    let i = Number.NEGATIVE_INFINITY;
+    for (const s of t)
+      s.objectId && (i = Math.max(i, s.objectId));
+    return i = Math.max(0, i) + 1, () => i++;
+  }
+  _assignObjectId(e, t, r = !1) {
+    const i = this._queryEngine.objectIdField;
+    e[i] = r && i in t ? t[i] : this._objectIdGenerator();
+  }
+  async _checkProjection(e) {
+    try {
+      await E(_, e);
+    } catch {
+      throw new I("geojson-layer", "Projection not supported");
+    }
+  }
+}
+export {
+  Ae as default
+};

package/dist/GeoRSSLayer-320f17b2.js

@@ -0,0 +1,73 @@
+import { d4 as p, bO as y, U as u, dl as m, c9 as d, e as o, y as i, c5 as c, b3 as h, c as S, dV as n, aa as f, dW as g, a9 as v, ab as b, a_ as C } from "./index-a8d87ec0.js";
+import { m as G } from "./MultiOriginJSONSupport-ec8788e6.js";
+import { n as _ } from "./BlendLayer-ced1717f.js";
+import { u as P } from "./OperationalLayer-d43d80b1.js";
+import { j as w } from "./PortalLayer-daca6a23.js";
+import { f as x } from "./RefreshableLayer-a0708abb.js";
+import { t as R } from "./ScaleRangeLayer-dc6d9c0e.js";
+import { I as k, c as $, d as j } from "./commonProperties-3f86f534.js";
+import "vue";
+import "./jsonUtils-34961e68.js";
+import "./parser-65ddb097.js";
+import "./portalItemUtils-052627b4.js";
+import "./ElevationInfo-a456026a.js";
+import "./unitConversionUtils-df3ffd70.js";
+import "./lengthUtils-7339106c.js";
+const F = ["atom", "xml"], E = { base: n, key: "type", typeMap: { "simple-line": f }, errorContext: "symbol" }, M = { base: n, key: "type", typeMap: { "picture-marker": g, "simple-marker": v }, errorContext: "symbol" }, L = { base: n, key: "type", typeMap: { "simple-fill": b }, errorContext: "symbol" };
+let t = class extends _(x(P(w(R(G(C)))))) {
+  constructor(...e) {
+    super(...e), this.description = null, this.fullExtent = null, this.legendEnabled = !0, this.lineSymbol = null, this.pointSymbol = null, this.polygonSymbol = null, this.operationalLayerType = "GeoRSS", this.url = null, this.type = "geo-rss";
+  }
+  normalizeCtorArgs(e, r) {
+    return typeof e == "string" ? { url: e, ...r } : e;
+  }
+  readFeatureCollections(e, r) {
+    return r.featureCollection.layers.forEach((s) => {
+      var a;
+      const l = s.layerDefinition.drawingInfo.renderer.symbol;
+      l && l.type === "esriSFS" && ((a = l.outline) != null && a.style.includes("esriSFS")) && (l.outline.style = "esriSLSSolid");
+    }), r.featureCollection.layers;
+  }
+  get hasPoints() {
+    return this._hasGeometry("esriGeometryPoint");
+  }
+  get hasPolylines() {
+    return this._hasGeometry("esriGeometryPolyline");
+  }
+  get hasPolygons() {
+    return this._hasGeometry("esriGeometryPolygon");
+  }
+  get title() {
+    const e = this._get("title");
+    return e && this.originOf("title") !== "defaults" ? e : this.url ? p(this.url, F) || "GeoRSS" : e || "";
+  }
+  set title(e) {
+    this._set("title", e);
+  }
+  load(e) {
+    const r = e != null ? e.signal : null;
+    return this.addResolvingPromise(this.loadFromPortal({ supportedTypes: ["Map Service", "Feature Service", "Feature Collection", "Scene Service"] }, e).catch(y).then(() => this._fetchService(r)).then((s) => {
+      this.read(s, { origin: "service" });
+    })), Promise.resolve(this);
+  }
+  async hasDataChanged() {
+    const e = await this._fetchService();
+    return this.read(e, { origin: "service", ignoreDefaults: !0 }), !0;
+  }
+  async _fetchService(e) {
+    const r = this.spatialReference, { data: s } = await u(d.geoRSSServiceUrl, { query: { url: this.url, refresh: !!this.loaded || void 0, outSR: m(r) ? void 0 : r.wkid ?? JSON.stringify(r) }, signal: e });
+    return s;
+  }
+  _hasGeometry(e) {
+    var r;
+    return ((r = this.featureCollections) == null ? void 0 : r.some((s) => {
+      var l, a;
+      return ((l = s.featureSet) == null ? void 0 : l.geometryType) === e && ((a = s.featureSet.features) == null ? void 0 : a.length) > 0;
+    })) ?? !1;
+  }
+};
+o([i()], t.prototype, "description", void 0), o([i()], t.prototype, "featureCollections", void 0), o([c("service", "featureCollections", ["featureCollection.layers"])], t.prototype, "readFeatureCollections", null), o([i({ type: h, json: { name: "lookAtExtent" } })], t.prototype, "fullExtent", void 0), o([i(k)], t.prototype, "id", void 0), o([i($)], t.prototype, "legendEnabled", void 0), o([i({ types: E, json: { write: !0 } })], t.prototype, "lineSymbol", void 0), o([i({ type: ["show", "hide"] })], t.prototype, "listMode", void 0), o([i({ types: M, json: { write: !0 } })], t.prototype, "pointSymbol", void 0), o([i({ types: L, json: { write: !0 } })], t.prototype, "polygonSymbol", void 0), o([i({ type: ["GeoRSS"] })], t.prototype, "operationalLayerType", void 0), o([i(j)], t.prototype, "url", void 0), o([i({ json: { origins: { service: { read: { source: "name", reader: (e) => e || void 0 } } } } })], t.prototype, "title", null), o([i({ readOnly: !0, json: { read: !1 }, value: "geo-rss" })], t.prototype, "type", void 0), t = o([S("esri.layers.GeoRSSLayer")], t);
+const Q = t;
+export {
+  Q as default
+};

package/dist/GeoRSSLayerView2D-4683eb47.js

@@ -0,0 +1,140 @@
+import { o as l, P as h, V as g, w, e as f, c as d } from "./index-a8d87ec0.js";
+import { t as u, m as n } from "./jsonUtils-65dc6fdf.js";
+import { d as V } from "./FeatureSet-29d82bc9.js";
+import { m as b, u as S } from "./LayerView-2b3b1a70.js";
+import { t as _ } from "./GraphicContainer-9bd07fb2.js";
+import { $ as T } from "./GraphicsView2D-3103ed12.js";
+import "vue";
+import "./UniqueValueRenderer-56a91680.js";
+import "./ColorStop-81b2ebbf.js";
+import "./diffUtils-b887dbbc.js";
+import "./colorRamps-4ea8b8f7.js";
+import "./sizeVariableUtils-a1b694d8.js";
+import "./visualVariableUtils-d45d2e59.js";
+import "./lengthUtils-7339106c.js";
+import "./jsonUtils-980c608d.js";
+import "./styleUtils-52e000d6.js";
+import "./LRUCache-948c7d75.js";
+import "./MemCache-1532e921.js";
+import "./Version-9c75ca2b.js";
+import "./FieldsIndex-7d8f3589.js";
+import "./UnknownTimeZone-e62caf07.js";
+import "./OverrideHelper-880a7e09.js";
+import "./colorUtils-611a3fa1.js";
+import "./vec42-d5675dd5.js";
+import "./vec4f64-043e974c.js";
+import "./utils-a7d5b733.js";
+import "./quantizationUtils-4616cce9.js";
+import "./heatmapUtils-582b52e1.js";
+import "./scaleUtils-6153583e.js";
+import "./Container-5cca9103.js";
+import "./parser-65ddb097.js";
+import "./highlightReasons-6f0f9ef6.js";
+import "./definitions-a00a3a6c.js";
+import "./enums-2c166c09.js";
+import "./Texture-b28260ca.js";
+import "./AGraphicContainer-b6e32ab3.js";
+import "./TechniqueInstance-9c0d4dcf.js";
+import "./UpdateTracking2D-bf4e8a89.js";
+import "./TurboLine-87dd880a.js";
+import "./enums-fa8f05ab.js";
+import "./earcut-da8e2a55.js";
+import "./GeometryUtils-b855940e.js";
+import "./OptimizedGeometry-3b808152.js";
+import "./Rect-894f011c.js";
+import "./LabelMetric-39280634.js";
+import "./Program-8b1e5f48.js";
+import "./BufferObject-6f0ccf08.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./defaults-f025f8a3.js";
+import "./defaultsJSON-ba17aa15.js";
+import "./BindType-5e76c8e1.js";
+import "./Util-6762e3c9.js";
+import "./constants-5bd557fe.js";
+import "./TileContainer-09ca940a.js";
+import "./WGLContainer-f2c4f5da.js";
+import "./VertexArrayObject-e736d4c8.js";
+import "./vec4f32-b2628ced.js";
+import "./ProgramTemplate-e4360f44.js";
+import "./StyleDefinition-f4862d5a.js";
+import "./config-61215215.js";
+import "./featureConversionUtils-8fd0a407.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./FeatureCommandQueue-d1572e0d.js";
+import "./vec3f32-304a6a9c.js";
+import "./AttributeStore-f80857be.js";
+import "./labelUtils-333abe25.js";
+import "./TimeOnly-bb600899.js";
+import "./timeSupport-3ddd7e4b.js";
+import "./json-5febf88a.js";
+import "./normalizeUtilsSync-71d587bd.js";
+let y = class extends b(S) {
+  constructor() {
+    super(...arguments), this._graphicsViewMap = {}, this._popupTemplates = /* @__PURE__ */ new Map(), this.graphicsViews = [];
+  }
+  async hitTest(t, o) {
+    if (!this.graphicsViews.length)
+      return null;
+    const e = this.layer;
+    return this.graphicsViews.reverse().flatMap((r) => {
+      const i = this._popupTemplates.get(r), s = r.hitTest(t);
+      for (const p of s)
+        p.layer = e, p.sourceLayer = e, p.popupTemplate = i;
+      return s;
+    }).map((r) => ({ type: "graphic", graphic: r, layer: e, mapPoint: t }));
+  }
+  update(t) {
+    if (this.graphicsViews)
+      for (const o of this.graphicsViews)
+        o.processUpdate(t);
+  }
+  attach() {
+    this.addAttachHandles([l(() => {
+      var t;
+      return (t = this.layer) == null ? void 0 : t.featureCollections;
+    }, (t) => {
+      this._clear();
+      for (const { popupInfo: o, featureSet: e, layerDefinition: r } of t) {
+        const i = V.fromJSON(e), s = new g(i.features), p = r.drawingInfo, c = o ? w.fromJSON(o) : null, m = u(p.renderer), a = new T({ requestUpdateCallback: () => this.requestUpdate(), view: this.view, graphics: s, renderer: m, container: new _(this.view.featuresTilingScheme) });
+        this._graphicsViewMap[i.geometryType] = a, this._popupTemplates.set(a, c), i.geometryType !== "polygon" || this.layer.polygonSymbol ? i.geometryType !== "polyline" || this.layer.lineSymbol ? i.geometryType !== "point" || this.layer.pointSymbol || (this.layer.pointSymbol = m.symbol) : this.layer.lineSymbol = m.symbol : this.layer.polygonSymbol = m.symbol, this.graphicsViews.push(a), this.container.addChild(a.container);
+      }
+    }, h), l(() => {
+      var t;
+      return (t = this.layer) == null ? void 0 : t.polygonSymbol;
+    }, (t) => {
+      this._graphicsViewMap.polygon.renderer = new n({ symbol: t });
+    }, h), l(() => {
+      var t;
+      return (t = this.layer) == null ? void 0 : t.lineSymbol;
+    }, (t) => {
+      this._graphicsViewMap.polyline.renderer = new n({ symbol: t });
+    }, h), l(() => {
+      var t;
+      return (t = this.layer) == null ? void 0 : t.pointSymbol;
+    }, (t) => {
+      this._graphicsViewMap.point.renderer = new n({ symbol: t });
+    }, h)]);
+  }
+  detach() {
+    this._clear();
+  }
+  moveStart() {
+  }
+  moveEnd() {
+  }
+  viewChange() {
+    for (const t of this.graphicsViews)
+      t.viewChange();
+  }
+  _clear() {
+    this.container.removeAllChildren();
+    for (const t of this.graphicsViews)
+      t.destroy();
+    this._graphicsViewMap = {}, this._popupTemplates.clear(), this.graphicsViews.length = 0;
+  }
+};
+y = f([d("esri.views.2d.layers.GeoRSSLayerView2D")], y);
+const Et = y;
+export {
+  Et as default
+};