@agrotools1/at-components 0.2.0 → 0.2.2

package/dist/ExportImageParameters-c6c4bc61.js

@@ -0,0 +1,66 @@
+import { e as t, y as a, c as h, S as c, q as p } from "./index-01c737ed.js";
+import { d as u } from "./scaleUtils-bdf8b6cb.js";
+import { j as b } from "./commonProperties-f9559903.js";
+import { n as m } from "./floorFilterUtils-936f7587.js";
+import { n as d } from "./sublayerUtils-eaac2486.js";
+const f = { visible: "visibleSublayers", definitionExpression: "layerDefs", labelingInfo: "hasDynamicLayers", labelsVisible: "hasDynamicLayers", opacity: "hasDynamicLayers", minScale: "visibleSublayers", maxScale: "visibleSublayers", renderer: "hasDynamicLayers", source: "hasDynamicLayers" };
+let r = class extends c {
+  constructor(e) {
+    super(e), this.floors = null, this.scale = 0;
+  }
+  destroy() {
+    this.layer = null;
+  }
+  get dynamicLayers() {
+    if (!this.hasDynamicLayers)
+      return null;
+    const e = this.visibleSublayers.map((s) => {
+      const o = m(this.floors, s);
+      return s.toExportImageJSON(o);
+    });
+    return e.length ? JSON.stringify(e) : null;
+  }
+  get hasDynamicLayers() {
+    return this.layer && d(this.visibleSublayers, this.layer.serviceSublayers, this.layer.gdbVersion);
+  }
+  set layer(e) {
+    this._get("layer") !== e && (this._set("layer", e), this.removeHandles("layer"), e && this.addHandles([e.allSublayers.on("change", () => this.notifyChange("visibleSublayers")), e.on("sublayer-update", (s) => this.notifyChange(f[s.propertyName]))], "layer"));
+  }
+  get layers() {
+    const e = this.visibleSublayers;
+    return e ? e.length ? "show:" + e.map((s) => s.id).join(",") : "show:-1" : null;
+  }
+  get layerDefs() {
+    var o;
+    const e = !!((o = this.floors) != null && o.length), s = this.visibleSublayers.filter((l) => l.definitionExpression != null || e && l.floorInfo != null);
+    return s.length ? JSON.stringify(s.reduce((l, n) => {
+      const i = m(this.floors, n), y = p(i, n.definitionExpression);
+      return y != null && (l[n.id] = y), l;
+    }, {})) : null;
+  }
+  get version() {
+    this.commitProperty("layers"), this.commitProperty("layerDefs"), this.commitProperty("dynamicLayers"), this.commitProperty("timeExtent");
+    const e = this.layer;
+    return e && (e.commitProperty("dpi"), e.commitProperty("imageFormat"), e.commitProperty("imageTransparency"), e.commitProperty("gdbVersion")), (this._get("version") || 0) + 1;
+  }
+  get visibleSublayers() {
+    const e = [];
+    if (!this.layer)
+      return e;
+    const s = this.layer.sublayers, o = this.scale, l = (i) => {
+      i.visible && (o === 0 || u(o, i.minScale, i.maxScale)) && (i.sublayers ? i.sublayers.forEach(l) : e.unshift(i));
+    };
+    s && s.forEach(l);
+    const n = this._get("visibleSublayers");
+    return !n || n.length !== e.length || n.some((i, y) => e[y] !== i) ? e : n;
+  }
+  toJSON() {
+    const e = this.layer;
+    let s = { dpi: e.dpi, format: e.imageFormat, transparent: e.imageTransparency, gdbVersion: e.gdbVersion || null };
+    return this.hasDynamicLayers && this.dynamicLayers ? s.dynamicLayers = this.dynamicLayers : s = { ...s, layers: this.layers, layerDefs: this.layerDefs }, s;
+  }
+};
+t([a({ readOnly: !0 })], r.prototype, "dynamicLayers", null), t([a()], r.prototype, "floors", void 0), t([a({ readOnly: !0 })], r.prototype, "hasDynamicLayers", null), t([a()], r.prototype, "layer", null), t([a({ readOnly: !0 })], r.prototype, "layers", null), t([a({ readOnly: !0 })], r.prototype, "layerDefs", null), t([a({ type: Number })], r.prototype, "scale", void 0), t([a(b)], r.prototype, "timeExtent", void 0), t([a({ readOnly: !0 })], r.prototype, "version", null), t([a({ readOnly: !0 })], r.prototype, "visibleSublayers", null), r = t([h("esri.layers.mixins.ExportImageParameters")], r);
+export {
+  r as m
+};

package/dist/ExportStrategy-908f5b8d.js

@@ -0,0 +1,93 @@
+import { aG as W, n as E, e as p, y as c, c as $, S as H, k as R, bJ as _, aH as N, bO as T, dL as q, ee as z, cZ as I, h as B } from "./index-01c737ed.js";
+import { b as C } from "./Bitmap-f775c851.js";
+const O = Math.PI / 180;
+function U(e) {
+  return e * O;
+}
+function j(e, i) {
+  const s = U(i.rotation), t = Math.abs(Math.cos(s)), r = Math.abs(Math.sin(s)), [o, n] = i.size;
+  return e[0] = Math.round(n * r + o * t), e[1] = Math.round(n * t + o * r), e;
+}
+function k(e, i, s, t) {
+  const [r, o] = i, [n, a] = t, l = 0.5 * s;
+  return e[0] = r - l * n, e[1] = o - l * a, e[2] = r + l * n, e[3] = o + l * a, e;
+}
+const u = W(), m = [0, 0], v = new E(0, 0, 0, 0), y = { container: null, fetchSource: null, requestUpdate: null, imageMaxWidth: 2048, imageMaxHeight: 2048, imageRotationSupported: !1, imageNormalizationSupported: !1, hidpi: !1 };
+let h = class extends H {
+  constructor(e) {
+    super(e), this._imagePromise = null, this.bitmaps = [], this.hidpi = y.hidpi, this.imageMaxWidth = y.imageMaxWidth, this.imageMaxHeight = y.imageMaxHeight, this.imageRotationSupported = y.imageRotationSupported, this.imageNormalizationSupported = y.imageNormalizationSupported, this.update = R(async (i, s) => {
+      if (_(s), !i.stationary || this.destroyed)
+        return;
+      const t = i.state, r = N(t.spatialReference), o = this.hidpi ? i.pixelRatio : 1, n = this.imageNormalizationSupported && t.worldScreenWidth && t.worldScreenWidth < t.size[0], a = this.imageMaxWidth ?? 0, l = this.imageMaxHeight ?? 0;
+      n ? (m[0] = t.worldScreenWidth, m[1] = t.size[1]) : this.imageRotationSupported ? (m[0] = t.size[0], m[1] = t.size[1]) : j(m, t);
+      const S = Math.floor(m[0] * o) > a || Math.floor(m[1] * o) > l, M = r && (t.extent.xmin < r.valid[0] || t.extent.xmax > r.valid[1]), x = !this.imageNormalizationSupported && M, w = !S && !x, f = this.imageRotationSupported ? t.rotation : 0, b = this.container.children.slice();
+      if (w) {
+        const d = n ? t.paddedViewState.center : t.center;
+        this._imagePromise && console.error("Image promise was not defined!"), this._imagePromise = this._singleExport(t, m, d, t.resolution, f, o, s);
+      } else {
+        let d = Math.min(a, l);
+        x && (d = Math.min(t.worldScreenWidth, d)), this._imagePromise = this._tiledExport(t, d, o, s);
+      }
+      try {
+        const d = await this._imagePromise ?? [];
+        _(s);
+        const P = [];
+        if (this._imagePromise = null, this.destroyed)
+          return;
+        this.bitmaps = d;
+        for (const g of b)
+          d.includes(g) || P.push(g.fadeOut().then(() => {
+            g.remove(), g.destroy();
+          }));
+        for (const g of d)
+          P.push(g.fadeIn());
+        await Promise.all(P);
+      } catch (d) {
+        this._imagePromise = null, T(d);
+      }
+    }, 5e3), this.updateExports = R(async (i) => {
+      const s = [];
+      for (const t of this.container.children) {
+        if (!t.visible || !t.stage)
+          return;
+        s.push(i(t).then(() => {
+          t.invalidateTexture(), t.requestRender();
+        }));
+      }
+      this._imagePromise = q(s).then(() => this._imagePromise = null), await this._imagePromise;
+    });
+  }
+  destroy() {
+    this.bitmaps.forEach((e) => e.destroy()), this.bitmaps = [];
+  }
+  get updating() {
+    return !this.destroyed && this._imagePromise !== null;
+  }
+  async _export(e, i, s, t, r, o) {
+    const n = await this.fetchSource(e, Math.floor(i * r), Math.floor(s * r), { rotation: t, pixelRatio: r, signal: o });
+    _(o);
+    const a = new C(null, !0);
+    return a.x = e.xmin, a.y = e.ymax, a.resolution = e.width / i, a.rotation = t, a.pixelRatio = r, a.opacity = 0, this.container.addChild(a), await a.setSourceAsync(n, o), _(o), a;
+  }
+  async _singleExport(e, i, s, t, r, o, n) {
+    k(u, s, t, i);
+    const a = z(u, e.spatialReference);
+    return [await this._export(a, i[0], i[1], r, o, n)];
+  }
+  _tiledExport(e, i, s, t) {
+    const r = I.create({ size: i, spatialReference: e.spatialReference, scales: [e.scale] }), o = new B(r), n = o.getTileCoverage(e);
+    if (!n)
+      return null;
+    const a = [];
+    return n.forEach((l, S, M, x) => {
+      v.set(l, S, M, 0), o.getTileBounds(u, v);
+      const w = z(u, e.spatialReference);
+      a.push(this._export(w, i, i, 0, s, t).then((f) => (x !== 0 && (v.set(l, S, M, x), o.getTileBounds(u, v), f.x = u[0], f.y = u[3]), f)));
+    }), Promise.all(a);
+  }
+};
+p([c()], h.prototype, "_imagePromise", void 0), p([c()], h.prototype, "bitmaps", void 0), p([c()], h.prototype, "container", void 0), p([c()], h.prototype, "fetchSource", void 0), p([c()], h.prototype, "hidpi", void 0), p([c()], h.prototype, "imageMaxWidth", void 0), p([c()], h.prototype, "imageMaxHeight", void 0), p([c()], h.prototype, "imageRotationSupported", void 0), p([c()], h.prototype, "imageNormalizationSupported", void 0), p([c()], h.prototype, "requestUpdate", void 0), p([c()], h.prototype, "updating", null), h = p([$("esri.views.2d.layers.support.ExportStrategy")], h);
+const J = h;
+export {
+  J as v
+};

package/dist/ExportWMSImageParameters-34da6b46.js

@@ -0,0 +1,33 @@
+import { e as t, y as l, c as m, S as h } from "./index-01c737ed.js";
+const b = { visible: "visibleSublayers" };
+let s = class extends h {
+  constructor(e) {
+    super(e), this.scale = 0;
+  }
+  set layer(e) {
+    this._get("layer") !== e && (this._set("layer", e), this.removeHandles("layer"), e && this.addHandles([e.sublayers.on("change", () => this.notifyChange("visibleSublayers")), e.on("wms-sublayer-update", (r) => this.notifyChange(b[r.propertyName]))], "layer"));
+  }
+  get layers() {
+    return this.visibleSublayers.filter(({ name: e }) => e).map(({ name: e }) => e).join();
+  }
+  get version() {
+    this.commitProperty("layers");
+    const e = this.layer;
+    return e && e.commitProperty("imageTransparency"), (this._get("version") || 0) + 1;
+  }
+  get visibleSublayers() {
+    const { layer: e, scale: r } = this, a = e == null ? void 0 : e.sublayers, i = [], o = (n) => {
+      const { minScale: y, maxScale: p, sublayers: u, visible: c } = n;
+      c && (r === 0 || (y === 0 || r <= y) && (p === 0 || r >= p)) && (u ? u.forEach(o) : i.push(n));
+    };
+    return a == null || a.forEach(o), i;
+  }
+  toJSON() {
+    const { layer: e, layers: r } = this, { imageFormat: a, imageTransparency: i, version: o } = e;
+    return { format: a, request: "GetMap", service: "WMS", styles: "", transparent: i ? "TRUE" : "FALSE", version: o, layers: r };
+  }
+};
+t([l()], s.prototype, "layer", null), t([l({ readOnly: !0 })], s.prototype, "layers", null), t([l({ type: Number })], s.prototype, "scale", void 0), t([l({ readOnly: !0 })], s.prototype, "version", null), t([l({ readOnly: !0 })], s.prototype, "visibleSublayers", null), s = t([m("esri.layers.support.ExportWMSImageParameters")], s);
+export {
+  s as a
+};

package/dist/External-14daf0c1.js

@@ -0,0 +1,110 @@
+import { dN as b, bJ as p, U as g } from "./index-01c737ed.js";
+import { c as N, u as A, i as v } from "./infoFor3D-bf4e6c95.js";
+class m {
+  constructor(r, s, t) {
+    this.assetName = r, this.assetMimeType = s, this.parts = t;
+  }
+  equals(r) {
+    return this === r || this.assetName === r.assetName && this.assetMimeType === r.assetMimeType && b(this.parts, r.parts, (s, t) => s.equals(t));
+  }
+  isOnService(r) {
+    return this.parts.every((s) => s.isOnService(r));
+  }
+  makeHash() {
+    let r = "";
+    for (const s of this.parts)
+      r += s.partHash;
+    return r;
+  }
+  async toBlob(r) {
+    const { parts: s } = this;
+    if (s.length === 1)
+      return s[0].toBlob(r);
+    const t = await Promise.all(s.map((a) => a.toBlob(r)));
+    return p(r), new Blob(t);
+  }
+}
+class H {
+  constructor(r, s) {
+    this.partUrl = r, this.partHash = s;
+  }
+  equals(r) {
+    return this === r || this.partUrl === r.partUrl && this.partHash === r.partHash;
+  }
+  isOnService(r) {
+    return this.partUrl.startsWith(`${r.path}/assets/`);
+  }
+  async toBlob(r) {
+    const { data: s } = await g(this.partUrl, { responseType: "blob" });
+    return p(r), s;
+  }
+}
+function M(e) {
+  return $(e == null ? void 0 : e.source);
+}
+function u(e) {
+  return Array.isArray(e) ? e.every((r) => r instanceof m) : !1;
+}
+const c = /^(model\/gltf\+json)|(model\/gltf-binary)$/, f = /\.(gltf|glb)/i;
+function $(e) {
+  return e ? Array.isArray(e) ? e.some(l) : l(e) : !1;
+}
+function l(e) {
+  if (e instanceof File) {
+    const { type: r, name: s } = e;
+    return c.test(r) || f.test(s);
+  }
+  return c.test(e.assetMimeType) || f.test(e.assetName);
+}
+function d(e, r) {
+  if (!e)
+    return !1;
+  const { source: s } = e;
+  return U(s, r);
+}
+function q(e, r) {
+  if (e === r)
+    return !0;
+  const { source: s } = e, { source: t } = r;
+  if (s === t)
+    return !0;
+  if (u(s) && u(t)) {
+    if (s.length !== t.length)
+      return !1;
+    const a = (n, o) => n.assetName < o.assetName ? -1 : n.assetName > o.assetName ? 1 : 0, i = [...s].sort(a), y = [...t].sort(a);
+    for (let n = 0; n < i.length; ++n)
+      if (!i[n].equals(y[n]))
+        return !1;
+    return !0;
+  }
+  return !1;
+}
+function U(e, r) {
+  if (Array.isArray(e)) {
+    const s = e;
+    return s.length > 0 && s.every((t) => h(t, r));
+  }
+  return h(e, r);
+}
+function h(e, r) {
+  return e instanceof m && e.isOnService(r);
+}
+function O(e, r) {
+  return e instanceof File ? N(e, r) : A(e.assetMimeType, r) ?? v(e.assetName, r);
+}
+function S(e) {
+  return Array.isArray(e) ? e : [e];
+}
+function w(e) {
+  return !!e.original;
+}
+export {
+  S as A,
+  O as N,
+  d as h,
+  m as i,
+  H as o,
+  M as u,
+  w as v,
+  q as y
+};

package/dist/FeatureCollectionSnappingSource-f97a1829.js

@@ -0,0 +1,130 @@
+import { S as E, o as c, P as h, H as F, bJ as s, e as p, y as n, c as V, dE as $ } from "./index-01c737ed.js";
+import { t as C, j as D, y as A } from "./MeasurementWidgetContent-e4888ef2.js";
+import { E as I } from "./elevationInfoUtils-5456a079.js";
+import { a as P, o as G } from "./queryEngineUtils-cb8e309e.js";
+import { i as d, r as q, n as S } from "./symbologySnappingCandidates-14d94b6b.js";
+import "vue";
+import "./vec42-36edeb73.js";
+import "./vec4f64-043e974c.js";
+import "./plane-3398eec1.js";
+import "./mat3f64-03233387.js";
+import "./mat4f64-cce69db4.js";
+import "./quatf64-bec1af25.js";
+import "./sphere-908cd9aa.js";
+import "./ObjectStack-10d91171.js";
+import "./projectVectorToVector-5163db7a.js";
+import "./projectPointToVector-7dc831a9.js";
+import "./meshVertexSpaceUtils-6efe3dcc.js";
+import "./MeshLocalVertexSpace-00151564.js";
+import "./vec3-f79c600d.js";
+import "./Scheduler-eacc84bb.js";
+import "./RenderState-b244097f.js";
+import "./quantityUtils-5cd4cf90.js";
+import "./unitConversionUtils-f0ebaf75.js";
+import "./lengthUtils-695e744c.js";
+import "./InteractiveAnalysisViewModel-b046fcb9.js";
+import "./geometryEngineBase-527e8b63.js";
+import "./colorUtils-54f4b662.js";
+import "./vec4f32-b2628ced.js";
+import "./Octree-78797046.js";
+import "./Util-002f5109.js";
+import "./lineSegment-3aa941f5.js";
+import "./triangle-8a3a2ba8.js";
+import "./DoubleArray-5076283e.js";
+import "./glUtil-8f8bce6b.js";
+import "./enums-2c166c09.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./InterleavedLayout-32973c8a.js";
+import "./BufferView-004ad517.js";
+import "./types-adba9034.js";
+import "./VertexArrayObject-07998745.js";
+import "./Texture-22a8cca5.js";
+import "./VertexAttribute-faad30bf.js";
+import "./VertexColor.glsl-e415cf02.js";
+import "./OrderIndependentTransparency-3eadfe42.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./BindType-5e76c8e1.js";
+import "./Indices-e6dc3b15.js";
+import "./doublePrecisionUtils-46e21550.js";
+import "./requestImageUtils-37d79281.js";
+import "./orientedBoundingBox-554ccdc6.js";
+import "./quat-a508aed3.js";
+import "./computeTranslationToOriginAndRotation-4876cb93.js";
+import "./BufferObject-cbd0168e.js";
+import "./axisAngleDegrees-32643b7c.js";
+import "./NestedMap-83f8e815.js";
+import "./floatRGBA-516d7961.js";
+import "./MemCache-a9232ec2.js";
+import "./vec3f32-304a6a9c.js";
+import "./FeatureFilter-8c5e44b1.js";
+import "./floorFilterUtils-936f7587.js";
+import "./layerViewUtils-052e603c.js";
+import "./geometryEngine-d3bb2fd6.js";
+import "./hydrated-0e1c7565.js";
+import "./VertexSnappingCandidate-b676241f.js";
+import "./LRUCache-27e8c401.js";
+let r = class extends E {
+  get availability() {
+    return 1;
+  }
+  get updating() {
+    return this.layerSource.updating;
+  }
+  get _snappingElevationAligner() {
+    const { view: t } = this, { layer: e } = this.layerSource, i = t != null && t.type === "3d";
+    if (!i || e.type === "subtype-group")
+      return d();
+    const o = async (a, l) => (await $(t.whenLayerView(e), l)).elevationAlignPointsInFeatures(a, l);
+    return d(i, { elevationInfo: e.elevationInfo, alignPointsInFeatures: o });
+  }
+  get _snappingElevationFilter() {
+    const { view: t } = this, e = t != null && t.type === "3d" && this.layerSource.layer.type !== "subtype-group";
+    return q(e);
+  }
+  get _symbologySnappingFetcher() {
+    const { view: t } = this, { layer: e } = this.layerSource;
+    return t != null && t.type === "3d" && e.type !== "subtype-group" ? S(this._symbologySnappingSupported, async (i, o) => {
+      const a = await t.whenLayerView(e);
+      return s(o), a.queryForSymbologySnapping({ candidates: i, spatialReference: t.spatialReference }, o);
+    }) : S();
+  }
+  get _symbologySnappingSupported() {
+    return this._layerView3D != null && this._layerView3D.symbologySnappingSupported;
+  }
+  initialize() {
+    const { view: t } = this, { layer: e } = this.layerSource;
+    t != null && t.type === "3d" && e.type !== "subtype-group" && (t.whenLayerView(e).then((i) => this._layerView3D = i), this.addHandles([t.elevationProvider.on("elevation-change", ({ context: i }) => {
+      const { elevationInfo: o } = e;
+      I(i, o) && this._snappingElevationAligner.notifyElevationSourceChange();
+    }), c(() => e.elevationInfo, () => this._snappingElevationAligner.notifyElevationSourceChange(), h), c(() => {
+      var i;
+      return this._layerView3D != null ? (i = this._layerView3D.processor) == null ? void 0 : i.renderer : null;
+    }, () => this._symbologySnappingFetcher.notifySymbologyChange(), h), F(() => {
+      var i;
+      return (i = this._layerView3D) == null ? void 0 : i.layer;
+    }, ["edits", "apply-edits", "graphic-update"], () => this._symbologySnappingFetcher.notifySymbologyChange())]));
+  }
+  constructor(t) {
+    super(t), this.view = null, this._layerView3D = null, this._memoizedMakeGetGroundElevation = C(G);
+  }
+  refresh() {
+  }
+  async fetchCandidates(t, e) {
+    var g;
+    const { layer: i } = this.layerSource, o = i.source;
+    if (!(o != null && o.querySnapping))
+      return [];
+    const a = D(i), l = A(t, ((g = this.view) == null ? void 0 : g.type) ?? "2d", a), v = await o.querySnapping(l, { signal: e });
+    s(e);
+    const y = t.coordinateHelper.spatialReference, m = await this._snappingElevationAligner.alignCandidates(v.candidates, y, e);
+    s(e);
+    const u = await this._symbologySnappingFetcher.fetch(m, e);
+    s(e);
+    const w = u.length === 0 ? m : [...m, ...u], _ = this._snappingElevationFilter.filter(l, w), f = this._memoizedMakeGetGroundElevation(this.view, y);
+    return _.map((b) => P(b, f));
+  }
+};
+p([n({ constructOnly: !0 })], r.prototype, "layerSource", void 0), p([n({ constructOnly: !0 })], r.prototype, "view", void 0), p([n()], r.prototype, "_snappingElevationAligner", null), p([n()], r.prototype, "_snappingElevationFilter", null), p([n()], r.prototype, "_symbologySnappingFetcher", null), p([n()], r.prototype, "_layerView3D", void 0), p([n()], r.prototype, "_symbologySnappingSupported", null), r = p([V("esri.views.interactive.snapping.featureSources.FeatureCollectionSnappingSource")], r);
+export {
+  r as FeatureCollectionSnappingSource
+};