@agrotools1/at-components 0.3.4 → 0.3.5

package/dist/icon-6764e79e.js

@@ -0,0 +1,127 @@
+import { aV as m, aW as b, aT as h, aX as x, aY as g } from "./index-a8d87ec0.js";
+import { g as v, t as z } from "./dom-b589b728.js";
+import { c as I } from "./observers-745d564e.js";
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
+ * v2.7.1
+ */
+const D = {
+  icon: "icon",
+  flipRtl: "flip-rtl"
+}, d = {}, u = {}, f = {
+  s: 16,
+  m: 24,
+  l: 32
+};
+async function y({ icon: n, scale: t }) {
+  const s = f[t], e = C(n), a = e.charAt(e.length - 1) === "F", i = `${a ? e.substring(0, e.length - 1) : e}${s}${a ? "F" : ""}`;
+  if (d[i])
+    return d[i];
+  u[i] || (u[i] = fetch(g(`./assets/icon/${i}.json`)).then((o) => o.json()).catch(() => (console.error(`"${i}" is not a valid calcite-ui-icon name`), "")));
+  const c = await u[i];
+  return d[i] = c, c;
+}
+function C(n) {
+  const t = !isNaN(Number(n.charAt(0))), s = n.split("-");
+  if (s.length > 0) {
+    const a = /[a-z]/i;
+    n = s.map((l, i) => l.replace(a, function(o, p) {
+      return i === 0 && p === 0 ? o : o.toUpperCase();
+    })).join("");
+  }
+  return t ? `i${n}` : n;
+}
+const w = ":host{display:inline-flex;color:var(--calcite-ui-icon-color)}:host([scale=s]){inline-size:16px;block-size:16px;min-inline-size:16px;min-block-size:16px}:host([scale=m]){inline-size:24px;block-size:24px;min-inline-size:24px;min-block-size:24px}:host([scale=l]){inline-size:32px;block-size:32px;min-inline-size:32px;min-block-size:32px}.flip-rtl{transform:scaleX(-1)}.svg{display:block}:host([hidden]){display:none}[hidden]{display:none}", k = /* @__PURE__ */ m(class extends b {
+  constructor() {
+    super(), this.__registerHost(), this.__attachShadow(), this.icon = null, this.flipRtl = !1, this.scale = "m", this.textLabel = void 0, this.pathData = void 0, this.visible = !1;
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Lifecycle
+  //
+  //--------------------------------------------------------------------------
+  connectedCallback() {
+    this.waitUntilVisible(() => {
+      this.visible = !0, this.loadIconPathData();
+    });
+  }
+  disconnectedCallback() {
+    var t;
+    (t = this.intersectionObserver) == null || t.disconnect(), this.intersectionObserver = null;
+  }
+  async componentWillLoad() {
+    this.loadIconPathData();
+  }
+  render() {
+    const { el: t, flipRtl: s, pathData: e, scale: a, textLabel: l } = this, i = v(t), c = f[a], o = !!l, p = [].concat(e || "");
+    return h(x, { "aria-hidden": z(!o), "aria-label": o ? l : null, role: o ? "img" : null }, h("svg", { "aria-hidden": "true", class: {
+      [D.flipRtl]: i === "rtl" && s,
+      svg: !0
+    }, fill: "currentColor", height: "100%", viewBox: `0 0 ${c} ${c}`, width: "100%", xmlns: "http://www.w3.org/2000/svg" }, p.map((r) => typeof r == "string" ? h("path", { d: r }) : h("path", { d: r.d, opacity: "opacity" in r ? r.opacity : 1 }))));
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Private Methods
+  //
+  //--------------------------------------------------------------------------
+  async loadIconPathData() {
+    const { icon: t, scale: s, visible: e } = this;
+    if (!t || !e)
+      return;
+    const a = await y({ icon: t, scale: s });
+    t === this.icon && (this.pathData = a);
+  }
+  waitUntilVisible(t) {
+    if (this.intersectionObserver = I("intersection", (s) => {
+      s.forEach((e) => {
+        e.isIntersecting && (this.intersectionObserver.disconnect(), this.intersectionObserver = null, t());
+      });
+    }, { rootMargin: "50px" }), !this.intersectionObserver) {
+      t();
+      return;
+    }
+    this.intersectionObserver.observe(this.el);
+  }
+  static get assetsDirs() {
+    return ["assets"];
+  }
+  get el() {
+    return this;
+  }
+  static get watchers() {
+    return {
+      icon: ["loadIconPathData"],
+      scale: ["loadIconPathData"]
+    };
+  }
+  static get style() {
+    return w;
+  }
+}, [1, "calcite-icon", {
+  icon: [513],
+  flipRtl: [516, "flip-rtl"],
+  scale: [513],
+  textLabel: [1, "text-label"],
+  pathData: [32],
+  visible: [32]
+}, void 0, {
+  icon: ["loadIconPathData"],
+  scale: ["loadIconPathData"]
+}]);
+function P() {
+  if (typeof customElements > "u")
+    return;
+  ["calcite-icon"].forEach((t) => {
+    switch (t) {
+      case "calcite-icon":
+        customElements.get(t) || customElements.define(t, k);
+        break;
+    }
+  });
+}
+P();
+export {
+  k as I,
+  P as d
+};

package/dist/imageBitmapUtils-d56cd963.js

@@ -0,0 +1,23 @@
+import { W as l, bJ as c } from "./index-a8d87ec0.js";
+async function u(a, e, t) {
+  let r;
+  try {
+    r = await createImageBitmap(a);
+  } catch (o) {
+    throw new l("request:server", `Unable to load ${e}`, { url: e, error: o });
+  }
+  return c(t), r;
+}
+async function w(a, e, t, r, o) {
+  let n;
+  try {
+    n = await createImageBitmap(a);
+  } catch (s) {
+    throw new l("request:server", `Unable to load tile ${e}/${t}/${r}`, { error: s, level: e, row: t, col: r });
+  }
+  return c(o), n;
+}
+export {
+  w as o,
+  u as t
+};

package/dist/imageUtils-5fc5f2e1.js

@@ -0,0 +1,69 @@
+import { R as m, T as d, U as u, i as w, W as p } from "./index-a8d87ec0.js";
+let i = null, c = !0;
+function T(n, a, t) {
+  if (!n || !a)
+    throw new Error("Cannot construct image data without dimensions");
+  if (c)
+    try {
+      return new ImageData(n, a);
+    } catch {
+      c = !1;
+    }
+  return f(n, a, t);
+}
+function U(n, a, t, e) {
+  if (!a || !t)
+    throw new Error("Cannot construct image data without dimensions");
+  if (c)
+    try {
+      return new ImageData(n, a, t);
+    } catch {
+      c = !1;
+    }
+  const r = f(a, t, e);
+  return r.data.set(n, 0), r;
+}
+function y() {
+  return i || (i = document.createElement("canvas"), i.width = 1, i.height = 1), i;
+}
+function f(n, a, t) {
+  return t || (t = y()), t.getContext("2d").createImageData(n, a);
+}
+async function g(n, a) {
+  const t = window.URL.createObjectURL(n);
+  try {
+    const { data: e } = await u(t, { ...a, responseType: "image" });
+    return e;
+  } catch (e) {
+    throw w(e) ? e : new p("invalid-image", `Could not fetch requested image at ${t}`);
+  } finally {
+    window.URL.revokeObjectURL(t);
+  }
+}
+async function b(n, a) {
+  const { arrayBuffer: t, mediaType: e } = await h(n, a), r = e === "image/png";
+  if (e === "image/gif") {
+    const { isAnimatedGIF: o, parseGif: s } = await import("./gif-24ef6c2c.js");
+    if (o(t))
+      return s(t, a);
+  }
+  if (r) {
+    const { isAnimatedPNG: o, parseApng: s } = await import("./apng-9d467a98.js");
+    if (o(t))
+      return s(t, a);
+  }
+  return g(new Blob([t], { type: e }), a);
+}
+async function h(n, a) {
+  var r;
+  const t = m(n);
+  if (t != null && t.isBase64)
+    return { arrayBuffer: d(t.data), mediaType: t.mediaType };
+  const e = await u(n, { responseType: "array-buffer", ...a });
+  return { arrayBuffer: e.data, mediaType: ((r = e.getHeader) == null ? void 0 : r.call(e, "Content-Type")) ?? "" };
+}
+export {
+  U as c,
+  b as p,
+  T as s
+};

package/dist/imageUtils-d0a1bdd3.js

@@ -0,0 +1,89 @@
+import { fd as m, aG as M, e as V, c as y } from "./index-a8d87ec0.js";
+import { b as I } from "./Bitmap-d7c41f66.js";
+import { r as T, h as _ } from "./WGLContainer-f2c4f5da.js";
+import { E as c } from "./Container-5cca9103.js";
+import { i as A } from "./TileContainer-09ca940a.js";
+let F = class extends T {
+  constructor(e, i, r, s, n, o, a = null) {
+    super(e, i, r, s, n, o), this.bitmap = new I(a), this.bitmap.coordScale = [n, o], this.bitmap.once("isReady", () => this.ready());
+  }
+  destroy() {
+    super.destroy(), this.bitmap.destroy();
+  }
+  beforeRender(e) {
+    this.bitmap.beforeRender(e), super.beforeRender(e);
+  }
+  afterRender(e) {
+    this.bitmap.afterRender(e), super.afterRender(e);
+  }
+  set stencilRef(e) {
+    this.bitmap.stencilRef = e;
+  }
+  get stencilRef() {
+    return this.bitmap.stencilRef;
+  }
+  _createTransforms() {
+    return { displayViewScreenMat3: m(), tileMat3: m() };
+  }
+  setTransform(e) {
+    super.setTransform(e), this.bitmap.transforms.displayViewScreenMat3 = this.transforms.displayViewScreenMat3;
+  }
+  onAttach() {
+    this.bitmap.stage = this.stage;
+  }
+  onDetach() {
+    this.bitmap && (this.bitmap.stage = null);
+  }
+}, L = class extends A {
+  get requiresDedicatedFBO() {
+    return this.children.some((e) => e.bitmap.blendFunction === "additive");
+  }
+  createTile(e) {
+    const i = this._tileInfoView.getTileBounds(M(), e), r = this._tileInfoView.getTileResolution(e.level), [s, n] = this._tileInfoView.tileInfo.size;
+    return new F(e, r, i[0], i[3], s, n);
+  }
+  prepareRenderPasses(e) {
+    const i = e.registerRenderPass({ name: "bitmap (tile)", brushes: [_.bitmap], target: () => this.children.map((r) => r.bitmap), drawPhase: c.MAP });
+    return [...super.prepareRenderPasses(e), i];
+  }
+  doRender(e) {
+    this.visible && e.drawPhase === c.MAP && super.doRender(e);
+  }
+};
+const z = (t) => {
+  let e = class extends t {
+    attach() {
+      this.view.timeline.record(`${this.layer.title} (BitmapTileLayer) Attach`), this._bitmapView = new L(this._tileInfoView), this.container.addChild(this._bitmapView);
+    }
+    detach() {
+      var i;
+      this.container.removeChild(this._bitmapView), (i = this._bitmapView) == null || i.removeAllChildren(), this._bitmapView = null;
+    }
+  };
+  return e = V([y("esri.views.2d.layers.BitmapTileLayerView2D")], e), e;
+};
+function P(t) {
+  return t instanceof HTMLImageElement ? t.naturalWidth : t.width;
+}
+function $(t) {
+  return t instanceof HTMLImageElement ? t.naturalHeight : t.height;
+}
+function X(t, e, i, r) {
+  if (i.level === r.level)
+    return e;
+  const s = t.tileInfo.size, n = t.getTileResolution(i.level), o = t.getTileResolution(r.level);
+  let a = t.getLODInfoAt(r.level);
+  const p = a.getXForColumn(r.col), u = a.getYForRow(r.row);
+  a = t.getLODInfoAt(i.level);
+  const f = a.getXForColumn(i.col), b = a.getYForRow(i.row), l = P(e) / s[0], h = $(e) / s[1], w = Math.round(l * ((p - f) / n)), g = Math.round(h * (-(u - b) / n)), R = Math.round(l * s[0] * (o / n)), v = Math.round(h * s[1] * (o / n)), d = C(s);
+  return d.getContext("2d").drawImage(e, w, g, R, v, 0, 0, s[0], s[1]), d;
+}
+function C(t) {
+  const e = document.createElement("canvas");
+  return [e.width, e.height] = t, e;
+}
+export {
+  X as n,
+  C as o,
+  z as r
+};

package/dist/imageryUtils-31c938b0.js

@@ -0,0 +1,43 @@
+import { $ as y, j as n } from "./utils-e4309923.js";
+import { l as c, a as p, i as u, f as i } from "./portalItemUtils-052627b4.js";
+import "./index-a8d87ec0.js";
+import "vue";
+import "./originUtils-87edf087.js";
+import "./multiOriginJSONSupportUtils-207ba4d4.js";
+import "./jsonContext-b5489a22.js";
+import "./saveAPIKeyUtils-1a4f92e5.js";
+import "./saveUtils-5b62c0b1.js";
+const s = "Image Service", g = "imagery-layer-save", v = "imagery-layer-save-as", f = "imagery-tile-layer-save", d = "imagery-tile-layer-save-as";
+function m(r) {
+  var t;
+  if (r.type === "imagery")
+    return { isValid: !0 };
+  const { raster: e } = r, a = (e == null ? void 0 : e.datasetFormat) === "Function" ? (t = e.primaryRasters) == null ? void 0 : t.rasters[0] : e;
+  return { isValid: (a == null ? void 0 : a.datasetFormat) === "RasterTileServer" && (a.tileType === "Raster" || a.tileType === "Map"), errorMessage: "imagery tile layer should be created from a tiled image service." };
+}
+function o(r) {
+  const e = r.layerJSON;
+  return Promise.resolve(e && Object.keys(e).length ? e : null);
+}
+async function T(r, e) {
+  const { parsedUrl: a, title: t, fullExtent: l } = r;
+  e.url = a.path, e.title || (e.title = t);
+  try {
+    e.extent = await c(l);
+  } catch {
+    e.extent = void 0;
+  }
+  p(e, i.METADATA), r.type === "imagery-tile" && u(e, i.TILED_IMAGERY);
+}
+async function F(r, e) {
+  const a = r.type === "imagery" ? g : f;
+  return y({ layer: r, itemType: s, validateLayer: m, createItemData: o, errorNamePrefix: a }, e);
+}
+async function L(r, e, a) {
+  const t = r.type === "imagery" ? v : d;
+  return n({ layer: r, itemType: s, validateLayer: m, createItemData: o, errorNamePrefix: t, newItem: e, setItemProperties: T }, a);
+}
+export {
+  F as save,
+  L as saveAs
+};