@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/Graphics3DDrapedGraphicLayer.js

@@ -0,0 +1,84 @@
+import { s as S } from "../../../../chunks/vec32.js";
+import { create as l } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { create as p, empty as c, expandWithRect as G, center as m, set as f, toRect as y } from "../../../../geometry/support/aaBoundingBox.js";
+import { create as R } from "../../../../geometry/support/aaBoundingRect.js";
+import { demResolutionForBoundingBox as _ } from "./graphicUtils.js";
+import { Object3DState as b } from "../../webgl-engine/lib/basicInterfaces.js";
+import { DirtyOperation as g, DirtyState as h } from "../../webgl-engine/lib/ModelDirtyTypes.js";
+class E {
+  constructor(e, t, s, a) {
+    this.graphics3DSymbolLayer = e, this.renderGeometries = t, this.boundingBox = s, this._drapeSourceRenderer = a, this.type = "draped", this.stage = null, this._visible = !1, this._addedToStage = !1, this.isElevationSource = !1;
+  }
+  initialize(e) {
+    this.stage = e.stage;
+  }
+  setVisibility(e) {
+    if (this.stage != null && this._visible !== e) {
+      if (this._visible = e, e && !this._addedToStage)
+        return this._addedToStage = !0, void this._drapeSourceRenderer.addGeometries(this.renderGeometries, g.ADD);
+      if (e || this._addedToStage) {
+        for (const t of this.renderGeometries)
+          t.visible = this._visible;
+        this._drapeSourceRenderer.modifyGeometries(this.renderGeometries, h.VISIBILITY);
+      }
+    }
+  }
+  destroy() {
+    this.stage && this._addedToStage && this._drapeSourceRenderer.removeGeometries(this.renderGeometries, g.REMOVE), this._addedToStage = !1, this._visible = !1, this.stage = null;
+  }
+  getCenterObjectSpace(e = l()) {
+    return S(e, 0, 0, 0);
+  }
+  getBoundingBoxObjectSpace(e = p()) {
+    return c(e);
+  }
+  addObjectState(e, t) {
+    e === b.Highlight && (this.renderGeometries.forEach((s) => {
+      const a = s.geometry.addHighlight();
+      t.addRenderGeometry(s, a, this);
+    }), this._addedToStage && this._drapeSourceRenderer.modifyGeometries(this.renderGeometries, h.HIGHLIGHT));
+  }
+  removeObjectState(e) {
+    this.renderGeometries.forEach((t) => {
+      e.removeRenderGeometry(t);
+    });
+  }
+  removeRenderGeometryObjectState(e, t) {
+    e.geometry.removeHighlight(t), this._addedToStage && this._drapeSourceRenderer.modifyGeometries(this.renderGeometries, h.HIGHLIGHT);
+  }
+  computeAttachmentOrigin(e) {
+    for (const t of this.renderGeometries)
+      t.geometry.computeAttachmentOrigin(d) && (e.draped.origin[0] += d[0], e.draped.origin[1] += d[1], e.draped.num++);
+  }
+  async getProjectedBoundingBox(e, t, s, a, r) {
+    c(r);
+    for (let i = 0; i < this.renderGeometries.length; i++) {
+      const n = this.renderGeometries[i];
+      this._getRenderGeometryProjectedBoundingRect(n, e, u, s), G(r, u);
+    }
+    if (t) {
+      let i;
+      m(r, d);
+      const n = _(r, t.service.spatialReference, t);
+      try {
+        i = await t.service.queryElevation(d[0], d[1], a, n, "ground");
+      } catch {
+      }
+      i != null && (r[2] = Math.min(r[2], i), r[5] = Math.max(r[5], i));
+    }
+    return r;
+  }
+  _getRenderGeometryProjectedBoundingRect(e, t, s, a) {
+    if (this.boundingBox)
+      f(o, this.boundingBox);
+    else {
+      const r = e.boundingSphere, i = r[3];
+      o[0] = r[0] - i, o[1] = r[1] - i, o[2] = r[2] - i, o[3] = r[0] + i, o[4] = r[1] + i, o[5] = r[2] + i;
+    }
+    return t(o, 0, 2), this.calculateRelativeScreenBounds && a.push({ location: m(o), screenSpaceBoundingRect: this.calculateRelativeScreenBounds() }), y(o, s);
+  }
+}
+const u = R(), o = p(), d = l();
+export {
+  E as Graphics3DDrapedGraphicLayer
+};

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

@@ -0,0 +1,93 @@
+import { _ as a } from "../../../../chunks/tslib.es6.js";
+import c from "../../../../core/Accessor.js";
+import g from "../../../../core/Evented.js";
+import { watch as d } from "../../../../core/reactiveUtils.js";
+import { property as n } from "../../../../core/accessorSupport/decorators/property.js";
+import "../../../../core/has.js";
+import "../../../../core/Logger.js";
+import "../../../../core/RandomLCG.js";
+import { subclass as y } from "../../../../core/accessorSupport/decorators/subclass.js";
+import { ExtentSet as u } from "./ExtentSet.js";
+import { UpdatePolicy as _ } from "../../webgl-engine/lib/UpdatePolicy.js";
+import { TaskPriority as h } from "../../../support/Scheduler.js";
+let s = class extends c {
+  constructor(t) {
+    super(t), this._dirtyExtents = new u(), this._globalDirty = !1, this._averageExtentUpdateSize = 0, this._dirtyGraphicsSet = /* @__PURE__ */ new Set(), this._updateElevation = !1, this.graphicsCoreOwner = null, this.graphicsCore = null, this.events = new g();
+  }
+  initialize() {
+    var i;
+    const t = this.elevationProvider, e = this.graphicsCoreOwner.view.resourceController.scheduler;
+    this._task = e.registerTask(l((i = this.graphicsCore.layer.elevationInfo) == null ? void 0 : i.mode), this), this.addHandles([t.on("elevation-change", (r) => this._elevationChanged(r)), d(() => this.graphicsCoreOwner.suspended, () => this._suspendedChange()), this._task, d(() => {
+      var r;
+      return l((r = this.graphicsCore.layer.elevationInfo) == null ? void 0 : r.mode);
+    }, (r) => this._task.priority = r)]);
+  }
+  destroy() {
+    this._dirtyGraphicsSet.clear(), this.graphicsCoreOwner = null, this.graphicsCore = null, this.queryGraphicUIDsInExtent = null, this.elevationProvider = null;
+  }
+  clear() {
+    this._dirtyGraphicsSet.clear(), this.notifyChange("updating");
+  }
+  _suspendedChange() {
+    this.graphicsCoreOwner.suspended === !0 ? this._updateElevation = !1 : this.graphicsCoreOwner.suspended === !1 && this._updateElevation && (this._globalDirty = !0, this.notifyChange("updating"));
+  }
+  elevationInfoChange() {
+    this._globalDirty = !0, this.notifyChange("updating");
+  }
+  get updating() {
+    return this.running;
+  }
+  get running() {
+    return this._dirtyGraphicsSet.size > 0 || this._dirtyExtents && !this._dirtyExtents.empty || this._globalDirty;
+  }
+  get updatingRemaining() {
+    return this._dirtyGraphicsSet.size + this._dirtyExtents.size * this._averageExtentUpdateSize;
+  }
+  runTask(t) {
+    for (this._globalDirty && (this._markAllGraphicsElevationDirty(), this._globalDirty = !1, t.madeProgress()), t.run(() => this._dirtyExtents.merge(t)); this.running && !t.done; )
+      this._updateDirtyGraphics(t), this._updateDirtyExtents(t);
+    this.notifyChange("updating");
+  }
+  _updateDirtyGraphics(t) {
+    const e = this.graphicsCoreOwner.view.renderCoordsHelper, i = this.graphicsCore.effectiveUpdatePolicy === _.ASYNC;
+    for (const r of this._dirtyGraphicsSet.keys()) {
+      const o = this.graphicsCore.getGraphics3DGraphicById(r);
+      if (this._dirtyGraphicsSet.delete(r), o != null && (o.alignWithElevation(this.elevationProvider, e, i), this.graphicsCoreOwner.view.deconflictor.setDirty(), t.madeProgress()), t.done)
+        return;
+    }
+  }
+  _updateDirtyExtents(t) {
+    for (; !this._dirtyExtents.empty && !t.done; ) {
+      const e = this._dirtyExtents.pop(), i = this.elevationProvider.spatialReference;
+      this.events.emit("invalidate-elevation", { extent: e, spatialReference: i });
+      const r = this._dirtyGraphicsSet.size;
+      this.queryGraphicUIDsInExtent(e, i, (o) => {
+        const p = this.graphicsCore.getGraphics3DGraphicById(o);
+        p != null && p.needsElevationUpdates() && this._dirtyGraphicsSet.add(o);
+      }), this._averageExtentUpdateSize = 0.1 * (this._dirtyGraphicsSet.size - r) + 0.9 * this._averageExtentUpdateSize, t.madeProgress();
+    }
+  }
+  _markAllGraphicsElevationDirty() {
+    this._dirtyExtents.clear(), this._dirtyGraphicsSet.clear(), this.graphicsCore.graphics3DGraphics.forEach((t, e) => this._dirtyGraphicsSet.add(e));
+  }
+  _elevationChanged(t) {
+    if (t.context === "scene" && (!this.graphicsCore.layer.elevationInfo || this.graphicsCore.layer.elevationInfo.mode !== "relative-to-scene"))
+      return;
+    const e = t.extent;
+    if (this.graphicsCoreOwner.suspended) {
+      if (!this._updateElevation) {
+        const i = this.graphicsCore.computedExtent;
+        i && e[2] > i.xmin && e[0] < i.xmax && e[3] > i.ymin && e[1] < i.ymax && (this._updateElevation = !0);
+      }
+      this.events.emit("invalidate-elevation", t);
+    } else
+      e[0] === -1 / 0 ? this._globalDirty = !0 : this._dirtyExtents.add(e), this.notifyChange("updating");
+  }
+};
+function l(t) {
+  return t == null ? h.ELEVATION_ALIGNMENT : t === "relative-to-scene" ? h.ELEVATION_ALIGNMENT_SCENE : h.ELEVATION_ALIGNMENT;
+}
+a([n()], s.prototype, "graphicsCoreOwner", void 0), a([n()], s.prototype, "graphicsCore", void 0), a([n()], s.prototype, "queryGraphicUIDsInExtent", void 0), a([n()], s.prototype, "elevationProvider", void 0), a([n({ readOnly: !0 })], s.prototype, "updating", null), a([n({ readOnly: !0 })], s.prototype, "updatingRemaining", null), s = a([y("esri.views.3d.layers.graphics.Graphics3DElevationAlignment")], s);
+export {
+  s as Graphics3DElevationAlignment
+};

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

@@ -0,0 +1,221 @@
+import "../../../../core/has.js";
+import ge from "../../../../core/Error.js";
+import { clone as H } from "../../../../core/lang.js";
+import { getMetersPerVerticalUnitForSR as ye } from "../../../../core/unitUtils.js";
+import { e as fe } from "../../../../chunks/earcut.js";
+import { normalFromMat4 as _e } from "../../../../core/libs/gl-matrix-2/math/mat3.js";
+import { create as be } from "../../../../core/libs/gl-matrix-2/factories/mat3f64.js";
+import { invert as xe, invertOrIdentity as Se } from "../../../../core/libs/gl-matrix-2/math/mat4.js";
+import { create as Y } from "../../../../core/libs/gl-matrix-2/factories/mat4f64.js";
+import { c as Pe, n as ue, s as R, f as ee, b as Ee, e as k } from "../../../../chunks/vec32.js";
+import { fromArray as $e, create as I } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { computeTranslationToOriginAndRotation as ve } from "../../../../geometry/projection/computeTranslationToOriginAndRotation.js";
+import { create as Ce, empty as Ie, expandWithBuffer as Oe, intersectsClippingArea as Ae } from "../../../../geometry/support/aaBoundingBox.js";
+import { newDoubleArray as T } from "../../../../geometry/support/DoubleArray.js";
+import { newIndexArray as te, getZeroIndexArray as Me } from "../../../../geometry/support/Indices.js";
+import { a as Le } from "../../../../chunks/vec3.js";
+import { makeVertexCandidate as we, makeEdgeCandidate as re } from "../../../../layers/graphics/data/SnappingCandidate.js";
+import { getDriverAxisSizeValue as ze } from "../../../../renderers/support/renderingInfoUtils.js";
+import { ViewingMode as De } from "../../../ViewingMode.js";
+import { needsElevationUpdates3D as ae, SampleElevationInfo as Re } from "./elevationAlignmentUtils.js";
+import { Graphics3DObject3DGraphicLayer as Be } from "./Graphics3DObject3DGraphicLayer.js";
+import { Graphics3DSymbolLayer as Ge } from "./Graphics3DSymbolLayer.js";
+import { validateSymbolLayerSize as Te, computeCentroid as Ve } from "./graphicUtils.js";
+import { ApplyRendererDiffResult as se } from "./interfaces.js";
+import { geometryAsPolygon as Ue } from "./polygonUtils.js";
+import { createMaterial as Ne } from "../support/edgeUtils.js";
+import { debugFlags as je } from "../../support/debugFlags.js";
+import { SamplePosition as Fe } from "../../support/ElevationProvider.js";
+import { geometryToRenderInfo as He } from "../../support/renderInfoUtils/polygon.js";
+import { NormalType as ke } from "../../webgl-engine/core/shaderLibrary/attributes/NormalAttribute.glsl.js";
+import { Attribute as W } from "../../webgl-engine/lib/Attribute.js";
+import { CullFaceOptions as Z } from "../../webgl-engine/lib/basicInterfaces.js";
+import { ContentObjectType as We } from "../../webgl-engine/lib/ContentObjectType.js";
+import { Geometry as Ze } from "../../webgl-engine/lib/Geometry.js";
+import { isGeometryWithMapPositions as qe } from "../../webgl-engine/lib/GeometryWithMapPositions.js";
+import { compressNormals as Ye } from "../../webgl-engine/lib/Normals.js";
+import { Object3D as Je } from "../../webgl-engine/lib/Object3D.js";
+import { VertexAttribute as w } from "../../webgl-engine/lib/VertexAttribute.js";
+import { DefaultMaterial as ne } from "../../webgl-engine/materials/DefaultMaterial.js";
+const Ke = ["polygon", "extent"];
+class Ft extends Ge {
+  constructor(t, a, e, r) {
+    super(t, a, e, r), this.ensureDrapedStatus(!1);
+  }
+  async doLoad() {
+    var i, l;
+    if (!this._drivenProperties.size) {
+      const m = Te(this._getSymbolSize());
+      if (m)
+        throw new ge("graphics3dextrudesymbollayer:invalid-size", m);
+    }
+    const t = (l = (i = this.symbolLayer) == null ? void 0 : i.material) == null ? void 0 : l.color, a = this._getCombinedOpacityAndColor(t), e = $e(a), r = a[3], o = r < 1 || this.needsDrivenTransparentPass, s = { usePBR: this._context.physicalBasedRenderingEnabled, isSchematic: !0, diffuse: e, ambient: e, opacity: r, transparent: o, cullFace: o ? Z.None : Z.Back, hasVertexColors: !0, hasSlicePlane: this._context.slicePlaneEnabled, castShadows: this.symbolLayer.castShadows, offsetTransparentBackfaces: !0, normalType: ke.Compressed };
+    this._materials[v.Main] = new ne(s), this._materials[v.Bottom] = new ne({ ...s, cullFace: Z.Back }), this._context.stage.addMany(this._materials);
+  }
+  destroy() {
+    super.destroy(), this._context.stage.removeMany(this._materials), this._materials.length = 0;
+  }
+  createGraphics3DGraphic(t) {
+    const a = t.graphic;
+    if (!this._validateGeometry(a.geometry, Ke, this.symbolLayer.type))
+      return null;
+    const e = this._getVertexOpacityAndColor(t.renderingInfo, 255), r = this.setGraphicElevationContext(a);
+    return this._createAs3DShape(a, t.renderingInfo, e, r, a.uid);
+  }
+  layerOpacityChanged(t, a) {
+    var i, l, m, _;
+    const e = (l = (i = this.symbolLayer) == null ? void 0 : i.material) == null ? void 0 : l.color, r = this._getCombinedOpacity(e), o = r < 1 || this.needsDrivenTransparentPass;
+    (m = this._materials[v.Main]) == null || m.setParameters({ opacity: r, transparent: o }), (_ = this._materials[v.Bottom]) == null || _.setParameters({ opacity: r, transparent: o });
+    const s = this._getLayerOpacity();
+    t.forEach((y) => {
+      const d = a(y);
+      d != null && d.layerOpacityChanged(s, this._context.isAsync);
+    });
+  }
+  layerElevationInfoChanged(t, a) {
+    return this.updateGraphics3DGraphicElevationInfo(t, a, ae);
+  }
+  slicePlaneEnabledChanged(t, a) {
+    var e, r;
+    return (e = this._materials[v.Main]) == null || e.setParameters({ hasSlicePlane: this._context.slicePlaneEnabled }), (r = this._materials[v.Bottom]) == null || r.setParameters({ hasSlicePlane: this._context.slicePlaneEnabled }), t.forEach((o) => {
+      const s = a(o);
+      s != null && s.slicePlaneEnabledChanged(this._context.slicePlaneEnabled, this._context.isAsync);
+    }), !0;
+  }
+  physicalBasedRenderingChanged() {
+    var a, e;
+    const t = { usePBR: this._context.physicalBasedRenderingEnabled, isSchematic: !0 };
+    return (a = this._materials[v.Main]) == null || a.setParameters(t), (e = this._materials[v.Bottom]) == null || e.setParameters(t), !0;
+  }
+  _getExtrusionSize(t) {
+    let a;
+    return a = t.size && this._drivenProperties.size ? ze(t.size, 2) ?? 0 : this._getSymbolSize(), a /= this._context.renderCoordsHelper.unitInMeters, a;
+  }
+  applyRendererDiff(t, a) {
+    return this._drivenPropertiesChanged(a) ? se.RecreateSymbol : se.RecreateGraphics;
+  }
+  async queryForSnapping(t, a, e, r) {
+    const o = this._getExtrusionSize(e) * this._context.renderCoordsHelper.unitInMeters / ye(a), { objectId: s, target: i } = t, l = H(i);
+    switch (l.z = (l.z ?? 0) + o, t.type) {
+      case "edge": {
+        const { start: m, end: _ } = t, y = H(m), d = H(_);
+        return y.z = (y.z ?? 0) + o, d.z = (d.z ?? 0) + o, [re(s, l, 1 / 0, y, d)];
+      }
+      case "vertex":
+        return [we(s, l, 1 / 0), re(s, i, 1 / 0, i, l)];
+      default:
+        return [];
+    }
+  }
+  _getSymbolSize() {
+    return this.symbolLayer.size ?? 1;
+  }
+  _createAs3DShape(t, a, e, r, o) {
+    const s = Ue(t.geometry);
+    if (s == null)
+      return null;
+    if (s.rings.length === 0 || !s.rings.some(($) => $.length > 0))
+      return this._logGeometryValidationWarnings(s.rings, "rings", "ExtrudeSymbol3DLayer"), null;
+    const i = He(s, this._context.elevationProvider, this._context.renderCoordsHelper, r);
+    this._logGeometryCreationWarnings(i, s.rings, "rings", "ExtrudeSymbol3DLayer");
+    const l = Ve(s);
+    if (l == null)
+      return null;
+    const m = new Array(), _ = new Array(), y = Ce(), d = Y(), x = I(), u = this._context.renderCoordsHelper.viewingMode === De.Global;
+    u || this._context.renderCoordsHelper.worldUpAtPosition(null, x), ve(s.spatialReference, [l.x, l.y, 0], d, this._context.renderCoordsHelper.spatialReference);
+    const h = Y();
+    xe(h, d);
+    const S = be();
+    _e(S, h);
+    const { polygons: p, mapPositions: c, position: g } = i;
+    for (const $ of p) {
+      const A = $.count;
+      if (this._context.clippingExtent && (Ie(y), Oe(y, $.mapPositions), !Ae(y, this._context.clippingExtent)))
+        continue;
+      const z = fe($.mapPositions, $.holeIndices, 3);
+      if (z.length === 0)
+        continue;
+      const B = z.length, M = 6 * A, N = te(M + B), j = te(B), G = T(3 * M), J = T(3 * M), K = T(3 * M), Q = T(M);
+      Qe(g, c, z, $, G, K, J, Q, N, j, this._getExtrusionSize(a), x, u), Le(G, G, h);
+      const X = this._context.stage.renderView.getObjectAndLayerIdColor({ graphicUid: o, layerUid: this._context.layer.uid }), F = new at(G, K, Ye(J), Q);
+      m.push(oe(this._materials[v.Main], N, N.length - j.length, F, e, X), oe(this._materials[v.Bottom], j, 0, F, e, X)), _.push(F.heights);
+    }
+    if (m.length === 0)
+      return null;
+    const f = new Je({ geometries: m, layerUid: this._context.layer.uid, graphicUid: o, isElevationSource: !0 });
+    f.transformation = d;
+    const O = Ne(this.symbolLayer, { opacity: this._getLayerOpacity() }), b = O != null ? { baseMaterial: this._materials[v.Main], edgeMaterials: [O], properties: { mergeGeometries: !0, hasSlicePlane: this._context.slicePlaneEnabled } } : null, C = new Be(this, f, m, null, null, ($, A, z, B, M) => tt($, A, z, B, M, _), r, b);
+    return C.alignedSampledElevation = i.sampledElevation, C.needsElevationUpdates = ae(r.mode), C;
+  }
+}
+function oe(n, t, a, e, r, o) {
+  const s = Me(t.length), i = [[w.POSITION, new W(e.positions, t, 3, !0)], [w.NORMALCOMPRESSED, new W(e.normals, t, 2, !0)], [w.COLOR, new W(r, s, 4, !0)]];
+  return new Ze(n, i, e.elevation, We.Mesh, o, a);
+}
+function Qe(n, t, a, e, r, o, s, i, l, m, _, y, d) {
+  const x = a.length / 3;
+  let u = 0, h = 2 * e.count;
+  Xe(n, t, e.index, e.count, a, 0, x, r, o, s, i, l, m, h, _, y, d);
+  let S = 2 * e.count;
+  h = 0, ie(r, o, i, s, u, e.pathLengths[0], e.count, S, l, h, _), S += 4 * e.pathLengths[0], h += 2 * e.pathLengths[0], u += e.pathLengths[0];
+  for (let p = 1; p < e.pathLengths.length; ++p)
+    ie(r, o, i, s, u, e.pathLengths[p], e.count, S, l, h, _), S += 4 * e.pathLengths[p], h += 2 * e.pathLengths[p], u += e.pathLengths[p];
+}
+function Xe(n, t, a, e, r, o, s, i, l, m, _, y, d, x, u, h, S) {
+  Pe(P, h);
+  const p = u > 0 ? 1 : -1;
+  let c = 3 * a, g = 0, f = 3 * g, O = e, b = 3 * O;
+  for (let A = 0; A < e; ++A)
+    S && (P[0] = n[c], P[1] = n[c + 1], P[2] = n[c + 2], ue(P, P)), i[f] = n[c], i[f + 1] = n[c + 1], i[f + 2] = n[c + 2], l[f] = t[c], l[f + 1] = t[c + 1], l[f + 2] = t[c + 2], m[f] = -p * P[0], m[f + 1] = -p * P[1], m[f + 2] = -p * P[2], _[g] = 0, i[b] = n[c] + u * P[0], i[b + 1] = n[c + 1] + u * P[1], i[b + 2] = n[c + 2] + u * P[2], l[b] = t[c], l[b + 1] = t[c + 1], l[b + 2] = t[c + 2], m[b] = p * P[0], m[b + 1] = p * P[1], m[b + 2] = p * P[2], _[O] = u, f += 3, b += 3, c += 3, g += 1, O += 1;
+  c = 3 * o, f = 0, b = 3 * x;
+  const C = u < 0 ? de : pe, $ = u < 0 ? pe : de;
+  for (let A = 0; A < s; ++A)
+    d[f] = r[c + C[0]], d[f + 1] = r[c + C[1]], d[f + 2] = r[c + C[2]], y[b] = r[c + $[0]] + e, y[b + 1] = r[c + $[1]] + e, y[b + 2] = r[c + $[2]] + e, f += 3, b += 3, c += 3;
+}
+function V(n, t, a, e, r, o, s) {
+  e[o] = e[s], s *= 3, n[o *= 3] = n[s], n[o + 1] = n[s + 1], n[o + 2] = n[s + 2], t[o] = t[s], t[o + 1] = t[s + 1], t[o + 2] = t[s + 2], a[o] = r[0], a[o + 1] = r[1], a[o + 2] = r[2];
+}
+const D = I();
+function ie(n, t, a, e, r, o, s, i, l, m, _) {
+  let y = r, d = r + 1, x = r + s, u = r + s + 1, h = i, S = i + 1, p = i + 2 * o, c = i + 2 * o + 1;
+  _ < 0 && (y = r + s + 1, u = r), m *= 3;
+  for (let g = 0; g < o; ++g)
+    g === o - 1 && (_ > 0 ? (d = r, u = r + s) : (d = r, y = r + s)), et(n, y, d, x, D), V(n, t, e, a, D, h, y), V(n, t, e, a, D, S, d), V(n, t, e, a, D, p, x), V(n, t, e, a, D, c, u), l[m++] = h, l[m++] = p, l[m++] = c, l[m++] = h, l[m++] = c, l[m++] = S, y++, d++, x++, u++, h += 2, S += 2, p += 2, c += 2;
+}
+const q = I(), le = I(), ce = I(), me = I(), he = I();
+function et(n, t, a, e, r) {
+  t *= 3, a *= 3, e *= 3, R(q, n[t++], n[t++], n[t++]), R(le, n[a++], n[a++], n[a++]), R(ce, n[e++], n[e++], n[e++]), ee(me, le, q), ee(he, ce, q), Ee(r, he, me), ue(r, r);
+}
+const L = I();
+function tt(n, t, a, e, r, o) {
+  const s = n.stageObject, i = s.geometries, l = i.length, m = t.mode !== "absolute-height";
+  let _ = 0;
+  const y = s.transformation, d = Se(Y(), y);
+  for (let x = 0; x < l; x += 2) {
+    const u = i[x];
+    if (!qe(u))
+      continue;
+    const h = u.getMutableAttribute(w.POSITION).data, S = o[x / 2], p = new Fe(u.mapPositions), c = h.length / 3;
+    let g = 0, f = !1, O = 0;
+    for (let b = 0; b < c; b++) {
+      L[0] = h[g], L[1] = h[g + 1], L[2] = h[g + 2], e(p, U), m && (O += U.sampledElevation), je.TESTS_DISABLE_OPTIMIZATIONS ? (R(E, p.array[p.offset], p.array[p.offset + 1], U.z + S[g / 3]), a != null && r.toRenderCoords(E, a, E), k(E, E, d)) : (R(E, h[g], h[g + 1], h[g + 2]), k(E, E, y), r.setAltitude(E, U.z + S[g / 3]), k(E, E, d)), h[g] = E[0], h[g + 1] = E[1], h[g + 2] = E[2];
+      const C = rt / r.unitInMeters;
+      (Math.abs(L[0] - h[g]) >= C || Math.abs(L[1] - h[g + 1]) >= C || Math.abs(L[2] - h[g + 2]) >= C) && (f = !0), p.offset += 3, g += 3;
+    }
+    f && (u.invalidateBoundingInfo(), s.geometryVertexAttributeUpdated(i[x], w.POSITION), i[x + 1].invalidateBoundingInfo(), s.geometryVertexAttributeUpdated(i[x + 1], w.POSITION)), _ += O / c;
+  }
+  return _ / l;
+}
+const E = I(), P = I(), U = new Re(), pe = [0, 2, 1], de = [0, 1, 2], rt = 0.01;
+var v;
+(function(n) {
+  n[n.Main = 0] = "Main", n[n.Bottom = 1] = "Bottom";
+})(v || (v = {}));
+class at {
+  constructor(t, a, e, r) {
+    this.positions = t, this.elevation = a, this.normals = e, this.heights = r;
+  }
+}
+export {
+  Ft as Graphics3DExtrudeSymbolLayer
+};

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

@@ -0,0 +1,43 @@
+import { _ as a } from "../../../../chunks/tslib.es6.js";
+import l from "../../../../core/Accessor.js";
+import u from "../../../../core/Evented.js";
+import { property as s } from "../../../../core/accessorSupport/decorators/property.js";
+import "../../../../core/has.js";
+import "../../../../core/Logger.js";
+import "../../../../core/RandomLCG.js";
+import { subclass as d } from "../../../../core/accessorSupport/decorators/subclass.js";
+import { projectPoint as m } from "../../../../geometry/projection.js";
+import { create as g } from "../../../../geometry/support/aaBoundingBox.js";
+import { getObjectId as y } from "../../../../layers/graphics/dehydratedFeatures.js";
+import { OptimizedFeature as f } from "../../../../layers/graphics/OptimizedFeature.js";
+import b from "../../../../layers/graphics/OptimizedGeometry.js";
+import { optimizedFeatureQueryEngineAdapter as n } from "../../../../layers/graphics/data/optimizedFeatureQueryEngineAdapter.js";
+const c = g();
+let i = class extends l {
+  constructor(p) {
+    super(p), this.events = new u(), this.hasZ = null, this.hasM = null, this.objectIdField = null, this.featureAdapter = { getAttribute: (t, e) => "graphic" in t ? t.graphic.attributes[e] : n.getAttribute(t, e), getAttributes: (t) => "graphic" in t ? t.graphic.attributes : n.getAttributes(t), getObjectId: (t) => "graphic" in t ? y(t.graphic, this.objectIdField) ?? void 0 : n.getObjectId(t), getGeometry: (t) => "graphic" in t ? t.getAsOptimizedGeometry(this.hasZ, this.hasM) : n.getGeometry(t), getCentroid: (t, e) => {
+      if ("graphic" in t) {
+        let r = null;
+        t.centroid != null ? r = t.centroid : t.graphic.geometry.type === "point" && m(t.graphic.geometry, h, this.viewSpatialReference) && (r = h);
+        const o = new Array(2 + (e.hasZ ? 1 : 0) + (e.hasM ? 1 : 0));
+        return r == null ? (o[0] = 0, o[1] = 0, o[2] = 0, o[3] = 0) : (o[0] = r.x, o[1] = r.y, e.hasZ && (o[2] = r.hasZ ? r.z : 0), e.hasM && (o[e.hasZ ? 3 : 2] = r.hasM ? r.m : 0)), new b([], o);
+      }
+      return n.getCentroid(t, e);
+    }, cloneWithGeometry: (t, e) => "graphic" in t ? new f(e, this.featureAdapter.getAttributes(t), null, this.featureAdapter.getObjectId(t)) : n.cloneWithGeometry(t, e) };
+  }
+  forEachInBounds(p, t) {
+    this.getSpatialIndex().forEachInBounds(p, t);
+  }
+  forEachBounds(p, t) {
+    const e = this.getSpatialIndex();
+    for (const r of p) {
+      const o = this.featureAdapter.getObjectId(r);
+      e.getBounds(o, c) != null && t(c);
+    }
+  }
+};
+a([s({ constructOnly: !0 })], i.prototype, "getSpatialIndex", void 0), a([s({ constructOnly: !0 })], i.prototype, "forEach", void 0), a([s({ constructOnly: !0 })], i.prototype, "hasZ", void 0), a([s({ constructOnly: !0 })], i.prototype, "hasM", void 0), a([s({ constructOnly: !0 })], i.prototype, "objectIdField", void 0), a([s({ constructOnly: !0 })], i.prototype, "viewSpatialReference", void 0), a([s({ constructOnly: !0 })], i.prototype, "featureSpatialReference", void 0), i = a([d("esri.views.3d.layers.graphics.Graphics3DFeatureStore")], i);
+const h = { type: "point", x: 0, y: 0, hasZ: !1, hasM: !1, spatialReference: null };
+export {
+  i as Graphics3DFeatureStore
+};

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

@@ -0,0 +1,78 @@
+import { _ as o } from "../../../../chunks/tslib.es6.js";
+import c from "../../../../core/Accessor.js";
+import { watch as h, sync as d, initial as _ } from "../../../../core/reactiveUtils.js";
+import { property as l } from "../../../../core/accessorSupport/decorators/property.js";
+import "../../../../core/has.js";
+import "../../../../core/Logger.js";
+import "../../../../core/RandomLCG.js";
+import { subclass as m } from "../../../../core/accessorSupport/decorators/subclass.js";
+import { getReferenceEllipsoid as u } from "../../../../geometry/ellipsoidUtils.js";
+import { FrustumExtentIntersection as g } from "../../support/FrustumExtentIntersection.js";
+import { TaskPriority as w } from "../../../support/Scheduler.js";
+import { Yield as y } from "../../../support/Yield.js";
+const f = 1.2;
+let a = class extends c {
+  constructor(e) {
+    super(e), this.suspended = !1, this._extent = null, this._extentIntersectionDirty = !0, this._isVisibleBelowSurfaceInternal = !1, this.graphicsCoreOwner = null, this.updating = !0;
+  }
+  initialize() {
+    const { graphicsCoreOwner: e } = this;
+    this._extentIntersection = new g({ renderCoordsHelper: e.view.renderCoordsHelper });
+    const t = e.view, i = t.basemapTerrain, s = t.resourceController.scheduler;
+    this.addHandles([t.on("resize", () => this._viewChange()), h(() => t.state.camera, () => this._viewChange(), d), s.registerTask(w.FRUSTUM_VISIBILITY, this), h(() => i.visibleElevationBounds, () => this._elevationBoundsChange())]), t.viewingMode === "local" ? this._isVisibleBelowSurface = !0 : this.addHandles([h(() => {
+      var r, n, p;
+      return [i.baseOpacity, i.wireframe, (p = (n = (r = t.map) == null ? void 0 : r.ground) == null ? void 0 : n.navigationConstraint) == null ? void 0 : p.type];
+    }, () => this._updateIsVisibleBelowSurface(), _)]);
+  }
+  destroy() {
+    this._set("graphicsCoreOwner", null), this._extent = null, this._extentIntersection = null;
+  }
+  _setDirty() {
+    this.updating || this._set("updating", !0);
+  }
+  setExtent(e) {
+    this._extent = e, this._extentIntersectionDirty = !0, this._setDirty();
+  }
+  _viewChange() {
+    this._setDirty();
+  }
+  _elevationBoundsChange() {
+    this._setDirty(), this._extentIntersectionDirty = !0;
+  }
+  set _isVisibleBelowSurface(e) {
+    this._isVisibleBelowSurfaceInternal = e, this._setDirty(), this._extentIntersectionDirty = !0;
+  }
+  _updateIsVisibleBelowSurface() {
+    var r, n;
+    const e = this.graphicsCoreOwner.view, t = e.basemapTerrain, i = e.viewingMode === "local", s = ((n = (r = e.map.ground) == null ? void 0 : r.navigationConstraint) == null ? void 0 : n.type) === "none";
+    this._isVisibleBelowSurface = i || !t.opaque || s;
+  }
+  _updateExtentIntersection() {
+    if (!this._extentIntersectionDirty)
+      return;
+    this._extentIntersectionDirty = !1;
+    const e = this.graphicsCoreOwner.view;
+    let t;
+    if (this._isVisibleBelowSurfaceInternal)
+      t = -0.3 * u(e.spatialReference).radius;
+    else {
+      const { min: i, max: s } = e.basemapTerrain.visibleElevationBounds;
+      t = i - Math.max(1, (s - i) * (f - 1));
+    }
+    this._extentIntersection.update(this._extent, e.spatialReference, t);
+  }
+  get running() {
+    return this.updating;
+  }
+  runTask(e) {
+    if (this._set("updating", !1), !this._extent)
+      return this._set("suspended", !1), y;
+    this._updateExtentIntersection();
+    const t = this.graphicsCoreOwner.view.frustum, i = u(this.graphicsCoreOwner.view.spatialReference).radius;
+    this._set("suspended", !this._extentIntersection.isVisibleInFrustum(t, i)), e.madeProgress();
+  }
+};
+o([l({ readOnly: !0 })], a.prototype, "suspended", void 0), o([l({ constructOnly: !0 })], a.prototype, "graphicsCoreOwner", void 0), o([l({ readOnly: !0 })], a.prototype, "updating", void 0), a = o([m("esri.views.3d.layers.graphics.Graphics3DFrustumVisibility")], a);
+export {
+  a as Graphics3DFrustumVisibility
+};