@agrotools1/at-components 0.6.15 → 0.6.17

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/Graphics3DWaterSymbolLayer.js

@@ -0,0 +1,151 @@
+import E from "../../../../Color.js";
+import { getMetersPerUnitForSR as L } from "../../../../core/unitUtils.js";
+import { e as x } from "../../../../chunks/earcut.js";
+import { set as O } from "../../../../core/libs/gl-matrix-2/math/vec2.js";
+import { fromValues as T, create as f } from "../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { b as R } from "../../../../chunks/vec42.js";
+import { toRadian as $ } from "../../../../core/libs/gl-matrix-2/math/common.js";
+import { create as V, empty as g, expandWithBuffer as _, intersectsClippingArea as v, expandWithAABB as U } from "../../../../geometry/support/aaBoundingBox.js";
+import { create as W, empty as B, expandPointInPlace as M } from "../../../../geometry/support/aaBoundingRect.js";
+import { newDoubleArray as D, doubleSubArray as C } from "../../../../geometry/support/DoubleArray.js";
+import { perVertexElevationAligner as I } from "./ElevationAligners.js";
+import { SymbolUpdateType as y, elevationModeChangeUpdateType as j, needsElevationUpdates2D as b } from "./elevationAlignmentUtils.js";
+import { Graphics3DDrapedGraphicLayer as z } from "./Graphics3DDrapedGraphicLayer.js";
+import { Graphics3DObject3DGraphicLayer as F } from "./Graphics3DObject3DGraphicLayer.js";
+import { Graphics3DSymbolLayer as N } from "./Graphics3DSymbolLayer.js";
+import { geometryAsPolygon as S, createWaterGeometry as G, PolygonCreationDataBase as P } from "./polygonUtils.js";
+import { geometryToRenderInfo as H, geometryToRenderInfoDraped as k } from "../../support/renderInfoUtils/polygon.js";
+import { Object3D as q } from "../../webgl-engine/lib/Object3D.js";
+import { RenderGeometry as J } from "../../webgl-engine/lib/RenderGeometry.js";
+import { WaterMaterialParameters as K, WaterMaterial as Q } from "../../webgl-engine/materials/WaterMaterial.js";
+import { wavePresets as X } from "../../webgl-engine/materials/internal/waterMaterialUtils.js";
+const Y = ["polyline", "polygon", "extent"];
+class l extends N {
+  constructor(e, t, r, o) {
+    super(e, t, r, o);
+  }
+  async doLoad() {
+  }
+  destroy() {
+    super.destroy(), this._context.stage.remove(this._materials[0]), this._materials.length = 0;
+  }
+  createGraphics3DGraphic(e) {
+    const t = e.graphic;
+    if (!this._validateGeometry(t.geometry, Y, this.symbolLayer.type))
+      return null;
+    const r = this.setGraphicElevationContext(t);
+    return this.ensureDrapedStatus(r.mode === "on-the-ground"), this.ensureMaterial(), this.draped ? this._createAsOverlay(t) : this._createAs3DShape(t, r, t.uid);
+  }
+  ensureMaterial() {
+    if (this._materials[0])
+      return;
+    const e = new K(), t = this.symbolLayer.color;
+    t != null && (e.color = E.toUnitRGBA(t));
+    const r = this._getCombinedOpacity(t, { hasIntrinsicColor: !0 });
+    e.color = [e.color[0], e.color[1], e.color[2], r], e.transparent = r < 1 || this.needsDrivenTransparentPass, e.waveDirection = this.symbolLayer.waveDirection != null ? l.headingVectorFromAngle(this.symbolLayer.waveDirection) : T(0, 0);
+    const o = this.symbolLayer.waveStrength + "-" + this.symbolLayer.waterbodySize, s = X[o];
+    e.waveStrength = s.waveStrength, e.waveTextureRepeat = s.textureRepeat, e.waveVelocity = s.waveVelocity, e.flowStrength = s.perturbationStrength, e.hasSlicePlane = this._context.slicePlaneEnabled, e.draped = this.draped, this._materials[0] = new Q(e), this._context.stage.add(this._materials[0]);
+  }
+  layerOpacityChanged() {
+    if (this._materials[0] == null)
+      return;
+    const e = this._materials[0].parameters.color, t = this._getCombinedOpacity(this.symbolLayer.color, { hasIntrinsicColor: !0 }), r = t < 1 || this.needsDrivenTransparentPass;
+    this._materials[0].setParameters({ color: [e[0], e[1], e[2], t], transparent: r });
+  }
+  layerElevationInfoChanged(e, t, r) {
+    const o = this._elevationContext.mode, s = j(l.elevationModeChangeTypes, r, o);
+    if (s !== y.UPDATE)
+      return s;
+    const i = b(o);
+    return this.updateGraphics3DGraphicElevationInfo(e, t, () => i);
+  }
+  slicePlaneEnabledChanged() {
+    var e;
+    return (e = this._materials[0]) == null || e.setParameters({ hasSlicePlane: this._context.slicePlaneEnabled }), !0;
+  }
+  physicalBasedRenderingChanged() {
+    return !0;
+  }
+  _createAs3DShape(e, t, r) {
+    var p;
+    const o = S(e.geometry);
+    if (o == null)
+      return null;
+    const s = H(o, this._context.elevationProvider, this._context.renderCoordsHelper, t), i = s.position.length / 3, n = D(2 * i);
+    this._createUVCoordsFromVertices(n, s.mapPositions, i, this._context.elevationProvider.spatialReference);
+    const a = new Z(s, n, this._context.layer.uid, e.uid);
+    if (a.objectAndLayerIdColor = (p = this._context.stage.renderView) == null ? void 0 : p.getObjectAndLayerIdColor(a), this._create3DShapeGeometries(a), this._logGeometryCreationWarnings(a.renderData, o.rings, "rings", "WaterSymbol3DLayer"), a.outGeometries.length === 0)
+      return null;
+    const m = new q({ geometries: a.outGeometries, castShadow: !1, layerUid: this._context.layer.uid, graphicUid: r }), h = new F(this, m, a.outGeometries, null, null, I, t);
+    return h.alignedSampledElevation = a.renderData.sampledElevation, h.needsElevationUpdates = b(t.mode), h;
+  }
+  _createUVCoordsFromVertices(e, t, r, o) {
+    const s = L(o);
+    B(c);
+    for (let a = 0; a < r; a++)
+      O(A, t[3 * a], t[3 * a + 1]), M(c, A);
+    R(c, c, s);
+    const i = c[0] % l.unitSizeOfTexture, n = c[1] % l.unitSizeOfTexture;
+    u[0] = c[0] - i, u[1] = c[1] - n;
+    for (let a = 0; a < r; a++)
+      e[2 * a] = (t[3 * a] * s - u[0]) / l.unitSizeOfTexture, e[2 * a + 1] = (t[3 * a + 1] * s - u[1]) / l.unitSizeOfTexture;
+  }
+  _create3DShapeGeometries(e) {
+    const t = e.renderData.polygons, r = e.uvCoords;
+    for (const { count: o, index: s, position: i, mapPositions: n, holeIndices: a } of t) {
+      if (this._context.clippingExtent != null && (g(d), _(d, n), !v(d, this._context.clippingExtent)))
+        continue;
+      const m = x(n, a, 3);
+      if (m.length === 0)
+        continue;
+      const h = C(r, 2 * s, 2 * o), p = G({ material: this._materials[0], indices: m, mapPositions: n, attributeData: { position: i, uv0: h } }, e.objectAndLayerIdColor);
+      e.outGeometries.push(p);
+    }
+  }
+  _createAsOverlay(e) {
+    var n;
+    const t = S(e.geometry);
+    if (t == null)
+      return null;
+    this._materials[0].renderPriority = this._renderPriority;
+    const r = k(t, this._context.overlaySR), o = r.position.length / 3, s = D(2 * o);
+    this._createUVCoordsFromVertices(s, r.position, o, this._context.overlaySR);
+    const i = new ee(r, s, this._context.layer.uid, e.uid);
+    return i.objectAndLayerIdColor = (n = this._context.stage.renderView) == null ? void 0 : n.getObjectAndLayerIdColor(i), i.outBoundingBox = g(), this._createAsOverlayWater(i), this._logGeometryCreationWarnings(i.renderData, t.rings, "rings", "WaterSymbol3DLayer"), i.outGeometries.length === 0 ? null : new z(this, i.outGeometries, i.outBoundingBox, this._context.drapeSourceRenderer);
+  }
+  _createAsOverlayWater(e) {
+    const t = e.uvCoords, r = e.renderData.polygons;
+    for (const { position: o, holeIndices: s, index: i, count: n } of r) {
+      if (g(d), _(d, o), !v(d, this._context.clippingExtent))
+        continue;
+      U(e.outBoundingBox, d);
+      const a = x(o, s, 3);
+      if (a.length === 0)
+        continue;
+      const m = C(t, 2 * i, 2 * n), h = G({ material: this._materials[0], indices: a, attributeData: { position: o, uv0: m } }, e.objectAndLayerIdColor);
+      e.outGeometries.push(new J(h, e));
+    }
+  }
+  static headingVectorFromAngle(e) {
+    const t = f(), r = $(e);
+    return t[0] = Math.sin(r), t[1] = Math.cos(r), t;
+  }
+  test() {
+    return { ...super.test(), create3DShape: (e) => this._createAs3DShape(e.graphic, e.elevationContext, e.graphicUid), ensureMaterial: () => this.ensureMaterial() };
+  }
+}
+l.unitSizeOfTexture = 100, l.elevationModeChangeTypes = { definedChanged: y.RECREATE, staysOnTheGround: y.NONE, onTheGroundChanged: y.RECREATE };
+const u = f(), c = W(), A = f(), d = V();
+class Z extends P {
+  constructor(e, t, r, o) {
+    super(e, r, o), this.uvCoords = t;
+  }
+}
+class ee extends P {
+  constructor(e, t, r, o) {
+    super(e, r, o), this.uvCoords = t;
+  }
+}
+export {
+  l as Graphics3DWaterSymbolLayer
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/Graphics3DWebStyleSymbol.js

@@ -0,0 +1,57 @@
+import { emptySymbolComplexity as l } from "./defaultSymbolComplexity.js";
+import { ApplyRendererDiffResult as a } from "./interfaces.js";
+import { Loadable as o } from "./Loadable.js";
+class c extends o {
+  constructor(r, t, s) {
+    super(t), this.symbol = r, this._convert = s, this.symbologySnappingSupported = !1, this.graphics3DSymbol = null, this.referenced = 0;
+  }
+  getSymbolLayerSize(r) {
+    return this.graphics3DSymbol != null ? this.graphics3DSymbol.getSymbolLayerSize(r) : null;
+  }
+  get symbolLayers() {
+    return this.graphics3DSymbol != null ? this.graphics3DSymbol.symbolLayers : [];
+  }
+  get extentPadding() {
+    return this.graphics3DSymbol != null ? this.graphics3DSymbol.extentPadding : 0;
+  }
+  async doLoad(r) {
+    const t = await this.symbol.fetchSymbol({ signal: r });
+    t.id = this.symbol.id, this.graphics3DSymbol = this._convert(t), this.graphics3DSymbol != null && await this.graphics3DSymbol.load();
+  }
+  createGraphics3DGraphic(r) {
+    return this.graphics3DSymbol != null ? this.graphics3DSymbol.createGraphics3DGraphic(r, this) : null;
+  }
+  get complexity() {
+    return this.graphics3DSymbol != null ? this.graphics3DSymbol.complexity : l;
+  }
+  globalPropertyChanged(r, t) {
+    return this.graphics3DSymbol != null && this.graphics3DSymbol.globalPropertyChanged(r, t);
+  }
+  applyRendererDiff(r, t) {
+    return this.graphics3DSymbol != null ? this.graphics3DSymbol.applyRendererDiff(r, t) : a.RecreateSymbol;
+  }
+  prepareSymbolPatch(r) {
+    this.graphics3DSymbol != null && this.graphics3DSymbol.prepareSymbolPatch(r);
+  }
+  updateGeometry(r, t) {
+    return this.graphics3DSymbol != null && this.graphics3DSymbol.updateGeometry(r, t);
+  }
+  updateTransform(r, t, s, e) {
+    var i;
+    return ((i = this.graphics3DSymbol) == null ? void 0 : i.updateTransform(r, t, s, e)) ?? !1;
+  }
+  onRemoveGraphic() {
+  }
+  getFastUpdateStatus() {
+    return this.graphics3DSymbol != null ? this.graphics3DSymbol.getFastUpdateStatus() : { loading: 1, fast: 0, slow: 0 };
+  }
+  destroy() {
+    this.graphics3DSymbol != null && this.graphics3DSymbol.destroy(), this.graphics3DSymbol = void 0, super.destroy();
+  }
+  get destroyed() {
+    return this.graphics3DSymbol === void 0;
+  }
+}
+export {
+  c as Graphics3DWebStyleSymbol
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/GraphicsCorePerformanceInfo.js

@@ -0,0 +1,8 @@
+class n {
+  constructor(s, i, r) {
+    this.visible = s, this.missing = i, this.pending = r;
+  }
+}
+export {
+  n as GraphicsCorePerformanceInfo
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/GraphicsProcessor.js

@@ -0,0 +1,192 @@
+import { _ as n } from "../../../../chunks/tslib.es6.js";
+import h from "../../../../Graphic.js";
+import g from "../../../../core/Accessor.js";
+import m from "../../../../core/Collection.js";
+import { makeHandle as f } from "../../../../core/handleUtils.js";
+import { destroyMaybe as c } from "../../../../core/maybe.js";
+import { isAbortError as b } from "../../../../core/promiseUtils.js";
+import { watch as u, sync as C, syncAndInitial as w } from "../../../../core/reactiveUtils.js";
+import { property as a } from "../../../../core/accessorSupport/decorators/property.js";
+import "../../../../core/has.js";
+import "../../../../core/Logger.js";
+import "../../../../core/RandomLCG.js";
+import { subclass as S } from "../../../../core/accessorSupport/decorators/subclass.js";
+import { diff as V } from "../../../../core/accessorSupport/diffUtils.js";
+import { UpdatingHandles as E } from "../../../../core/support/UpdatingHandles.js";
+import v from "../../../../layers/Layer.js";
+import { hydrateGraphic as G } from "../../../../layers/graphics/hydratedFeatures.js";
+import { getRenderingInfo as O, getRenderingInfoAsync as x } from "../../../../renderers/support/renderingInfoUtils.js";
+import _ from "../../../../rest/support/Query.js";
+import { DrapeSourceType as P } from "../interfaces.js";
+import { suspendResumeExtentOptimism as A } from "./constants.js";
+import { Graphics3DCore as j } from "./Graphics3DCore.js";
+import { Graphics3DElevationAlignment as D } from "./Graphics3DElevationAlignment.js";
+import { Graphics3DFrustumVisibility as I } from "./Graphics3DFrustumVisibility.js";
+import { Graphics3DObjectStates as H } from "./Graphics3DObjectStates.js";
+import { Graphics3DScaleVisibility as R } from "./Graphics3DScaleVisibility.js";
+import { enlargeExtent as z } from "./graphicUtils.js";
+import { Object3DState as p } from "../../webgl-engine/lib/basicInterfaces.js";
+import { UpdatePolicy as U } from "../../webgl-engine/lib/UpdatePolicy.js";
+let r = class extends g {
+  constructor(i) {
+    super(i), this.type = "graphics-3d", this.graphicsCore = null, this.drapeSourceType = P.Features, this.scaleVisibilityEnabled = !1, this.frustumVisibilityEnabled = !1, this._suspendResumeExtent = null, this._updatingHandles = new E();
+  }
+  initialize() {
+    const { layer: i } = this, t = "effectiveScaleRange" in i ? i : null, o = this.scaleVisibilityEnabled && t != null, e = new j({ owner: this, layer: this.owner.layer, preferredUpdatePolicy: U.SYNC, graphicSymbolSupported: !0, componentFactories: { elevationAlignment: (s, l) => new D({ graphicsCoreOwner: this, graphicsCore: s, queryGraphicUIDsInExtent: l, elevationProvider: this.view.elevationProvider }), scaleVisibility: o ? (s, l) => new R({ graphicsCoreOwner: this, layer: t, queryGraphicUIDsInExtent: l, graphicsCore: s, basemapTerrain: this.owner.view.basemapTerrain }) : null, objectStates: (s) => new H(s) } });
+    if (this._set("graphicsCore", e), this.frustumVisibilityEnabled && this._set("frustumVisibility", new I({ graphicsCoreOwner: this })), "fullOpacity" in this.owner) {
+      const s = this.owner;
+      this._updatingHandles.add(() => s.fullOpacity, () => this.graphicsCore.opacityChange());
+    }
+    if ("elevationInfo" in i) {
+      const s = i;
+      this._updatingHandles.add(() => s.elevationInfo, (l, y) => {
+        V(l, y) && this._updatingHandles.addPromise(this.graphicsCore.elevationInfoChange());
+      });
+    }
+    this._set("initializePromise", this._initializeAsync()), this._updatingHandles.addPromise(this.initializePromise);
+  }
+  async _initializeAsync() {
+    try {
+      await this.graphicsCore.initializePromise;
+    } catch (i) {
+      if (b(i))
+        return;
+      throw i;
+    }
+    this.destroyed || (this.addHandles(u(() => this.view.clippingArea, () => this._updateClippingExtent(), C)), this._updateClippingExtent(), this._setupSuspendResumeExtent(), this.graphicsCore.startCreateGraphics());
+  }
+  destroy() {
+    this._updatingHandles.destroy(), this._set("frustumVisibility", c(this.frustumVisibility)), this._set("graphicsCore", c(this.graphicsCore));
+  }
+  get layer() {
+    return this.owner.layer;
+  }
+  get view() {
+    return this.owner.view;
+  }
+  get scaleVisibility() {
+    var i;
+    return (i = this.graphicsCore) == null ? void 0 : i.scaleVisibility;
+  }
+  get elevationAlignment() {
+    var i;
+    return (i = this.graphicsCore) == null ? void 0 : i.elevationAlignment;
+  }
+  get objectStates() {
+    var i;
+    return (i = this.graphicsCore) == null ? void 0 : i.objectStates;
+  }
+  get scaleVisibilitySuspended() {
+    return !(this.scaleVisibility == null || !this.scaleVisibility.suspended);
+  }
+  get frustumVisibilitySuspended() {
+    return this.frustumVisibility != null && this.frustumVisibility.suspended;
+  }
+  get suspended() {
+    return this.owner.suspended ?? !1;
+  }
+  get updating() {
+    var i;
+    return !!((i = this.graphicsCore) != null && i.updating || this.scaleVisibility != null && this.scaleVisibility.updating || this.frustumVisibility != null && this.frustumVisibility.updating || this._updatingHandles.updating);
+  }
+  get graphics3DGraphics() {
+    var i;
+    return (i = this.graphicsCore) == null ? void 0 : i.graphics3DGraphics;
+  }
+  get graphics3DGraphicsByObjectID() {
+    var i;
+    return (i = this.graphicsCore) == null ? void 0 : i.graphics3DGraphicsByObjectID;
+  }
+  get loadedGraphics() {
+    return this.owner.loadedGraphics;
+  }
+  get fullOpacity() {
+    return this.owner.fullOpacity ?? 1;
+  }
+  get slicePlaneEnabled() {
+    return this.owner.slicePlaneEnabled;
+  }
+  get updatePolicy() {
+    return this.owner.updatePolicy;
+  }
+  notifyGraphicGeometryChanged(i) {
+    this.graphicsCore.notifyGraphicGeometryChanged(i);
+  }
+  notifyGraphicVisibilityChanged(i) {
+    this.graphicsCore.notifyGraphicVisibilityChanged(i);
+  }
+  getRenderingInfo(i, t, o) {
+    const e = O(i, { renderer: t, arcade: o });
+    if (e != null && e.color) {
+      const s = e.color;
+      s[0] = s[0] / 255, s[1] = s[1] / 255, s[2] = s[2] / 255;
+    }
+    return e;
+  }
+  getRenderingInfoAsync(i, t, o, e) {
+    return x(i, { renderer: t, arcade: o, ...e });
+  }
+  getHit(i) {
+    if (this.owner.loadedGraphics) {
+      const t = this.owner.loadedGraphics.find((o) => o.uid === i);
+      if (t) {
+        const o = this.layer instanceof v ? this.layer : null, e = G(t, o);
+        return { type: "graphic", graphic: e, layer: e.layer };
+      }
+    }
+    return null;
+  }
+  whenGraphicBounds(i, t) {
+    return this.graphicsCore ? this.graphicsCore.whenGraphicBounds(i, t) : Promise.reject();
+  }
+  computeAttachmentOrigin(i, t) {
+    return this.graphicsCore ? this.graphicsCore.computeAttachmentOrigin(i, t) : null;
+  }
+  getSymbolLayerSize(i, t) {
+    return this.graphicsCore ? this.graphicsCore.getSymbolLayerSize(i, t) : null;
+  }
+  maskOccludee(i) {
+    const { set: t, handle: o } = this.objectStates.acquireSet(p.MaskOccludee, null);
+    return this.objectStates.setUid(t, i.uid), o;
+  }
+  highlight(i) {
+    if (i instanceof _)
+      return d;
+    if (typeof i == "number")
+      return this.highlight([i]);
+    if (i instanceof h)
+      return this.highlight([i]);
+    if (i instanceof m && (i = i.toArray()), Array.isArray(i) && i.length > 0) {
+      if (i[0] instanceof h) {
+        const t = i.map((s) => s.uid), { set: o, handle: e } = this.objectStates.acquireSet(p.Highlight, null);
+        return this.objectStates.setUids(o, t), e;
+      }
+      if (typeof i[0] == "number") {
+        const t = i, { set: o, handle: e } = this.objectStates.acquireSet(p.Highlight, null);
+        return this.objectStates.setObjectIds(o, t), e;
+      }
+    }
+    return d;
+  }
+  _setupSuspendResumeExtent() {
+    const { scaleVisibility: i, frustumVisibility: t } = this;
+    if (i == null && t == null)
+      return;
+    const o = ({ computedExtent: e, extentPadding: s }) => {
+      this._suspendResumeExtent = z(e, this._suspendResumeExtent, A, s), i != null && i.setExtent(this._suspendResumeExtent), t != null && t.setExtent(this._suspendResumeExtent);
+    };
+    this.addHandles(u(() => {
+      var e, s;
+      return { computedExtent: (e = this.graphicsCore) == null ? void 0 : e.computedExtent, extentPadding: (s = this.graphicsCore) == null ? void 0 : s.extentPadding };
+    }, (e) => o(e), w));
+  }
+  _updateClippingExtent() {
+    const i = this.view.clippingArea;
+    this.graphicsCore.setClippingExtent(i, this.view.spatialReference) && this.graphicsCore.recreateAllGraphics();
+  }
+};
+n([a()], r.prototype, "type", void 0), n([a({ constructOnly: !0 })], r.prototype, "owner", void 0), n([a()], r.prototype, "layer", null), n([a()], r.prototype, "view", null), n([a({ constructOnly: !0 })], r.prototype, "graphicsCore", void 0), n([a()], r.prototype, "scaleVisibility", null), n([a({ constructOnly: !0 })], r.prototype, "frustumVisibility", void 0), n([a()], r.prototype, "elevationAlignment", null), n([a()], r.prototype, "objectStates", null), n([a()], r.prototype, "scaleVisibilitySuspended", null), n([a({ readOnly: !0 })], r.prototype, "frustumVisibilitySuspended", null), n([a()], r.prototype, "suspended", null), n([a({ readOnly: !0 })], r.prototype, "updating", null), n([a()], r.prototype, "loadedGraphics", null), n([a()], r.prototype, "fullOpacity", null), n([a()], r.prototype, "slicePlaneEnabled", null), n([a()], r.prototype, "drapeSourceType", void 0), n([a()], r.prototype, "updatePolicy", null), n([a({ constructOnly: !0 })], r.prototype, "scaleVisibilityEnabled", void 0), n([a({ constructOnly: !0 })], r.prototype, "frustumVisibilityEnabled", void 0), n([a()], r.prototype, "initializePromise", void 0), r = n([S("esri.views.3d.layers.graphics.GraphicsProcessor")], r);
+const d = f();
+export {
+  r as GraphicsProcessor
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/LabelParameters.js

@@ -0,0 +1,17 @@
+import { create as i } from "../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { create as f } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { fromValues as h } from "../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
+class u {
+  constructor(t, e = "center", s = !1, r = i(), a = h(0, 0, 0, -1), n = "world", l = f(), o = 0) {
+    this.verticalOffset = t, this.anchor = e, this.hasLabelVerticalOffset = s, this.screenOffset = r, this.centerOffset = a, this.centerOffsetUnits = n, this.translation = l, this.elevationOffset = o;
+  }
+}
+class P {
+  constructor(t, e = "center", s = "center", r = null, a = i()) {
+    this.placement = t, this.horizontalPlacement = e, this.verticalPlacement = s, this.text = r, this.displaySize = a;
+  }
+}
+export {
+  P as LabelParameters,
+  u as LabelPlacement
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/Loadable.js

@@ -0,0 +1,32 @@
+import { abortMaybe as a } from "../../../../core/maybe.js";
+import { isAbortError as e } from "../../../../core/promiseUtils.js";
+class d {
+  constructor(r) {
+    this.schedule = r, this._abortController = null, this._loadStatus = o.LOADING, this._loadError = null, this._loader = null, this.logger = null;
+  }
+  destroy() {
+    this.abortLoad();
+  }
+  get loadStatus() {
+    return this._loadStatus;
+  }
+  load(r, s) {
+    return this._loadStatus === o.LOADED ? (r && r(), this._loader ?? Promise.resolve()) : this._loadStatus === o.FAILED ? (s && s(this._loadError), this._loader ?? Promise.resolve()) : (this._loader == null && (this._abortController = new AbortController(), this._loader = this.doLoad(this._abortController.signal).then(() => {
+      this._abortController = null, this._loadStatus = o.LOADED;
+    }, (l) => {
+      throw this._loadError = l, this._abortController = null, this._loadStatus = o.FAILED, !e(l) && this.logger && l.message && this.logger.warn(l.message), l;
+    })), this._loader.then(r, s).catch(() => {
+    }), this._loader);
+  }
+  abortLoad() {
+    this._abortController != null ? this._abortController = a(this._abortController) : this._loadStatus === o.LOADING && (this._loadStatus = o.FAILED), this._loader = null;
+  }
+}
+var o;
+(function(t) {
+  t[t.LOADING = 0] = "LOADING", t[t.LOADED = 1] = "LOADED", t[t.FAILED = 2] = "FAILED";
+})(o || (o = {}));
+export {
+  o as LoadStatus,
+  d as Loadable
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/MeshFastUpdateProcessor.js

@@ -0,0 +1,85 @@
+import { DefaultMaterial as d } from "../../webgl-engine/materials/DefaultMaterial.js";
+class M {
+  constructor() {
+    this._fastTransformOriginalMaterials = /* @__PURE__ */ new Map(), this._fastTransformClonedMaterials = /* @__PURE__ */ new Map(), this._graphicReferenceCount = 0;
+  }
+  enable(a, t, s) {
+    a.enableFastTransformUpdates((e) => {
+      if (this._graphicReferenceCount <= 1) {
+        if (this._fastTransformOriginalMaterials.has(e))
+          return e;
+        const r = t.byMaterial(e);
+        return this._fastTransformOriginalMaterials.set(e, r), t.delete(e), e;
+      }
+      const i = new d(e.parameters);
+      return s.stage.add(i), this._fastTransformClonedMaterials.set(i, e), i;
+    }, s.localOriginFactory);
+  }
+  disable(a, t, s) {
+    const e = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
+    a.disableFastTransformUpdates((r) => {
+      if (!this._fastTransformClonedMaterials.has(r)) {
+        const l = r, o = this._fastTransformOriginalMaterials.get(l);
+        return t.has(o.uid) ? (e.add(l), t.byUid(o.uid).material) : (i.add(l), o.material);
+      }
+      const n = r, h = this._fastTransformClonedMaterials.get(n);
+      return this._fastTransformClonedMaterials.delete(n), s.stage.remove(n), h;
+    });
+    for (const r of e)
+      this._fastTransformOriginalMaterials.delete(r), s.stage.remove(r);
+    for (const r of i) {
+      const n = this._fastTransformOriginalMaterials.get(r);
+      this._fastTransformOriginalMaterials.delete(r), t.set(n.uid, n);
+    }
+  }
+  onAddGraphic() {
+    this._graphicReferenceCount++;
+  }
+  onRemoveGraphic(a, t, s) {
+    this._graphicReferenceCount--, this.disable(a, t, s);
+  }
+  forEachMaterialInfo(a) {
+    this._fastTransformOriginalMaterials.forEach(a);
+  }
+  forEachClonedMaterial(a) {
+    this._fastTransformClonedMaterials.forEach(a);
+  }
+  destroy(a) {
+    a.removeMany(Array.from(this._fastTransformClonedMaterials.keys())), a.removeMany(Array.from(this._fastTransformOriginalMaterials.values(), ({ material: t }) => t)), this._fastTransformClonedMaterials.clear(), this._fastTransformOriginalMaterials.clear();
+  }
+}
+class m {
+  constructor() {
+    this._byUid = /* @__PURE__ */ new Map(), this._byMaterial = /* @__PURE__ */ new Map();
+  }
+  get materials() {
+    return Array.from(this._byUid.values(), (a) => a.material);
+  }
+  byUid(a) {
+    return this._byUid.get(a);
+  }
+  byMaterial(a) {
+    return this._byMaterial.get(a);
+  }
+  set(a, t) {
+    this._byUid.set(a, t), this._byMaterial.set(t.material, t);
+  }
+  delete(a) {
+    var s;
+    const t = (s = this._byMaterial.get(a)) == null ? void 0 : s.uid;
+    t && (this._byUid.delete(t), this._byMaterial.delete(a));
+  }
+  has(a) {
+    return this._byUid.has(a);
+  }
+  forEachMaterialInfo(a) {
+    this._byUid.forEach(a);
+  }
+  clear() {
+    this._byUid.clear(), this._byMaterial.clear();
+  }
+}
+export {
+  m as MaterialInfoCache,
+  M as MeshFastUpdateProcessor
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/SpatialIndex2D.js

@@ -0,0 +1,70 @@
+import { _ as a } from "../../../../chunks/tslib.es6.js";
+import h from "../../../../core/Accessor.js";
+import u from "../../../../core/has.js";
+import { destroyMaybe as p } from "../../../../core/maybe.js";
+import { property as r } from "../../../../core/accessorSupport/decorators/property.js";
+import "../../../../core/Logger.js";
+import "../../../../core/RandomLCG.js";
+import { subclass as l } from "../../../../core/accessorSupport/decorators/subclass.js";
+import { PooledRBush as m } from "../../../../core/libs/rbush/PooledRBush.js";
+import { fromRect as c } from "../../../../geometry/support/aaBoundingBox.js";
+import { getObjectId as d } from "../../../../layers/graphics/dehydratedFeatures.js";
+let n = class extends h {
+  constructor(t) {
+    super(t), this._index = new m(9, u("esri-csp-restrictions") ? (e) => ({ minX: e.extent[0], minY: e.extent[1], maxX: e.extent[2], maxY: e.extent[3] }) : [".extent[0]", ".extent[1]", ".extent[2]", ".extent[3]"]), this._missing = /* @__PURE__ */ new Set(), this._boundsByFeature = /* @__PURE__ */ new Map(), this.spatialReference = null, this.hasZ = null, this.hasM = null, this.objectIdField = null, this.updating = !1;
+  }
+  setup(t) {
+    this._addMany(t);
+  }
+  destroy() {
+    this._missing.clear(), this._index = p(this._index), this._boundsByFeature.clear(), this._boundsByFeature = null;
+  }
+  update() {
+    this._missing.size > 0 && (this._addMany(Array.from(this._missing.values())), this.updating = !1, this._missing.clear());
+  }
+  get updatingRemaining() {
+    return this._missing.size;
+  }
+  queryGraphicUIDsInExtent(t, e, i) {
+    e != null && e.equals(this.spatialReference) && (s.minX = t[0], s.minY = t[1], s.maxX = t[2], s.maxY = t[3], this.update(), this._index.search(s, (o) => i(o.graphic.uid)));
+  }
+  add(t) {
+    this._missing.add(t), this.updating = !0;
+  }
+  remove(t) {
+    if (this._missing.delete(t))
+      return void (this.updating = this._missing.size > 0);
+    this._index.remove(t);
+    const e = d(t.graphic, this._get("objectIdField"));
+    e != null && this._boundsByFeature.delete(e);
+  }
+  _addMany(t) {
+    if (t.length === 0)
+      return;
+    const e = this._get("objectIdField");
+    for (const i of t) {
+      i.computeExtent(this.spatialReference);
+      const o = d(i.graphic, e);
+      o != null && this._boundsByFeature.set(o, i.extent);
+    }
+    this._index.load(t);
+  }
+  clear() {
+    this._index.clear(), this._missing.clear(), this._boundsByFeature.clear(), this.updating = !1;
+  }
+  forEachInBounds(t, e) {
+    s.minX = t[0], s.minY = t[1], s.maxX = t[2], s.maxY = t[3], this.update(), this._index.search(s, (i) => {
+      e(i);
+    });
+  }
+  getBounds(t, e) {
+    this.update();
+    const i = this._boundsByFeature.get(t);
+    return i ? c(e, i) : null;
+  }
+};
+a([r({ constructOnly: !0 })], n.prototype, "spatialReference", void 0), a([r({ constructOnly: !0 })], n.prototype, "hasZ", void 0), a([r({ constructOnly: !0 })], n.prototype, "hasM", void 0), a([r({ constructOnly: !0 })], n.prototype, "objectIdField", void 0), a([r()], n.prototype, "updating", void 0), a([r({ readOnly: !0 })], n.prototype, "updatingRemaining", null), n = a([l("esri.views.3d.layers.graphics.SpatialIndex2D")], n);
+const s = { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+export {
+  n as SpatialIndex2D
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/SymbolComplexity.js

@@ -0,0 +1,32 @@
+class r {
+  constructor(e) {
+    this.estimated = !1, this.verticesPerFeature = e.verticesPerFeature ?? 0, this.verticesPerCoordinate = e.verticesPerCoordinate ?? 0, this.drawCallsPerFeature = e.drawCallsPerFeature ?? 0, this.memory = e.memory ?? new i();
+  }
+}
+class a extends r {
+  constructor(e) {
+    super(e), this.estimated = !0;
+  }
+}
+class o extends r {
+  constructor(e, s) {
+    super(s), this.numComplexities = e;
+  }
+}
+class l extends a {
+  constructor(e, s) {
+    super(s), this.numComplexities = e;
+  }
+}
+class i {
+  constructor() {
+    this.bytesPerFeature = 0, this.bytesPerFeatureLabel = 0, this.resourceBytes = 0, this.draped = { bytesPerFeature: 0, bytesPerFeatureLabel: 0 };
+  }
+}
+export {
+  o as AggregateSymbolComplexity,
+  l as EstimatedAggregateSymbolComplexity,
+  a as EstimatedSymbolComplexity,
+  r as SymbolComplexity,
+  i as SymbolComplexityMemory
+};

package/dist/node_modules/.pnpm/@arcgis_core@4.29.10/node_modules/@arcgis/core/views/3d/layers/graphics/constants.js

@@ -0,0 +1,6 @@
+import { ZEROS as t } from "../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
+const e = 1.2, n = t;
+export {
+  e as suspendResumeExtentOptimism,
+  n as transparentUnit
+};