@agrotools1/at-components 0.3.2 → 0.3.3

package/dist/pbf-a85c52b3.js

@@ -0,0 +1,215 @@
+import { aO as d, aQ as g } from "./index-3b4c2147.js";
+var a;
+(function(n) {
+  n[n.varint = 0] = "varint", n[n.fixed64 = 1] = "fixed64", n[n.delimited = 2] = "delimited", n[n.fixed32 = 5] = "fixed32", n[n.unknown = 99] = "unknown";
+})(a || (a = {}));
+const p = 4294967296, u = new TextDecoder("utf-8"), f = d("safari") || d("ios") ? 6 : d("ff") ? 12 : 32;
+class o {
+  constructor(t, i, s = 0, e = t ? t.byteLength : 0) {
+    this._tag = 0, this._dataType = a.unknown, this._init(t, i, s, e);
+  }
+  _init(t, i, s, e) {
+    this._data = t, this._dataView = i, this._pos = s, this._end = e;
+  }
+  asUnsafe() {
+    return this;
+  }
+  clone() {
+    return new o(this._data, this._dataView, this._pos, this._end);
+  }
+  pos() {
+    return this._pos;
+  }
+  move(t) {
+    this._pos = t;
+  }
+  nextTag(t) {
+    for (; ; ) {
+      if (this._pos === this._end)
+        return !1;
+      const i = this._decodeVarint();
+      if (this._tag = i >> 3, this._dataType = 7 & i, !t || t === this._tag)
+        break;
+      this.skip();
+    }
+    return !0;
+  }
+  next() {
+    if (this._pos === this._end)
+      return !1;
+    const t = this._decodeVarint();
+    return this._tag = t >> 3, this._dataType = 7 & t, !0;
+  }
+  empty() {
+    return this._pos >= this._end;
+  }
+  tag() {
+    return this._tag;
+  }
+  getInt32() {
+    return this._decodeVarint();
+  }
+  getInt64() {
+    return this._decodeVarint();
+  }
+  getUInt32() {
+    let t = 4294967295;
+    if (t = (127 & this._data[this._pos]) >>> 0, this._data[this._pos++] < 128 || (t = (t | (127 & this._data[this._pos]) << 7) >>> 0, this._data[this._pos++] < 128) || (t = (t | (127 & this._data[this._pos]) << 14) >>> 0, this._data[this._pos++] < 128) || (t = (t | (127 & this._data[this._pos]) << 21) >>> 0, this._data[this._pos++] < 128) || (t = (t | (15 & this._data[this._pos]) << 28) >>> 0, this._data[this._pos++] < 128))
+      return t;
+    throw new Error("Varint overflow");
+  }
+  getUInt64() {
+    return this._decodeVarint();
+  }
+  getSInt32() {
+    const t = this.getUInt32();
+    return t >>> 1 ^ -(1 & t) | 0;
+  }
+  getSInt64() {
+    return this._decodeSVarint();
+  }
+  getBool() {
+    const t = this._data[this._pos] !== 0;
+    return this._skip(1), t;
+  }
+  getEnum() {
+    return this._decodeVarint();
+  }
+  getFixed64() {
+    const t = this._dataView, i = this._pos, s = t.getUint32(i, !0) + t.getUint32(i + 4, !0) * p;
+    return this._skip(8), s;
+  }
+  getSFixed64() {
+    const t = this._dataView, i = this._pos, s = t.getUint32(i, !0) + t.getInt32(i + 4, !0) * p;
+    return this._skip(8), s;
+  }
+  getDouble() {
+    const t = this._dataView.getFloat64(this._pos, !0);
+    return this._skip(8), t;
+  }
+  getFixed32() {
+    const t = this._dataView.getUint32(this._pos, !0);
+    return this._skip(4), t;
+  }
+  getSFixed32() {
+    const t = this._dataView.getInt32(this._pos, !0);
+    return this._skip(4), t;
+  }
+  getFloat() {
+    const t = this._dataView.getFloat32(this._pos, !0);
+    return this._skip(4), t;
+  }
+  getString() {
+    const t = this._getLength(), i = this._pos, s = this._toString(this._data, i, i + t);
+    return this._skip(t), s;
+  }
+  getBytes() {
+    const t = this._getLength(), i = this._pos, s = this._toBytes(this._data, i, i + t);
+    return this._skip(t), s;
+  }
+  getLength() {
+    return this._getLengthUnsafe();
+  }
+  processMessageWithArgs(t, i, s, e) {
+    const r = this.getMessage(), h = t(r, i, s, e);
+    return r.release(), h;
+  }
+  processMessage(t) {
+    const i = this.getMessage(), s = t(i);
+    return i.release(), s;
+  }
+  getMessage() {
+    const t = this._getLength(), i = o.pool.acquire();
+    return i._init(this._data, this._dataView, this._pos, this._pos + t), this._skip(t), i;
+  }
+  release() {
+    o.pool.release(this);
+  }
+  dataType() {
+    return this._dataType;
+  }
+  skip() {
+    switch (this._dataType) {
+      case a.varint:
+        this._decodeVarint();
+        break;
+      case a.fixed64:
+        this._skip(8);
+        break;
+      case a.delimited:
+        this._skip(this._getLength());
+        break;
+      case a.fixed32:
+        this._skip(4);
+        break;
+      default:
+        throw new Error("Invalid data type!");
+    }
+  }
+  skipLen(t) {
+    this._skip(t);
+  }
+  _skip(t) {
+    if (this._pos + t > this._end)
+      throw new Error("Attempt to skip past the end of buffer!");
+    this._pos += t;
+  }
+  _decodeVarint() {
+    const t = this._data;
+    let i = this._pos, s = 0, e = 0;
+    if (this._end - i >= 10)
+      do {
+        if (e = t[i++], s |= 127 & e, (128 & e) == 0 || (e = t[i++], s |= (127 & e) << 7, (128 & e) == 0) || (e = t[i++], s |= (127 & e) << 14, (128 & e) == 0) || (e = t[i++], s |= (127 & e) << 21, (128 & e) == 0) || (e = t[i++], s += 268435456 * (127 & e), (128 & e) == 0) || (e = t[i++], s += 34359738368 * (127 & e), (128 & e) == 0) || (e = t[i++], s += 4398046511104 * (127 & e), (128 & e) == 0) || (e = t[i++], s += 562949953421312 * (127 & e), (128 & e) == 0) || (e = t[i++], s += 72057594037927940 * (127 & e), (128 & e) == 0) || (e = t[i++], s += 9223372036854776e3 * (127 & e), (128 & e) == 0))
+          break;
+        throw new Error("Varint too long!");
+      } while (0);
+    else {
+      let r = 1;
+      for (; i !== this._end && (e = t[i], (128 & e) != 0); )
+        ++i, s += (127 & e) * r, r *= 128;
+      if (i === this._end)
+        throw new Error("Varint overrun!");
+      ++i, s += e * r;
+    }
+    return this._pos = i, s;
+  }
+  _decodeSVarint() {
+    const t = this._data;
+    let i, s = 0, e = 0;
+    const r = 1 & t[this._pos];
+    if (e = t[this._pos++], s |= 127 & e, (128 & e) == 0 || (e = t[this._pos++], s |= (127 & e) << 7, (128 & e) == 0) || (e = t[this._pos++], s |= (127 & e) << 14, (128 & e) == 0) || (e = t[this._pos++], s |= (127 & e) << 21, (128 & e) == 0) || (e = t[this._pos++], s += 268435456 * (127 & e), (128 & e) == 0) || (e = t[this._pos++], s += 34359738368 * (127 & e), (128 & e) == 0) || (e = t[this._pos++], s += 4398046511104 * (127 & e), (128 & e) == 0))
+      return r ? -(s + 1) / 2 : s / 2;
+    if (i = BigInt(s), e = t[this._pos++], i += 0x2000000000000n * BigInt(127 & e), (128 & e) == 0 || (e = t[this._pos++], i += 0x100000000000000n * BigInt(127 & e), (128 & e) == 0) || (e = t[this._pos++], i += 0x8000000000000000n * BigInt(127 & e), (128 & e) == 0))
+      return Number(r ? -(i + 1n) / 2n : i / 2n);
+    throw new Error("Varint too long!");
+  }
+  _getLength() {
+    if (this._dataType !== a.delimited)
+      throw new Error("Not a delimited data type!");
+    return this._decodeVarint();
+  }
+  _getLengthUnsafe() {
+    return this.getUInt32();
+  }
+  _toString(t, i, s) {
+    if ((s = Math.min(this._end, s)) - i > f) {
+      const h = t.subarray(i, s);
+      return u.decode(h);
+    }
+    let e = "", r = "";
+    for (let h = i; h < s; ++h) {
+      const _ = t[h];
+      128 & _ ? r += "%" + _.toString(16) : (e += decodeURIComponent(r) + String.fromCharCode(_), r = "");
+    }
+    return r.length && (e += decodeURIComponent(r)), e;
+  }
+  _toBytes(t, i, s) {
+    return s = Math.min(this._end, s), new Uint8Array(t.buffer, i, s - i);
+  }
+}
+o.pool = new g(o, void 0, (n) => {
+  n._data = null, n._dataView = null;
+});
+export {
+  o as n
+};

package/dist/pbfQueryUtils-5f25f81f.js

@@ -0,0 +1,422 @@
+import { G as I, ct as d, W as w } from "./index-3b4c2147.js";
+import { n as S } from "./pbf-a85c52b3.js";
+import { s as U, t as G, e as y } from "./OptimizedGeometry-3b808152.js";
+import { e as D } from "./OptimizedFeatureSet-54e095c4.js";
+const F = ["esriGeometryPoint", "esriGeometryMultipoint", "esriGeometryPolyline", "esriGeometryPolygon"];
+let Y = class {
+  constructor(e) {
+    this._options = e, this.geometryTypes = F, this._coordinatePtr = 0, this._vertexDimension = 0;
+  }
+  createFeatureResult() {
+    return new D();
+  }
+  prepareFeatures(e) {
+    this._vertexDimension = 2, e.hasZ && this._vertexDimension++, e.hasM && this._vertexDimension++;
+  }
+  finishFeatureResult(e) {
+    if (!(e != null && e.features) || !e.hasZ || !this._options.sourceSpatialReference || !e.spatialReference || I(e.spatialReference, this._options.sourceSpatialReference) || e.spatialReference.vcsWkid)
+      return;
+    const a = d(this._options.sourceSpatialReference) / d(e.spatialReference);
+    if (a !== 1)
+      for (const n of e.features) {
+        if (!U(n))
+          continue;
+        const s = n.geometry.coords;
+        for (let r = 2; r < s.length; r += 3)
+          s[r] *= a;
+      }
+  }
+  addFeature(e, a) {
+    e.features.push(a);
+  }
+  createFeature() {
+    return new G();
+  }
+  createSpatialReference() {
+    return { wkid: 0 };
+  }
+  createGeometry() {
+    return new y();
+  }
+  addField(e, a) {
+    e.fields.push(a);
+  }
+  allocateCoordinates(e) {
+    e.coords.length = e.lengths.reduce((a, n) => a + n, 0) * this._vertexDimension, this._coordinatePtr = 0;
+  }
+  addCoordinate(e, a) {
+    e.coords[this._coordinatePtr++] = a;
+  }
+  addCoordinatePoint(e, a) {
+    e.coords.push(a);
+  }
+  addLength(e, a) {
+    e.lengths.push(a);
+  }
+  addQueryGeometry(e, a) {
+    e.queryGeometry = a.queryGeometry, e.queryGeometryType = a.queryGeometryType;
+  }
+  createPointGeometry() {
+    return new y();
+  }
+};
+const h = ["esriFieldTypeSmallInteger", "esriFieldTypeInteger", "esriFieldTypeSingle", "esriFieldTypeDouble", "esriFieldTypeString", "esriFieldTypeDate", "esriFieldTypeOID", "esriFieldTypeGeometry", "esriFieldTypeBlob", "esriFieldTypeRaster", "esriFieldTypeGUID", "esriFieldTypeGlobalID", "esriFieldTypeXML", "esriFieldTypeBigInteger", "esriFieldTypeDateOnly", "esriFieldTypeTimeOnly", "esriFieldTypeTimestampOffset"], b = ["sqlTypeBigInt", "sqlTypeBinary", "sqlTypeBit", "sqlTypeChar", "sqlTypeDate", "sqlTypeDecimal", "sqlTypeDouble", "sqlTypeFloat", "sqlTypeGeometry", "sqlTypeGUID", "sqlTypeInteger", "sqlTypeLongNVarchar", "sqlTypeLongVarbinary", "sqlTypeLongVarchar", "sqlTypeNChar", "sqlTypeNVarchar", "sqlTypeOther", "sqlTypeReal", "sqlTypeSmallInt", "sqlTypeSqlXml", "sqlTypeTime", "sqlTypeTimestamp", "sqlTypeTimestamp2", "sqlTypeTinyInt", "sqlTypeVarbinary", "sqlTypeVarchar"], m = ["upperLeft", "lowerLeft"];
+function k(t) {
+  return t >= h.length ? null : h[t];
+}
+function R(t) {
+  return t >= b.length ? null : b[t];
+}
+function T(t) {
+  return t >= m.length ? null : m[t];
+}
+function q(t, e) {
+  return e >= t.geometryTypes.length ? null : t.geometryTypes[e];
+}
+function x(t, e, a) {
+  const s = t.asUnsafe(), r = e.createPointGeometry(a);
+  for (; s.next(); )
+    switch (s.tag()) {
+      case 3: {
+        const o = s.getUInt32(), i = s.pos() + o;
+        let c = 0;
+        for (; s.pos() < i; )
+          e.addCoordinatePoint(r, s.getSInt64(), c++);
+        break;
+      }
+      default:
+        s.skip();
+    }
+  return r;
+}
+function M(t, e, a) {
+  const r = t.asUnsafe(), o = e.createGeometry(a), i = 2 + (a.hasZ ? 1 : 0) + (a.hasM ? 1 : 0);
+  for (; r.next(); )
+    switch (r.tag()) {
+      case 2: {
+        const c = r.getUInt32(), p = r.pos() + c;
+        let l = 0;
+        for (; r.pos() < p; )
+          e.addLength(o, r.getUInt32(), l++);
+        break;
+      }
+      case 3: {
+        const c = r.getUInt32(), p = r.pos() + c;
+        let l = 0;
+        for (e.allocateCoordinates(o); r.pos() < p; )
+          e.addCoordinate(o, r.getSInt64(), l), l++, l === i && (l = 0);
+        break;
+      }
+      default:
+        r.skip();
+    }
+  return o;
+}
+function P(t) {
+  const s = t.asUnsafe(), r = new y();
+  let o = "esriGeometryPoint";
+  for (; s.next(); )
+    switch (s.tag()) {
+      case 2: {
+        const i = s.getUInt32(), c = s.pos() + i;
+        for (; s.pos() < c; )
+          r.lengths.push(s.getUInt32());
+        break;
+      }
+      case 3: {
+        const i = s.getUInt32(), c = s.pos() + i;
+        for (; s.pos() < c; )
+          r.coords.push(s.getSInt64());
+        break;
+      }
+      case 1:
+        o = F[s.getEnum()];
+        break;
+      default:
+        s.skip();
+    }
+  return { queryGeometry: r, queryGeometryType: o };
+}
+function W(t) {
+  const l = t.asUnsafe();
+  for (; l.next(); )
+    switch (l.tag()) {
+      case 1:
+        return l.getString();
+      case 2:
+        return l.getFloat();
+      case 3:
+        return l.getDouble();
+      case 4:
+        return l.getSInt32();
+      case 5:
+        return l.getUInt32();
+      case 6:
+        return l.getInt64();
+      case 7:
+        return l.getUInt64();
+      case 8:
+        return l.getSInt64();
+      case 9:
+        return l.getBool();
+      default:
+        return l.skip(), null;
+    }
+  return null;
+}
+function _(t) {
+  const i = t.asUnsafe(), c = { type: k(0) };
+  for (; i.next(); )
+    switch (i.tag()) {
+      case 1:
+        c.name = i.getString();
+        break;
+      case 2:
+        c.type = k(i.getEnum());
+        break;
+      case 3:
+        c.alias = i.getString();
+        break;
+      case 4:
+        c.sqlType = R(i.getEnum());
+        break;
+      case 5:
+        i.skip();
+        break;
+      case 6:
+        c.defaultValue = i.getString();
+        break;
+      default:
+        i.skip();
+    }
+  return c;
+}
+function B(t) {
+  const n = {}, s = t.asUnsafe();
+  for (; s.next(); )
+    switch (s.tag()) {
+      case 1:
+        n.name = s.getString();
+        break;
+      case 2:
+        n.isSystemMaintained = s.getBool();
+        break;
+      default:
+        s.skip();
+    }
+  return n;
+}
+function L(t, e, a, n) {
+  const i = e.createFeature(a);
+  let c = 0;
+  for (; t.next(); )
+    switch (t.tag()) {
+      case 1: {
+        const p = n[c++].name;
+        i.attributes[p] = t.processMessage(W);
+        break;
+      }
+      case 2:
+        i.geometry = t.processMessageWithArgs(M, e, a);
+        break;
+      case 4:
+        i.centroid = t.processMessageWithArgs(x, e, a);
+        break;
+      default:
+        t.skip();
+    }
+  return i;
+}
+function N(t) {
+  const r = [1, 1, 1, 1], o = t.asUnsafe();
+  for (; o.next(); )
+    switch (o.tag()) {
+      case 1:
+        r[0] = o.getDouble();
+        break;
+      case 2:
+        r[1] = o.getDouble();
+        break;
+      case 4:
+        r[2] = o.getDouble();
+        break;
+      case 3:
+        r[3] = o.getDouble();
+        break;
+      default:
+        o.skip();
+    }
+  return r;
+}
+function A(t) {
+  const r = [0, 0, 0, 0], o = t.asUnsafe();
+  for (; o.next(); )
+    switch (o.tag()) {
+      case 1:
+        r[0] = o.getDouble();
+        break;
+      case 2:
+        r[1] = o.getDouble();
+        break;
+      case 4:
+        r[2] = o.getDouble();
+        break;
+      case 3:
+        r[3] = o.getDouble();
+        break;
+      default:
+        o.skip();
+    }
+  return r;
+}
+function V(t) {
+  const s = { originPosition: T(0) }, r = t.asUnsafe();
+  for (; r.next(); )
+    switch (r.tag()) {
+      case 1:
+        s.originPosition = T(r.getEnum());
+        break;
+      case 2:
+        s.scale = r.processMessage(N);
+        break;
+      case 3:
+        s.translate = r.processMessage(A);
+        break;
+      default:
+        r.skip();
+    }
+  return s;
+}
+function C(t) {
+  const s = {}, r = t.asUnsafe();
+  for (; r.next(); )
+    switch (r.tag()) {
+      case 1:
+        s.shapeAreaFieldName = r.getString();
+        break;
+      case 2:
+        s.shapeLengthFieldName = r.getString();
+        break;
+      case 3:
+        s.units = r.getString();
+        break;
+      default:
+        r.skip();
+    }
+  return s;
+}
+function v(t, e) {
+  const i = e.createSpatialReference();
+  for (; t.next(); )
+    switch (t.tag()) {
+      case 1:
+        i.wkid = t.getUInt32();
+        break;
+      case 5:
+        i.wkt = t.getString();
+        break;
+      case 2:
+        i.latestWkid = t.getUInt32();
+        break;
+      case 3:
+        i.vcsWkid = t.getUInt32();
+        break;
+      case 4:
+        i.latestVcsWkid = t.getUInt32();
+        break;
+      default:
+        t.skip();
+    }
+  return i;
+}
+function E(t, e) {
+  const u = e.createFeatureResult(), g = t.asUnsafe();
+  u.geometryType = q(e, 0);
+  let f = !1;
+  for (; g.next(); )
+    switch (g.tag()) {
+      case 1:
+        u.objectIdFieldName = g.getString();
+        break;
+      case 3:
+        u.globalIdFieldName = g.getString();
+        break;
+      case 4:
+        u.geohashFieldName = g.getString();
+        break;
+      case 5:
+        u.geometryProperties = g.processMessage(C);
+        break;
+      case 7:
+        u.geometryType = q(e, g.getEnum());
+        break;
+      case 8:
+        u.spatialReference = g.processMessageWithArgs(v, e);
+        break;
+      case 10:
+        u.hasZ = g.getBool();
+        break;
+      case 11:
+        u.hasM = g.getBool();
+        break;
+      case 12:
+        u.transform = g.processMessage(V);
+        break;
+      case 9:
+        u.exceededTransferLimit = g.getBool();
+        break;
+      case 13:
+        e.addField(u, g.processMessage(_));
+        break;
+      case 15:
+        f || (e.prepareFeatures(u), f = !0), e.addFeature(u, g.processMessageWithArgs(L, e, u, u.fields));
+        break;
+      case 2:
+        u.uniqueIdField = g.processMessage(B);
+        break;
+      default:
+        g.skip();
+    }
+  return e.finishFeatureResult(u), u;
+}
+function $(t, e) {
+  const s = {};
+  let r = null;
+  for (; t.next(); )
+    switch (t.tag()) {
+      case 4:
+        r = t.processMessageWithArgs(P);
+        break;
+      case 1:
+        s.featureResult = t.processMessageWithArgs(E, e);
+        break;
+      default:
+        t.skip();
+    }
+  return r != null && s.featureResult && e.addQueryGeometry(s, r), s;
+}
+function O(t, e) {
+  try {
+    const n = new S(new Uint8Array(t), new DataView(t)), s = {};
+    for (; n.next(); )
+      n.tag() === 2 ? s.queryResult = n.processMessageWithArgs($, e) : n.skip();
+    return s;
+  } catch (a) {
+    throw new w("query:parsing-pbf", "Error while parsing FeatureSet PBF payload", { error: a });
+  }
+}
+function te(t, e) {
+  const a = O(t, e), n = a.queryResult.featureResult, s = a.queryResult.queryGeometry, r = a.queryResult.queryGeometryType;
+  if (n && n.features && n.features.length && n.objectIdFieldName) {
+    const o = n.objectIdFieldName;
+    for (const i of n.features)
+      i.attributes && (i.objectId = i.attributes[o]);
+  }
+  return n && (n.queryGeometry = s, n.queryGeometryType = r), n;
+}
+export {
+  Y as a,
+  _ as b,
+  V as h,
+  te as t
+};