@agrotools1/at-components 0.2.0 → 0.2.2

package/dist/OverrideHelper-82325a2c.js

@@ -0,0 +1,242 @@
+import { s as M, W as C, bz as d, eG as I, ad as x } from "./index-01c737ed.js";
+import { o as k } from "./colorUtils-54f4b662.js";
+import { j as O, z as b, G as h, s as S, l as N } from "./utils-7a88ec6a.js";
+import { U as g, v as P, q as G, k as w } from "./quantizationUtils-0a8f74c6.js";
+function T(c, e, r, t, i) {
+  if (c == null)
+    return null;
+  const s = c.referencesGeometry() && i ? $(e, t, i) : e, n = c.repurposeFeature(s);
+  try {
+    return c.evaluate({ ...r, $feature: n }, c.services);
+  } catch (o) {
+    return M.getLogger("esri.views.2d.support.arcadeOnDemand").warn("Feature arcade evaluation failed:", o), null;
+  }
+}
+const y = /* @__PURE__ */ new Map();
+function $(c, e, r) {
+  const { transform: t, hasZ: i, hasM: s } = r;
+  y.has(e) || y.set(e, E(e));
+  const n = y.get(e)(c.geometry, t, i, s);
+  return { ...c, geometry: n };
+}
+function E(c) {
+  const e = {};
+  switch (c) {
+    case "esriGeometryPoint":
+      return (r, t, i, s) => w(t, e, r, i, s);
+    case "esriGeometryPolygon":
+      return (r, t, i, s) => G(t, e, r, i, s);
+    case "esriGeometryPolyline":
+      return (r, t, i, s) => P(t, e, r, i, s);
+    case "esriGeometryMultipoint":
+      return (r, t, i, s) => g(t, e, r, i, s);
+    default:
+      return M.getLogger("esri.views.2d.support.arcadeOnDemand").error(new C("mapview-arcade", `Unable to handle geometryType: ${c}`)), (r) => r;
+  }
+}
+const A = (c) => {
+  if (!c)
+    return [0, 0, 0, 0];
+  const { r: e, g: r, b: t, a: i } = c;
+  return [e, r, t, 255 * i];
+};
+class a {
+  static findApplicableOverrides(e, r, t) {
+    if (e && r) {
+      if (e.primitiveName) {
+        let i = !1;
+        for (const s of t)
+          if (s.primitiveName === e.primitiveName) {
+            i = !0;
+            break;
+          }
+        if (!i)
+          for (const s of r)
+            s.primitiveName === e.primitiveName && t.push(s);
+      }
+      switch (e.type) {
+        case "CIMPointSymbol":
+        case "CIMLineSymbol":
+        case "CIMPolygonSymbol":
+          if (e.effects)
+            for (const i of e.effects)
+              a.findApplicableOverrides(i, r, t);
+          if (e.symbolLayers)
+            for (const i of e.symbolLayers)
+              a.findApplicableOverrides(i, r, t);
+          break;
+        case "CIMTextSymbol":
+          break;
+        case "CIMSolidStroke":
+        case "CIMPictureStroke":
+        case "CIMGradientStroke":
+        case "CIMSolidFill":
+        case "CIMPictureFill":
+        case "CIMHatchFill":
+        case "CIMGradientFill":
+        case "CIMVectorMarker":
+        case "CIMCharacterMarker":
+        case "CIMPictureMarker":
+          if (e.effects)
+            for (const i of e.effects)
+              a.findApplicableOverrides(i, r, t);
+          if (e.markerPlacement && a.findApplicableOverrides(e.markerPlacement, r, t), e.type === "CIMVectorMarker") {
+            if (e.markerGraphics)
+              for (const i of e.markerGraphics)
+                a.findApplicableOverrides(i, r, t), a.findApplicableOverrides(i.symbol, r, t);
+          } else
+            e.type === "CIMCharacterMarker" ? a.findApplicableOverrides(e.symbol, r, t) : e.type === "CIMHatchFill" ? a.findApplicableOverrides(e.lineSymbol, r, t) : e.type === "CIMPictureMarker" && a.findApplicableOverrides(e.animatedSymbolProperties, r, t);
+      }
+    }
+  }
+  static findEffectOverrides(e, r) {
+    if (!e)
+      return null;
+    if (e.type === "CIMGeometricEffectDashes" && O(e), !r || !e.primitiveName)
+      return { type: "cim-effect-info", effect: e, overrides: [] };
+    const t = e.primitiveName, i = [];
+    for (const s of r)
+      s.primitiveName === t && i.push({ ...s, propertyName: b(s.propertyName) });
+    return { type: "cim-effect-info", effect: e, overrides: i };
+  }
+  static async resolveSymbolOverrides(e, r, t, i, s, n, o) {
+    if (!(e != null && e.symbol))
+      return null;
+    let { symbol: p, primitiveOverrides: l } = e;
+    const u = !!l;
+    if (!u && !i)
+      return p;
+    p = d(p), l = d(l);
+    let v = !0;
+    if (r || (r = { attributes: {} }, v = !1), u) {
+      if (v || (l = l.filter((f) => {
+        var m;
+        return !((m = f.valueExpressionInfo) != null && m.expression.includes("$feature"));
+      })), o || (l = l.filter((f) => {
+        var m;
+        return !((m = f.valueExpressionInfo) != null && m.expression.includes("$view"));
+      })), l.length > 0) {
+        const f = { spatialReference: t, fields: h(r.attributes), geometryType: s };
+        await a.createRenderExpressions(l, f), a.evaluateOverrides(l, r, s ?? "esriGeometryPoint", n, o);
+      }
+      a.applyOverrides(p, l);
+    }
+    return i && a.applyDictionaryTextOverrides(p, r, i, null), p;
+  }
+  static async createRenderExpressions(e, r) {
+    const t = [];
+    for (const i of e) {
+      const s = i.valueExpressionInfo;
+      if (!s || a._expressionToRenderExpression.has(s.expression))
+        continue;
+      const n = I(s.expression, r.spatialReference, r.fields);
+      t.push(n), n.then((o) => a._expressionToRenderExpression.set(s.expression, o));
+    }
+    t.length > 0 && await Promise.all(t);
+  }
+  static evaluateOverrides(e, r, t, i, s) {
+    const n = { $view: { scale: s == null ? void 0 : s.scale } };
+    for (const o of e) {
+      o.value && typeof o.value == "object" && k(o.value) && (o.propertyName === "Color" || o.propertyName === "StrokeColor") && (o.value = A(o.value));
+      const p = o.valueExpressionInfo;
+      if (!p)
+        continue;
+      const l = a._expressionToRenderExpression.get(p.expression);
+      l && (o.value = T(l, r, n, t, i));
+    }
+  }
+  static applyDictionaryTextOverrides(e, r, t, i, s = "Normal") {
+    if (e != null && e.type)
+      switch (e.type) {
+        case "CIMPointSymbol":
+        case "CIMLineSymbol":
+        case "CIMPolygonSymbol":
+        case "CIMTextSymbol":
+          {
+            const n = e.symbolLayers;
+            if (!n)
+              return;
+            for (const o of n)
+              o && o.type === "CIMVectorMarker" && a.applyDictionaryTextOverrides(o, r, t, i, e.type === "CIMTextSymbol" ? e.textCase : s);
+          }
+          break;
+        case "CIMVectorMarker":
+          {
+            const n = e.markerGraphics;
+            if (!n)
+              return;
+            for (const o of n)
+              o && a.applyDictionaryTextOverrides(o, r, t, i);
+          }
+          break;
+        case "CIMMarkerGraphic": {
+          const n = e.textString;
+          if (n && n.includes("[")) {
+            const o = S(n, t);
+            e.textString = N(r, o, i, s);
+          }
+        }
+      }
+  }
+  static applyOverrides(e, r, t, i) {
+    if (e.primitiveName) {
+      for (const s of r)
+        if (s.primitiveName === e.primitiveName) {
+          const n = b(s.propertyName);
+          if (i && i.push({ cim: e, nocapPropertyName: n, value: e[n] }), t) {
+            let o = !1;
+            for (const p of t)
+              p.primitiveName === e.primitiveName && (o = !0);
+            o || t.push(s);
+          }
+          s.value != null && (e[n] = s.value);
+        }
+    }
+    switch (e.type) {
+      case "CIMPointSymbol":
+      case "CIMLineSymbol":
+      case "CIMPolygonSymbol":
+        if (e.effects)
+          for (const s of e.effects)
+            a.applyOverrides(s, r, t, i);
+        if (e.symbolLayers)
+          for (const s of e.symbolLayers)
+            a.applyOverrides(s, r, t, i);
+        break;
+      case "CIMTextSymbol":
+        break;
+      case "CIMSolidStroke":
+      case "CIMSolidFill":
+      case "CIMVectorMarker":
+        if (e.effects)
+          for (const s of e.effects)
+            a.applyOverrides(s, r, t, i);
+        if (e.type === "CIMVectorMarker" && e.markerGraphics)
+          for (const s of e.markerGraphics)
+            a.applyOverrides(s, r, t, i), a.applyOverrides(s.symbol, r, t, i);
+    }
+  }
+  static restoreOverrides(e) {
+    for (const r of e)
+      r.cim[r.nocapPropertyName] = r.value;
+  }
+  static buildOverrideKey(e) {
+    let r = "";
+    for (const t of e)
+      t.value !== void 0 && (r += `${t.primitiveName}${t.propertyName}${JSON.stringify(t.value)}`);
+    return r;
+  }
+  static toValue(e, r) {
+    if (e === "DashTemplate")
+      return r.split(" ").map((t) => Number(t));
+    if (e === "Color") {
+      const t = new x(r).toRgba();
+      return t[3] *= 255, t;
+    }
+    return r;
+  }
+}
+a._expressionToRenderExpression = /* @__PURE__ */ new Map();
+export {
+  a as f
+};

package/dist/PBFDecoderWorker-f6517afc.js

@@ -0,0 +1,213 @@
+import { cu as c, bR as d, c6 as p, cv as f, gZ as m } from "./index-01c737ed.js";
+import { p as y, r as _ } from "./featureConversionUtils-650d7601.js";
+import { t as g } from "./pbfQueryUtils-a6ca7e23.js";
+import "vue";
+import "./OptimizedGeometry-3b808152.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./pbf-5dd791f5.js";
+let b = class {
+  constructor(t, e, s) {
+    this.uid = t, this.geometry = e, this.attributes = s, this.visible = !0, this.objectId = null, this.centroid = null;
+  }
+};
+class P {
+  constructor() {
+    this.exceededTransferLimit = !1, this.features = [], this.fields = [], this.hasM = !1, this.hasZ = !1, this.geometryType = null, this.objectIdFieldName = null, this.globalIdFieldName = null, this.geometryProperties = null, this.geohashFieldName = null, this.spatialReference = null, this.transform = null;
+  }
+}
+function C(i, t, e, s) {
+  if (t != null && t.size && e != null && i)
+    for (const r in i) {
+      if (!t.has(r))
+        continue;
+      const o = i[r];
+      typeof o == "string" && o.length > e && (s(r), i[r] = "");
+    }
+}
+function G(i, t) {
+  return t;
+}
+function l(i, t, e, s) {
+  switch (e) {
+    case 0:
+      return h(i, t + s, 0);
+    case 1:
+      return i.originPosition === "lowerLeft" ? h(i, t + s, 1) : M(i, t + s, 1);
+  }
+}
+function u(i, t, e, s) {
+  return e === 2 ? h(i, t, 2) : l(i, t, e, s);
+}
+function A(i, t, e, s) {
+  return e === 2 ? h(i, t, 3) : l(i, t, e, s);
+}
+function v(i, t, e, s) {
+  return e === 3 ? h(i, t, 3) : u(i, t, e, s);
+}
+function h({ translate: i, scale: t }, e, s) {
+  return i[s] + e * t[s];
+}
+function M({ translate: i, scale: t }, e, s) {
+  return i[s] - e * t[s];
+}
+class R {
+  constructor(t) {
+    this._options = t, this.geometryTypes = ["point", "multipoint", "polyline", "polygon"], this._previousCoordinate = [0, 0], this._transform = null, this._applyTransform = G, this._lengths = [], this._currentLengthIndex = 0, this._toAddInCurrentPath = 0, this._vertexDimension = 0, this._coordinateBuffer = null, this._coordinateBufferPtr = 0, this._attributesConstructor = class {
+    }, this._missingAttributes = [];
+  }
+  get missingAttributes() {
+    return this._missingAttributes;
+  }
+  createFeatureResult() {
+    return new P();
+  }
+  finishFeatureResult(t) {
+    if (this._options.applyTransform && (t.transform = null), this._attributesConstructor = class {
+    }, this._coordinateBuffer = null, this._lengths.length = 0, !t.hasZ)
+      return;
+    const e = c(t.geometryType, this._options.sourceSpatialReference, t.spatialReference);
+    if (e != null)
+      for (const s of t.features)
+        e(s.geometry);
+  }
+  createSpatialReference() {
+    return new d();
+  }
+  addField(t, e) {
+    t.fields.push(p.fromJSON(e));
+    const s = t.fields.map((r) => r.name);
+    this._attributesConstructor = function() {
+      for (const r of s)
+        this[r] = null;
+    };
+  }
+  addFeature(t, e) {
+    const s = this._options.maxStringAttributeLength, r = this._options.maxStringAttributeFields;
+    C(e.attributes, r, s, (o) => {
+      const n = e.attributes[t.objectIdFieldName];
+      n != null && this._missingAttributes.push({ objectId: n, attribute: o });
+    }), t.features.push(e);
+  }
+  addQueryGeometry(t, e) {
+    const { queryGeometry: s, queryGeometryType: r } = e, o = y(s.clone(), s, !1, !1, this._transform), n = _(o, r, !1, !1);
+    let a = null;
+    switch (r) {
+      case "esriGeometryPoint":
+        a = "point";
+        break;
+      case "esriGeometryPolygon":
+        a = "polygon";
+        break;
+      case "esriGeometryPolyline":
+        a = "polyline";
+        break;
+      case "esriGeometryMultipoint":
+        a = "multipoint";
+    }
+    n.type = a, t.queryGeometryType = r, t.queryGeometry = n;
+  }
+  prepareFeatures(t) {
+    switch (this._transform = t.transform ?? null, this._options.applyTransform && t.transform && (this._applyTransform = this._deriveApplyTransform(t)), this._vertexDimension = 2, t.hasZ && this._vertexDimension++, t.hasM && this._vertexDimension++, t.geometryType) {
+      case "point":
+        this.addCoordinate = (e, s, r) => this.addCoordinatePoint(e, s, r), this.createGeometry = (e) => this.createPointGeometry(e);
+        break;
+      case "polygon":
+        this.addCoordinate = (e, s, r) => this._addCoordinatePolygon(e, s, r), this.createGeometry = (e) => this._createPolygonGeometry(e);
+        break;
+      case "polyline":
+        this.addCoordinate = (e, s, r) => this._addCoordinatePolyline(e, s, r), this.createGeometry = (e) => this._createPolylineGeometry(e);
+        break;
+      case "multipoint":
+        this.addCoordinate = (e, s, r) => this._addCoordinateMultipoint(e, s, r), this.createGeometry = (e) => this._createMultipointGeometry(e);
+        break;
+      case "mesh":
+      case "extent":
+        break;
+      default:
+        f(t.geometryType);
+    }
+  }
+  createFeature() {
+    return this._lengths.length = 0, this._currentLengthIndex = 0, this._previousCoordinate[0] = 0, this._previousCoordinate[1] = 0, new b(m(), null, new this._attributesConstructor());
+  }
+  allocateCoordinates() {
+    const t = this._lengths.reduce((e, s) => e + s, 0);
+    this._coordinateBuffer = new Float64Array(t * this._vertexDimension), this._coordinateBufferPtr = 0;
+  }
+  addLength(t, e) {
+    this._lengths.length === 0 && (this._toAddInCurrentPath = e), this._lengths.push(e);
+  }
+  createPointGeometry(t) {
+    const e = { type: "point", x: 0, y: 0, spatialReference: t.spatialReference, hasZ: !!t.hasZ, hasM: !!t.hasM };
+    return e.hasZ && (e.z = 0), e.hasM && (e.m = 0), e;
+  }
+  addCoordinatePoint(t, e, s) {
+    const r = this._transform ? this._applyTransform(this._transform, e, s, 0) : e;
+    if (r != null)
+      switch (s) {
+        case 0:
+          t.x = r;
+          break;
+        case 1:
+          t.y = r;
+          break;
+        case 2:
+          t.hasZ ? t.z = r : t.m = r;
+          break;
+        case 3:
+          t.m = r;
+      }
+  }
+  _transformPathLikeValue(t, e) {
+    let s = 0;
+    return e <= 1 && (s = this._previousCoordinate[e], this._previousCoordinate[e] += t), this._transform ? this._applyTransform(this._transform, t, e, s) : t;
+  }
+  _addCoordinatePolyline(t, e, s) {
+    this._dehydratedAddPointsCoordinate(t.paths, e, s);
+  }
+  _addCoordinatePolygon(t, e, s) {
+    this._dehydratedAddPointsCoordinate(t.rings, e, s);
+  }
+  _addCoordinateMultipoint(t, e, s) {
+    s === 0 && t.points.push([]);
+    const r = this._transformPathLikeValue(e, s);
+    t.points[t.points.length - 1].push(r);
+  }
+  _createPolygonGeometry(t) {
+    return { type: "polygon", rings: [[]], spatialReference: t.spatialReference, hasZ: !!t.hasZ, hasM: !!t.hasM };
+  }
+  _createPolylineGeometry(t) {
+    return { type: "polyline", paths: [[]], spatialReference: t.spatialReference, hasZ: !!t.hasZ, hasM: !!t.hasM };
+  }
+  _createMultipointGeometry(t) {
+    return { type: "multipoint", points: [], spatialReference: t.spatialReference, hasZ: !!t.hasZ, hasM: !!t.hasM };
+  }
+  _dehydratedAddPointsCoordinate(t, e, s) {
+    s === 0 && this._toAddInCurrentPath-- == 0 && (t.push([]), this._toAddInCurrentPath = this._lengths[++this._currentLengthIndex] - 1, this._previousCoordinate[0] = 0, this._previousCoordinate[1] = 0);
+    const r = this._transformPathLikeValue(e, s), o = t[t.length - 1], n = this._coordinateBuffer;
+    if (n) {
+      if (s === 0) {
+        const a = this._coordinateBufferPtr * Float64Array.BYTES_PER_ELEMENT;
+        o.push(new Float64Array(n.buffer, a, this._vertexDimension));
+      }
+      n[this._coordinateBufferPtr++] = r;
+    }
+  }
+  _deriveApplyTransform(t) {
+    const { hasZ: e, hasM: s } = t;
+    return e && s ? v : e ? u : s ? A : l;
+  }
+}
+class T {
+  _parseFeatureQuery(t) {
+    var o;
+    const e = new R(t.options), s = g(t.buffer, e), r = { ...s, spatialReference: (o = s.spatialReference) == null ? void 0 : o.toJSON(), fields: s.fields ? s.fields.map((n) => n.toJSON()) : void 0, missingAttributes: e.missingAttributes };
+    return Promise.resolve(r);
+  }
+}
+function N() {
+  return new T();
+}
+export {
+  N as default
+};

package/dist/PointCloudLayer-cff43a10.js

@@ -0,0 +1,197 @@
+import { e as r, y as o, c as y, bx as B, ea as x, db as v, bz as u, c6 as b, ba as _, bO as V, iq as C, W as l, d1 as L, U as N, s as P, w as O, c5 as E, c2 as A, a_ as D } from "./index-01c737ed.js";
+import { m as K } from "./MultiOriginJSONSupport-bb258670.js";
+import { i as k } from "./APIKeyMixin-9511e0a5.js";
+import { l as G } from "./ArcGISService-3f8d89c1.js";
+import { e as M } from "./CustomParametersMixin-b3432b3e.js";
+import { u as U } from "./OperationalLayer-55af27d6.js";
+import { j as z } from "./PortalLayer-07b3c53e.js";
+import { t as W } from "./ScaleRangeLayer-7ddf00b4.js";
+import { L as Z, P as T } from "./SceneService-fb9f0142.js";
+import { y as H, f as J, c as Q } from "./commonProperties-f9559903.js";
+import { s as X } from "./fieldProperties-edfa24cb.js";
+import { c as q, d as Y, b as ee, a as te } from "./PointCloudUniqueValueRenderer-f337a895.js";
+import { I as F, x as re, Z as oe } from "./elevationInfoUtils-5456a079.js";
+import { p as ie } from "./popupUtils-d871563b.js";
+import "vue";
+import "./portalItemUtils-4c4caad0.js";
+import "./originUtils-87edf087.js";
+import "./multiOriginJSONSupportUtils-207ba4d4.js";
+import "./jsonContext-2dc288b1.js";
+import "./resourceUtils-374db840.js";
+import "./resourceUtils-0d68cbc2.js";
+import "./saveAPIKeyUtils-1a3d4a8a.js";
+import "./saveUtils-43fdc547.js";
+import "./ElevationInfo-fad03d5e.js";
+import "./unitConversionUtils-f0ebaf75.js";
+import "./lengthUtils-695e744c.js";
+import "./FieldsIndex-75cca4d0.js";
+import "./UnknownTimeZone-220952b5.js";
+import "./ColorStop-7187f368.js";
+let f = class extends B {
+  constructor(e) {
+    super(e), this.field = null, this.type = null;
+  }
+  clone() {
+    return console.warn(".clone() is not implemented for " + this.declaredClass), null;
+  }
+};
+r([o({ type: String, json: { write: { enabled: !0, isRequired: !0 } } })], f.prototype, "field", void 0), r([o({ readOnly: !0, nonNullable: !0, json: { read: !1 } })], f.prototype, "type", void 0), f = r([y("esri.layers.pointCloudFilters.PointCloudFilter")], f);
+const g = f;
+var w;
+let d = w = class extends g {
+  constructor(e) {
+    super(e), this.requiredClearBits = null, this.requiredSetBits = null, this.type = "bitfield";
+  }
+  clone() {
+    return new w({ field: this.field, requiredClearBits: u(this.requiredClearBits), requiredSetBits: u(this.requiredSetBits) });
+  }
+};
+r([o({ type: [x], json: { write: { enabled: !0, overridePolicy() {
+  return { enabled: !0, isRequired: !this.requiredSetBits };
+} } } })], d.prototype, "requiredClearBits", void 0), r([o({ type: [x], json: { write: { enabled: !0, overridePolicy() {
+  return { enabled: !0, isRequired: !this.requiredClearBits };
+} } } })], d.prototype, "requiredSetBits", void 0), r([v({ pointCloudBitfieldFilter: "bitfield" })], d.prototype, "type", void 0), d = w = r([y("esri.layers.pointCloudFilters.PointCloudBitfieldFilter")], d);
+const se = d;
+var I;
+let m = I = class extends g {
+  constructor(e) {
+    super(e), this.includedReturns = [], this.type = "return";
+  }
+  clone() {
+    return new I({ field: this.field, includedReturns: u(this.includedReturns) });
+  }
+};
+r([o({ type: [["firstOfMany", "last", "lastOfMany", "single"]], json: { write: { enabled: !0, isRequired: !0 } } })], m.prototype, "includedReturns", void 0), r([v({ pointCloudReturnFilter: "return" })], m.prototype, "type", void 0), m = I = r([y("esri.layers.pointCloudFilters.PointCloudReturnFilter")], m);
+const ne = m;
+var $;
+let p = $ = class extends g {
+  constructor(e) {
+    super(e), this.mode = "exclude", this.type = "value", this.values = [];
+  }
+  clone() {
+    return new $({ field: this.field, mode: this.mode, values: u(this.values) });
+  }
+};
+r([o({ type: ["exclude", "include"], json: { write: { enabled: !0, isRequired: !0 } } })], p.prototype, "mode", void 0), r([v({ pointCloudValueFilter: "value" })], p.prototype, "type", void 0), r([o({ type: [Number], json: { write: { enabled: !0, isRequired: !0 } } })], p.prototype, "values", void 0), p = $ = r([y("esri.layers.pointCloudFilters.PointCloudValueFilter")], p);
+const ae = p, le = { key: "type", base: g, typeMap: { value: ae, bitfield: se, return: ne } };
+var S;
+let h = S = class extends q {
+  constructor(e) {
+    super(e), this.type = "point-cloud-rgb", this.field = null;
+  }
+  clone() {
+    return new S({ ...this.cloneProperties(), field: u(this.field) });
+  }
+};
+r([v({ pointCloudRGBRenderer: "point-cloud-rgb" })], h.prototype, "type", void 0), r([o({ type: String, json: { write: !0 } })], h.prototype, "field", void 0), h = S = r([y("esri.renderers.PointCloudRGBRenderer")], h);
+const de = h, R = { key: "type", base: q, typeMap: { "point-cloud-class-breaks": Y, "point-cloud-rgb": de, "point-cloud-stretch": ee, "point-cloud-unique-value": te }, errorContext: "renderer" }, j = X();
+let i = class extends Z(G(U(z(W(K(M(k(D)))))))) {
+  constructor(...e) {
+    super(...e), this.operationalLayerType = "PointCloudLayer", this.popupEnabled = !0, this.popupTemplate = null, this.opacity = 1, this.filters = [], this.fields = null, this.fieldsIndex = null, this.outFields = null, this.path = null, this.legendEnabled = !0, this.renderer = null, this.type = "point-cloud";
+  }
+  normalizeCtorArgs(e, t) {
+    return typeof e == "string" ? { url: e, ...t } : e;
+  }
+  get defaultPopupTemplate() {
+    return this.attributeStorageInfo ? this.createPopupTemplate() : null;
+  }
+  getFieldDomain(e) {
+    const t = this.fieldsIndex.get(e);
+    return t != null && t.domain ? t.domain : null;
+  }
+  readServiceFields(e, t, n) {
+    return Array.isArray(e) ? e.map((s) => {
+      const a = new b();
+      return s.type === "FieldTypeInteger" && ((s = u(s)).type = "esriFieldTypeInteger"), a.read(s, n), a;
+    }) : Array.isArray(t.attributeStorageInfo) ? t.attributeStorageInfo.map((s) => new b({ name: s.name, type: s.name === "ELEVATION" ? "double" : "integer" })) : null;
+  }
+  set elevationInfo(e) {
+    this._set("elevationInfo", e), this._validateElevationInfo();
+  }
+  writeRenderer(e, t, n, s) {
+    _("layerDefinition.drawingInfo.renderer", e.write({}, s), t);
+  }
+  load(e) {
+    const t = e != null ? e.signal : null, n = this.loadFromPortal({ supportedTypes: ["Scene Service"] }, e).catch(V).then(() => this._fetchService(t));
+    return this.addResolvingPromise(n), Promise.resolve(this);
+  }
+  createPopupTemplate(e) {
+    const t = ie(this, e);
+    return t && (this._formatPopupTemplateReturnsField(t), this._formatPopupTemplateRGBField(t)), t;
+  }
+  _formatPopupTemplateReturnsField(e) {
+    var a;
+    const t = this.fieldsIndex.get("RETURNS");
+    if (!t)
+      return;
+    const n = (a = e.fieldInfos) == null ? void 0 : a.find((c) => c.fieldName === t.name);
+    if (!n)
+      return;
+    const s = new C({ name: "pcl-returns-decoded", title: t.alias || t.name, expression: `
+        var returnValue = $feature.${t.name};
+        return (returnValue % 16) + " / " + Floor(returnValue / 16);
+      ` });
+    e.expressionInfos = [...e.expressionInfos || [], s], n.fieldName = "expression/pcl-returns-decoded";
+  }
+  _formatPopupTemplateRGBField(e) {
+    var a;
+    const t = this.fieldsIndex.get("RGB");
+    if (!t)
+      return;
+    const n = (a = e.fieldInfos) == null ? void 0 : a.find((c) => c.fieldName === t.name);
+    if (!n)
+      return;
+    const s = new C({ name: "pcl-rgb-decoded", title: t.alias || t.name, expression: `
+        var rgb = $feature.${t.name};
+        var red = Floor(rgb / 65536, 0);
+        var green = Floor((rgb - (red * 65536)) / 256,0);
+        var blue = rgb - (red * 65536) - (green * 256);
+
+        return "rgb(" + red + "," + green + "," + blue + ")";
+      ` });
+    e.expressionInfos = [...e.expressionInfos || [], s], n.fieldName = "expression/pcl-rgb-decoded";
+  }
+  async queryCachedStatistics(e, t) {
+    if (await this.load(t), !this.attributeStorageInfo)
+      throw new l("scenelayer:no-cached-statistics", "Cached statistics are not available for this layer");
+    const n = this.fieldsIndex.get(e);
+    if (!n)
+      throw new l("pointcloudlayer:field-unexisting", `Field '${e}' does not exist on the layer`);
+    for (const s of this.attributeStorageInfo)
+      if (s.name === n.name) {
+        const a = L(this.parsedUrl.path, `./statistics/${s.key}`);
+        return N(a, { query: { f: "json", ...this.customParameters, token: this.apiKey }, responseType: "json", signal: t ? t.signal : null }).then((c) => c.data);
+      }
+    throw new l("pointcloudlayer:no-cached-statistics", "Cached statistics for this attribute are not available");
+  }
+  async saveAs(e, t) {
+    return this._debouncedSaveOperations(T.SAVE_AS, { ...t, getTypeKeywords: () => this._getTypeKeywords(), portalItemLayerType: "point-cloud" }, e);
+  }
+  async save() {
+    const e = { getTypeKeywords: () => this._getTypeKeywords(), portalItemLayerType: "point-cloud" };
+    return this._debouncedSaveOperations(T.SAVE, e);
+  }
+  validateLayer(e) {
+    if (e.layerType && e.layerType !== "PointCloud")
+      throw new l("pointcloudlayer:layer-type-not-supported", "PointCloudLayer does not support this layer type", { layerType: e.layerType });
+    if (isNaN(this.version.major) || isNaN(this.version.minor))
+      throw new l("layer:service-version-not-supported", "Service version is not supported.", { serviceVersion: this.version.versionString, supportedVersions: "1.x-2.x" });
+    if (this.version.major > 2)
+      throw new l("layer:service-version-too-new", "Service version is too new.", { serviceVersion: this.version.versionString, supportedVersions: "1.x-2.x" });
+  }
+  hasCachedStatistics(e) {
+    return this.attributeStorageInfo != null && this.attributeStorageInfo.some((t) => t.name === e);
+  }
+  _getTypeKeywords() {
+    return ["PointCloud"];
+  }
+  _validateElevationInfo() {
+    const e = this.elevationInfo;
+    F(P.getLogger(this), re("Point cloud layers", "absolute-height", e)), F(P.getLogger(this), oe("Point cloud layers", e));
+  }
+};
+r([o({ type: ["PointCloudLayer"] })], i.prototype, "operationalLayerType", void 0), r([o(H)], i.prototype, "popupEnabled", void 0), r([o({ type: O, json: { name: "popupInfo", write: !0 } })], i.prototype, "popupTemplate", void 0), r([o({ readOnly: !0, json: { read: !1 } })], i.prototype, "defaultPopupTemplate", null), r([o({ readOnly: !0, json: { write: !1, read: !1, origins: { "web-document": { write: !1, read: !1 } } } })], i.prototype, "opacity", void 0), r([o({ type: ["show", "hide"] })], i.prototype, "listMode", void 0), r([o({ types: [le], json: { origins: { service: { read: { source: "filters" } } }, name: "layerDefinition.filters", write: !0 } })], i.prototype, "filters", void 0), r([o({ type: [b] })], i.prototype, "fields", void 0), r([o(j.fieldsIndex)], i.prototype, "fieldsIndex", void 0), r([E("service", "fields", ["fields", "attributeStorageInfo"])], i.prototype, "readServiceFields", null), r([o(j.outFields)], i.prototype, "outFields", void 0), r([o({ readOnly: !0 })], i.prototype, "attributeStorageInfo", void 0), r([o(J)], i.prototype, "elevationInfo", null), r([o({ type: String, json: { origins: { "web-scene": { read: !0, write: !0 }, "portal-item": { read: !0, write: !0 } }, read: !1 } })], i.prototype, "path", void 0), r([o(Q)], i.prototype, "legendEnabled", void 0), r([o({ types: R, json: { origins: { service: { read: { source: "drawingInfo.renderer" } } }, name: "layerDefinition.drawingInfo.renderer", write: { target: { "layerDefinition.drawingInfo.renderer": { types: R }, "layerDefinition.drawingInfo.transparency": { type: Number } } } } })], i.prototype, "renderer", void 0), r([A("renderer")], i.prototype, "writeRenderer", null), r([o({ json: { read: !1 }, readOnly: !0 })], i.prototype, "type", void 0), i = r([y("esri.layers.PointCloudLayer")], i);
+const Ae = i;
+export {
+  Ae as default
+};