@agrotools1/at-components 0.3.5-5 → 0.3.6-5

package/dist/GraphicsLayer-435613fc.js

@@ -0,0 +1,38 @@
+import { d as s, e as t, y as i, aZ as a, c as p, a_ as h } from "./index-5b6496c1.js";
+import { n } from "./BlendLayer-b601f585.js";
+import { t as c } from "./ScaleRangeLayer-5ee887eb.js";
+import { h as d } from "./ElevationInfo-ed1f4555.js";
+let r = class extends n(c(h)) {
+  constructor(e) {
+    super(e), this.elevationInfo = null, this.graphics = new s(), this.screenSizePerspectiveEnabled = !0, this.type = "graphics", this.internal = !1;
+  }
+  destroy() {
+    this.removeAll(), this.graphics.destroy();
+  }
+  add(e) {
+    return this.graphics.add(e), this;
+  }
+  addMany(e) {
+    return this.graphics.addMany(e), this;
+  }
+  removeAll() {
+    return this.graphics.removeAll(), this;
+  }
+  remove(e) {
+    this.graphics.remove(e);
+  }
+  removeMany(e) {
+    this.graphics.removeMany(e);
+  }
+  on(e, o) {
+    return super.on(e, o);
+  }
+  graphicChanged(e) {
+    this.emit("graphic-update", e);
+  }
+};
+t([i({ type: d })], r.prototype, "elevationInfo", void 0), t([i(a(s, "graphics"))], r.prototype, "graphics", void 0), t([i({ type: ["show", "hide"] })], r.prototype, "listMode", void 0), t([i()], r.prototype, "screenSizePerspectiveEnabled", void 0), t([i({ readOnly: !0 })], r.prototype, "type", void 0), t([i({ constructOnly: !0 })], r.prototype, "internal", void 0), r = t([p("esri.layers.GraphicsLayer")], r);
+const g = r;
+export {
+  g as h
+};

package/dist/GraphicsLayerView2D-396a5c04.js

@@ -0,0 +1,114 @@
+import { x as a, z as m, V as g, B as n, g as o, e as s, y as c, c as l } from "./index-5b6496c1.js";
+import { t as d } from "./highlightReasons-70b84c32.js";
+import { m as u, u as w } from "./LayerView-dc4ce424.js";
+import { t as y } from "./GraphicContainer-c29d537d.js";
+import { $ as V } from "./GraphicsView2D-548609f3.js";
+import { t as f } from "./HighlightCounter-eca069ae.js";
+import "vue";
+import "./scaleUtils-20fabb63.js";
+import "./Container-14f505c0.js";
+import "./parser-60d688e7.js";
+import "./definitions-a00a3a6c.js";
+import "./enums-2c166c09.js";
+import "./Texture-e434c1ed.js";
+import "./AGraphicContainer-8c9b2ac4.js";
+import "./TechniqueInstance-8f9c46f9.js";
+import "./UpdateTracking2D-2c532d68.js";
+import "./TurboLine-33d9b8e3.js";
+import "./enums-fa8f05ab.js";
+import "./earcut-0620e773.js";
+import "./GeometryUtils-0befb2c3.js";
+import "./OptimizedGeometry-3b808152.js";
+import "./utils-66783f9d.js";
+import "./Rect-894f011c.js";
+import "./LabelMetric-868f5063.js";
+import "./Program-ffdb8d8b.js";
+import "./BufferObject-48edf970.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./defaults-c2a9563f.js";
+import "./defaultsJSON-ba17aa15.js";
+import "./BindType-5e76c8e1.js";
+import "./Util-79c67a06.js";
+import "./vec42-3cf082e4.js";
+import "./vec4f64-043e974c.js";
+import "./constants-5bd557fe.js";
+import "./TileContainer-3cb306b0.js";
+import "./WGLContainer-02f424a7.js";
+import "./VertexArrayObject-3c588329.js";
+import "./vec4f32-b2628ced.js";
+import "./ProgramTemplate-cd8ea7d1.js";
+import "./StyleDefinition-f4862d5a.js";
+import "./config-61215215.js";
+import "./featureConversionUtils-3c1e5c64.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./FeatureCommandQueue-54607a57.js";
+import "./lengthUtils-f0bfb8e2.js";
+import "./vec3f32-304a6a9c.js";
+import "./FieldsIndex-7395c158.js";
+import "./UnknownTimeZone-6e630bad.js";
+import "./OverrideHelper-9a853be0.js";
+import "./colorUtils-2fce3a34.js";
+import "./quantizationUtils-8294a9a0.js";
+import "./AttributeStore-f7cfcb7c.js";
+import "./labelUtils-58cb2a65.js";
+import "./TimeOnly-21ef799a.js";
+import "./timeSupport-88190ba5.js";
+import "./json-5febf88a.js";
+import "./diffUtils-65d58fa2.js";
+import "./normalizeUtilsSync-7db162b9.js";
+let p = class extends u(w) {
+  constructor() {
+    super(...arguments), this._highlightCounter = new f();
+  }
+  attach() {
+    this.graphicsView = new V({ requestUpdateCallback: () => this.requestUpdate(), view: this.view, graphics: this.layer.graphics, container: new y(this.view.featuresTilingScheme), layerId: this.layer.id }), this.container.addChild(this.graphicsView.container), this.addAttachHandles(this.layer.on("graphic-update", this.graphicsView.graphicUpdateHandler)), this._updateHighlight();
+  }
+  detach() {
+    this.container.removeAllChildren(), this.graphicsView = a(this.graphicsView);
+  }
+  async hitTest(i) {
+    return this.graphicsView ? this.graphicsView.hitTest(i).map((t) => ({ type: "graphic", graphic: t, mapPoint: i, layer: this.layer })) : null;
+  }
+  queryGraphics() {
+    return Promise.resolve(this.graphicsView.graphics);
+  }
+  update(i) {
+    this.graphicsView.processUpdate(i);
+  }
+  moveStart() {
+  }
+  viewChange() {
+    this.graphicsView.viewChange();
+  }
+  moveEnd() {
+  }
+  isUpdating() {
+    return !this.graphicsView || this.graphicsView.updating;
+  }
+  highlight(i, t = "highlight") {
+    let r;
+    typeof i == "number" ? r = [i] : i instanceof m ? r = [i.uid] : Array.isArray(i) && i.length > 0 ? r = typeof i[0] == "number" ? i : i.map((h) => h && h.uid) : g.isCollection(i) && i.length > 0 && (r = i.map((h) => h && h.uid).toArray());
+    const e = r == null ? void 0 : r.filter(n);
+    return e != null && e.length ? (this._addHighlight(e, t), o(() => this._removeHighlight(e, t))) : o();
+  }
+  _addHighlight(i, t) {
+    this._highlightCounter.addReason(i, t), this._updateHighlight();
+  }
+  _removeHighlight(i, t) {
+    this._highlightCounter.deleteReason(i, t), this._updateHighlight();
+  }
+  _updateHighlight() {
+    var t;
+    const i = [];
+    for (const r of this._highlightCounter.ids()) {
+      const e = this._highlightCounter.getHighestReason(r), h = d(e);
+      i.push({ objectId: r, highlightFlags: h });
+    }
+    (t = this.graphicsView) == null || t.setHighlight(i);
+  }
+};
+s([c()], p.prototype, "graphicsView", void 0), p = s([l("esri.views.2d.layers.GraphicsLayerView2D")], p);
+const $i = p;
+export {
+  $i as default
+};

package/dist/GraphicsSnappingSource-d1256955.js

@@ -0,0 +1,273 @@
+import { S, dF as v, P as u, o as w, H as b, dG as k, bJ as m, dj as E, bS as F, b0 as C, b6 as P, bT as $, dB as G, e as a, y as l, c as H, dE as I, dH as A } from "./index-5b6496c1.js";
+import { t as R, f as O, y as x } from "./MeasurementWidgetContent-4d42eedf.js";
+import { a as z } from "./normalizeUtilsSync-7db162b9.js";
+import { o as Z } from "./featureConversionUtils-3c1e5c64.js";
+import { t as M } from "./OptimizedGeometry-3b808152.js";
+import { m as L } from "./FeatureStore-5880cfb5.js";
+import { $ as W } from "./QueryEngine-3fd7ffd7.js";
+import { Z as j } from "./FieldsIndex-7395c158.js";
+import { E as J } from "./elevationInfoUtils-f23e102a.js";
+import { J as y } from "./utils-ef92af53.js";
+import { a as T, o as q } from "./queryEngineUtils-049e3277.js";
+import { i as g, r as N, n as _ } from "./symbologySnappingCandidates-60ac5870.js";
+import { I as U } from "./Scheduler-57f58fb5.js";
+import "vue";
+import "./vec42-3cf082e4.js";
+import "./vec4f64-043e974c.js";
+import "./plane-c68e0078.js";
+import "./mat3f64-03233387.js";
+import "./mat4f64-cce69db4.js";
+import "./quatf64-bec1af25.js";
+import "./sphere-c8b8d2f4.js";
+import "./ObjectStack-e1b78554.js";
+import "./projectVectorToVector-94ea313f.js";
+import "./projectPointToVector-4f88b833.js";
+import "./meshVertexSpaceUtils-5ad91792.js";
+import "./MeshLocalVertexSpace-b50bc760.js";
+import "./vec3-6fc5c98f.js";
+import "./quantityUtils-7b42fe24.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./BoundsStore-870db8b1.js";
+import "./PooledRBush-e6121cf5.js";
+import "./timeSupport-88190ba5.js";
+import "./json-5febf88a.js";
+import "./MemCache-e0d2fb77.js";
+import "./LRUCache-9af70841.js";
+import "./WhereClause-c7269737.js";
+import "./TimeOnly-21ef799a.js";
+import "./UnknownTimeZone-6e630bad.js";
+import "./QueryEngineCapabilities-0d8477a2.js";
+import "./quantizationUtils-8294a9a0.js";
+import "./utils-9793ea80.js";
+import "./heatmapUtils-1c9f8343.js";
+import "./utils-b2f7854d.js";
+import "./utils-7d562724.js";
+import "./ClassBreaksDefinition-f70c82c6.js";
+import "./unitConversionUtils-106c6b0b.js";
+import "./lengthUtils-f0bfb8e2.js";
+import "./parser-60d688e7.js";
+import "./utils-66783f9d.js";
+import "./InteractiveAnalysisViewModel-83bf375d.js";
+import "./geometryEngineBase-c4b11c2f.js";
+import "./colorUtils-2fce3a34.js";
+import "./vec4f32-b2628ced.js";
+import "./Octree-f900126e.js";
+import "./Util-79c67a06.js";
+import "./lineSegment-c22cd085.js";
+import "./triangle-0ad4da78.js";
+import "./DoubleArray-b024f2e4.js";
+import "./glUtil-8f8bce6b.js";
+import "./enums-2c166c09.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./InterleavedLayout-73357178.js";
+import "./BufferView-35ce41c8.js";
+import "./types-adba9034.js";
+import "./VertexArrayObject-3c588329.js";
+import "./Texture-e434c1ed.js";
+import "./VertexAttribute-faad30bf.js";
+import "./VertexColor.glsl-bf540843.js";
+import "./OrderIndependentTransparency-3eadfe42.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./BindType-5e76c8e1.js";
+import "./Indices-0f1d8539.js";
+import "./doublePrecisionUtils-46e21550.js";
+import "./requestImageUtils-c953d853.js";
+import "./orientedBoundingBox-6d95d542.js";
+import "./quat-4e06fa53.js";
+import "./computeTranslationToOriginAndRotation-d7eabc4f.js";
+import "./BufferObject-48edf970.js";
+import "./axisAngleDegrees-c59eac48.js";
+import "./RenderState-b244097f.js";
+import "./NestedMap-83f8e815.js";
+import "./floatRGBA-589cf5b3.js";
+import "./vec3f32-304a6a9c.js";
+import "./FeatureFilter-c664009b.js";
+import "./floorFilterUtils-936f7587.js";
+import "./layerViewUtils-052e603c.js";
+import "./geometryEngine-962a31ac.js";
+import "./hydrated-9a3c2b9e.js";
+import "./VertexSnappingCandidate-ff1026f6.js";
+const f = "graphics-collections";
+let n = class extends S {
+  get updating() {
+    return this._updatingHandles.updating;
+  }
+  get _hasZ() {
+    const t = this.view;
+    return t != null && t.type === "3d" && this.layerSource.layer.type !== "map-notes";
+  }
+  get _snappingElevationAligner() {
+    const { view: t } = this, { layer: e } = this.layerSource, i = t != null && t.type === "3d";
+    if (!i || e.type === "map-notes")
+      return g();
+    const o = async (r, s) => (await I(t.whenLayerView(e), s)).elevationAlignPointsInFeatures(r, s);
+    return g(i, { elevationInfo: e.elevationInfo, alignPointsInFeatures: o });
+  }
+  get _snappingElevationFilter() {
+    const { view: t } = this, e = t != null && t.type === "3d" && this.layerSource.layer.type !== "map-notes";
+    return N(e);
+  }
+  get _symbologySnappingFetcher() {
+    const { view: t } = this, { layer: e } = this.layerSource, i = t != null && t.type === "3d", o = this._extrudedPolygonSymbolsCount > 0;
+    return i && e.type !== "map-notes" && o ? _(o, async (r, s) => {
+      const p = await t.whenLayerView(e);
+      return m(s), p.queryForSymbologySnapping({ candidates: r, spatialReference: t.spatialReference }, s);
+    }) : _();
+  }
+  constructor(t) {
+    super(t), this.availability = 1, this._sources = { multipoint: null, point: null, polygon: null, polyline: null }, this._loadedWkids = /* @__PURE__ */ new Set(), this._loadedWkts = /* @__PURE__ */ new Set(), this._pendingAdds = [], this._extrudedPolygonSymbolsCount = 0, this._updatingHandles = new v(), this._memoizedMakeGetGroundElevation = R(q);
+  }
+  destroy() {
+    for (const t of this._pendingAdds)
+      t.task.abort();
+    this._pendingAdds.length = 0, this._mapSources((t) => this._destroySource(t)), this._updatingHandles.destroy();
+  }
+  initialize() {
+    this._updatingHandles.add(() => this.getGraphicsLayers(), (i) => {
+      this._updatingHandles.removeHandles(f);
+      for (const o of i)
+        this._addMany(o.graphics.toArray()), this.addHandles([o.on("graphic-update", (r) => this._onGraphicUpdate(r)), this._updatingHandles.addOnCollectionChange(() => o.graphics, (r) => this._onGraphicsChanged(r))], f);
+    }, u);
+    const { view: t } = this, { layer: e } = this.layerSource;
+    t != null && t.type === "3d" && e.type !== "map-notes" && t.elevationProvider && this.addHandles([t.elevationProvider.on("elevation-change", ({ context: i }) => {
+      J(i, e.elevationInfo) && this._snappingElevationAligner.notifyElevationSourceChange();
+    }), w(() => e.elevationInfo, () => this._snappingElevationAligner.notifyElevationSourceChange(), u), b(() => e, ["edits", "apply-edits", "graphic-update"], () => this._symbologySnappingFetcher.notifySymbologyChange())]);
+  }
+  async fetchCandidates(t, e) {
+    const { point: i, coordinateHelper: { spatialReference: o } } = t, r = await k(this._mapSources((d) => this._fetchCandidatesForSource(d, t, e)));
+    m(e);
+    const s = this._memoizedMakeGetGroundElevation(this.view, o), p = r.flat().map((d) => T(d, s));
+    return O(i, p), p;
+  }
+  async _fetchCandidatesForSource(t, e, i) {
+    var h;
+    const o = x(e, ((h = this.view) == null ? void 0 : h.type) ?? "2d"), r = await t.queryEngine.executeQueryForSnapping(o, i);
+    m(i);
+    const s = await this._snappingElevationAligner.alignCandidates(r.candidates, e.coordinateHelper.spatialReference, i);
+    m(i);
+    const p = await this._symbologySnappingFetcher.fetch(s, i);
+    m(i);
+    const d = p.length === 0 ? s : [...s, ...p];
+    return this._snappingElevationFilter.filter(o, d);
+  }
+  refresh() {
+  }
+  _onGraphicUpdate(t) {
+    if (this.getGraphicsLayers().some((e) => e.graphics.includes(t.graphic)))
+      switch (t.property) {
+        case "geometry":
+        case "visible":
+          this._remove(t.graphic), this._addMany([t.graphic]);
+      }
+  }
+  _onGraphicsChanged(t) {
+    for (const e of t.removed)
+      this._remove(e);
+    this._addMany(t.added);
+  }
+  _addMany(t) {
+    const e = [], i = /* @__PURE__ */ new Map();
+    for (const o of t)
+      o.geometry != null && (this._needsInitializeProjection(o.geometry.spatialReference) ? (e.push(o.geometry.spatialReference), i.set(o.uid, o)) : this._add(o));
+    this._createPendingAdd(e, i);
+  }
+  _createPendingAdd(t, e) {
+    if (!t.length)
+      return;
+    const i = E(async (s) => {
+      await F(t.map((p) => ({ source: p, dest: this.spatialReference })), { signal: s }), this._markLoadedSpatialReferences(t);
+      for (const [, p] of e)
+        this._add(p);
+    });
+    this._updatingHandles.addPromise(i.promise);
+    const o = { task: i, graphics: e }, r = () => A(this._pendingAdds, o);
+    i.promise.then(r, r), this._pendingAdds.push(o);
+  }
+  _markLoadedSpatialReferences(t) {
+    for (const e of t) {
+      e.wkid != null && this._loadedWkids.add(e.wkid);
+      const i = e.wkt2 || e.wkt;
+      i && this._loadedWkts.add(i);
+    }
+  }
+  _add(t) {
+    if (t.geometry == null || !t.visible)
+      return;
+    let e = t.geometry;
+    if (e.type === "mesh")
+      return;
+    e.type === "extent" && (e = C.fromExtent(e));
+    const i = this._ensureSource(e.type);
+    if (i == null)
+      return;
+    const o = this._createOptimizedFeature(t.uid, e);
+    o != null && (i.featureStore.add(o), y(t.symbol) && this._extrudedPolygonSymbolsCount++);
+  }
+  _needsInitializeProjection(t) {
+    if (t.wkid != null && this._loadedWkids.has(t.wkid))
+      return !1;
+    const e = t.wkt2 || t.wkt;
+    return (!e || !this._loadedWkts.has(e)) && !P(t, this.spatialReference);
+  }
+  _createOptimizedFeature(t, e) {
+    const i = $(z(e), this.spatialReference);
+    if (!i)
+      return null;
+    const o = this._ensureGeometryHasZ(i), r = Z(o, this._hasZ, !1);
+    return new M(r, { [c]: t }, null, t);
+  }
+  _ensureGeometryHasZ(t) {
+    if (!this._hasZ)
+      return t;
+    const e = (o) => {
+      for (; o.length < 3; )
+        o.push(0);
+    }, i = t.clone();
+    switch (i.hasZ = !0, i.type) {
+      case "point":
+        i.z = i.z ?? 0;
+        break;
+      case "multipoint":
+        i.points.forEach(e);
+        break;
+      case "polyline":
+        i.paths.forEach((o) => o.forEach(e));
+        break;
+      case "polygon":
+        i.rings.forEach((o) => o.forEach(e));
+    }
+    return i;
+  }
+  _ensureSource(t) {
+    const e = this._sources[t];
+    if (e != null)
+      return e;
+    const i = this._createSource(t);
+    return this._sources[t] = i, i;
+  }
+  _createSource(t) {
+    const e = G.toJSON(t), i = this._hasZ, o = new L({ geometryType: e, hasZ: i, hasM: !1 });
+    return { featureStore: o, queryEngine: new W({ featureStore: o, fieldsIndex: j.fromLayerJSON({ fields: [{ name: c, type: "esriFieldTypeOID", alias: c }] }), geometryType: e, hasM: !1, hasZ: i, objectIdField: c, spatialReference: this.spatialReference, priority: U.SNAPPING, scheduler: this.view != null && this.view.type === "3d" ? this.view.resourceController.scheduler : null }), type: t };
+  }
+  _remove(t) {
+    this._mapSources((e) => this._removeFromSource(e, t));
+    for (const e of this._pendingAdds)
+      e.graphics.delete(t.uid), e.graphics.size === 0 && e.task.abort();
+  }
+  _removeFromSource(t, e) {
+    const i = e.uid;
+    t.featureStore.has(i) && (t.featureStore.removeById(e.uid), y(e.symbol) && this._extrudedPolygonSymbolsCount--);
+  }
+  _destroySource(t) {
+    t.queryEngine.destroy(), this._sources[t.type] = null;
+  }
+  _mapSources(t) {
+    const { point: e, polygon: i, polyline: o, multipoint: r } = this._sources, s = [];
+    return e != null && s.push(t(e)), i != null && s.push(t(i)), o != null && s.push(t(o)), r != null && s.push(t(r)), s;
+  }
+};
+a([l()], n.prototype, "getGraphicsLayers", void 0), a([l({ constructOnly: !0 })], n.prototype, "layerSource", void 0), a([l({ constructOnly: !0 })], n.prototype, "spatialReference", void 0), a([l({ constructOnly: !0 })], n.prototype, "view", void 0), a([l({ readOnly: !0 })], n.prototype, "updating", null), a([l({ readOnly: !0 })], n.prototype, "availability", void 0), a([l()], n.prototype, "_hasZ", null), a([l()], n.prototype, "_snappingElevationAligner", null), a([l()], n.prototype, "_snappingElevationFilter", null), a([l()], n.prototype, "_symbologySnappingFetcher", null), a([l()], n.prototype, "_extrudedPolygonSymbolsCount", void 0), n = a([H("esri.views.interactive.snapping.featureSources.GraphicsSnappingSource")], n);
+const c = "OBJECTID";
+export {
+  n as GraphicsSnappingSource
+};