@agrotools1/at-components 0.2.5 → 0.2.8-5

package/dist/TileContainer-6b12d8e1.js

@@ -0,0 +1,31 @@
+import { aO as l } from "./index-a450f76b.js";
+import { E as n } from "./Container-879e59ef.js";
+import { n as i, _ as a, y as o } from "./WGLContainer-f4c4a8dc.js";
+const c = (s, e) => s.key.level - e.key.level != 0 ? s.key.level - e.key.level : s.key.row - e.key.row != 0 ? s.key.row - e.key.row : s.key.col - e.key.col;
+class f extends i {
+  constructor(e) {
+    super(), this._tileInfoView = e;
+  }
+  renderChildren(e) {
+    this.sortChildren(c), this.setStencilReference(e), super.renderChildren(e);
+  }
+  createRenderParams(e) {
+    const { state: r } = e, t = super.createRenderParams(e);
+    return t.requiredLevel = this._tileInfoView.getClosestInfoForScale(r.scale).level, t.displayLevel = this._tileInfoView.tileInfo.scaleToZoom(r.scale), t;
+  }
+  prepareRenderPasses(e) {
+    const r = super.prepareRenderPasses(e);
+    return r.push(e.registerRenderPass({ name: "stencil", brushes: [a], drawPhase: n.DEBUG | n.MAP | n.HIGHLIGHT | n.LABEL, target: () => this.getStencilTarget() })), l("esri-tiles-debug") && r.push(e.registerRenderPass({ name: "tileInfo", brushes: [o], drawPhase: n.DEBUG, target: () => this.children })), r;
+  }
+  getStencilTarget() {
+    return this.children;
+  }
+  setStencilReference(e) {
+    let r = 1;
+    for (const t of this.children)
+      t.stencilRef = r++;
+  }
+}
+export {
+  f as i
+};

package/dist/TileInfoTilemapCache-b78dac78.js

@@ -0,0 +1,38 @@
+import { c_ as s, W as h, i as r } from "./index-a450f76b.js";
+class f {
+  constructor(i, e = 0, l = i.lods[i.lods.length - 1].level) {
+    this.tileInfo = i, this.minLOD = e, this.maxLOD = l, i.lodAt(e) || (this.minLOD = i.lods[0].level), i.lodAt(l) || (this.maxLOD = i.lods[i.lods.length - 1].level);
+  }
+  get effectiveMinLOD() {
+    return this.minLOD ?? this.tileInfo.lods[0].level;
+  }
+  get effectiveMaxLOD() {
+    return this.maxLOD ?? this.tileInfo.lods[this.tileInfo.lods.length - 1].level;
+  }
+  getAvailability(i, e, l) {
+    var a;
+    const t = (a = this.tileInfo) == null ? void 0 : a.lodAt(i);
+    return !t || i < this.minLOD || i > this.maxLOD ? "unavailable" : t.cols && t.rows ? l >= t.cols[0] && l <= t.cols[1] && e >= t.rows[0] && e <= t.rows[1] ? "unknown" : "unavailable" : "unknown";
+  }
+  async fetchAvailability(i, e, l, t) {
+    await s(t);
+    const a = this.getAvailability(i, e, l);
+    if (a === "unavailable")
+      throw new h("tile-map:tile-unavailable", "Tile is not available", { level: i, row: e, col: l });
+    return a;
+  }
+  async fetchAvailabilityUpsample(i, e, l, t, a) {
+    await s(a), t.level = i, t.row = e, t.col = l;
+    const n = this.tileInfo;
+    return n.updateTileInfo(t), this.fetchAvailability(i, e, l, a).catch((o) => {
+      if (r(o))
+        throw o;
+      if (n.upsampleTile(t))
+        return this.fetchAvailabilityUpsample(t.level, t.row, t.col, t, a);
+      throw o;
+    });
+  }
+}
+export {
+  f as e
+};

package/dist/TileLayer-4db1b607.js

@@ -0,0 +1,194 @@
+import { bO as _, bR as v, cT as S, U as m, eh as T, e8 as b, W as u, bL as w, ci as O, dC as $, dt as R, e as s, y as a, c5 as U, c2 as W, ei as L, c as P, a_ as j } from "./index-a450f76b.js";
+import { m as A } from "./MultiOriginJSONSupport-677c0e5f.js";
+import { i as B } from "./APIKeyMixin-6c797b4c.js";
+import { p as C } from "./ArcGISCachedService-e0930844.js";
+import { m as I, f as M, Y as N } from "./SublayersOwner-dfd52113.js";
+import { l as k } from "./ArcGISService-81baed4d.js";
+import { n as D } from "./BlendLayer-38d68343.js";
+import { e as J } from "./CustomParametersMixin-c281d5e7.js";
+import { u as q } from "./OperationalLayer-96cb1405.js";
+import { j as G } from "./PortalLayer-60c1c36d.js";
+import { f as V } from "./RefreshableLayer-0d1a28eb.js";
+import { t as E } from "./ScaleRangeLayer-d06647e5.js";
+import { d as x } from "./commonProperties-7d8f6b56.js";
+import { o as y } from "./imageBitmapUtils-12016538.js";
+import "vue";
+import "./TileInfoTilemapCache-b78dac78.js";
+import "./TilemapCache-671945d2.js";
+import "./ByteSizeUnit-90df2840.js";
+import "./LRUCache-d9e4b57a.js";
+import "./MemCache-6249a3f0.js";
+import "./Version-014efc62.js";
+import "./portalItemUtils-07c1c29f.js";
+import "./UniqueValueRenderer-e4a27dfc.js";
+import "./ColorStop-d5b563ab.js";
+import "./diffUtils-cccaeaa2.js";
+import "./colorRamps-100595ab.js";
+import "./sizeVariableUtils-a1b694d8.js";
+import "./visualVariableUtils-7ae62b11.js";
+import "./lengthUtils-15c44621.js";
+import "./jsonUtils-dbeb4b10.js";
+import "./styleUtils-31e64784.js";
+import "./jsonUtils-59cbda09.js";
+import "./FieldsIndex-fd635f39.js";
+import "./UnknownTimeZone-832b690f.js";
+import "./OverrideHelper-f9ba3c94.js";
+import "./colorUtils-1a8cc2f8.js";
+import "./vec42-1641eab7.js";
+import "./vec4f64-043e974c.js";
+import "./utils-5a4ac69c.js";
+import "./quantizationUtils-dde8a0c2.js";
+import "./heatmapUtils-81245e4b.js";
+import "./QueryTask-07de3621.js";
+import "./infoFor3D-bf4e6c95.js";
+import "./executeForIds-48f5ccd3.js";
+import "./query-581e35c7.js";
+import "./pbfQueryUtils-780daa49.js";
+import "./pbf-4b5a905e.js";
+import "./OptimizedGeometry-3b808152.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./queryZScale-b9c83898.js";
+import "./executeQueryJSON-f5d65f6d.js";
+import "./FeatureSet-769d2f68.js";
+import "./executeQueryPBF-4ff20838.js";
+import "./featureConversionUtils-8635d4bd.js";
+import "./FeatureType-69365546.js";
+import "./FeatureTemplate-1be6448a.js";
+import "./LabelClass-909af0e5.js";
+import "./labelUtils-17e6e19c.js";
+import "./defaults-3495cefd.js";
+import "./defaultsJSON-ba17aa15.js";
+import "./labelingInfo-7583b96a.js";
+import "./LayerFloorInfo-8abaffaa.js";
+import "./serviceCapabilitiesUtils-266d7001.js";
+import "./AttachmentQuery-1667a134.js";
+import "./popupUtils-5d826c7a.js";
+import "./sublayerUtils-d60d357a.js";
+import "./jsonUtils-599f89fd.js";
+import "./parser-54b64f9a.js";
+import "./ElevationInfo-016cc1c4.js";
+import "./unitConversionUtils-ad9151e0.js";
+var d;
+const f = ["Canvas/World_Dark_Gray_Base", "Canvas/World_Dark_Gray_Reference", "Canvas/World_Light_Gray_Base", "Canvas/World_Light_Gray_Reference", "Elevation/World_Hillshade", "Elevation/World_Hillshade_Dark", "Ocean/World_Ocean_Base", "Ocean/World_Ocean_Reference", "Ocean_Basemap", "Reference/World_Boundaries_and_Places", "Reference/World_Boundaries_and_Places_Alternate", "Reference/World_Transportation", "World_Imagery", "World_Street_Map", "World_Topo_Map"];
+let i = d = class extends D(E(I(C(M(q(G(k(A(V(B(J(j)))))))))))) {
+  constructor(...e) {
+    super(...e), this.listMode = "show", this.isReference = null, this.operationalLayerType = "ArcGISTiledMapServiceLayer", this.resampling = !0, this.sourceJSON = null, this.spatialReference = null, this.path = null, this.sublayers = null, this.type = "tile", this.url = null;
+  }
+  normalizeCtorArgs(e, r) {
+    return typeof e == "string" ? { url: e, ...r } : e;
+  }
+  load(e) {
+    const r = e != null ? e.signal : null;
+    return this.addResolvingPromise(this.loadFromPortal({ supportedTypes: ["Map Service"] }, e).catch(_).then(() => this._fetchService(r))), Promise.resolve(this);
+  }
+  get attributionDataUrl() {
+    var r;
+    const e = (r = this.parsedUrl) == null ? void 0 : r.path.toLowerCase();
+    return e ? this._getDefaultAttribution(this._getMapName(e)) : null;
+  }
+  readSpatialReference(e, r) {
+    var t;
+    return (e = e || ((t = r.tileInfo) == null ? void 0 : t.spatialReference)) && v.fromJSON(e);
+  }
+  writeSublayers(e, r, t, o) {
+    if (!this.loaded || !e)
+      return;
+    const p = e.slice().reverse().flatten(({ sublayers: l }) => l && l.toArray().reverse()).toArray(), n = [], c = { writeSublayerStructure: !1, ...o };
+    p.forEach((l) => {
+      const h = l.write({}, c);
+      n.push(h);
+    }), n.some((l) => Object.keys(l).length > 1) && (r.layers = n);
+  }
+  get tileServers() {
+    var e;
+    return this._getDefaultTileServers((e = this.parsedUrl) == null ? void 0 : e.path);
+  }
+  castTileServers(e) {
+    return Array.isArray(e) ? e.map((r) => S(r).path) : null;
+  }
+  fetchTile(e, r, t, o = {}) {
+    const { signal: p } = o, n = this.getTileUrl(e, r, t), c = { responseType: "image", signal: p, query: { ...this.refreshParameters } };
+    return m(n, c).then((l) => l.data);
+  }
+  async fetchImageBitmapTile(e, r, t, o = {}) {
+    const { signal: p } = o;
+    if (this.fetchTile !== d.prototype.fetchTile) {
+      const h = await this.fetchTile(e, r, t, o);
+      return y(h, e, r, t, p);
+    }
+    const n = this.getTileUrl(e, r, t), c = { responseType: "blob", signal: p, query: { ...this.refreshParameters } }, { data: l } = await m(n, c);
+    return y(l, e, r, t, p);
+  }
+  getTileUrl(e, r, t) {
+    var c, l;
+    const o = !this.capabilities.operations.supportsTileMap && this.supportsBlankTile, p = T({ ...(c = this.parsedUrl) == null ? void 0 : c.query, blankTile: !o && null, ...this.customParameters, token: this.apiKey }), n = this.tileServers;
+    return `${n && n.length ? n[r % n.length] : (l = this.parsedUrl) == null ? void 0 : l.path}/tile/${e}/${r}/${t}${p ? "?" + p : ""}`;
+  }
+  loadAll() {
+    return b(this, (e) => {
+      e(this.allSublayers);
+    });
+  }
+  _fetchService(e) {
+    return new Promise((r, t) => {
+      if (this.sourceJSON) {
+        if (this.sourceJSON.bandCount != null && this.sourceJSON.pixelSizeX != null)
+          throw new u("tile-layer:unsupported-url", "use ImageryTileLayer to open a tiled image service");
+        return void r({ data: this.sourceJSON });
+      }
+      if (!this.parsedUrl)
+        throw new u("tile-layer:undefined-url", "layer's url is not defined");
+      const o = w(this.parsedUrl.path);
+      if (o != null && o.serverType === "ImageServer")
+        throw new u("tile-layer:unsupported-url", "use ImageryTileLayer to open a tiled image service");
+      m(this.parsedUrl.path, { query: { f: "json", ...this.parsedUrl.query, ...this.customParameters, token: this.apiKey }, responseType: "json", signal: e }).then(r, t);
+    }).then((r) => {
+      let t = this.url;
+      if (r.ssl && (t = this.url = t.replace(/^http:/i, "https:")), this.sourceJSON = r.data, this.read(r.data, { origin: "service", url: this.parsedUrl }), this.version === 10.1 && !O(t))
+        return this._fetchServerVersion(t, e).then((o) => {
+          this.read({ currentVersion: o });
+        }).catch(() => {
+        });
+    });
+  }
+  _fetchServerVersion(e, r) {
+    if (!$(e))
+      return Promise.reject();
+    const t = e.replace(/(.*\/rest)\/.*/i, "$1") + "/info";
+    return m(t, { query: { f: "json", ...this.customParameters, token: this.apiKey }, responseType: "json", signal: r }).then((o) => {
+      if (o.data && o.data.currentVersion)
+        return o.data.currentVersion;
+      throw new u("tile-layer:version-not-available");
+    });
+  }
+  _getMapName(e) {
+    const r = e.match(/^(?:https?:)?\/\/(server\.arcgisonline\.com|services\.arcgisonline\.com|ibasemaps-api\.arcgis\.com)\/arcgis\/rest\/services\/([^\/]+(\/[^\/]+)*)\/mapserver/i);
+    return r ? r[2] : void 0;
+  }
+  _getDefaultAttribution(e) {
+    if (e == null)
+      return null;
+    let r;
+    e = e.toLowerCase();
+    for (let t = 0, o = f.length; t < o; t++)
+      if (r = f[t], r.toLowerCase().includes(e))
+        return R("//static.arcgis.com/attribution/" + r);
+    return null;
+  }
+  _getDefaultTileServers(e) {
+    if (e == null)
+      return [];
+    const r = e.search(/^(?:https?:)?\/\/server\.arcgisonline\.com/i) !== -1, t = e.search(/^(?:https?:)?\/\/services\.arcgisonline\.com/i) !== -1;
+    return r || t ? [e, e.replace(r ? /server\.arcgisonline/i : /services\.arcgisonline/i, r ? "services.arcgisonline" : "server.arcgisonline")] : [];
+  }
+  get hasOverriddenFetchTile() {
+    return !this.fetchTile[g];
+  }
+};
+s([a({ readOnly: !0 })], i.prototype, "attributionDataUrl", null), s([a({ type: ["show", "hide", "hide-children"] })], i.prototype, "listMode", void 0), s([a({ json: { read: !0, write: !0 } })], i.prototype, "blendMode", void 0), s([a({ type: Boolean, json: { read: !1, write: { enabled: !0, overridePolicy: () => ({ enabled: !1 }) } } })], i.prototype, "isReference", void 0), s([a({ readOnly: !0, type: ["ArcGISTiledMapServiceLayer"] })], i.prototype, "operationalLayerType", void 0), s([a({ type: Boolean })], i.prototype, "resampling", void 0), s([a()], i.prototype, "sourceJSON", void 0), s([a({ type: v })], i.prototype, "spatialReference", void 0), s([U("spatialReference", ["spatialReference", "tileInfo"])], i.prototype, "readSpatialReference", null), s([a({ type: String, json: { origins: { "web-scene": { read: !0, write: !0 } }, read: !1 } })], i.prototype, "path", void 0), s([a({ readOnly: !0 })], i.prototype, "sublayers", void 0), s([W("sublayers", { layers: { type: [N] } })], i.prototype, "writeSublayers", null), s([a({ json: { read: !1, write: !1 } })], i.prototype, "popupEnabled", void 0), s([a()], i.prototype, "tileServers", null), s([L("tileServers")], i.prototype, "castTileServers", null), s([a({ readOnly: !0, json: { read: !1 } })], i.prototype, "type", void 0), s([a(x)], i.prototype, "url", void 0), i = d = s([P("esri.layers.TileLayer")], i);
+const g = Symbol("default-fetch-tile");
+i.prototype.fetchTile[g] = !0;
+const nr = i;
+export {
+  nr as default
+};

package/dist/TileLayerView2D-1f2d0b4c.js

@@ -0,0 +1,187 @@
+import { d as w, h as y, m as I, f as V, g as v, G as H, i as o, n as u, s as T, e as n, y as g, c as q } from "./index-a450f76b.js";
+import "./colorUtils-1a8cc2f8.js";
+import "./GeometryUtils-42ae242b.js";
+import "./UpdateTracking2D-881e1d79.js";
+import "./enums-fa8f05ab.js";
+import "./definitions-a00a3a6c.js";
+import "./defaults-3495cefd.js";
+import "./OverrideHelper-f9ba3c94.js";
+import "./floatRGBA-8dd8f77f.js";
+import "./Container-879e59ef.js";
+import "./WGLContainer-f4c4a8dc.js";
+import "./vec4f32-b2628ced.js";
+import "./Texture-08e8abdd.js";
+import "./enums-2c166c09.js";
+import "./Program-5b5c8288.js";
+import "./LabelMetric-a3f892e4.js";
+import "./StyleDefinition-f4862d5a.js";
+import "./enums-25d066fc.js";
+import "./MagnifierPrograms-4170fe79.js";
+import "./pbf-4b5a905e.js";
+import "./FeatureCommandQueue-68735fa7.js";
+import "./OrderIndependentTransparency-3eadfe42.js";
+import "./testSVGPremultipliedAlpha-bb386a75.js";
+import { $ as U } from "./GraphicsView2D-5c69cd54.js";
+import "./earcut-1a1bdd2c.js";
+import "./vec3f32-304a6a9c.js";
+import { r as S, o as f, n as d } from "./imageUtils-b38618d9.js";
+import { m as b, u as C } from "./LayerView-2a8c8edc.js";
+import { h as Q } from "./HighlightGraphicContainer-5887470a.js";
+import { i as $ } from "./RefreshableLayerView-19c8ff47.js";
+import { S as L, U as P } from "./MapServiceLayerViewHelper-f4014bfb.js";
+import { r as k } from "./drapedUtils-dfe3325a.js";
+import "vue";
+import "./vec42-1641eab7.js";
+import "./vec4f64-043e974c.js";
+import "./TurboLine-cb0c9eaa.js";
+import "./OptimizedGeometry-3b808152.js";
+import "./utils-5a4ac69c.js";
+import "./Rect-894f011c.js";
+import "./BindType-5e76c8e1.js";
+import "./Util-b8d78341.js";
+import "./highlightReasons-23d6c956.js";
+import "./constants-5bd557fe.js";
+import "./defaultsJSON-ba17aa15.js";
+import "./quantizationUtils-dde8a0c2.js";
+import "./parser-54b64f9a.js";
+import "./BufferObject-faafd842.js";
+import "./VertexArrayObject-4c6a6897.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./ProgramTemplate-62d54e1b.js";
+import "./config-61215215.js";
+import "./featureConversionUtils-8635d4bd.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./CircularArray-b2bc1dfd.js";
+import "./AttributeStore-2f8bce1a.js";
+import "./labelUtils-17e6e19c.js";
+import "./FieldsIndex-fd635f39.js";
+import "./UnknownTimeZone-832b690f.js";
+import "./TimeOnly-40ea9bb9.js";
+import "./timeSupport-2eb266be.js";
+import "./json-5febf88a.js";
+import "./diffUtils-cccaeaa2.js";
+import "./lengthUtils-15c44621.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./normalizeUtilsSync-90304e5d.js";
+import "./Bitmap-625c3ae1.js";
+import "./TileContainer-6b12d8e1.js";
+import "./scaleUtils-7e908168.js";
+import "./AGraphicContainer-232b465f.js";
+import "./TechniqueInstance-f272ce92.js";
+import "./floorFilterUtils-936f7587.js";
+import "./sublayerUtils-d60d357a.js";
+import "./popupUtils-8f261298.js";
+const F = [0, 0];
+let a = class extends $(S(b(C))) {
+  constructor() {
+    super(...arguments), this._fetchQueue = null, this._highlightGraphics = new w(), this._highlightView = null, this._popupHighlightHelper = null, this._tileStrategy = null, this.layer = null;
+  }
+  get resampling() {
+    return !("resampling" in this.layer) || this.layer.resampling !== !1;
+  }
+  get tilemapCache() {
+    return "tilemapCache" in this.layer ? this.layer.tilemapCache : null;
+  }
+  update(t) {
+    var i;
+    this._fetchQueue.pause(), this._fetchQueue.state = t.state, this._tileStrategy.update(t), this._fetchQueue.resume(), (i = this._highlightView) == null || i.processUpdate(t);
+  }
+  attach() {
+    const t = "tileServers" in this.layer ? this.layer.tileServers : null, i = this.tilemapCache;
+    if (this._tileInfoView = new y(this.layer.tileInfo, this.layer.fullExtent, i == null ? void 0 : i.effectiveMinLOD, i == null ? void 0 : i.effectiveMaxLOD), this._fetchQueue = new I({ tileInfoView: this._tileInfoView, concurrency: t && 10 * t.length || 10, process: (e, r) => this.fetchTile(e, r) }), this._tileStrategy = new V({ cachePolicy: "keep", resampling: this.resampling, acquireTile: (e) => this.acquireTile(e), releaseTile: (e) => this.releaseTile(e), tileInfoView: this._tileInfoView }), L(this, this.layer)) {
+      const e = this._highlightView = new U({ view: this.view, graphics: this._highlightGraphics, requestUpdateCallback: () => this.requestUpdate(), container: new Q(this.view.featuresTilingScheme), defaultPointSymbolEnabled: !1 });
+      this.container.addChild(this._highlightView.container), this._popupHighlightHelper = new P({ createFetchPopupFeaturesQueryGeometry: (r, h) => k(r, h, this.view), highlightGraphics: this._highlightGraphics, highlightGraphicUpdated: (r, h) => {
+        e.graphicUpdateHandler({ graphic: r, property: h });
+      }, layerView: this, updatingHandles: this._updatingHandles });
+    }
+    this.requestUpdate(), this.addAttachHandles(this._updatingHandles.add(() => this.resampling, () => {
+      this.doRefresh();
+    })), super.attach();
+  }
+  detach() {
+    var t, i;
+    super.detach(), this._tileStrategy.destroy(), this._fetchQueue.clear(), this.container.removeAllChildren(), (t = this._popupHighlightHelper) == null || t.destroy(), (i = this._highlightView) == null || i.destroy(), this._fetchQueue = this._tileStrategy = this._tileInfoView = this._popupHighlightHelper = null;
+  }
+  async fetchPopupFeaturesAtLocation(t, i) {
+    return this._popupHighlightHelper ? this._popupHighlightHelper.fetchPopupFeaturesAtLocation(t, i) : [];
+  }
+  highlight(t) {
+    return this._popupHighlightHelper ? this._popupHighlightHelper.highlight(t) : v();
+  }
+  moveStart() {
+    this.requestUpdate();
+  }
+  viewChange() {
+    this.requestUpdate();
+  }
+  moveEnd() {
+    this.requestUpdate();
+  }
+  supportsSpatialReference(t) {
+    var i;
+    return H((i = this.layer.tileInfo) == null ? void 0 : i.spatialReference, t);
+  }
+  async doRefresh() {
+    if (this.attached) {
+      if (this.suspended)
+        return this._tileStrategy.clear(), void this.requestUpdate();
+      this._fetchQueue.reset(), this._tileStrategy.refresh((t) => this._updatingHandles.addPromise(this._enqueueTileFetch(t)));
+    }
+  }
+  acquireTile(t) {
+    const i = this._bitmapView.createTile(t), e = i.bitmap;
+    return [e.x, e.y] = this._tileInfoView.getTileCoords(F, i.key), e.resolution = this._tileInfoView.getTileResolution(i.key), [e.width, e.height] = this._tileInfoView.tileInfo.size, this._updatingHandles.addPromise(this._enqueueTileFetch(i)), this._bitmapView.addChild(i), this.requestUpdate(), i;
+  }
+  releaseTile(t) {
+    this._fetchQueue.abort(t.key.id), this._bitmapView.removeChild(t), t.once("detach", () => t.destroy()), this.requestUpdate();
+  }
+  async fetchTile(t, i = {}) {
+    const e = this.tilemapCache, { signal: r, resamplingLevel: h = 0 } = i;
+    if (!e)
+      try {
+        return await this._fetchImage(t, r);
+      } catch (s) {
+        if (!o(s) && !this.resampling)
+          return f(this._tileInfoView.tileInfo.size);
+        if (h < 3) {
+          const m = this._tileInfoView.getTileParentId(t.id);
+          if (m) {
+            const c = new u(m), _ = await this.fetchTile(c, { ...i, resamplingLevel: h + 1 });
+            return d(this._tileInfoView, _, c, t);
+          }
+        }
+        throw s;
+      }
+    const p = new u(0, 0, 0, 0);
+    let l;
+    try {
+      if (await e.fetchAvailabilityUpsample(t.level, t.row, t.col, p, { signal: r }), p.level !== t.level && !this.resampling)
+        return f(this._tileInfoView.tileInfo.size);
+      l = await this._fetchImage(p, r);
+    } catch (s) {
+      if (o(s))
+        throw s;
+      l = await this._fetchImage(t, r);
+    }
+    return this.resampling ? d(this._tileInfoView, l, p, t) : l;
+  }
+  async _enqueueTileFetch(t) {
+    if (!this._fetchQueue.has(t.key.id)) {
+      try {
+        const i = await this._fetchQueue.push(t.key);
+        t.bitmap.source = i, t.bitmap.width = this._tileInfoView.tileInfo.size[0], t.bitmap.height = this._tileInfoView.tileInfo.size[1], t.once("attach", () => this.requestUpdate());
+      } catch (i) {
+        o(i) || T.getLogger(this).error(i);
+      }
+      this.requestUpdate();
+    }
+  }
+  async _fetchImage(t, i) {
+    return this.layer.fetchImageBitmapTile(t.level, t.row, t.col, { signal: i });
+  }
+};
+n([g()], a.prototype, "resampling", null), n([g()], a.prototype, "tilemapCache", null), a = n([q("esri.views.2d.layers.TileLayerView2D")], a);
+const ii = a;
+export {
+  ii as default
+};

package/dist/TilemapCache-671945d2.js

@@ -0,0 +1,189 @@
+import { bs as A, bz as D, gS as S, U as $, gT as z, W as m, bH as q, e as d, y, S as L, o as P, P as U, gU as x, i as _, gV as C, gW as M, eh as E, c as I, gX as k, g as j, fu as H } from "./index-a450f76b.js";
+import { E as N } from "./ByteSizeUnit-90df2840.js";
+import { e as F } from "./LRUCache-d9e4b57a.js";
+function J(e, i = !1) {
+  return e <= A ? i ? new Array(e).fill(0) : new Array(e) : new Uint32Array(e);
+}
+class w {
+  constructor(i) {
+    this._validateJSON(i);
+    const { location: a, data: t } = i;
+    this.location = Object.freeze(D(a));
+    const l = this.location.width, n = this.location.height;
+    let r = !0, o = !0;
+    const c = Math.ceil(l * n / 32), s = J(c);
+    let h = 0;
+    for (let f = 0; f < t.length; f++) {
+      const u = f % 32;
+      t[f] ? (o = !1, s[h] |= 1 << u) : r = !1, u === 31 && ++h;
+    }
+    o ? (this._availability = "unavailable", this.byteSize = 40) : r ? (this._availability = "available", this.byteSize = 40) : (this._availability = s, this.byteSize = 40 + S(s));
+  }
+  getAvailability(i, a) {
+    if (this._availability === "unavailable" || this._availability === "available")
+      return this._availability;
+    const t = (i - this.location.top) * this.location.width + (a - this.location.left), l = t % 32, n = t >> 5, r = this._availability;
+    return n < 0 || n > r.length ? "unknown" : r[n] & 1 << l ? "available" : "unavailable";
+  }
+  static fromDefinition(i, a) {
+    const t = i.service.request || $, { row: l, col: n, width: r, height: o } = i, c = { query: { f: "json" } };
+    return a = a ? { ...c, ...a } : c, t(R(i), a).then((s) => s.data).catch((s) => {
+      if (s && s.details && s.details.httpStatus === 422)
+        return { location: { top: l, left: n, width: r, height: o }, valid: !0, data: z(r * o, 0) };
+      throw s;
+    }).then((s) => {
+      if (s.location && (s.location.top !== l || s.location.left !== n || s.location.width !== r || s.location.height !== o))
+        throw new m("tilemap:location-mismatch", "Tilemap response for different location than requested", { response: s, definition: { top: l, left: n, width: r, height: o } });
+      return w.fromJSON(s);
+    });
+  }
+  static fromJSON(i) {
+    return Object.freeze(new w(i));
+  }
+  _validateJSON(i) {
+    if (!(i != null && i.location))
+      throw new m("tilemap:missing-location", "Location missing from tilemap response");
+    if (i.valid === !1)
+      throw new m("tilemap:invalid", "Tilemap response was marked as invalid");
+    if (!i.data)
+      throw new m("tilemap:missing-data", "Data missing from tilemap response");
+    if (!Array.isArray(i.data))
+      throw new m("tilemap:data-mismatch", "Data must be an array of numbers");
+    if (i.data.length !== i.location.width * i.location.height)
+      throw new m("tilemap:data-mismatch", "Number of data items does not match width/height of tilemap");
+  }
+}
+function T(e) {
+  return `${e.level}/${e.row}/${e.col}/${e.width}/${e.height}`;
+}
+function R(e) {
+  var t;
+  let i;
+  if ((t = e.service.tileServers) != null && t.length) {
+    const l = e.service.tileServers;
+    i = `${l && l.length ? l[e.row % l.length] : e.service.url}/tilemap/${e.level}/${e.row}/${e.col}/${e.width}/${e.height}`;
+  } else
+    i = `${e.service.url}/tilemap/${e.level}/${e.row}/${e.col}/${e.width}/${e.height}`;
+  const a = e.service.query;
+  return a && (i = `${i}?${a}`), i;
+}
+var v;
+let p = v = class extends L {
+  constructor(e) {
+    super(e), this._pendingTilemapRequests = {}, this.request = $, this.size = 32, this._prefetchingEnabled = !0;
+  }
+  initialize() {
+    this._tilemapCache = new F(2 * N.MEGABYTES), this.addHandles(P(() => {
+      const { layer: e } = this;
+      return [e == null ? void 0 : e.parsedUrl, e == null ? void 0 : e.tileServers, e == null ? void 0 : e.apiKey, e == null ? void 0 : e.customParameters];
+    }, () => this._initializeTilemapDefinition(), U));
+  }
+  get effectiveMinLOD() {
+    return this.minLOD ?? this.layer.tileInfo.lods[0].level;
+  }
+  get effectiveMaxLOD() {
+    return this.maxLOD ?? this.layer.tileInfo.lods[this.layer.tileInfo.lods.length - 1].level;
+  }
+  fetchTilemap(e, i, a, t) {
+    if (!this.layer.tileInfo.lodAt(e) || e < this.effectiveMinLOD || e > this.effectiveMaxLOD)
+      return Promise.reject(new m("tilemap-cache:level-unavailable", `Level ${e} is unavailable in the service`));
+    const l = this._tmpTilemapDefinition, n = this._tilemapFromCache(e, i, a, l);
+    if (n)
+      return Promise.resolve(n);
+    const r = t == null ? void 0 : t.signal;
+    return t = { ...t, signal: null }, new Promise((o, c) => {
+      x(r, () => c(k()));
+      const s = T(l);
+      let h = this._pendingTilemapRequests[s];
+      if (!h) {
+        h = w.fromDefinition(l, t).then((u) => (this._tilemapCache.put(s, u, u.byteSize), u));
+        const f = () => {
+          delete this._pendingTilemapRequests[s];
+        };
+        this._pendingTilemapRequests[s] = h, h.then(f, f);
+      }
+      h.then(o, c);
+    });
+  }
+  getAvailability(e, i, a) {
+    if (!this.layer.tileInfo.lodAt(e) || e < this.effectiveMinLOD || e > this.effectiveMaxLOD)
+      return "unavailable";
+    const t = this._tilemapFromCache(e, i, a, this._tmpTilemapDefinition);
+    return t ? t.getAvailability(i, a) : "unknown";
+  }
+  fetchAvailability(e, i, a, t) {
+    return !this.layer.tileInfo.lodAt(e) || e < this.effectiveMinLOD || e > this.effectiveMaxLOD ? Promise.reject(new m("tile-map:tile-unavailable", "Tile is not available", { level: e, row: i, col: a })) : this.fetchTilemap(e, i, a, t).catch((l) => l).then((l) => {
+      if (l instanceof w) {
+        const n = l.getAvailability(i, a);
+        if (n === "unavailable")
+          throw new m("tile-map:tile-unavailable", "Tile is not available", { level: e, row: i, col: a });
+        return n;
+      }
+      if (_(l))
+        throw l;
+      return "unknown";
+    });
+  }
+  fetchAvailabilityUpsample(e, i, a, t, l) {
+    t.level = e, t.row = i, t.col = a;
+    const n = this.layer.tileInfo;
+    n.updateTileInfo(t);
+    const r = this.fetchAvailability(e, i, a, l).catch((o) => {
+      if (_(o))
+        throw o;
+      if (n.upsampleTile(t))
+        return this.fetchAvailabilityUpsample(t.level, t.row, t.col, t, l);
+      throw o;
+    });
+    return this._fetchAvailabilityUpsamplePrefetch(t.id, e, i, a, l, r), r;
+  }
+  async _fetchAvailabilityUpsamplePrefetch(e, i, a, t, l, n) {
+    if (!this._prefetchingEnabled || e == null)
+      return;
+    const r = `prefetch-${e}`;
+    if (this.hasHandles(r))
+      return;
+    const o = new AbortController();
+    n.then(() => o.abort(), () => o.abort());
+    let c = !1;
+    const s = j(() => {
+      c || (c = !0, o.abort());
+    });
+    if (this.addHandles(s, r), await C(10, o.signal).catch(() => {
+    }), c || (c = !0, this.removeHandles(r)), M(o))
+      return;
+    const h = new H(e, i, a, t), f = { ...l, signal: o.signal }, u = this.layer.tileInfo;
+    for (let O = 0; v._prefetches.length < v._maxPrefetch && u.upsampleTile(h); ++O) {
+      const b = this.fetchAvailability(h.level, h.row, h.col, f);
+      v._prefetches.push(b);
+      const g = () => {
+        v._prefetches.removeUnordered(b);
+      };
+      b.then(g, g);
+    }
+  }
+  _initializeTilemapDefinition() {
+    var t;
+    if (!this.layer.parsedUrl)
+      return;
+    const { parsedUrl: e, apiKey: i, customParameters: a } = this.layer;
+    this._tilemapCache.clear(), this._tmpTilemapDefinition = { service: { url: e.path, query: E({ ...e.query, ...a, token: i ?? ((t = e.query) == null ? void 0 : t.token) }), tileServers: this.layer.tileServers, request: this.request }, width: this.size, height: this.size, level: 0, row: 0, col: 0 };
+  }
+  _tilemapFromCache(e, i, a, t) {
+    t.level = e, t.row = i - i % this.size, t.col = a - a % this.size;
+    const l = T(t);
+    return this._tilemapCache.get(l);
+  }
+  get test() {
+    const e = this;
+    return { get prefetchingEnabled() {
+      return e._prefetchingEnabled;
+    }, set prefetchingEnabled(i) {
+      e._prefetchingEnabled = i;
+    }, hasTilemap: (i, a, t) => !!e._tilemapFromCache(i, a, t, e._tmpTilemapDefinition) };
+  }
+};
+p._maxPrefetch = 4, p._prefetches = new q({ initialSize: v._maxPrefetch }), d([y({ constructOnly: !0 })], p.prototype, "layer", void 0), d([y({ constructOnly: !0 })], p.prototype, "minLOD", void 0), d([y({ constructOnly: !0 })], p.prototype, "maxLOD", void 0), d([y({ constructOnly: !0 })], p.prototype, "request", void 0), d([y({ constructOnly: !0 })], p.prototype, "size", void 0), p = v = d([I("esri.layers.support.TilemapCache")], p);
+export {
+  p as T
+};