@agrotools1/at-components 0.3.2 → 0.3.4-5

package/dist/GraphicsLayer-f9b7fc38.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-a3d05a4e.js";
+import { n } from "./BlendLayer-fe666ccb.js";
+import { t as c } from "./ScaleRangeLayer-414b8a64.js";
+import { h as d } from "./ElevationInfo-f8db9c05.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-31708583.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-a3d05a4e.js";
+import { t as d } from "./highlightReasons-a80df9f0.js";
+import { m as u, u as w } from "./LayerView-bcde8d4b.js";
+import { t as y } from "./GraphicContainer-2be3c944.js";
+import { $ as V } from "./GraphicsView2D-48bc6a8a.js";
+import { t as f } from "./HighlightCounter-749018b1.js";
+import "vue";
+import "./scaleUtils-e0e8699b.js";
+import "./Container-24bcabec.js";
+import "./parser-841f10cd.js";
+import "./definitions-a00a3a6c.js";
+import "./enums-2c166c09.js";
+import "./Texture-a9913471.js";
+import "./AGraphicContainer-289ab6ad.js";
+import "./TechniqueInstance-405c1ac4.js";
+import "./UpdateTracking2D-b7498801.js";
+import "./TurboLine-fcb2a814.js";
+import "./enums-fa8f05ab.js";
+import "./earcut-45176401.js";
+import "./GeometryUtils-2dea36fe.js";
+import "./OptimizedGeometry-3b808152.js";
+import "./utils-809f2c0c.js";
+import "./Rect-894f011c.js";
+import "./LabelMetric-1da9f3ab.js";
+import "./Program-af89bf2f.js";
+import "./BufferObject-e3e67b62.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./defaults-571bdae0.js";
+import "./defaultsJSON-ba17aa15.js";
+import "./BindType-5e76c8e1.js";
+import "./Util-cdfa8555.js";
+import "./vec42-1ca3a15b.js";
+import "./vec4f64-043e974c.js";
+import "./constants-5bd557fe.js";
+import "./TileContainer-57eb0b8b.js";
+import "./WGLContainer-e1088cce.js";
+import "./VertexArrayObject-d100959c.js";
+import "./vec4f32-b2628ced.js";
+import "./ProgramTemplate-593ab67d.js";
+import "./StyleDefinition-f4862d5a.js";
+import "./config-61215215.js";
+import "./featureConversionUtils-ce35042f.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./FeatureCommandQueue-45208582.js";
+import "./lengthUtils-2f2cfc0b.js";
+import "./vec3f32-304a6a9c.js";
+import "./FieldsIndex-d7b95cd7.js";
+import "./UnknownTimeZone-7580972b.js";
+import "./OverrideHelper-7739efeb.js";
+import "./colorUtils-80904254.js";
+import "./quantizationUtils-3b9c62f9.js";
+import "./AttributeStore-bc1f7e65.js";
+import "./labelUtils-7fcadb59.js";
+import "./TimeOnly-f2b12057.js";
+import "./timeSupport-86600ac7.js";
+import "./json-5febf88a.js";
+import "./diffUtils-d595111c.js";
+import "./normalizeUtilsSync-bea2fc58.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-1c67e61d.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-a3d05a4e.js";
+import { t as R, f as O, y as x } from "./MeasurementWidgetContent-e2f7712f.js";
+import { a as z } from "./normalizeUtilsSync-bea2fc58.js";
+import { o as Z } from "./featureConversionUtils-ce35042f.js";
+import { t as M } from "./OptimizedGeometry-3b808152.js";
+import { m as L } from "./FeatureStore-d8da0232.js";
+import { $ as W } from "./QueryEngine-5b170abd.js";
+import { Z as j } from "./FieldsIndex-d7b95cd7.js";
+import { E as J } from "./elevationInfoUtils-1d1e5962.js";
+import { J as y } from "./utils-b145a3ab.js";
+import { a as T, o as q } from "./queryEngineUtils-0566980b.js";
+import { i as g, r as N, n as _ } from "./symbologySnappingCandidates-b74bba63.js";
+import { I as U } from "./Scheduler-cad9ed50.js";
+import "vue";
+import "./vec42-1ca3a15b.js";
+import "./vec4f64-043e974c.js";
+import "./plane-7439f515.js";
+import "./mat3f64-03233387.js";
+import "./mat4f64-cce69db4.js";
+import "./quatf64-bec1af25.js";
+import "./sphere-4b51c308.js";
+import "./ObjectStack-2dcbe343.js";
+import "./projectVectorToVector-dc4f9075.js";
+import "./projectPointToVector-1d44e9e0.js";
+import "./meshVertexSpaceUtils-91f680d6.js";
+import "./MeshLocalVertexSpace-2a137632.js";
+import "./vec3-1254a687.js";
+import "./quantityUtils-8fb2344b.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./BoundsStore-8e05ef4f.js";
+import "./PooledRBush-0535aeb8.js";
+import "./timeSupport-86600ac7.js";
+import "./json-5febf88a.js";
+import "./MemCache-edc290a8.js";
+import "./LRUCache-18372286.js";
+import "./WhereClause-2298322b.js";
+import "./TimeOnly-f2b12057.js";
+import "./UnknownTimeZone-7580972b.js";
+import "./QueryEngineCapabilities-0d8477a2.js";
+import "./quantizationUtils-3b9c62f9.js";
+import "./utils-18a172d8.js";
+import "./heatmapUtils-fa02af83.js";
+import "./utils-ca305337.js";
+import "./utils-5c22cc59.js";
+import "./ClassBreaksDefinition-74d45c4a.js";
+import "./unitConversionUtils-1f174f0a.js";
+import "./lengthUtils-2f2cfc0b.js";
+import "./parser-841f10cd.js";
+import "./utils-809f2c0c.js";
+import "./InteractiveAnalysisViewModel-7f97091f.js";
+import "./geometryEngineBase-f4b5ba37.js";
+import "./colorUtils-80904254.js";
+import "./vec4f32-b2628ced.js";
+import "./Octree-4cefe4d0.js";
+import "./Util-cdfa8555.js";
+import "./lineSegment-738773c9.js";
+import "./triangle-0862aaaa.js";
+import "./DoubleArray-831931a7.js";
+import "./glUtil-8f8bce6b.js";
+import "./enums-2c166c09.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./InterleavedLayout-6b6c63b3.js";
+import "./BufferView-68dc0cfa.js";
+import "./types-adba9034.js";
+import "./VertexArrayObject-d100959c.js";
+import "./Texture-a9913471.js";
+import "./VertexAttribute-faad30bf.js";
+import "./VertexColor.glsl-39d73de9.js";
+import "./OrderIndependentTransparency-3eadfe42.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./BindType-5e76c8e1.js";
+import "./Indices-47421f35.js";
+import "./doublePrecisionUtils-46e21550.js";
+import "./requestImageUtils-27feb4bc.js";
+import "./orientedBoundingBox-dcadfac1.js";
+import "./quat-21571234.js";
+import "./computeTranslationToOriginAndRotation-afe53590.js";
+import "./BufferObject-e3e67b62.js";
+import "./axisAngleDegrees-541e21e5.js";
+import "./RenderState-b244097f.js";
+import "./NestedMap-83f8e815.js";
+import "./floatRGBA-db3504b8.js";
+import "./vec3f32-304a6a9c.js";
+import "./FeatureFilter-e04ef24c.js";
+import "./floorFilterUtils-936f7587.js";
+import "./layerViewUtils-052e603c.js";
+import "./geometryEngine-2e792902.js";
+import "./hydrated-ffe82711.js";
+import "./VertexSnappingCandidate-4ec8ecd9.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
+};