@agrotools1/at-components 0.6.16 → 0.6.17

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

@@ -0,0 +1,158 @@
+import { isSome as u } from "../../../../core/arrayUtils.js";
+import { forEach as f } from "../../../../core/asyncUtils.js";
+import { onAbortOrThrow as b, throwIfAborted as c } from "../../../../core/promiseUtils.js";
+import { totalSymbolComplexities as L } from "./defaultSymbolComplexity.js";
+import { Graphics3DGraphic as g } from "./Graphics3DGraphic.js";
+import { Graphics3DObject3DGraphicLayer as S } from "./Graphics3DObject3DGraphicLayer.js";
+import { Graphics3DSymbolLayerCreationContext as G } from "./Graphics3DSymbolCreationContext.js";
+import { make as _ } from "./Graphics3DSymbolLayerFactory.js";
+import { ApplyRendererDiffResult as y } from "./interfaces.js";
+import { Loadable as D, LoadStatus as h } from "./Loadable.js";
+class v extends D {
+  set symbol(t) {
+    this._symbol = t, t.symbolLayers.forEach((r, s) => {
+      const e = this.symbolLayers[s];
+      e != null && (e.symbol = t, e.symbolLayer = r);
+    });
+  }
+  get symbol() {
+    return this._symbol;
+  }
+  constructor(t, r, s) {
+    super(r.schedule), this._symbol = t, this._context = r, this._backgroundLayers = s, this._destroyed = !1, this.symbolLayers = new Array(), this.referenced = 0, this._extentPadding = 0;
+  }
+  async doLoad(t) {
+    let r = this._symbol.symbolLayers;
+    this._extentPadding = 0, this._backgroundLayers && (r = this._backgroundLayers.concat(r));
+    const s = r.length;
+    for (; this.symbolLayers.length < r.length; )
+      this.symbolLayers.push(null);
+    this.symbolLayers.length = r.length;
+    const e = [];
+    for (let o = 0; o < s; o++) {
+      const a = r.at(o);
+      if (a.enabled === !1)
+        continue;
+      i.renderPriority = 1 - (1 + o) / s, i.renderPriorityStep = 1 / s, i.ignoreDrivers = a.ignoreDrivers;
+      const l = _(this.symbol, a, this._context, i), n = b(t, () => {
+        this.symbolLayers[o] = null, l.destroy();
+      });
+      n && e.push(n), this.symbolLayers[o] = l;
+    }
+    if (await f(this.symbolLayers, async (o, a) => {
+      if (o != null)
+        try {
+          await o.load(), this._extentPadding += Math.max(this._extentPadding, o.extentPadding);
+        } catch {
+          this.symbolLayers[a] = null;
+        }
+    }), e.forEach((o) => o.remove()), c(t), this.symbolLayers.length && !this.symbolLayers.some((o) => !!o))
+      throw new Error();
+  }
+  getSymbolLayerSize(t) {
+    const r = this.symbolLayers[t];
+    return r != null ? r.getCachedSize() : null;
+  }
+  get extentPadding() {
+    return this._extentPadding;
+  }
+  get symbologySnappingSupported() {
+    return this.symbolLayers.some((t) => t == null ? void 0 : t.queryForSnapping);
+  }
+  createGraphics3DGraphic(t, r) {
+    var a, l;
+    const s = t.graphic, e = this.symbolLayers.map((n) => (n == null ? void 0 : n.createGraphics3DGraphic(t)) ?? null), o = this._context.arcade || ((l = (a = this._context.featureExpressionInfoContext) == null ? void 0 : a.arcade) == null ? void 0 : l.modules) || null;
+    return new g(s, r || this, e, t.layer, o);
+  }
+  get complexity() {
+    return L(this.symbolLayers.map((t) => t != null ? t.complexity : null));
+  }
+  globalPropertyChanged(t, r) {
+    const s = this.symbolLayers.length;
+    for (let e = 0; e < s; e++) {
+      const o = this.symbolLayers[e], a = (l) => {
+        const n = l.layers[e];
+        return n instanceof S ? n : null;
+      };
+      if (o != null && !o.globalPropertyChanged(t, r, a))
+        return !1;
+    }
+    return !0;
+  }
+  applyRendererDiff(t, r) {
+    return this.loadStatus !== h.LOADED ? y.RecreateSymbol : this.symbolLayers.reduce((s, e) => s !== y.RecreateSymbol && e != null ? Math.min(s, e.applyRendererDiff(t, r)) : s, y.FastUpdate);
+  }
+  prepareSymbolPatch(t) {
+    if (this.loadStatus === h.FAILED || t.diff.type !== "partial")
+      return;
+    const r = t.diff.diff;
+    if (!r.symbolLayers || r.symbolLayers.type !== "partial")
+      return;
+    const s = r.symbolLayers.diff;
+    this.symbolLayers.forEach((e, o) => {
+      if (e == null)
+        return;
+      const a = s[o];
+      if (a) {
+        const l = { diff: a, graphics3DGraphicPatches: [], symbolLayerStatePatches: [] };
+        e.prepareSymbolLayerPatch(l), t.symbolStatePatches.push(...l.symbolLayerStatePatches), l.graphics3DGraphicPatches.length && t.graphics3DGraphicPatches.push((n, p) => {
+          const m = n.layers[o];
+          m != null && l.graphics3DGraphicPatches.forEach((d) => d(m, p));
+        });
+      }
+    });
+  }
+  updateGeometry(t, r) {
+    return this._updateGeometryOrTransform(t, (s, e) => s.updateGeometry(e, r));
+  }
+  updateTransform(t, r, s, e) {
+    return this._updateGeometryOrTransform(t, (o, a) => o.updateTransform(a, r, s, e));
+  }
+  _updateGeometryOrTransform(t, r) {
+    for (let s = 0; s < this.symbolLayers.length; s++) {
+      const e = this.symbolLayers[s];
+      if (e == null)
+        continue;
+      const o = t.layers[s];
+      if (!o || !r(e, o))
+        return !1;
+    }
+    return !0;
+  }
+  onRemoveGraphic(t) {
+    for (let r = 0; r < this.symbolLayers.length; r++) {
+      const s = this.symbolLayers[r];
+      if (s == null)
+        continue;
+      const e = t.layers[r];
+      e != null && s.onRemoveGraphic(e);
+    }
+  }
+  getFastUpdateStatus() {
+    let t = 0, r = 0, s = 0;
+    return this.symbolLayers.forEach((e) => {
+      e != null && (e.loadStatus === h.LOADING ? t++ : e.isFastUpdatesEnabled() ? s++ : r++);
+    }), { loading: t, slow: r, fast: s };
+  }
+  async queryForSnapping(t, r, s, e) {
+    const o = this.symbolLayers.filter(u).filter((l) => l.queryForSnapping != null).map((l) => l.queryForSnapping(t, r, s, e)), a = await Promise.all(o);
+    return c(e), a.flat();
+  }
+  destroy() {
+    if (this.destroyed)
+      console.error("Graphics3DSymbol.destroy called when already destroyed!");
+    else {
+      super.destroy();
+      for (const t of this.symbolLayers)
+        t != null && t.destroy();
+      this.symbolLayers.length = 0, this._destroyed = !0;
+    }
+  }
+  get destroyed() {
+    return this._destroyed;
+  }
+}
+const i = new G();
+export {
+  v as Graphics3DSymbol
+};

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

@@ -0,0 +1,14 @@
+class i {
+  constructor(s, r) {
+    this.scheduler = s, this.schedule = r, this.sharedResources = null, this.streamDataRequester = null, this.elevationProvider = null, this.renderer = null, this.stage = null, this.clippingExtent = null, this.renderCoordsHelper = null, this.overlaySR = null, this.layer = null, this.drapeSourceRenderer = null, this.graphicsCoreOwner = null, this.localOriginFactory = null, this.featureExpressionInfoContext = null, this.screenSizePerspectiveEnabled = !0, this.slicePlaneEnabled = !1, this.physicalBasedRenderingEnabled = !1, this.skipHighSymbolLods = !1, this.isAsync = !1;
+  }
+}
+class t {
+  constructor() {
+    this.renderPriority = 0, this.renderPriorityStep = 1, this.ignoreDrivers = !1;
+  }
+}
+export {
+  i as Graphics3DSymbolCreationContext,
+  t as Graphics3DSymbolLayerCreationContext
+};

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

@@ -0,0 +1,8 @@
+import { Graphics3DPointSymbol as p } from "./Graphics3DPointSymbol.js";
+import { Graphics3DSymbol as t } from "./Graphics3DSymbol.js";
+function i(o, r, m) {
+  return o.type === "point-3d" ? new p(o, r, m) : new t(o, r, m);
+}
+export {
+  i as make
+};

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

@@ -0,0 +1,195 @@
+import g from "../../../../Color.js";
+import "../../../../core/has.js";
+import v from "../../../../core/Logger.js";
+import { ONES as _ } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { fromValues as x } from "../../../../core/libs/gl-matrix-2/factories/vec4f64.js";
+import { defaultSymbolLayerComplexity as C } from "./defaultSymbolComplexity.js";
+import { SymbolUpdateType as d } from "./elevationAlignmentUtils.js";
+import { ElevationContext as y } from "./ElevationContext.js";
+import { zeroContext as b } from "./featureExpressionInfoUtils.js";
+import { mixinColorAndOpacity as u } from "./graphicUtils.js";
+import { ApplyRendererDiffResult as E } from "./interfaces.js";
+import { Loadable as O } from "./Loadable.js";
+import { getAttributeValue as c } from "../support/FastSymbolUpdates.js";
+const l = () => v.getLogger("esri.views.3d.layers.graphics.Graphics3DSymbolLayer");
+class k extends O {
+  constructor(e, t, i, r) {
+    super(i.schedule), this.symbol = e, this.symbolLayer = t, this._context = i, this.ignoreDrivers = !1, this._drivenProperties = { color: !1, opacity: !1, opacityAlwaysOpaque: !0, size: !1 }, this._materials = [], this.usedMemory = 0, this.logger = l(), this._elevationOptions = { supportsOffsetAdjustment: !1, supportsOnTheGround: !0 }, this.skipHighSymbolLodsChanged = !0, this._renderPriority = r.renderPriority, this._renderPriorityStep = r.renderPriorityStep, this._elevationContext = new y(), this.complexity = this.computeComplexity(), this.ignoreDrivers = r.ignoreDrivers, this.ignoreDrivers || (this._drivenProperties = f(this._context.renderer)), this._updateElevationContext();
+  }
+  getCachedSize() {
+    return null;
+  }
+  get extentPadding() {
+    return 0;
+  }
+  get materials() {
+    return this._materials;
+  }
+  _drivenPropertiesChanged(e) {
+    if (this.ignoreDrivers)
+      return !1;
+    const t = this._drivenProperties, i = f(e);
+    return i.color !== t.color || i.opacity !== t.opacity || i.opacityAlwaysOpaque !== t.opacityAlwaysOpaque || i.size !== t.size;
+  }
+  get needsDrivenTransparentPass() {
+    return this._drivenProperties.opacity && !this._drivenProperties.opacityAlwaysOpaque;
+  }
+  _logGeometryCreationWarnings(e, t, i, r) {
+    const o = e.projectionSuccess, n = "polygons" in e ? e.polygons : null, s = `${r} geometry failed to be created`;
+    let a = null;
+    o ? !this._logGeometryValidationWarnings(t, i, r) && n && n.length === 0 && i === "rings" && t.length > 0 && t[0].length > 2 && (a = `${s} (filled rings should use clockwise winding - try reversing the order of vertices)`) : a = `${s} (failed to project geometry to view spatial reference)`, a && l().warnOncePerTick(a);
+  }
+  _logGeometryValidationWarnings(e, t, i) {
+    const r = `${i} geometry failed to be created`;
+    return !e.length || e.length === 1 && !e[0].length ? (l().warnOncePerTick(`${r} (no ${t} were defined)`), !0) : (!Array.isArray(e) || !Array.isArray(e[0])) && (l().warnOncePerTick(`${r} (${t} should be defined as a 2D array)`), !0);
+  }
+  _validateGeometry(e, t = null, i = null) {
+    if (t != null && !t.includes(e.type))
+      return this.logger.warn("unsupported geometry type for " + i + ` symbol: ${e.type}`), !1;
+    if (e.type === "point") {
+      const r = e;
+      if (!isFinite(r.x) || !isFinite(r.y))
+        return l().warn("point coordinate is not a valid number, graphic skipped"), !1;
+    }
+    return !0;
+  }
+  _defaultElevationInfoNoZ() {
+    return w;
+  }
+  _defaultElevationInfoZ() {
+    return P;
+  }
+  _updateElevationContext() {
+    this._elevationInfoOverride != null ? (this._elevationContext.setFromElevationInfo(this._elevationInfoOverride), this._elevationContext.updateFeatureExpressionInfoContext(null)) : this._context.layer.elevationInfo ? (this._elevationContext.setFromElevationInfo(this._context.layer.elevationInfo), this._elevationContext.updateFeatureExpressionInfoContext(this._context.featureExpressionInfoContext)) : this._elevationContext.reset();
+  }
+  getDefaultElevationInfo(e) {
+    return e.hasZ ? this._defaultElevationInfoZ() : this._defaultElevationInfoNoZ();
+  }
+  getGeometryElevationMode(e, t = this.getDefaultElevationInfo(e)) {
+    return this._elevationContext.mode || t.mode;
+  }
+  setElevationInfoOverride(e) {
+    this._elevationInfoOverride = e, this._updateElevationContext();
+  }
+  setGraphicElevationContext(e, t = new y()) {
+    const i = e.geometry, r = this.getDefaultElevationInfo(i);
+    t.unit = this._elevationContext.unit != null ? this._elevationContext.unit : r.unit, t.mode = this.getGeometryElevationMode(i, r), t.offsetMeters = this._elevationContext.meterUnitOffset ?? r.offset ?? 0;
+    const o = !this._elevationOptions.supportsOnTheGround && t.mode === "on-the-ground";
+    o && (t.mode = "relative-to-ground", t.offsetMeters = 0);
+    const n = o ? b : this._elevationContext.featureExpressionInfoContext;
+    return t.updateFeatureExpressionInfoContext(n, e, this._context.layer), t;
+  }
+  prepareSymbolLayerPatch(e) {
+  }
+  updateGeometry(e, t) {
+    return !1;
+  }
+  updateTransform(e, t, i, r) {
+    return !1;
+  }
+  onRemoveGraphic(e) {
+  }
+  _getLayerOpacity() {
+    return this._context.graphicsCoreOwner && "fullOpacity" in this._context.graphicsCoreOwner ? this._context.graphicsCoreOwner.fullOpacity ?? 0 : this._context.layer.opacity ?? 1;
+  }
+  _getCombinedOpacity(e, t = m) {
+    let i = 1;
+    return this.draped || (i *= this._getLayerOpacity()), this._drivenProperties.opacity || (e != null ? i *= e.a : t.hasIntrinsicColor || (i = 0)), i;
+  }
+  _getCombinedOpacityAndColor(e, t = m) {
+    const i = this._getCombinedOpacity(e, t);
+    if (this._drivenProperties.color)
+      return u(null, i);
+    const r = e != null ? g.toUnitRGB(e) : _;
+    return u(r, i);
+  }
+  _getVertexOpacityAndColor(e, t = null) {
+    const i = this._drivenProperties.color ? e.color : null, r = this._drivenProperties.opacity ? e.opacity : null, o = u(i, r);
+    return t && (o[0] *= t, o[1] *= t, o[2] *= t, o[3] *= t), o;
+  }
+  isFastUpdatesEnabled() {
+    return this._fastUpdates != null;
+  }
+  computeComplexity() {
+    return C(this.symbol, this.symbolLayer);
+  }
+  globalPropertyChanged(e, t, i) {
+    switch (e) {
+      case "opacity":
+        return this.layerOpacityChanged(t, i), !0;
+      case "elevationInfo": {
+        const r = this._elevationContext.mode;
+        return this._updateElevationContext(), this.layerElevationInfoChanged(t, i, r) !== d.RECREATE;
+      }
+      case "slicePlaneEnabled":
+        return this.slicePlaneEnabledChanged(t, i);
+      case "physicalBasedRenderingEnabled":
+        return this.physicalBasedRenderingChanged();
+      case "pixelRatio":
+        return this.pixelRatioChanged;
+      case "skipHighSymbolLods":
+        return this.skipHighSymbolLodsChanged;
+      default:
+        return !1;
+    }
+  }
+  get pixelRatioChanged() {
+    return !0;
+  }
+  updateGraphics3DGraphicElevationInfo(e, t, i) {
+    let r = d.UPDATE;
+    return e.forEach((o) => {
+      const n = t(o);
+      if (n != null) {
+        const s = o.graphic;
+        this.setGraphicElevationContext(s, n.elevationContext), n.needsElevationUpdates = i(n.elevationContext.mode);
+      } else
+        r = d.RECREATE;
+    }), r;
+  }
+  applyRendererDiff(e, t) {
+    return E.RecreateSymbol;
+  }
+  getFastUpdateAttrValues(e) {
+    if (!this._fastUpdates)
+      return null;
+    const t = this._fastUpdates.visualVariables, i = t.size ? c(t.size.field, e) : 0, r = t.color ? c(t.color.field, e) : 0, o = t.opacity ? c(t.opacity.field, e) : 0;
+    return x(i, r, o, 0);
+  }
+  get draped() {
+    return this._draped;
+  }
+  ensureDrapedStatus(e) {
+    return this._draped == null ? (this._draped = e, !0) : (e !== this.draped && l().warnOnce("A symbol can only produce either draped or non-draped visualizations. Use two separate symbol instances for draped and non-draped graphics if necessary."), !1);
+  }
+  test() {
+    const e = () => {
+      var t, i, r, o, n, s, a, h;
+      return { size: ((i = (t = this._fastUpdates) == null ? void 0 : t.visualVariables.size) == null ? void 0 : i.field) ?? null, color: ((o = (r = this._fastUpdates) == null ? void 0 : r.visualVariables.color) == null ? void 0 : o.field) ?? null, opacity: ((s = (n = this._fastUpdates) == null ? void 0 : n.visualVariables.opacity) == null ? void 0 : s.field) ?? null, rotation: ((h = (a = this._fastUpdates) == null ? void 0 : a.visualVariables.rotation) == null ? void 0 : h.field) ?? null };
+    };
+    return { drivenProperties: this._drivenProperties, getVisVarFields: e };
+  }
+}
+function f(p) {
+  const e = { color: !1, opacity: !1, opacityAlwaysOpaque: !0, size: !1 };
+  return p && "visualVariables" in p && p.visualVariables && p.visualVariables.forEach((t) => {
+    switch (t.type) {
+      case "color":
+        if (e.color = !0, t.stops)
+          for (let i = 0; i < t.stops.length; i++) {
+            const r = t.stops[i].color;
+            r && (e.opacity = !0, r.a < 1 && (e.opacityAlwaysOpaque = !1));
+          }
+        break;
+      case "opacity":
+        e.opacity = !0, e.opacityAlwaysOpaque = !1;
+        break;
+      case "size":
+        e.size = !0;
+    }
+  }), e;
+}
+const w = { mode: "on-the-ground", offset: 0, unit: "meters" }, P = { mode: "absolute-height", offset: 0, unit: "meters" }, m = { hasIntrinsicColor: !1 };
+export {
+  k as Graphics3DSymbolLayer
+};

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

@@ -0,0 +1,19 @@
+import i from "../../../../core/Logger.js";
+import { Graphics3DExtrudeSymbolLayer as s } from "./Graphics3DExtrudeSymbolLayer.js";
+import { Graphics3DIconSymbolLayer as y } from "./Graphics3DIconSymbolLayer.js";
+import { Graphics3DLineSymbolLayer as p } from "./Graphics3DLineSymbolLayer.js";
+import { Graphics3DMeshFillSymbolLayer as l } from "./Graphics3DMeshFillSymbolLayer.js";
+import { Graphics3DObjectSymbolLayer as c } from "./Graphics3DObjectSymbolLayer.js";
+import { Graphics3DPathSymbolLayer as h } from "./Graphics3DPathSymbolLayer.js";
+import { Graphics3DPolygonFillSymbolLayer as n } from "./Graphics3DPolygonFillSymbolLayer.js";
+import { Graphics3DTextSymbolLayer as b } from "./Graphics3DTextSymbolLayer.js";
+import { Graphics3DWaterSymbolLayer as f } from "./Graphics3DWaterSymbolLayer.js";
+function $(o, r, t, m) {
+  var e;
+  const a = ((e = D[o.type]) == null ? void 0 : e[r.type]) || L[r.type];
+  return a ? new a(o, r, t, m) : (i.getLogger("esri.views.3d.layers.graphics.Graphics3DSymbolLayerFactory").error("GraphicsLayerFactory#make", `unknown symbol type ${r.type}`), null);
+}
+const L = { icon: y, object: c, line: p, path: h, fill: n, extrude: s, text: b, water: f }, D = { "mesh-3d": { fill: l } };
+export {
+  $ as make
+};

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

@@ -0,0 +1,153 @@
+import M from "../../../../core/Error.js";
+import { isPromiseLike as k } from "../../../../core/promiseUtils.js";
+import { pt2px as $ } from "../../../../core/screenUtils.js";
+import { fromValues as w, ZEROS as N, create as P } from "../../../../core/libs/gl-matrix-2/factories/vec2f64.js";
+import { fromValues as Z } from "../../../../core/libs/gl-matrix-2/factories/vec3f64.js";
+import { hasCalloutSupport as q, textSymbolLayerSupportsVerticalOffset as B } from "../../../../symbols/callouts/calloutUtils.js";
+import { perObjectElevationAligner as J } from "./ElevationAligners.js";
+import { SymbolUpdateType as Q, needsElevationUpdates2D as O } from "./elevationAlignmentUtils.js";
+import { ElevationContext as X } from "./ElevationContext.js";
+import { Graphics3DObject3DGraphicLayer as Y } from "./Graphics3DObject3DGraphicLayer.js";
+import { Graphics3DObjectMetadata as K } from "./Graphics3DObjectMetadata.js";
+import { Graphics3DSymbolLayer as ee } from "./Graphics3DSymbolLayer.js";
+import { validateSymbolLayerSize as te } from "./graphicUtils.js";
+import { LabelParameters as re, LabelPlacement as ne } from "./LabelParameters.js";
+import { verticalScreenOffsetFromAlignment as se, verticalPlacementFromAlignment as ae, textRenderAlignmentFromHorizontalPlacement as oe, horizontalPlacementToAnchorX as ie, anchorFromPlacements as le, namedAnchorToHUDMaterialAnchorPos as ce } from "./placementUtils.js";
+import { placePointOnGeometry as S, createStageObject as me, extendPointGraphicElevationContext as pe } from "./pointUtils.js";
+import { getFontMetrics as he } from "../../webgl-engine/lib/FontMetrics.js";
+import { createPointGeometry as fe } from "../../webgl-engine/lib/GeometryUtil.js";
+import { TextRenderParameters as ue } from "../../webgl-engine/lib/TextRenderParameters.js";
+import de from "../../webgl-engine/lib/TextTextureFactory.js";
+import { HUDMaterial as L } from "../../webgl-engine/materials/HUDMaterial.js";
+const ye = Z(0, 0, 1);
+class Ie extends ee {
+  constructor(t, r, n, e) {
+    super(t, r, n, e), this._elevationOptions = { supportsOffsetAdjustment: !0, supportsOnTheGround: !1 }, this.ensureDrapedStatus(!1);
+  }
+  async doLoad() {
+    if (!this._drivenProperties.size) {
+      const t = te(this.symbolLayer.size);
+      if (t)
+        throw new M("graphics3dtextsymbollayer:invalid-size", t);
+    }
+    await this._createTextRenderParameters();
+  }
+  async _createTextRenderParameters() {
+    const t = this._context.graphicsCoreOwner.view.state.rasterPixelRatio;
+    this._textRenderParameters = await ue.fromSymbol(this.symbolLayer, t);
+  }
+  destroy() {
+    super.destroy();
+  }
+  createGraphics3DGraphic(t) {
+    const r = t.graphic, n = S(r.geometry);
+    if (n == null)
+      return this.logger.warn(`unsupported geometry type for text symbol: ${r.geometry.type}`), null;
+    const e = this.symbolLayer.text;
+    if (e == null || e === "")
+      return null;
+    const p = q(this.symbol) && this.symbol.hasVisibleVerticalOffset() ? this.symbol.verticalOffset : null;
+    if (p != null && !B(this.symbolLayer))
+      return this.logger.errorOncePerTick(`Callouts and vertical offset on text symbols are currently only supported with 'center' horizontal alignment (not with '${this.symbolLayer.horizontalAlignment}' alignment)`), null;
+    const { verticalAlignment: l } = this.symbolLayer, h = new ne(p);
+    se(l, h.screenOffset);
+    const c = new re(h, this.symbolLayer.horizontalAlignment, ae(l));
+    return this._createAs3DShape(r, n, e, c);
+  }
+  createLabel(t, r, n, e, p) {
+    const l = t.graphic, h = S(l.geometry);
+    if (h == null)
+      return this.logger.warn(`unsupported geometry type for label: ${l.geometry.type}`), null;
+    const c = r.text;
+    return !c || /^\s+$/.test(c) ? null : this._createAs3DShape(l, h, c, r, n, e, p);
+  }
+  setGraphicElevationContext(t, r, n = 0) {
+    return super.setGraphicElevationContext(t, r), r.addOffsetRenderUnits(n), r;
+  }
+  layerOpacityChanged() {
+    return this.logger.warn("layer opacity change not yet implemented in Graphics3DTextSymbolLayer"), !1;
+  }
+  layerElevationInfoChanged(t, r) {
+    return E(t, r, (n, e) => {
+      this.updateGraphicElevationContext(e, n);
+    }), Q.UPDATE;
+  }
+  slicePlaneEnabledChanged(t, r) {
+    return E(t, r, (n) => {
+      for (const e of n.stageObject.geometries)
+        e.material.setParameters({ hasSlicePlane: this._context.slicePlaneEnabled });
+    }), !0;
+  }
+  physicalBasedRenderingChanged() {
+    return !0;
+  }
+  get pixelRatioChanged() {
+    return !1;
+  }
+  updateGraphicElevationContext(t, r) {
+    const n = r.elevationContext;
+    this.setGraphicElevationContext(t, n, r.metadata != null ? r.metadata.elevationOffset : 0), r.needsElevationUpdates = O(n.mode) || n.mode === "absolute-height";
+  }
+  _defaultElevationInfoNoZ() {
+    return xe;
+  }
+  _createAs3DShape(t, r, n, e, p = null, l = null, h = () => e.placement.elevationOffset) {
+    var b;
+    const c = this.setGraphicElevationContext(t, new X(), e.placement.elevationOffset), _ = ((b = t.geometry) == null ? void 0 : b.type) === "polyline", z = t.uid;
+    let i = null, f = null;
+    if (l == null) {
+      const s = oe(e.horizontalPlacement);
+      i = new de(n, s, this._textRenderParameters);
+      let a = null;
+      if (this._context.sharedResources.textures != null) {
+        f = this._context.sharedResources.textures.fromData(i.key, () => i.create()), f.texture.events.on("unloaded", () => a == null ? void 0 : a.release());
+        const o = this._context.stage.renderView.textureRepository.acquire(f.texture.id);
+        if (o == null || k(o))
+          return f.release(), null;
+        a = o;
+      }
+    }
+    const A = ge(i, e), m = { occlusionTest: !0, screenOffset: e.placement.screenOffset, anchorPosition: A, polygonOffset: !0, color: [1, 1, 1, 1], centerOffsetUnits: e.placement.centerOffsetUnits, drawInSecondSlot: !0 };
+    if (l ? m.textureId = l.id : f && (m.textureId = f.texture.id), e.placement.verticalOffset != null) {
+      const { screenLength: s, minWorldLength: a, maxWorldLength: o } = e.placement.verticalOffset;
+      m.verticalOffset = { screenLength: $(s), minWorldLength: a || 0, maxWorldLength: o ?? 1 / 0 };
+    }
+    if (this._context.screenSizePerspectiveEnabled) {
+      const { screenSizePerspectiveSettings: s, screenSizePerspectiveSettingsLabels: a } = this._context.sharedResources, o = he(this._textRenderParameters);
+      m.screenSizePerspective = a.overrideFontHeight(o.maxHeight), m.screenSizePerspectiveAlignment = s;
+    }
+    _ && (m.shaderPolygonOffset = 1e-4), m.hasSlicePlane = this._context.slicePlaneEnabled;
+    const C = (s, a) => {
+      const o = JSON.stringify(a);
+      let y = s.get(o);
+      return y == null && (y = new L(a), s.add(o, y)), y;
+    }, x = p ? C(p, m) : new L(m), G = e.placement.translation, D = i ? w(i.displayWidth, i.displayHeight) : N, R = e.placement.centerOffset, T = ye, U = P(), v = fe(x, T, G, null, D, R, U, null), g = me(this._context, r, v, c, z);
+    if (g == null)
+      return null;
+    const j = (s, a, o, y, W, F) => {
+      const I = h() || e.placement.elevationOffset, V = this.setGraphicElevationContext(t, a, I);
+      return J(s, V, o, y, W, F);
+    }, d = new Y(this, g.object, [v], p == null ? [x] : null, f, j, c);
+    d.alignedSampledElevation = g.sampledElevation, d.needsElevationUpdates = O(c.mode) || c.mode === "absolute-height", d.getScreenSize = (s = P()) => (s[0] = i ? i.displayWidth : e.displaySize[0], s[1] = i ? i.displayHeight : e.displaySize[1], s);
+    const H = new K(e.placement.elevationOffset, n);
+    return d.metadata = H, pe(d, r, this._context.elevationProvider), d;
+  }
+}
+function E(u, t, r) {
+  u && u.forEach((n) => {
+    const e = t(n);
+    e != null && r(e, n.graphic);
+  });
+}
+function ge(u, t) {
+  if (t.verticalPlacement === "baseline") {
+    const n = ie[t.horizontalPlacement], e = u != null ? u.baselineAnchorY : 0;
+    return w(n, e);
+  }
+  const r = le(t.horizontalPlacement, t.verticalPlacement);
+  return ce[r];
+}
+const xe = { mode: "relative-to-ground", offset: 0 };
+export {
+  Ie as Graphics3DTextSymbolLayer
+};