@agrotools1/at-components 0.2.5 → 0.2.8-5

package/dist/ImageryLayerView2D-f1c342ad.js

@@ -0,0 +1,352 @@
+import { e as a, y as o, c as v, S as R, i as b, s as _, z as P, k as A, b3 as B, o as f, fG as F, U as I, e7 as U, W as V, bJ as C, by as M, a$ as $, d as L, eD as E, V as S, g as q, aO as O } from "./index-a450f76b.js";
+import { d as j, f as H, a as N } from "./RasterVFDisplayObject-573f0530.js";
+import { m as G, u as J } from "./LayerView-2a8c8edc.js";
+import { $ as W } from "./GraphicsView2D-5c69cd54.js";
+import { h as K } from "./HighlightGraphicContainer-5887470a.js";
+import { M as Q, m as X, f as Y } from "./dataUtils-efd5edf8.js";
+import { a as Z } from "./BitmapContainer-ac2e261c.js";
+import { h as tt, E as D } from "./Container-879e59ef.js";
+import { l as et } from "./Bitmap-625c3ae1.js";
+import { v as it } from "./ExportStrategy-a42be397.js";
+import { J as rt } from "./rasterProjectionHelper-9e69c84d.js";
+import { n as st } from "./WGLContainer-f4c4a8dc.js";
+import { j as at } from "./commonProperties-7d8f6b56.js";
+import { p as ot } from "./popupUtils-8f261298.js";
+import { i as nt } from "./RefreshableLayerView-19c8ff47.js";
+import "vue";
+import "./BufferObject-faafd842.js";
+import "./Texture-08e8abdd.js";
+import "./enums-2c166c09.js";
+import "./VertexArrayObject-4c6a6897.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./LabelMetric-a3f892e4.js";
+import "./enums-fa8f05ab.js";
+import "./Program-5b5c8288.js";
+import "./scaleUtils-7e908168.js";
+import "./FieldsIndex-fd635f39.js";
+import "./UnknownTimeZone-832b690f.js";
+import "./UpdateTracking2D-881e1d79.js";
+import "./TurboLine-cb0c9eaa.js";
+import "./definitions-a00a3a6c.js";
+import "./earcut-1a1bdd2c.js";
+import "./GeometryUtils-42ae242b.js";
+import "./OptimizedGeometry-3b808152.js";
+import "./utils-5a4ac69c.js";
+import "./Rect-894f011c.js";
+import "./defaults-3495cefd.js";
+import "./defaultsJSON-ba17aa15.js";
+import "./BindType-5e76c8e1.js";
+import "./Util-b8d78341.js";
+import "./vec42-1641eab7.js";
+import "./vec4f64-043e974c.js";
+import "./highlightReasons-23d6c956.js";
+import "./constants-5bd557fe.js";
+import "./OverrideHelper-f9ba3c94.js";
+import "./colorUtils-1a8cc2f8.js";
+import "./quantizationUtils-dde8a0c2.js";
+import "./AttributeStore-2f8bce1a.js";
+import "./labelUtils-17e6e19c.js";
+import "./TimeOnly-40ea9bb9.js";
+import "./timeSupport-2eb266be.js";
+import "./featureConversionUtils-8635d4bd.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./json-5febf88a.js";
+import "./diffUtils-cccaeaa2.js";
+import "./FeatureCommandQueue-68735fa7.js";
+import "./lengthUtils-15c44621.js";
+import "./normalizeUtilsSync-90304e5d.js";
+import "./AGraphicContainer-232b465f.js";
+import "./TechniqueInstance-f272ce92.js";
+import "./TileContainer-6b12d8e1.js";
+import "./vec3f32-304a6a9c.js";
+import "./parser-54b64f9a.js";
+import "./vec4f32-b2628ced.js";
+import "./ProgramTemplate-62d54e1b.js";
+import "./StyleDefinition-f4862d5a.js";
+import "./config-61215215.js";
+import "./ElevationInfo-016cc1c4.js";
+import "./unitConversionUtils-ad9151e0.js";
+let h = class extends R {
+  constructor() {
+    super(...arguments), this.attached = !1, this.container = new tt(), this.updateRequested = !1, this.type = "imagery", this._bitmapView = new Z();
+  }
+  destroy() {
+    this.attached && (this.detach(), this.attached = !1), this.updateRequested = !1;
+  }
+  get updating() {
+    return !this.attached || this.isUpdating();
+  }
+  update(t) {
+    this.strategy.update(t).catch((e) => {
+      b(e) || _.getLogger(this).error(e);
+    });
+  }
+  hitTest(t) {
+    return new P({ attributes: {}, geometry: t.clone(), layer: this.layer });
+  }
+  attach() {
+    this.container.addChild(this._bitmapView);
+    const t = this.layer.version >= 10, e = this.layer.version >= 10.1 ? this.layer.imageMaxHeight : 2048, i = this.layer.version >= 10.1 ? this.layer.imageMaxWidth : 2048;
+    this.strategy = new it({ container: this._bitmapView, imageNormalizationSupported: t, imageMaxHeight: e, imageMaxWidth: i, fetchSource: this._fetchImage.bind(this), requestUpdate: () => this.requestUpdate() });
+  }
+  detach() {
+    this.strategy.destroy(), this._bitmapView.removeAllChildren(), this.container.removeAllChildren(), this.updateRequested = !1;
+  }
+  redraw() {
+    this.strategy.updateExports(async (t) => {
+      const { source: e } = t;
+      if (!e || e instanceof ImageBitmap)
+        return;
+      const i = await this.layer.applyRenderer({ extent: e.extent, pixelBlock: e.originalPixelBlock ?? e.pixelBlock });
+      e.filter = (r) => this.layer.pixelFilter ? this.layer.applyFilter(r) : { ...i, extent: e.extent };
+    }).catch((t) => {
+      b(t) || _.getLogger(this).error(t);
+    });
+  }
+  requestUpdate() {
+    this.updateRequested || (this.updateRequested = !0, this.view.requestUpdate());
+  }
+  isUpdating() {
+    return this.strategy.updating || this.updateRequested;
+  }
+  getPixelData() {
+    if (this.updating)
+      return null;
+    const t = this.strategy.bitmaps;
+    if (t.length === 1 && t[0].source)
+      return { extent: t[0].source.extent, pixelBlock: t[0].source.originalPixelBlock };
+    if (t.length > 1) {
+      const e = this.view.extent, i = t.map((s) => s.source).filter((s) => s.extent && s.extent.intersects(e)).map((s) => ({ extent: s.extent, pixelBlock: s.originalPixelBlock })), r = Q(i, e);
+      return r != null ? { extent: r.extent, pixelBlock: r.pixelBlock } : null;
+    }
+    return null;
+  }
+  async _fetchImage(t, e, i, r) {
+    var c;
+    (r = r || {}).timeExtent = this.timeExtent, r.requestAsImageElement = !0, r.returnImageBitmap = !0;
+    const s = await this.layer.fetchImage(t, e, i, r);
+    if (s.imageBitmap)
+      return s.imageBitmap;
+    const n = await this.layer.applyRenderer(s.pixelData, { signal: r.signal }), l = new et(n.pixelBlock, (c = n.extent) == null ? void 0 : c.clone(), s.pixelData.pixelBlock);
+    return l.filter = (p) => this.layer.applyFilter(p), l;
+  }
+};
+a([o()], h.prototype, "attached", void 0), a([o()], h.prototype, "container", void 0), a([o()], h.prototype, "layer", void 0), a([o()], h.prototype, "strategy", void 0), a([o()], h.prototype, "timeExtent", void 0), a([o()], h.prototype, "view", void 0), a([o()], h.prototype, "updateRequested", void 0), a([o()], h.prototype, "updating", null), a([o()], h.prototype, "type", void 0), h = a([v("esri.views.2d.layers.imagery.ImageryView2D")], h);
+const lt = h;
+class ht extends st {
+  constructor() {
+    super(...arguments), this.symbolTypes = ["triangle"];
+  }
+  prepareRenderPasses(e) {
+    const i = e.registerRenderPass({ name: "imagery (vf)", brushes: [j], target: () => this.children, drawPhase: D.MAP });
+    return [...super.prepareRenderPasses(e), i];
+  }
+  doRender(e) {
+    this.visible && e.drawPhase === D.MAP && this.symbolTypes.forEach((i) => {
+      e.renderPass = i, super.doRender(e);
+    });
+  }
+}
+let y = class extends R {
+  constructor(t) {
+    super(t), this._loading = null, this.update = A((e, i) => this._update(e, i).catch((r) => {
+      b(r) || _.getLogger(this).error(r);
+    }));
+  }
+  get updating() {
+    return !!this._loading;
+  }
+  redraw(t) {
+    if (!this.container.children.length)
+      return;
+    const e = this.container.children[0];
+    e.symbolizerParameters = t, e.invalidateVAO(), this.container.symbolTypes = t.style === "wind_speed" ? ["scalar", "triangle"] : t.style === "simple_scalar" ? ["scalar"] : ["triangle"], this.container.requestRender();
+  }
+  async _update(t, e, i) {
+    if (!t.stationary)
+      return;
+    const { extent: r, spatialReference: s } = t.state, n = new B({ xmin: r.xmin, ymin: r.ymin, xmax: r.xmax, ymax: r.ymax, spatialReference: s }), [l, c] = t.state.size;
+    this._loading = this.fetchPixels(n, l, c, i);
+    const p = await this._loading;
+    this._addToDisplay(p, e, t.state), this._loading = null;
+  }
+  _addToDisplay(t, e, i) {
+    if (t.pixelBlock == null)
+      return this.container.children.forEach((l) => l.destroy()), void this.container.removeAllChildren();
+    const { extent: r, pixelBlock: s } = t, n = new H(s);
+    n.offset = [0, 0], n.symbolizerParameters = e, n.rawPixelData = t, n.invalidateVAO(), n.x = r.xmin, n.y = r.ymax, n.pixelRatio = i.pixelRatio, n.rotation = i.rotation, n.resolution = i.resolution, n.width = s.width * e.symbolTileSize, n.height = s.height * e.symbolTileSize, this.container.children.forEach((l) => l.destroy()), this.container.removeAllChildren(), this.container.symbolTypes = e.style === "wind_speed" ? ["scalar", "triangle"] : e.style === "simple_scalar" ? ["scalar"] : ["triangle"], this.container.addChild(n);
+  }
+};
+a([o()], y.prototype, "fetchPixels", void 0), a([o()], y.prototype, "container", void 0), a([o()], y.prototype, "_loading", void 0), a([o()], y.prototype, "updating", null), y = a([v("esri.views.2d.layers.imagery.ImageryVFStrategy")], y);
+const pt = y;
+let m = class extends R {
+  constructor() {
+    super(...arguments), this.attached = !1, this.container = new ht(), this.type = "imageryVF", this._dataParameters = { exportParametersVersion: 0, bbox: "", symbolTileSize: 0, time: "" }, this._fetchpixels = async (t, e, i, r) => {
+      const s = await this._projectFullExtentPromise, { symbolTileSize: n } = this.layer.renderer, { extent: l, width: c, height: p } = X(t, e, i, n, s);
+      if (s != null && !s.intersects(t))
+        return { extent: l, pixelBlock: null };
+      const d = { bbox: `${l.xmin}, ${l.ymin}, ${l.xmax}, ${l.ymax}`, exportParametersVersion: this.layer.exportImageServiceParameters.version, symbolTileSize: n, time: JSON.stringify(this.timeExtent || "") };
+      if (this._canReuseVectorFieldData(d)) {
+        const u = this.getPixelData();
+        if (u != null && `${u.extent.xmin}, ${u.extent.ymin}, ${u.extent.xmax}, ${u.extent.ymax}` === d.bbox)
+          return u;
+      }
+      const { pixelData: g } = await this.layer.fetchImage(l, c, p, { timeExtent: this.timeExtent, requestAsImageElement: !1, signal: r });
+      this._dataParameters = d;
+      const x = g == null ? void 0 : g.pixelBlock;
+      return x == null ? { extent: l, pixelBlock: null } : { extent: l, pixelBlock: this.layer.rasterInfo.dataType === "vector-uv" ? Y(x, "vector-uv") : x };
+    };
+  }
+  get updating() {
+    return !this.attached || this._strategy.updating;
+  }
+  attach() {
+    this._projectFullExtentPromise = this._getProjectedFullExtent(this.view.spatialReference), this._strategy = new pt({ container: this.container, fetchPixels: this._fetchpixels }), this.addHandles(f(() => this.layer.renderer, (t) => this._updateSymbolizerParams(t), F), "attach");
+  }
+  detach() {
+    this._strategy.destroy(), this.container.children.forEach((t) => t.destroy()), this.container.removeAllChildren(), this.removeHandles("attach"), this._strategy = this.container = this._projectFullExtentPromise = null;
+  }
+  getPixelData() {
+    var r;
+    const t = (r = this.container.children[0]) == null ? void 0 : r.rawPixelData;
+    if (this.updating || !t)
+      return null;
+    const { extent: e, pixelBlock: i } = t;
+    return { extent: e, pixelBlock: i };
+  }
+  hitTest(t) {
+    return new P({ attributes: {}, geometry: t.clone(), layer: this.layer });
+  }
+  update(t) {
+    this._strategy.update(t, this._symbolizerParams).catch((e) => {
+      b(e) || _.getLogger(this).error(e);
+    });
+  }
+  redraw() {
+    const { renderer: t } = this.layer;
+    t && (this._updateSymbolizerParams(t), this._strategy.redraw(this._symbolizerParams));
+  }
+  _canReuseVectorFieldData(t) {
+    const e = this._dataParameters.exportParametersVersion === t.exportParametersVersion, i = this._dataParameters.time === t.time, r = this._dataParameters.symbolTileSize === t.symbolTileSize, s = this._dataParameters.bbox === t.bbox;
+    return e && i && r && s;
+  }
+  async _getProjectedFullExtent(t) {
+    try {
+      return rt(this.layer.fullExtent, t);
+    } catch {
+      try {
+        const i = (await I(this.layer.url, { query: { option: "footprints", outSR: U(t), f: "json" } })).data.featureCollection.layers[0].layerDefinition.extent;
+        return i ? B.fromJSON(i) : null;
+      } catch {
+        return null;
+      }
+    }
+  }
+  _updateSymbolizerParams(t) {
+    t.type === "vector-field" && (this._symbolizerParams = this.layer.symbolizer.generateWebGLParameters({ pixelBlock: null }));
+  }
+};
+a([o()], m.prototype, "attached", void 0), a([o()], m.prototype, "container", void 0), a([o()], m.prototype, "layer", void 0), a([o()], m.prototype, "timeExtent", void 0), a([o()], m.prototype, "type", void 0), a([o()], m.prototype, "view", void 0), a([o()], m.prototype, "updating", null), m = a([v("esri.views.2d.layers.imagery.VectorFieldView2D")], m);
+const mt = m, ct = (t) => {
+  let e = class extends t {
+    constructor() {
+      super(...arguments), this.view = null;
+    }
+    async fetchPopupFeaturesAtLocation(i, r) {
+      const { layer: s } = this;
+      if (!i)
+        throw new V("imagerylayerview:fetchPopupFeatures", "Nothing to fetch without area", { layer: s });
+      const { popupEnabled: n } = s, l = ot(s, r);
+      if (!n || l == null)
+        throw new V("imagerylayerview:fetchPopupFeatures", "Missing required popupTemplate or popupEnabled", { popupEnabled: n, popupTemplate: l });
+      const c = await l.getRequiredFields();
+      C(r);
+      const p = new M();
+      p.timeExtent = this.timeExtent, p.geometry = i, p.outFields = c, p.outSpatialReference = i.spatialReference;
+      const { resolution: d, spatialReference: g } = this.view, x = this.view.type === "2d" ? new $(d, d, g) : new $(0.5 * d, 0.5 * d, g), { returnTopmostRaster: u, showNoDataRecords: k } = l.layerOptions || { returnTopmostRaster: !0, showNoDataRecords: !1 }, T = { returnDomainValues: !0, returnTopmostRaster: u, pixelSize: x, showNoDataRecords: k, signal: r == null ? void 0 : r.signal };
+      return s.queryVisibleRasters(p, T).then((z) => z);
+    }
+    canResume() {
+      var i;
+      return !!super.canResume() && !((i = this.timeExtent) != null && i.isEmpty);
+    }
+  };
+  return a([o()], e.prototype, "layer", void 0), a([o()], e.prototype, "suspended", void 0), a([o(at)], e.prototype, "timeExtent", void 0), a([o()], e.prototype, "view", void 0), e = a([v("esri.views.layers.ImageryLayerView")], e), e;
+};
+let w = class extends ct(nt(G(J))) {
+  constructor() {
+    super(...arguments), this._exportImageVersion = -1, this._highlightGraphics = new L(), this._highlightView = void 0, this.layer = null, this.subview = null;
+  }
+  get pixelData() {
+    const { subview: t } = this;
+    return this.updating || !t ? null : "getPixelData" in t ? t.getPixelData() : null;
+  }
+  update(t) {
+    var e;
+    (e = this.subview) == null || e.update(t);
+  }
+  attach() {
+    this.layer.increaseRasterJobHandlerUsage(), this._setSubView(), this.view && (this._highlightView = new W({ view: this.view, graphics: this._highlightGraphics, requestUpdateCallback: () => this.requestUpdate(), container: new K(this.view.featuresTilingScheme) }), this.container.addChild(this._highlightView.container)), this.addAttachHandles([f(() => this.layer.exportImageServiceParameters.version, (t) => {
+      t && this._exportImageVersion !== t && (this._exportImageVersion = t, this.requestUpdate());
+    }, E), f(() => this.timeExtent, (t) => {
+      const { subview: e } = this;
+      e && (e.timeExtent = t, "redraw" in e ? this.requestUpdate() : e.redrawOrRefetch());
+    }, E), this.layer.on("redraw", () => {
+      const { subview: t } = this;
+      t && ("redraw" in t ? t.redraw() : t.redrawOrRefetch());
+    }), f(() => this.layer.renderer, () => this._setSubView())]);
+  }
+  detach() {
+    var t, e;
+    this.layer.decreaseRasterJobHandlerUsage(), this.container.removeAllChildren(), this._detachSubview(this.subview), (t = this.subview) == null || t.destroy(), this.subview = null, (e = this._highlightView) == null || e.destroy(), this._exportImageVersion = -1;
+  }
+  moveStart() {
+  }
+  viewChange() {
+  }
+  moveEnd() {
+    this.requestUpdate();
+  }
+  highlight(t, e) {
+    if (!((Array.isArray(t) ? t[0] : S.isCollection(t) ? t.at(0) : t) instanceof P))
+      return q();
+    let i = [];
+    return Array.isArray(t) || S.isCollection(t) ? i = t.map((r) => r.clone()) : t instanceof P && (i = [t.clone()]), this._highlightGraphics.addMany(i), q(() => this._highlightGraphics.removeMany(i));
+  }
+  async doRefresh() {
+    this.requestUpdate();
+  }
+  isUpdating() {
+    var e, i;
+    const t = !this.subview || this.subview.updating || !!((e = this._highlightView) != null && e.updating);
+    return O("esri-2d-log-updating") && console.log(`Updating ImageryLayerView2D (${this.layer.id}): ${t}
+-> subview ${!this.subview || this.subview.updating}
+-> higlightView ${(i = this._highlightView) == null ? void 0 : i.updating}
+`), t;
+  }
+  _setSubView() {
+    var i, r;
+    if (!this.view)
+      return;
+    const t = (i = this.layer.renderer) == null ? void 0 : i.type;
+    let e = "imagery";
+    if (t === "vector-field" ? e = "imageryVF" : t === "flow" && (e = "flow"), this.subview) {
+      const { type: s } = this.subview;
+      if (s === e)
+        return this._attachSubview(this.subview), void (s === "flow" ? this.subview.redrawOrRefetch() : s === "imagery" && this.layer.format === "lerc" ? this.subview.redraw() : this.requestUpdate());
+      this._detachSubview(this.subview), (r = this.subview) == null || r.destroy();
+    }
+    this.subview = e === "imagery" ? new lt({ layer: this.layer, view: this.view, timeExtent: this.timeExtent }) : e === "imageryVF" ? new mt({ layer: this.layer, view: this.view, timeExtent: this.timeExtent }) : new N({ layer: this.layer, layerView: this }), this._attachSubview(this.subview), this.requestUpdate();
+  }
+  _attachSubview(t) {
+    t && !t.attached && (t.attach(), t.attached = !0, this.container.addChildAt(t.container, 0));
+  }
+  _detachSubview(t) {
+    t != null && t.attached && (this.container.removeChild(t.container), t.detach(), t.attached = !1);
+  }
+};
+a([o()], w.prototype, "pixelData", null), a([o()], w.prototype, "subview", void 0), w = a([v("esri.views.2d.layers.ImageryLayerView2D")], w);
+const Ee = w;
+export {
+  Ee as default
+};