@agrotools1/at-components 0.3.4-5 → 0.3.5-5

package/dist/SnappingOperation-cb1044d4.js

@@ -0,0 +1,48 @@
+import { e as r, y as l, c as u, S as c, k as P, a as h, l as _ } from "./index-4ead5b97.js";
+import { I as d, F as g } from "./Scheduler-202e661b.js";
+let a = class extends c {
+  constructor(t) {
+    super(t), this.constrainResult = (s) => s, this._snapPoints = null, this._frameTask = null, this._abortController = null, this._stagedPoint = null, this._snap = P(async (s, n, o, i) => {
+      const e = this._frameTask;
+      if (e == null)
+        return;
+      const p = await e.schedule(() => n.snap({ ...s, context: o, signal: i }), i);
+      p.valid && await e.schedule(() => {
+        this.stagedPoint = p.apply(), s !== this._snapPoints && this._snapPoints != null && (this.stagedPoint = n.update({ ...this._snapPoints, context: o }));
+      }, i);
+    });
+  }
+  get stagedPoint() {
+    return this._stagedPoint;
+  }
+  set stagedPoint(t) {
+    this._stagedPoint = this.constrainResult(t);
+  }
+  initialize() {
+    var s, n;
+    const t = this.view.type === "3d" ? (n = (s = this.view) == null ? void 0 : s.resourceController) == null ? void 0 : n.scheduler : null;
+    this._frameTask = t != null ? t.registerTask(d.SNAPPING) : g;
+  }
+  destroy() {
+    this._abortController = h(this._abortController), this._frameTask = _(this._frameTask);
+  }
+  update(t, s, n) {
+    this._snapPoints = t;
+    const { point: o, scenePoint: i } = t, e = s.update({ point: o, scenePoint: i, context: n });
+    return this.stagedPoint = e, e;
+  }
+  async snap(t, s, n) {
+    const { point: o, scenePoint: i } = t;
+    return this.stagedPoint = s.update({ point: o, scenePoint: i, context: n }), this._snapPoints = t, this._abortController == null && (this._abortController = new AbortController()), this._snap(t, s, n, this._abortController.signal);
+  }
+  async snapAgainNearPreviousMapPoint(t, s) {
+    this._snapPoints != null && await this.snap(this._snapPoints, t, s);
+  }
+  abort() {
+    this._abortController = h(this._abortController), this._snapPoints = null;
+  }
+};
+r([l({ constructOnly: !0 })], a.prototype, "view", void 0), r([l()], a.prototype, "stagedPoint", null), r([l()], a.prototype, "constrainResult", void 0), r([l()], a.prototype, "_stagedPoint", void 0), a = r([u("esri.views.interactive.snapping.SnappingOperation")], a);
+export {
+  a as p
+};

package/dist/SourceLayerData-cd5f50cf.js

@@ -0,0 +1,116 @@
+import { h as g } from "./GeometryUtils-5c77f1b0.js";
+var u;
+(function(c) {
+  c[c.moveTo = 1] = "moveTo", c[c.lineTo = 2] = "lineTo", c[c.close = 7] = "close";
+})(u || (u = {}));
+class m {
+  constructor(e, t, o = 0) {
+    this.values = {}, this._geometry = void 0, this._pbfGeometry = null, this.featureIndex = o;
+    const s = t.keys, l = t.values, r = e.asUnsafe();
+    for (; r.next(); )
+      switch (r.tag()) {
+        case 1:
+          this.id = r.getUInt64();
+          break;
+        case 2: {
+          const i = r.getMessage().asUnsafe(), a = this.values;
+          for (; !i.empty(); ) {
+            const n = i.getUInt32(), h = i.getUInt32();
+            a[s[n]] = l[h];
+          }
+          i.release();
+          break;
+        }
+        case 3:
+          this.type = r.getUInt32();
+          break;
+        case 4:
+          this._pbfGeometry = r.getMessage();
+          break;
+        default:
+          r.skip();
+      }
+  }
+  getGeometry(e) {
+    if (this._geometry !== void 0)
+      return this._geometry;
+    if (!this._pbfGeometry)
+      return null;
+    const t = this._pbfGeometry.asUnsafe();
+    let o, s;
+    this._pbfGeometry = null, e ? e.reset(this.type) : o = [];
+    let l, r = u.moveTo, i = 0, a = 0, n = 0;
+    for (; !t.empty(); ) {
+      if (i === 0) {
+        const h = t.getUInt32();
+        r = 7 & h, i = h >> 3;
+      }
+      switch (i--, r) {
+        case u.moveTo:
+          a += t.getSInt32(), n += t.getSInt32(), e ? e.moveTo(a, n) : o && (s && o.push(s), s = [], s.push(new g(a, n)));
+          break;
+        case u.lineTo:
+          a += t.getSInt32(), n += t.getSInt32(), e ? e.lineTo(a, n) : s && s.push(new g(a, n));
+          break;
+        case u.close:
+          e ? e.close() : s && !s[0].equals(a, n) && s.push(s[0].clone());
+          break;
+        default:
+          throw t.release(), new Error("Invalid path operation");
+      }
+    }
+    return e ? l = e.result() : o && (s && o.push(s), l = o), t.release(), this._geometry = l, l;
+  }
+}
+class p {
+  constructor(e) {
+    this.extent = 4096, this.keys = [], this.values = [], this._pbfLayer = e.clone();
+    const t = e.asUnsafe();
+    for (; t.next(); )
+      switch (t.tag()) {
+        case 1:
+          this.name = t.getString();
+          break;
+        case 3:
+          this.keys.push(t.getString());
+          break;
+        case 4:
+          this.values.push(t.processMessage(p._parseValue));
+          break;
+        case 5:
+          this.extent = t.getUInt32();
+          break;
+        default:
+          t.skip();
+      }
+  }
+  getData() {
+    return this._pbfLayer;
+  }
+  static _parseValue(e) {
+    for (; e.next(); )
+      switch (e.tag()) {
+        case 1:
+          return e.getString();
+        case 2:
+          return e.getFloat();
+        case 3:
+          return e.getDouble();
+        case 4:
+          return e.getInt64();
+        case 5:
+          return e.getUInt64();
+        case 6:
+          return e.getSInt64();
+        case 7:
+          return e.getBool();
+        default:
+          e.skip();
+      }
+    return null;
+  }
+}
+export {
+  p as e,
+  m as s
+};