@geoscene/charts-components 5.0.19

package/dist/cdn/KM2WGERQ.js

@@ -0,0 +1,625 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import a from "./A7YNU2NS.js";
+import {
+  B as C,
+  g as V,
+  h as E,
+  k as j,
+  l as L,
+  t as W,
+  v as $,
+  w as g,
+  y,
+} from "./4B3QBH5T.js";
+import { a as z } from "./NKG4FLLR.js";
+export default $geoscene.t(
+  ([
+    Z,
+    { createClassBreaksRenderer: ee },
+    { getSchemes: te },
+    P,
+    { F: v, Kc: q, Sd: N },
+  ]) => {
+    function K(e) {
+      let s;
+      switch (e.length) {
+        case 4: {
+          let t = e.match(/^#?([\da-f]{1})([\da-f]{1})([\da-f]{1})$/iu);
+          t &&
+            (s = [
+              Number.parseInt(`${t[1]}${t[1]}`, 16),
+              Number.parseInt(`${t[2]}${t[2]}`, 16),
+              Number.parseInt(`${t[3]}${t[3]}`, 16),
+              255,
+            ]);
+          break;
+        }
+        case 5: {
+          let t = e.match(
+            /^#?([\da-f]{1})([\da-f]{1})([\da-f]{1})([\da-f]{1})$/iu
+          );
+          t &&
+            (s = [
+              Number.parseInt(`${t[1]}${t[1]}`, 16),
+              Number.parseInt(`${t[2]}${t[2]}`, 16),
+              Number.parseInt(`${t[3]}${t[3]}`, 16),
+              Number.parseInt(`${t[4]}${t[4]}`, 16),
+            ]);
+          break;
+        }
+        case 7: {
+          let t = e.match(/^#?([\da-f]{2})([\da-f]{2})([\da-f]{2})$/iu);
+          t &&
+            (s = [
+              Number.parseInt(t[1], 16),
+              Number.parseInt(t[2], 16),
+              Number.parseInt(t[3], 16),
+              255,
+            ]);
+          break;
+        }
+        case 9: {
+          let t = e.match(
+            /^#?([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})$/iu
+          );
+          t &&
+            (s = [
+              Number.parseInt(t[1], 16),
+              Number.parseInt(t[2], 16),
+              Number.parseInt(t[3], 16),
+              Number.parseInt(t[4], 16),
+            ]);
+          break;
+        }
+      }
+      return s;
+    }
+    function A(e) {
+      let s;
+      if (typeof e == "string" && e.startsWith("#")) {
+        let t = K(e);
+        t && (s = t);
+      } else
+        Array.isArray(e) &&
+          e.every((t) => typeof t == "number") &&
+          (e.length === 4 ? (s = e) : e.length === 3 && (s = [...e, 255]));
+      return s;
+    }
+    function G(e) {
+      return (
+        e === y.BackwardDiagonal ||
+        e === y.Cross ||
+        e === y.DiagonalCross ||
+        e === y.ForwardDiagonal ||
+        e === y.Horizontal ||
+        e === y.Null ||
+        e === y.Solid ||
+        e === y.Vertical
+      );
+    }
+    function w(e) {
+      return (
+        e === g.Dash ||
+        e === g.DashDot ||
+        e === g.DashDotDot ||
+        e === g.Dot ||
+        e === g.Null ||
+        e === g.Solid
+      );
+    }
+    function Q(e) {
+      let {
+          categoryField: s,
+          numericFields: t,
+          configFields: a,
+          inlineData: i,
+        } = e,
+        o = {};
+      return (
+        a &&
+          Object.keys(a).length > 0 &&
+          "dataItems" in i &&
+          ((o = { type: "uniqueValue", field1: s, uniqueValueInfos: [] }),
+          i.dataItems.forEach((n) => {
+            let l = n[s];
+            if (l != null) {
+              let r = { value: l };
+              t.forEach((c) => {
+                let m = A(n[`${a.fillColor}_${c}`]),
+                  f = n[`${a.fillOpacity}_${c}`],
+                  u = n[`${a.fillStyle}_${c}`],
+                  p = n[`${a.markerSize}_${c}`],
+                  b = A(n[`${a.outlineColor}_${c}`]),
+                  F = n[`${a.outlineOpacity}_${c}`],
+                  k = n[`${a.outlineWidth}_${c}`],
+                  D = n[`${a.outlineStyle}_${c}`],
+                  S = A(n[`${a.lineColor}_${c}`]),
+                  R = n[`${a.lineOpacity}_${c}`],
+                  I = n[`${a.lineWidth}_${c}`],
+                  x = n[`${a.lineStyle}_${c}`],
+                  B = n[`${a.displayLabel}_${c}`];
+                if (
+                  (typeof B == "string" && (r = { ...r, label: B }), p != null)
+                ) {
+                  let d = { type: C.SMS };
+                  p && typeof p == "number" && (d.size = p), (r.symbol = d);
+                }
+                if (m || G(u)) {
+                  let d =
+                    r.symbol && r.symbol.type === C.SMS
+                      ? r.symbol
+                      : { type: C.SFS };
+                  if (
+                    (m &&
+                      (f && typeof f == "number" && (m[3] = f), (d.color = m)),
+                    G(u) && (d.style = u),
+                    (r.symbol = d),
+                    b || k != null || w(D))
+                  ) {
+                    let O = { type: C.SLS };
+                    b &&
+                      (F && typeof F == "number" && (b[3] = F), (O.color = b)),
+                      w(D) && (O.style = D),
+                      k && typeof k == "number" && (O.width = k),
+                      (r.symbol.outline = O);
+                  }
+                } else if (S || I != null || w(x)) {
+                  let d = { type: C.SLS };
+                  S && (R && typeof R == "number" && (S[3] = R), (d.color = S)),
+                    w(x) && (d.style = x),
+                    I != null && typeof I == "number" && (d.width = I),
+                    (r.symbol = d);
+                }
+              }),
+                (r.label || r.symbol) && o.uniqueValueInfos.push(r);
+            }
+          })),
+        o
+      );
+    }
+    function U(e) {
+      let { numericFields: s, configFields: t, inlineData: a } = e,
+        i = a;
+      return (
+        "dataItems" in a &&
+          Object.entries(t).forEach(([o, n]) => {
+            s.forEach((l) => {
+              let r = `${n}_${l}`;
+              a.dataItems.forEach((c) => {
+                r in c && delete c[r];
+              });
+            });
+          }),
+        i
+      );
+    }
+    function X(e) {
+      let {
+          categoryField: s,
+          categoryType: t,
+          numericFields: a,
+          inlineData: i,
+        } = e,
+        o;
+      if ("dataItems" in i) {
+        let { dataItems: n } = i,
+          l = [],
+          r = "OBJECTID",
+          c = n.map((f, u) => {
+            let p = { ...f };
+            return (
+              "FID" in f ? (r = "FID") : "ObjectId" in f && (r = "ObjectId"),
+              p[r] || (p[r] = u),
+              { attributes: p }
+            );
+          });
+        l.push({ type: "esriFieldTypeOID", name: r });
+        let m;
+        switch (t) {
+          case "dateOnly":
+            m = $.DateOnly;
+            break;
+          case "timeStampOffset":
+            m = $.TimestampOffset;
+            break;
+          case "date":
+            m = $.Date;
+            break;
+          case "number":
+            m = $.Double;
+            break;
+          case "string":
+          default:
+            m = $.String;
+            break;
+        }
+        l.push({ type: m, name: s }),
+          a.forEach((f) => {
+            l.push({ type: $.Double, name: f });
+          }),
+          (o = {
+            id: "",
+            layerType: "ArcGISFeatureLayer",
+            featureCollection: {
+              layers: [
+                { layerDefinition: { fields: l }, featureSet: { features: c } },
+              ],
+            },
+          });
+      }
+      return o;
+    }
+    async function H(e) {
+      let {
+          categoryField: s,
+          categoryType: t,
+          numericFields: a,
+          configFields: i,
+          inlineData: o,
+        } = e,
+        n,
+        l,
+        r = V(o);
+      i &&
+        ((n = Q({
+          categoryField: s,
+          numericFields: a,
+          configFields: i,
+          inlineData: r,
+        })),
+        (r = U({ numericFields: a, configFields: i, inlineData: r })));
+      let c = X({
+        categoryField: s,
+        categoryType: t,
+        numericFields: a,
+        inlineData: r,
+      });
+      return c && (l = await q(c)), { chartRenderer: n, iLayer: c, layer: l };
+    }
+    function Y(e, s, t) {
+      let a = Math.max(0, Math.min(1, t));
+      return [
+        Math.round(e[0] + (s[0] - e[0]) * a),
+        Math.round(e[1] + (s[1] - e[1]) * a),
+        Math.round(e[2] + (s[2] - e[2]) * a),
+        Math.round(e[3] + (s[3] - e[3]) * a),
+      ];
+    }
+    function ae(e) {
+      let { colorRamp: s, numberOfClassBreaks: t, isFlipped: a } = e,
+        i = [],
+        o = [],
+        n = !1;
+      if (s.colorsForClassBreaks && s.colorsForClassBreaks.length > 0) {
+        let l = s.colorsForClassBreaks.find((r) => r.numClasses === t);
+        if (l?.colors?.length === t) {
+          let r = l.colors.map((c) => M(c));
+          r.every((c) => c !== void 0) && ((o = a ? r.reverse() : r), (n = !0));
+        }
+      }
+      if (!n) {
+        let l = s.colors || [];
+        if (l.length > 0) {
+          for (let r = 0; r < t; r++) {
+            let c = t > 1 ? r / (t - 1) : 0,
+              m = Math.floor(c * (l.length - 1)),
+              f = Math.min(m + 1, l.length - 1),
+              u = c * (l.length - 1) - m,
+              p = M(l[m]),
+              b = M(l[f]);
+            if (!p || !b) {
+              i = [];
+              break;
+            }
+            let F = Y(p, b, u);
+            i.push(F);
+          }
+          o = i;
+        }
+      }
+      return o;
+    }
+    function T(e) {
+      let {
+          numberOfClassBreaks: s,
+          selectedColorRamp: t,
+          colorRamp: a,
+          isFlipped: i = !1,
+        } = e,
+        o = [],
+        n = [136, 65, 157, 255],
+        l = [237, 248, 251, 255];
+      if (
+        (a && a.length > 0 && a.length === s
+          ? (o = a)
+          : t &&
+            (o = ae({ colorRamp: t, numberOfClassBreaks: s, isFlipped: i })),
+        o.length !== s)
+      ) {
+        (l = o[0] ?? a?.[0] ?? l),
+          (n =
+            o.length > 1 && o[o.length - 1] !== void 0 ? o[o.length - 1] : n);
+        let r = [l];
+        if (s > 1) {
+          for (let c = 1; c < s; c++) {
+            let m = c / (s - 1),
+              f = Y(l, n, m);
+            r.push(f);
+          }
+          r.push(n);
+        }
+        o = r;
+      }
+      return o;
+    }
+    function se(e, s = 2) {
+      return `\u2264 ${((t) => {
+        let a = "";
+        return t % 1 === 0 ? (a = t.toString()) : (a = t.toFixed(s)), a;
+      })(e)}`;
+    }
+    function Fe(e) {
+      let s = "#000000";
+      if (e && Array.isArray(e) && e.length >= 3) {
+        let t = h(e[0] || 0),
+          a = h(e[1] || 0),
+          i = h(e[2] || 0),
+          o = t.toString(16).padStart(2, "0"),
+          n = a.toString(16).padStart(2, "0"),
+          l = i.toString(16).padStart(2, "0");
+        s = `#${o}${n}${l}`;
+      }
+      return s;
+    }
+    var $e = {
+        all: ["*"],
+        light: ["light"],
+        dark: ["dark"],
+        redsAndYellows: ["oranges", "reds", "yellows"],
+        greens: ["greens"],
+        blues: ["blues"],
+        purplesAndPinks: ["purples", "pinks"],
+        browns: ["browns"],
+        grays: ["grays"],
+        bright: ["bright"],
+        subdued: ["subdued"],
+        colorblindFriendly: ["colorblind-friendly"],
+      },
+      ke = { all: "all" },
+      re = (e) => {
+        let s = 0,
+          t = (o) => {
+            let n = 0;
+            return (
+              o.forEach((l) => {
+                let r = l.toString().split(".")[1];
+                r && (n = Math.max(n, r.length));
+              }),
+              n
+            );
+          },
+          a = [...e].sort((o, n) => o - n),
+          i = t(a);
+        for (; s <= i && a.some((o, n) => n > 0 && N(o, s) <= N(a[n - 1], s)); )
+          s++;
+        return Math.min(s, i);
+      };
+    function h(e) {
+      return Math.max(0, Math.min(255, Math.round(e)));
+    }
+    function M(e) {
+      let s;
+      if (e instanceof Z) {
+        let t = e.toRgba();
+        s = [h(t[0]), h(t[1]), h(t[2]), h(t[3] * 255)];
+      } else if (
+        Array.isArray(e) &&
+        e.every((t) => typeof t == "number") &&
+        (e.length === 3 || e.length === 4)
+      ) {
+        let t = e.length >= 4 ? e[3] ?? 255 : 255,
+          a = h(t <= 1 ? t * 255 : t);
+        return [h(e[0] ?? 0), h(e[1] ?? 0), h(e[2] ?? 0), a];
+      }
+      return s;
+    }
+    function oe(e, s) {
+      let t = { exactN: 100, generated: 10, anyOverlap: 1 },
+        a = (l) => l.join(","),
+        i = (l) => E(l.map(M)),
+        o = (l, r) => L([...l], [...r]).length,
+        n;
+      if (e?.length) {
+        let l = i(e.map((u) => u.symbol?.color)),
+          r = new Set(l.map(a)),
+          c = l.length,
+          m = s.map((u) => {
+            let p = new Set(
+                i(T({ numberOfClassBreaks: c, selectedColorRamp: u })).map(a)
+              ),
+              b = o(r, p),
+              F =
+                u.colorsForClassBreaks?.find((B) => B.numClasses === c)
+                  ?.colors ?? [],
+              k = new Set(i(F).map(a)),
+              D = o(r, k),
+              S = [
+                ...(u.colors ?? []),
+                ...j(u.colorsForClassBreaks ?? [], (B) => B.colors ?? []),
+              ],
+              R = new Set(i(S).map(a)),
+              I = o(r, R),
+              x = D * t.exactN + b * t.generated + I * t.anyOverlap;
+            return { ramp: u, score: x };
+          }),
+          f = W(m, [(u) => -u.score, (u) => u.ramp.name]);
+        f[0]?.score > 0 && (n = f[0].ramp);
+      }
+      return n;
+    }
+    function Se(e, s) {
+      let t = !0;
+      if (!e?.length || s.length < 2) t = !1;
+      else {
+        let a = e.map(M),
+          i = s.map((o) => o.symbol.color);
+        if (a.length !== i.length) t = !1;
+        else {
+          let o = (r, c) =>
+              !!r &&
+              !!c &&
+              r.length === c.length &&
+              r.every((m, f) => m === c[f]),
+            n = 0,
+            l = i.length - 1;
+          for (; n < a.length && l >= 0; ) {
+            if (!o(a[n], i[l])) {
+              t = !1;
+              break;
+            }
+            n++, l--;
+          }
+        }
+      }
+      return t;
+    }
+    function Ie(e) {
+      let {
+        numberOfClassBreaks: s,
+        selectedColorRamp: t,
+        existingClassBreakInfos: a,
+        isFlipped: i,
+      } = e;
+      return T({
+        numberOfClassBreaks: s,
+        selectedColorRamp: t,
+        colorRamp: a?.map((o) => o.symbol?.color),
+        isFlipped: i,
+      });
+    }
+    function Be(e) {
+      let { classBreakInfos: s, colors: t } = e,
+        a = [];
+      for (let i = 0; i < s.length; i++) {
+        let o = s[i],
+          n = !!o.symbol,
+          l = t[i] ?? o.symbol?.color,
+          r = n && l ? { ...o, symbol: { ...o.symbol, color: l } } : o;
+        a.push(r);
+      }
+      return a;
+    }
+    async function ne(e) {
+      let {
+          data: s,
+          breaksCount: t,
+          classificationMethod: a,
+          layer: i,
+          xAxisField: o,
+          colorsForClassBreaks: n,
+        } = e,
+        l = [],
+        r = await H({
+          categoryField: o ?? "",
+          categoryType: z.DateAxisFormat,
+          numericFields: [v.valueField],
+          inlineData: s,
+        });
+      if (r.layer && i) {
+        let c = te({
+            geometryType: "point",
+            theme: "high-to-low",
+          })?.primaryScheme,
+          m = await ee({
+            layer: r.layer,
+            field: v.valueField,
+            classificationMethod: a,
+            numClasses: t,
+            colorScheme: c,
+          });
+        if (m?.classBreaksResult?.classBreakInfos?.length) {
+          let f = re(
+            m.classBreaksResult.classBreakInfos.map((u) => u.maxValue)
+          );
+          l = m.classBreaksResult.classBreakInfos.map((u, p) => ({
+            classMinValue: u.minValue,
+            classMaxValue: u.maxValue,
+            label: se(u.maxValue, f),
+            symbol: {
+              type: C.SFS,
+              style: y.Solid,
+              color: n?.[p] || [0, 0, 0, 255],
+              outline: { style: g.Solid, width: 0.5, color: [50, 50, 50, 0.6] },
+            },
+          }));
+        }
+      }
+      return l;
+    }
+    function le(e) {
+      let {
+        selectedColorRamp: s,
+        existingClassBreakInfos: t,
+        availableColorRamps: a,
+      } = e;
+      if (s) return s;
+      let i = a?.length ? a : J.esriColorRamps;
+      return (t?.length ? oe(t, i) : void 0) ?? J.defaultColorRampForCharts;
+    }
+    async function De(e) {
+      let {
+          data: s,
+          breaksCount: t,
+          classificationMethod: a,
+          layer: i,
+          xAxisField: o,
+          selectedColorRamp: n,
+          availableColorRamps: l,
+          existingClassBreakInfos: r,
+          useExistingColors: c,
+          isFlipped: m,
+        } = e,
+        f = le({
+          selectedColorRamp: n,
+          existingClassBreakInfos: r,
+          availableColorRamps: l,
+        }),
+        u = T({
+          numberOfClassBreaks: t,
+          selectedColorRamp: f,
+          colorRamp: c ? r?.map((p) => p.symbol?.color) : void 0,
+          isFlipped: m,
+        });
+      return await ne({
+        data: s,
+        classificationMethod: a,
+        breaksCount: t,
+        layer: i,
+        xAxisField: o,
+        colorsForClassBreaks: u,
+      });
+    }
+    var _ = P.all(),
+      J = {
+        esriColorRamps: _,
+        defaultColorRampForCharts: _.find((e) => e.name === "Blue 3") ?? _[0],
+      };
+    return {
+      a: Fe,
+      b: $e,
+      c: ke,
+      d: oe,
+      e: Se,
+      f: Ie,
+      g: Be,
+      h: le,
+      i: De,
+      j: J,
+    };
+  },
+  "Color",
+  "smartMapping/renderers/color",
+  "smartMapping/symbology/color",
+  "smartMapping/symbology/support/colorRamps",
+  a
+);