@agrotools1/at-components 0.2.4 → 0.2.5

package/dist/SceneService-da855dda.js

@@ -0,0 +1,215 @@
+import { U as f, W as y, e as n, y as d, bR as S, c5 as m, b3 as w, gR as j, c2 as P, c as L, k as O, fN as K, bL as $, h1 as U, h2 as V, s as x, h3 as M, cT as q, bM as C, bN as k } from "./index-6ebf29c1.js";
+import { i as R } from "./originUtils-87edf087.js";
+import { I as z, d as F } from "./commonProperties-d1f695a2.js";
+import { o as T } from "./jsonContext-45fce1e1.js";
+import { p as J, n as B } from "./resourceUtils-fa1a565f.js";
+import { i as E } from "./saveAPIKeyUtils-9f0454db.js";
+import { t as D } from "./saveUtils-22a6caa6.js";
+async function Z(c, a, e, t, i, r, s) {
+  let o = null;
+  if (e != null) {
+    const h = `${c}/nodepages/`, _ = h + Math.floor(e.rootIndex / e.nodesPerPage);
+    try {
+      return { type: "page", rootPage: (await f(_, { query: { f: "json", ...t, token: i }, responseType: "json", signal: s })).data, rootIndex: e.rootIndex, pageSize: e.nodesPerPage, lodMetric: e.lodSelectionMetricType, urlPrefix: h };
+    } catch (N) {
+      r != null && r.warn("#fetchIndexInfo()", "Failed to load root node page. Falling back to node documents.", _, N), o = N;
+    }
+  }
+  if (!a)
+    return null;
+  const l = a == null ? void 0 : a.split("/").pop(), p = `${c}/nodes/`, u = p + l;
+  try {
+    return { type: "node", rootNode: (await f(u, { query: { f: "json", ...t, token: i }, responseType: "json", signal: s })).data, urlPrefix: p };
+  } catch (h) {
+    throw new y("sceneservice:root-node-missing", "Root node missing.", { pageError: o, nodeError: h, url: u });
+  }
+}
+let H = null;
+function Q() {
+  return H;
+}
+const ie = (c) => {
+  let a = class extends c {
+    constructor() {
+      super(...arguments), this.spatialReference = null, this.fullExtent = null, this.heightModelInfo = null, this.minScale = 0, this.maxScale = 0, this.version = { major: Number.NaN, minor: Number.NaN, versionString: "" }, this.copyright = null, this.sublayerTitleMode = "item-title", this.title = null, this.layerId = null, this.indexInfo = null, this._debouncedSaveOperations = O(async (e, t, i) => {
+        switch (e) {
+          case v.SAVE:
+            return this._save(t);
+          case v.SAVE_AS:
+            return this._saveAs(i, t);
+        }
+      });
+    }
+    readSpatialReference(e, t) {
+      return this._readSpatialReference(t);
+    }
+    _readSpatialReference(e) {
+      if (e.spatialReference != null)
+        return S.fromJSON(e.spatialReference);
+      const t = e.store, i = t.indexCRS || t.geographicCRS, r = i && parseInt(i.substring(i.lastIndexOf("/") + 1, i.length), 10);
+      return r != null ? new S(r) : null;
+    }
+    readFullExtent(e, t, i) {
+      if (e != null && typeof e == "object") {
+        const o = e.spatialReference == null ? { ...e, spatialReference: this._readSpatialReference(t) } : e;
+        return w.fromJSON(o, i);
+      }
+      const r = t.store, s = this._readSpatialReference(t);
+      return s == null || (r == null ? void 0 : r.extent) == null || !Array.isArray(r.extent) || r.extent.some((o) => o < I) ? null : new w({ xmin: r.extent[0], ymin: r.extent[1], xmax: r.extent[2], ymax: r.extent[3], spatialReference: s });
+    }
+    parseVersionString(e) {
+      const t = { major: Number.NaN, minor: Number.NaN, versionString: e }, i = e.split(".");
+      return i.length >= 2 && (t.major = parseInt(i[0], 10), t.minor = parseInt(i[1], 10)), t;
+    }
+    readVersion(e, t) {
+      const i = t.store, r = i.version != null ? i.version.toString() : "";
+      return this.parseVersionString(r);
+    }
+    readTitlePortalItem(e) {
+      return this.sublayerTitleMode !== "item-title" ? void 0 : e;
+    }
+    readTitleService(e, t) {
+      var s;
+      const i = (s = this.portalItem) == null ? void 0 : s.title;
+      if (this.sublayerTitleMode === "item-title")
+        return K(this.url, t.name);
+      let r = t.name;
+      if (!r && this.url) {
+        const o = $(this.url);
+        o != null && (r = o.title);
+      }
+      return this.sublayerTitleMode === "item-title-and-service-name" && i && (r = i + " - " + r), U(r);
+    }
+    set url(e) {
+      const t = V({ layer: this, url: e, nonStandardUrlAllowed: !1, logger: x.getLogger(this) });
+      this._set("url", t.url), t.layerId != null && this._set("layerId", t.layerId);
+    }
+    writeUrl(e, t, i, r) {
+      M(this, e, "layers", t, r);
+    }
+    get parsedUrl() {
+      const e = this._get("url"), t = q(e);
+      return this.layerId != null && (t.path = `${t.path}/layers/${this.layerId}`), t;
+    }
+    async _fetchIndexAndUpdateExtent(e, t) {
+      this.indexInfo = Z(this.parsedUrl.path, this.rootNode, e, this.customParameters, this.apiKey, x.getLogger(this), t), this.fullExtent == null || this.fullExtent.hasZ || this._updateExtent(await this.indexInfo);
+    }
+    _updateExtent(e) {
+      var t, i, r, s;
+      if ((e == null ? void 0 : e.type) === "page") {
+        const o = e.rootIndex % e.pageSize, l = (i = (t = e.rootPage) == null ? void 0 : t.nodes) == null ? void 0 : i[o];
+        if (((r = l == null ? void 0 : l.obb) == null ? void 0 : r.center) == null || l.obb.halfSize == null)
+          throw new y("sceneservice:invalid-node-page", "Invalid node page.");
+        if (l.obb.center[0] < I || this.fullExtent == null || this.fullExtent.hasZ)
+          return;
+        const p = l.obb.halfSize, u = l.obb.center[2], h = Math.sqrt(p[0] * p[0] + p[1] * p[1] + p[2] * p[2]);
+        this.fullExtent.zmin = u - h, this.fullExtent.zmax = u + h;
+      } else if ((e == null ? void 0 : e.type) === "node") {
+        const o = (s = e.rootNode) == null ? void 0 : s.mbs;
+        if (!Array.isArray(o) || o.length !== 4 || o[0] < I)
+          return;
+        const l = o[2], p = o[3], { fullExtent: u } = this;
+        u && (u.zmin = l - p, u.zmax = l + p);
+      }
+    }
+    async _fetchService(e) {
+      if (this.url == null)
+        throw new y("sceneservice:url-not-set", "Scene service can not be loaded without valid portal item or url");
+      if (this.layerId == null && /SceneServer\/*$/i.test(this.url)) {
+        const t = await this._fetchFirstLayerId(e);
+        t != null && (this.layerId = t);
+      }
+      return this._fetchServiceLayer(e);
+    }
+    async _fetchFirstLayerId(e) {
+      const t = await f(this.url, { query: { f: "json", ...this.customParameters, token: this.apiKey }, responseType: "json", signal: e });
+      if (t.data && Array.isArray(t.data.layers) && t.data.layers.length > 0)
+        return t.data.layers[0].id;
+    }
+    async _fetchServiceLayer(e) {
+      var s;
+      const t = await f(((s = this.parsedUrl) == null ? void 0 : s.path) ?? "", { query: { f: "json", ...this.customParameters, token: this.apiKey }, responseType: "json", signal: e });
+      t.ssl && (this.url = this.url.replace(/^http:/i, "https:"));
+      let i = !1;
+      if (t.data.layerType && t.data.layerType === "Voxel" && (i = !0), i)
+        return this._fetchVoxelServiceLayer();
+      const r = t.data;
+      this.read(r, this._getServiceContext()), this.validateLayer(r);
+    }
+    async _fetchVoxelServiceLayer(e) {
+      var i;
+      const t = (await f(((i = this.parsedUrl) == null ? void 0 : i.path) + "/layer", { query: { f: "json", ...this.customParameters, token: this.apiKey }, responseType: "json", signal: e })).data;
+      this.read(t, this._getServiceContext()), this.validateLayer(t);
+    }
+    _getServiceContext() {
+      var e;
+      return { origin: "service", portalItem: this.portalItem, portal: (e = this.portalItem) == null ? void 0 : e.portal, url: this.parsedUrl };
+    }
+    async _ensureLoadBeforeSave() {
+      await this.load(), "beforeSave" in this && typeof this.beforeSave == "function" && await this.beforeSave();
+    }
+    validateLayer(e) {
+    }
+    _updateTypeKeywords(e, t, i) {
+      e.typeKeywords || (e.typeKeywords = []);
+      const r = t.getTypeKeywords();
+      for (const s of r)
+        e.typeKeywords.push(s);
+      e.typeKeywords && (e.typeKeywords = e.typeKeywords.filter((s, o, l) => l.indexOf(s) === o), i === g.newItem && (e.typeKeywords = e.typeKeywords.filter((s) => s !== "Hosted Service")));
+    }
+    async _saveAs(e, t) {
+      var p;
+      const i = { ...A, ...t };
+      let r = C.from(e);
+      if (!r)
+        throw new y("sceneservice:portal-item-required", "_saveAs() requires a portal item to save to");
+      E(r), r.id && (r = r.clone(), r.id = null);
+      const s = r.portal || k.getDefault();
+      await this._ensureLoadBeforeSave(), r.type = b, r.portal = s;
+      const o = T(r, "portal-item", !0), l = { layers: [this.write({}, o)] };
+      return await Promise.all(o.resources.pendingOperations ?? []), await this._validateAgainstJSONSchema(l, o, i), r.url = this.url, r.title || (r.title = this.title), this._updateTypeKeywords(r, i, g.newItem), await s.signIn(), await ((p = s.user) == null ? void 0 : p.addItem({ item: r, folder: i == null ? void 0 : i.folder, data: l })), await J(this.resourceReferences, o), this.portalItem = r, R(o), o.portalItem = r, r;
+    }
+    async _save(e) {
+      const t = { ...A, ...e };
+      if (!this.portalItem)
+        throw new y("sceneservice:portal-item-not-set", "Portal item to save to has not been set on this SceneService");
+      if (E(this.portalItem), this.portalItem.type !== b)
+        throw new y("sceneservice:portal-item-wrong-type", `Portal item needs to have type "${b}"`);
+      await this._ensureLoadBeforeSave();
+      const i = T(this.portalItem, "portal-item", !0), r = { layers: [this.write({}, i)] };
+      return await Promise.all(i.resources.pendingOperations ?? []), await this._validateAgainstJSONSchema(r, i, t), this.portalItem.url = this.url, this.portalItem.title || (this.portalItem.title = this.title), this._updateTypeKeywords(this.portalItem, t, g.existingItem), await B(this.portalItem, r, this.resourceReferences, i), R(i), this.portalItem;
+    }
+    async _validateAgainstJSONSchema(e, t, i) {
+      const r = i == null ? void 0 : i.validationOptions;
+      D(t, { errorName: "sceneservice:save" }, { ignoreUnsupported: r == null ? void 0 : r.ignoreUnsupported, supplementalUnsupportedErrors: ["scenemodification:unsupported"] });
+      const s = r == null ? void 0 : r.enabled, o = Q();
+      if (s && o) {
+        const l = (await o()).validate(e, i.portalItemLayerType);
+        if (!l.length)
+          return;
+        const p = `Layer item did not validate:
+${l.join(`
+`)}`;
+        if (x.getLogger(this).error(`_validateAgainstJSONSchema(): ${p}`), r.failPolicy === "throw") {
+          const u = l.map((h) => new y("sceneservice:schema-validation", h));
+          throw new y("sceneservice-validate:error", "Failed to save layer item due to schema validation, see `details.errors`.", { validationErrors: u });
+        }
+      }
+    }
+  };
+  return n([d(z)], a.prototype, "id", void 0), n([d({ type: S })], a.prototype, "spatialReference", void 0), n([m("spatialReference", ["spatialReference", "store.indexCRS", "store.geographicCRS"])], a.prototype, "readSpatialReference", null), n([d({ type: w })], a.prototype, "fullExtent", void 0), n([m("fullExtent", ["fullExtent", "store.extent", "spatialReference", "store.indexCRS", "store.geographicCRS"])], a.prototype, "readFullExtent", null), n([d({ readOnly: !0, type: j })], a.prototype, "heightModelInfo", void 0), n([d({ type: Number, json: { name: "layerDefinition.minScale", write: !0, origins: { service: { read: { source: "minScale" }, write: !1 } } } })], a.prototype, "minScale", void 0), n([d({ type: Number, json: { name: "layerDefinition.maxScale", write: !0, origins: { service: { read: { source: "maxScale" }, write: !1 } } } })], a.prototype, "maxScale", void 0), n([d({ readOnly: !0 })], a.prototype, "version", void 0), n([m("version", ["store.version"])], a.prototype, "readVersion", null), n([d({ type: String, json: { read: { source: "copyrightText" } } })], a.prototype, "copyright", void 0), n([d({ type: String, json: { read: !1 } })], a.prototype, "sublayerTitleMode", void 0), n([d({ type: String })], a.prototype, "title", void 0), n([m("portal-item", "title")], a.prototype, "readTitlePortalItem", null), n([m("service", "title", ["name"])], a.prototype, "readTitleService", null), n([d({ type: Number, json: { origins: { service: { read: { source: "id" } }, "portal-item": { write: { target: "id", isRequired: !0, ignoreOrigin: !0 }, read: !1 } } } })], a.prototype, "layerId", void 0), n([d(F)], a.prototype, "url", null), n([P("url")], a.prototype, "writeUrl", null), n([d()], a.prototype, "parsedUrl", null), n([d({ readOnly: !0 })], a.prototype, "store", void 0), n([d({ type: String, readOnly: !0, json: { read: { source: "store.rootNode" } } })], a.prototype, "rootNode", void 0), a = n([L("esri.layers.mixins.SceneService")], a), a;
+}, I = -1e38;
+var g;
+(function(c) {
+  c[c.existingItem = 0] = "existingItem", c[c.newItem = 1] = "newItem";
+})(g || (g = {}));
+const b = "Scene Service", A = { getTypeKeywords: () => [], portalItemLayerType: "unknown", validationOptions: { enabled: !0, ignoreUnsupported: !1, failPolicy: "throw" } };
+var v;
+(function(c) {
+  c[c.SAVE = 0] = "SAVE", c[c.SAVE_AS = 1] = "SAVE_AS";
+})(v || (v = {}));
+export {
+  ie as L,
+  v as P,
+  Z as r
+};

package/dist/Scheduler-b3c40220.js

@@ -0,0 +1,373 @@
+import { hc as f, gW as F, gX as g, ez as v, e as I, y as A, c as G, S as w, hd as m, bH as R, o as M, P as Q, l as B, I as d, s as H, he as V, p as Y, hf as $ } from "./index-6ebf29c1.js";
+import { I as o } from "./RenderState-b244097f.js";
+const D = Symbol("Yield");
+class x {
+  constructor() {
+    this._tasks = new Array(), this._runningTasks = f(0);
+  }
+  get length() {
+    return this._tasks.length;
+  }
+  get running() {
+    return this._runningTasks.value > 0;
+  }
+  destroy() {
+    this.cancelAll();
+  }
+  runTask(n) {
+    if (this.length === 0)
+      return D;
+    for (; !n.done && this._process(n); )
+      n.madeProgress();
+  }
+  push(n, a, _) {
+    return ++this._runningTasks.value, new Promise((h, e) => this._tasks.push(new b(h, e, n, a, _))).finally(() => --this._runningTasks.value);
+  }
+  unshift(n, a, _) {
+    return ++this._runningTasks.value, new Promise((h, e) => this._tasks.unshift(new b(h, e, n, a, _))).finally(() => --this._runningTasks.value);
+  }
+  _process(n) {
+    var _;
+    if (this._tasks.length === 0)
+      return !1;
+    const a = this._tasks.shift();
+    try {
+      const h = F(a.signal);
+      if (h && !a.abortCallback)
+        a.reject(g());
+      else {
+        const e = h ? (_ = a.abortCallback) == null ? void 0 : _.call(a, g()) : a.callback(n);
+        v(e) ? e.then(a.resolve, a.reject) : a.resolve(e);
+      }
+    } catch (h) {
+      a.reject(h);
+    }
+    return !0;
+  }
+  cancelAll() {
+    const n = g();
+    for (const a of this._tasks)
+      if (a.abortCallback) {
+        const _ = a.abortCallback(n);
+        a.resolve(_);
+      } else
+        a.reject(n);
+    this._tasks.length = 0;
+  }
+}
+class b {
+  constructor(n, a, _, h = void 0, e = void 0) {
+    this.resolve = n, this.reject = a, this.callback = _, this.signal = h, this.abortCallback = e;
+  }
+}
+let c = class extends w {
+  constructor() {
+    super(...arguments), this.SCHEDULER_LOG_SLOW_TASKS = !1, this.FEATURE_SERVICE_SNAPPING_SOURCE_TILE_TREE_SHOW_TILES = !1;
+  }
+};
+I([A()], c.prototype, "SCHEDULER_LOG_SLOW_TASKS", void 0), I([A()], c.prototype, "FEATURE_SERVICE_SNAPPING_SOURCE_TILE_TREE_SHOW_TILES", void 0), c = I([G("esri.views.support.DebugFlags")], c);
+const q = new c();
+var r;
+(function(s) {
+  s.RESOURCE_CONTROLLER_IMMEDIATE = "immediate", s.RESOURCE_CONTROLLER = "schedule", s.SLIDE = "slide", s.STREAM_DATA_LOADER = "stream loader", s.ELEVATION_QUERY = "elevation query", s.TERRAIN_SURFACE = "terrain", s.SURFACE_GEOMETRY_UPDATES = "surface geometry updates", s.LOD_RENDERER = "LoD renderer", s.GRAPHICS_CORE = "Graphics3D", s.I3S_CONTROLLER = "I3S", s.POINT_CLOUD_LAYER = "point cloud", s.FEATURE_TILE_FETCHER = "feature fetcher", s.OVERLAY = "overlay", s.STAGE = "stage", s.GRAPHICS_DECONFLICTOR = "graphics deconflictor", s.FILTER_VISIBILITY = "Graphics3D filter visibility", s.SCALE_VISIBILITY = "Graphics3D scale visibility", s.FRUSTUM_VISIBILITY = "Graphics3D frustum visibility", s.POINT_OF_INTEREST_FREQUENT = "POI frequent", s.POINT_OF_INTEREST_INFREQUENT = "POI infrequent", s.LABELER = "labeler", s.FEATURE_QUERY_ENGINE = "feature query", s.FEATURE_TILE_TREE = "feature tile tree", s.FEATURE_TILE_TREE_ACTIVE = "fast feature tile tree", s.ELEVATION_ALIGNMENT = "elevation alignment", s.ELEVATION_ALIGNMENT_SCENE = "elevation alignment scene", s.TEXT_TEXTURE_ATLAS = "text texture atlas", s.TEXTURE_UNLOAD = "texture unload", s.LINE_OF_SIGHT_TOOL = "line of sight tool", s.LINE_OF_SIGHT_TOOL_INTERACTIVE = "interactive line of sight tool", s.ELEVATION_PROFILE = "elevation profile", s.SNAPPING = "snapping", s.SHADOW_ACCUMULATOR = "shadow accumulator", s.CLOUDS_GENERATOR = "clouds generator", s[s.NONE = 0] = "NONE", s[s.TEST_PRIO = 1] = "TEST_PRIO";
+})(r || (r = {}));
+const l = 0, L = /* @__PURE__ */ new Map([[r.RESOURCE_CONTROLLER_IMMEDIATE, l], [r.RESOURCE_CONTROLLER, 4], [r.SLIDE, l], [r.STREAM_DATA_LOADER, l], [r.ELEVATION_QUERY, l], [r.TERRAIN_SURFACE, 1], [r.SURFACE_GEOMETRY_UPDATES, 1], [r.LOD_RENDERER, 2], [r.GRAPHICS_CORE, 2], [r.I3S_CONTROLLER, 2], [r.POINT_CLOUD_LAYER, 2], [r.FEATURE_TILE_FETCHER, 2], [r.OVERLAY, 4], [r.STAGE, 4], [r.GRAPHICS_DECONFLICTOR, 4], [r.FILTER_VISIBILITY, 4], [r.SCALE_VISIBILITY, 4], [r.FRUSTUM_VISIBILITY, 4], [r.CLOUDS_GENERATOR, 4], [r.POINT_OF_INTEREST_FREQUENT, 6], [r.POINT_OF_INTEREST_INFREQUENT, 30], [r.LABELER, 8], [r.FEATURE_QUERY_ENGINE, 8], [r.FEATURE_TILE_TREE, 16], [r.FEATURE_TILE_TREE_ACTIVE, l], [r.ELEVATION_ALIGNMENT, 12], [r.ELEVATION_ALIGNMENT_SCENE, 14], [r.TEXT_TEXTURE_ATLAS, 12], [r.TEXTURE_UNLOAD, 12], [r.LINE_OF_SIGHT_TOOL, 16], [r.LINE_OF_SIGHT_TOOL_INTERACTIVE, l], [r.SNAPPING, l], [r.SHADOW_ACCUMULATOR, 30]]);
+function S(s) {
+  return L.has(s) ? L.get(s) : typeof s == "number" ? s : 1;
+}
+const k = d(6.5), N = d(1), W = d(30), O = d(1e3 / 30), C = d(100), U = 0.9;
+var p, E;
+(function(s) {
+  class n {
+    get updating() {
+      return this._updating.value;
+    }
+    _updatingChanged() {
+      this._updating.value = this._tasks.some((e) => e.needsUpdate);
+    }
+    constructor() {
+      this._updating = f(!0), this._microTaskQueued = !1, this._frameNumber = 0, this.performanceInfo = { total: new m("total"), tasks: /* @__PURE__ */ new Map() }, this._frameTaskTimes = /* @__PURE__ */ new Map(), this._budget = new _(), this._state = o.INTERACTING, this._tasks = new R(), this._runQueue = new R(), this._load = 0, this._idleStateCallbacks = new R(), this._idleUpdatesStartFired = !1, this._forceTask = !1, this._debug = !1, this._debugHandle = M(() => q.SCHEDULER_LOG_SLOW_TASKS, (i) => this._debug = i, Q);
+      for (const i of Object.keys(r))
+        this.performanceInfo.tasks.set(r[i], new m(r[i]));
+      const e = this;
+      this._test = { FRAME_SAFETY_BUDGET: k, INTERACTING_BUDGET: O, IDLE_BUDGET: C, get availableBudget() {
+        return e._budget.budget;
+      }, usedBudget: 0, getBudget: () => e._budget, setBudget: (i) => e._budget = i, updateTask: (i) => this._updateTask(i), getState: (i) => this._getState(i), getRuntime: (i) => this._getRuntime(i), frameTaskTimes: this._frameTaskTimes, resetRuntimes: () => this._resetRuntimes(), getRunning: () => this._getRunning() };
+    }
+    destroy() {
+      this._tasks.toArray().forEach((e) => e.remove()), this._tasks.clear(), B(this._debugHandle), this._microTaskQueued = !1, this._updatingChanged();
+    }
+    taskRunningChanged(e) {
+      this._updatingChanged(), e && this._budget.remaining > 0 && !this._microTaskQueued && (this._microTaskQueued = !0, queueMicrotask(() => {
+        this._microTaskQueued && (this._microTaskQueued = !1, this._budget.remaining > 0 && this._schedule() && this.frame());
+      }));
+    }
+    registerTask(e, i) {
+      const t = new a(this, e, i);
+      return this._tasks.push(t), this._updatingChanged(), this.performanceInfo.tasks.has(e) || this.performanceInfo.tasks.set(e, new m(e)), t;
+    }
+    registerIdleStateCallbacks(e, i) {
+      const t = { idleBegin: e, idleEnd: i };
+      this._idleStateCallbacks.push(t), this.state === o.IDLE && this._idleUpdatesStartFired && t.idleBegin();
+      const u = this;
+      return { remove: () => this._removeIdleStateCallbacks(t), set idleBegin(T) {
+        u._idleUpdatesStartFired && (t.idleEnd(), u._state === o.IDLE && T()), t.idleBegin = T;
+      }, set idleEnd(T) {
+        t.idleEnd = T;
+      } };
+    }
+    get load() {
+      return this._load;
+    }
+    set state(e) {
+      this._state !== e && (this._state = e, this.state !== o.IDLE && this._idleUpdatesStartFired && (this._idleUpdatesStartFired = !1, this._idleStateCallbacks.forAll((i) => i.idleEnd())));
+    }
+    get state() {
+      return this._state;
+    }
+    updateBudget(e) {
+      this._test.usedBudget = 0, ++this._frameNumber;
+      let i = k, t = e.frameDuration, u = N;
+      switch (this.state) {
+        case o.IDLE:
+          i = d(0), t = d(Math.max(C, e.frameDuration)), u = W;
+          break;
+        case o.INTERACTING:
+          t = d(Math.max(O, e.frameDuration));
+        case o.ANIMATING:
+      }
+      return t = d(t - e.elapsedFrameTime - i), this.state !== o.IDLE && t < N && !this._forceTask ? (this._forceTask = !0, !1) : (t = d(Math.max(t, u)), this._budget.reset(t, this.state), this._updateLoad(), this._schedule());
+    }
+    frame() {
+      switch (this._forceTask = !1, this._microTaskQueued = !1, this.state) {
+        case o.IDLE:
+          this._idleUpdatesStartFired || (this._idleUpdatesStartFired = !0, this._idleStateCallbacks.forAll((e) => e.idleBegin())), this._runIdle();
+          break;
+        case o.INTERACTING:
+          this._runInteracting();
+          break;
+        default:
+          this._runAnimating();
+      }
+      this._test.usedBudget = this._budget.elapsed;
+    }
+    stopFrame() {
+      this._budget.reset(d(0), this._state), this._budget.madeProgress();
+    }
+    _removeIdleStateCallbacks(e) {
+      this._idleUpdatesStartFired && e.idleEnd(), this._idleStateCallbacks.removeUnordered(e);
+    }
+    removeTask(e) {
+      this._tasks.removeUnordered(e), this._runQueue.removeUnordered(e), this._updatingChanged();
+    }
+    _updateTask(e) {
+      this._tasks.forAll((i) => {
+        i.name === e && i.setPriority(e);
+      });
+    }
+    _getState(e) {
+      if (this._runQueue.some((t) => t.name === e))
+        return E.SCHEDULED;
+      let i = E.IDLE;
+      return this._tasks.forAll((t) => {
+        t.name === e && t.needsUpdate && (t.schedulePriority <= 1 ? i = E.READY : i !== E.READY && (i = E.WAITING));
+      }), i;
+    }
+    _getRuntime(e) {
+      let i = 0;
+      return this._tasks.forAll((t) => {
+        t.name === e && (i += t.runtime);
+      }), i;
+    }
+    _resetRuntimes() {
+      this._tasks.forAll((e) => e.runtime = 0);
+    }
+    _getRunning() {
+      const e = /* @__PURE__ */ new Map();
+      if (this._tasks.forAll((t) => {
+        t.needsUpdate && e.set(t.name, (e.get(t.name) || 0) + 1);
+      }), e.size === 0)
+        return null;
+      let i = "";
+      return e.forEach((t, u) => {
+        i += t > 1 ? ` ${t}x ${u}` : ` ${u}`;
+      }), i;
+    }
+    _runIdle() {
+      this._run();
+    }
+    _runInteracting() {
+      this._run();
+    }
+    _runAnimating() {
+      this._run();
+    }
+    _updateLoad() {
+      const e = this._tasks.reduce((i, t) => t.needsUpdate ? ++i : i, 0);
+      this._load = this._load * U + e * (1 - U);
+    }
+    _schedule() {
+      for (this._runQueue.filterInPlace((e) => !!e.needsUpdate || (e.schedulePriority = e.basePriority, !1)), this._tasks.forAll((e) => {
+        e.basePriority === l && e.needsUpdate && !this._runQueue.includes(e) && e.blockFrame !== this._frameNumber && this._runQueue.unshift(e);
+      }); this._runQueue.length === 0; ) {
+        let e = !1, i = 0;
+        if (this._tasks.forAll((t) => {
+          t.needsUpdate && t.schedulePriority !== 0 && t.basePriority !== l && t.blockFrame !== this._frameNumber && (e = !0, i = Math.max(i, t.basePriority), t.schedulePriority === 1 ? (t.schedulePriority = 0, this._runQueue.push(t)) : --t.schedulePriority);
+        }), !e)
+          return this._updatingChanged(), !1;
+      }
+      return this._updatingChanged(), !0;
+    }
+    _run() {
+      const e = this._budget.now();
+      this._startFrameTaskTimes();
+      do
+        for (; this._runQueue.length > 0; ) {
+          const i = this._budget.now(), t = this._runQueue.pop();
+          this._budget.resetProgress();
+          try {
+            t.task.runTask(this._budget) === D && (t.blockFrame = this._frameNumber);
+          } catch (T) {
+            H.getLogger("esri.views.support.Scheduler").error(`Exception in task "${t.name}"`, T), t.blockFrame = this._frameNumber;
+          }
+          !this._budget.hasProgressed && t.blockFrame !== this._frameNumber && t.needsUpdate && (t.name, r.I3S_CONTROLLER, t.blockFrame = this._frameNumber), t.schedulePriority = t.basePriority;
+          const u = this._budget.now() - i;
+          if (t.runtime += u, this._frameTaskTimes.set(t.priority, this._frameTaskTimes.get(t.priority) + u), this._debug && u > 2 * this._budget.budget && console.log("Task", t.name, "used", u, "of max", this._budget.budget, "ms"), this._budget.remaining <= 0)
+            return this._updatingChanged(), void this._recordFrameTaskTimes(this._budget.now() - e);
+        }
+      while (this._schedule());
+      this._updatingChanged(), this._recordFrameTaskTimes(this._budget.now() - e);
+    }
+    _startFrameTaskTimes() {
+      for (const e of Object.keys(r))
+        this._frameTaskTimes.set(r[e], 0);
+    }
+    _recordFrameTaskTimes(e) {
+      this._frameTaskTimes.forEach((i, t) => this.performanceInfo.tasks.get(t).record(i)), this.performanceInfo.total.record(e);
+    }
+    get test() {
+      return this._test;
+    }
+  }
+  s.Scheduler = n;
+  class a {
+    get task() {
+      return this._task.value;
+    }
+    get updating() {
+      return this._queue.running;
+    }
+    constructor(e, i, t) {
+      this._scheduler = e, this.name = i, this.blockFrame = 0, this.runtime = 0, this._queue = new x(), this._handles = new V(), this._basePriority = S(i), this.schedulePriority = this._basePriority, this._task = f(t ?? this._queue), this._handles.add(Y(() => this.task.running, (u) => e.taskRunningChanged(u)));
+    }
+    remove() {
+      this.processQueue(y), this._scheduler.removeTask(this), this.schedule = P.schedule, this.reschedule = P.reschedule, this._handles.destroy();
+    }
+    get basePriority() {
+      return this._basePriority;
+    }
+    setPriority(e) {
+      if (this.name === e)
+        return;
+      this.name = e;
+      const i = S(e);
+      this._basePriority !== l && this.schedulePriority === 0 || (this.schedulePriority = i), this._basePriority = i;
+    }
+    get priority() {
+      return this.name;
+    }
+    set priority(e) {
+      this.setPriority(e);
+    }
+    get needsUpdate() {
+      return this.updating || this.task.running;
+    }
+    schedule(e, i, t) {
+      return this._queue.push(e, i, t);
+    }
+    reschedule(e, i, t) {
+      return this._queue.unshift(e, i, t);
+    }
+    processQueue(e) {
+      return this._queue.runTask(e);
+    }
+  }
+  class _ {
+    constructor() {
+      this._begin = typeof performance < "u" ? performance.now() : 0, this._budget = 0, this._state = o.IDLE, this._done = !1, this._progressed = !1, this._enabled = !0;
+    }
+    run(e) {
+      return !this.done && (e() === !0 && this.madeProgress(), !0);
+    }
+    get done() {
+      return this._done;
+    }
+    get budget() {
+      return this._budget;
+    }
+    madeProgress() {
+      return this._progressed = !0, this._done = this.elapsed >= this._budget && this._enabled, this._done;
+    }
+    get state() {
+      return this._state;
+    }
+    get enabled() {
+      return this._enabled;
+    }
+    set enabled(e) {
+      this._enabled = e;
+    }
+    reset(e, i) {
+      this._begin = this.now(), this._budget = e, this._state = i, this.resetProgress();
+    }
+    get remaining() {
+      return Math.max(this._budget - this.elapsed, 0);
+    }
+    now() {
+      return performance.now();
+    }
+    get elapsed() {
+      return performance.now() - this._begin;
+    }
+    resetProgress() {
+      this._progressed = !1, this._done = !1;
+    }
+    get hasProgressed() {
+      return this._progressed;
+    }
+  }
+  s.Budget = _;
+})(p || (p = {})), function(s) {
+  s.SCHEDULED = "s", s.READY = "r", s.WAITING = "w", s.IDLE = "i";
+}(E || (E = {}));
+const y = (() => {
+  const s = new p.Budget();
+  return s.enabled = !1, s;
+})();
+class j {
+  remove() {
+  }
+  processQueue() {
+  }
+  schedule(n, a, _) {
+    try {
+      if (F(a)) {
+        const h = g();
+        return _ ? Promise.resolve(_(h)) : Promise.reject(h);
+      }
+      return $(n(y));
+    } catch (h) {
+      return Promise.reject(h);
+    }
+  }
+  reschedule(n, a, _) {
+    return this.schedule(n, a, _);
+  }
+}
+const P = new j();
+export {
+  y as C,
+  q as E,
+  P as F,
+  r as I
+};

package/dist/Search/test.mocks.d.ts

@@ -1,3 +1,3 @@
-import type { DropdownListItem } from "../Dropdown/List/Dropdown.List";
+import type { DropdownListItem } from "../Dropdown/List/Dropdown.list";
 declare const autoCompleteListMock: DropdownListItem[];
 export { autoCompleteListMock };

package/dist/Search/utils.d.ts

@@ -1,3 +1,3 @@
-import type { DropdownListItem } from "../Dropdown/List/Dropdown.List";
+import type { DropdownListItem } from "../Dropdown/List/Dropdown.list";
 declare function filterAutoCompleteList(autoCompleteList: DropdownListItem[] | undefined, value: string): DropdownListItem[] | undefined;
 export { filterAutoCompleteList };

package/dist/ShadedColorMaterial.glsl-f953e894.js

@@ -0,0 +1,64 @@
+import "./vec4f64-043e974c.js";
+import "./index-6ebf29c1.js";
+import "./mat4f64-cce69db4.js";
+import "./BindType-5e76c8e1.js";
+import "./OrderIndependentTransparency-3eadfe42.js";
+import "./VertexColor.glsl-cfafd4c9.js";
+import "./mat3f64-03233387.js";
+import "./VertexAttribute-faad30bf.js";
+import { p as eo } from "./InteractiveAnalysisViewModel-f0a0c72a.js";
+import "vue";
+import "./enums-2c166c09.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./Texture-b1727861.js";
+import "./vec42-27060a00.js";
+import "./Util-2ba07f64.js";
+import "./Indices-f0dca4b5.js";
+import "./triangle-07f96fb9.js";
+import "./ObjectStack-424092a9.js";
+import "./lineSegment-f45db35c.js";
+import "./plane-84e27261.js";
+import "./quatf64-bec1af25.js";
+import "./doublePrecisionUtils-46e21550.js";
+import "./lengthUtils-6a89d855.js";
+import "./requestImageUtils-caebcf1e.js";
+import "./sphere-418b76df.js";
+import "./orientedBoundingBox-4ae2c366.js";
+import "./quat-5502b70d.js";
+import "./computeTranslationToOriginAndRotation-cba163ab.js";
+import "./BufferView-5272765e.js";
+import "./geometryEngineBase-d653892b.js";
+import "./colorUtils-6d5e716b.js";
+import "./projectVectorToVector-b7e757a1.js";
+import "./projectPointToVector-1f1d1dc7.js";
+import "./elevationInfoUtils-c1caf596.js";
+import "./unitConversionUtils-c1bfd22b.js";
+import "./vec4f32-b2628ced.js";
+import "./Octree-21d216f2.js";
+import "./DoubleArray-bb8ff0fb.js";
+import "./glUtil-8f8bce6b.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./InterleavedLayout-9490090b.js";
+import "./types-adba9034.js";
+import "./VertexArrayObject-08a9d938.js";
+import "./BufferObject-22d914df.js";
+import "./axisAngleDegrees-de05cd64.js";
+import "./RenderState-b244097f.js";
+import "./NestedMap-83f8e815.js";
+import "./floatRGBA-005cc596.js";
+import "./MemCache-0861cc28.js";
+import "./Scheduler-b3c40220.js";
+import "./vec3f32-304a6a9c.js";
+import "./MeasurementWidgetContent-82971f95.js";
+import "./meshVertexSpaceUtils-c9b69510.js";
+import "./MeshLocalVertexSpace-6fe3a662.js";
+import "./vec3-61daf837.js";
+import "./quantityUtils-b64583f9.js";
+import "./FeatureFilter-1635b86a.js";
+import "./floorFilterUtils-936f7587.js";
+import "./layerViewUtils-052e603c.js";
+import "./geometryEngine-e18a460d.js";
+import "./hydrated-36edecd6.js";
+export {
+  eo as build
+};