@geoscene/charts-components 5.0.19

package/dist/chunks/chart-ui-utils2.js

@@ -0,0 +1,232 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import "@geoscene/toolkit/type";
+import { a as s, j as o } from "./series-types.js";
+import { a as u } from "./rest-js-object-literals.js";
+import { cU as p, de as f, b } from "./index.js";
+import "@geoscene/toolkit/intl";
+import "lodash-es";
+import "luxon";
+import "d3-array";
+import "@geoscene/core/Graphic.js";
+import "@geoscene/core/renderers/support/jsonUtils.js";
+import "@geoscene/core/symbols/support/symbolUtils.js";
+import "@geoscene/core/intl.js";
+import "@geoscene/core/layers/support/FeatureFilter.js";
+import "@geoscene/core/smartMapping/statistics/histogram.js";
+import "@geoscene/core/smartMapping/statistics/summaryStatistics.js";
+import "simple-statistics";
+import "@geoscene/core/request.js";
+import "@geoscene/core/core/sql.js";
+import "@geoscene/core/AttributeBinsGraphic.js";
+import "@geoscene/core/geometry/support/jsonUtils.js";
+import "@geoscene/core/rest/support/AttributeBinsQuery.js";
+import "@geoscene/core/rest/support/StatisticDefinition.js";
+import "@geoscene/core/time/TimeExtent.js";
+import "@geoscene/core/core/promiseUtils.js";
+import "./runtime.js";
+import { i as y } from "./utils.js";
+import { F as m, W as d } from "./interfaces.js";
+import { F as r } from "./common.js";
+const G = {
+    DebounceTimer: 400,
+    SliderTimer: 100,
+    PopoverTimer: 60,
+    customSortLimit: 100,
+  },
+  R = 10,
+  q = {
+    style: "decimal",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 3,
+  },
+  X = [
+    s.Count,
+    s.Sum,
+    s.Average,
+    s.ContinuousPercentile,
+    s.Minimum,
+    s.Maximum,
+    s.NoAggregation,
+  ],
+  $ = [s.Count, s.Sum];
+function J(e) {
+  let t;
+  switch (e) {
+    case r.Title:
+    case r.XAxisTitle:
+    case r.YAxisTitle:
+    case r.LegendTitle: {
+      t = m.Title;
+      break;
+    }
+    case r.Description:
+    case r.LegendText: {
+      t = m.Text;
+      break;
+    }
+    case r.AxisLabels:
+    case r.GuideLabels:
+    case r.DataLabels: {
+      t = m.Label;
+      break;
+    }
+    case r.Background:
+    case r.LeaderLines:
+    case r.AxisLines:
+    case r.GridLines: {
+      t = m.Palette;
+      break;
+    }
+  }
+  return t;
+}
+function Q(e, t, i) {
+  let a = !1;
+  const n = typeof e == "string" ? Number.parseFloat(e) : e,
+    c = typeof t == "string" ? Number.parseFloat(t) : t,
+    l = typeof i == "string" ? Number.parseFloat(i) : i;
+  return (
+    Number.isNaN(n) ||
+      (a =
+        (c === void 0 || Number.isNaN(c) || n >= c) &&
+        (l === void 0 || Number.isNaN(l) || n <= l)),
+    a
+  );
+}
+function Z(e, t) {
+  let i;
+  if (e !== null) {
+    const a = typeof e == "string" ? Number.parseFloat(e) : e;
+    f(a) ? (i = a) : f(t) && (i = t);
+  }
+  return i === void 0 ? "" : `${i}`;
+}
+function _(e) {
+  const { inputElement: t, status: i } = e;
+  t.status = i;
+}
+const ee = {
+  IDLE: "idle",
+  INVALID: "invalid",
+};
+function te(e, t) {
+  let i = "";
+  if (e !== void 0 && !Number.isNaN(e)) {
+    const a = p(document.documentElement);
+    i = Intl.NumberFormat(a, t).format(e);
+  }
+  return i;
+}
+function ie(e, t) {
+  let i = !1;
+  if (t !== void 0) {
+    const a = typeof t == "string" ? t.trim() : t,
+      n = e.trim();
+    typeof t == "string"
+      ? (i = a === n || (a === b && n === ""))
+      : (i = a.includes(n));
+  }
+  return i;
+}
+function ae(e) {
+  let t;
+  switch (e) {
+    case "trailing":
+      t = -200;
+      break;
+    case "leading":
+      t = 20;
+      break;
+    default:
+      t = 0;
+      break;
+  }
+  return t;
+}
+function re(e) {
+  return e === void 0 ||
+    Number.isNaN(e.r) ||
+    Number.isNaN(e.g) ||
+    Number.isNaN(e.b)
+    ? null
+    : e;
+}
+const ne = (e) => {
+    ["e", "E"].includes(e.key) && e.preventDefault();
+  },
+  se = (e) => {
+    if (e.pickListElement !== void 0) {
+      const t = e.pickListElement.selectedItems;
+      e.eventEmitter.emit({
+        contentKind: e.contentKind,
+        value: t.map((i) => i.value),
+      });
+    }
+  };
+function oe(e) {
+  let t = "solid";
+  switch (e) {
+    case u.Dash:
+      t = "dashed";
+      break;
+    case u.Dot:
+      t = "dotted";
+      break;
+    case u.Solid:
+    default:
+      t = "solid";
+      break;
+  }
+  return t;
+}
+function me(e, t) {
+  const i = document.createElement("a");
+  (i.style.display = "none"),
+    (i.download = t),
+    i.setAttribute("href", e),
+    i.click(),
+    i.remove(),
+    URL.revokeObjectURL(e);
+}
+function ce(e) {
+  return e != null && (e.style.removeProperty("opacity"), e.remove()), null;
+}
+function le(e) {
+  const t = !y(e?.config),
+    i = e.xTemporalBinning?.unit,
+    a = e.yTemporalBinning?.unit;
+  let n;
+  return (
+    t &&
+      i !== void 0 &&
+      a !== void 0 &&
+      (i === o.HourOfDay && a === o.DayOfWeek
+        ? (n = d.WeekByDayOfWeekAndHourOfDay)
+        : i === o.DayOfMonth &&
+          a === o.MonthOfYear &&
+          (n = d.YearByMonthAndDayOfMonth)),
+    n
+  );
+}
+export {
+  q as D,
+  ee as U,
+  G as a,
+  X as b,
+  ie as c,
+  ce as d,
+  se as e,
+  re as f,
+  oe as g,
+  ne as h,
+  Q as i,
+  le as j,
+  te as k,
+  ae as l,
+  _ as m,
+  J as n,
+  me as o,
+  $ as p,
+  R as q,
+  Z as s,
+};

package/dist/chunks/class-breaks.js

@@ -0,0 +1,370 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import D from "@geoscene/core/Color.js";
+import { createClassBreaksRenderer as E } from "@geoscene/core/smartMapping/renderers/color.js";
+import { az as R, ah as x } from "./index.js";
+import {
+  compact as A,
+  intersection as N,
+  flatMap as O,
+  sortBy as H,
+} from "lodash-es";
+import "@geoscene/toolkit/type";
+import { W as V } from "./series-types.js";
+import { a as P, c as K, f as $ } from "./rest-js-object-literals.js";
+import { getSchemes as L } from "@geoscene/core/smartMapping/symbology/color.js";
+import { b as W } from "./index3.js";
+import * as j from "@geoscene/core/smartMapping/symbology/support/colorRamps.js";
+function S(e, s, o) {
+  const t = Math.max(0, Math.min(1, o));
+  return [
+    Math.round(e[0] + (s[0] - e[0]) * t),
+    Math.round(e[1] + (s[1] - e[1]) * t),
+    Math.round(e[2] + (s[2] - e[2]) * t),
+    Math.round(e[3] + (s[3] - e[3]) * t),
+  ];
+}
+function z(e) {
+  const { colorRamp: s, numberOfClassBreaks: o, isFlipped: t } = e;
+  let l = [],
+    a = [],
+    c = !1;
+  if (s.colorsForClassBreaks && s.colorsForClassBreaks.length > 0) {
+    const r = s.colorsForClassBreaks.find((n) => n.numClasses === o);
+    if (r?.colors?.length === o) {
+      const n = r.colors.map((m) => g(m));
+      n.every((m) => m !== void 0) && ((a = t ? n.reverse() : n), (c = !0));
+    }
+  }
+  if (!c) {
+    const r = s.colors || [];
+    if (r.length > 0) {
+      for (let n = 0; n < o; n++) {
+        const i = o > 1 ? n / (o - 1) : 0,
+          m = Math.floor(i * (r.length - 1)),
+          d = Math.min(m + 1, r.length - 1),
+          p = i * (r.length - 1) - m,
+          u = g(r[m]),
+          h = g(r[d]);
+        if (!u || !h) {
+          l = [];
+          break;
+        }
+        const C = S(u, h, p);
+        l.push(C);
+      }
+      a = l;
+    }
+  }
+  return a;
+}
+function k(e) {
+  const {
+    numberOfClassBreaks: s,
+    selectedColorRamp: o,
+    colorRamp: t,
+    isFlipped: l = !1,
+  } = e;
+  let a = [],
+    c = [136, 65, 157, 255],
+    r = [237, 248, 251, 255];
+  if (
+    (t && t.length > 0 && t.length === s
+      ? (a = t)
+      : o && (a = z({ colorRamp: o, numberOfClassBreaks: s, isFlipped: l })),
+    a.length !== s)
+  ) {
+    (r = a[0] ?? t?.[0] ?? r),
+      (c = a.length > 1 && a[a.length - 1] !== void 0 ? a[a.length - 1] : c);
+    const n = [r];
+    if (s > 1) {
+      for (let i = 1; i < s; i++) {
+        const m = i / (s - 1),
+          d = S(r, c, m);
+        n.push(d);
+      }
+      n.push(c);
+    }
+    a = n;
+  }
+  return a;
+}
+function q(e, s = 2) {
+  return `≤ ${((t) => {
+    let l = "";
+    return t % 1 === 0 ? (l = t.toString()) : (l = t.toFixed(s)), l;
+  })(e)}`;
+}
+function re(e) {
+  let s = "#000000";
+  if (e && Array.isArray(e) && e.length >= 3) {
+    const o = f(e[0] || 0),
+      t = f(e[1] || 0),
+      l = f(e[2] || 0),
+      a = o.toString(16).padStart(2, "0"),
+      c = t.toString(16).padStart(2, "0"),
+      r = l.toString(16).padStart(2, "0");
+    s = `#${a}${c}${r}`;
+  }
+  return s;
+}
+const le = {
+    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"],
+  },
+  ne = {
+    all: "all",
+  },
+  G = (e) => {
+    let s = 0;
+    const o = (a) => {
+        let c = 0;
+        return (
+          a.forEach((r) => {
+            const n = r.toString().split(".")[1];
+            n && (c = Math.max(c, n.length));
+          }),
+          c
+        );
+      },
+      t = [...e].sort((a, c) => a - c),
+      l = o(t);
+    for (; s <= l && t.some((c, r) => r > 0 && x(c, s) <= x(t[r - 1], s)); )
+      s++;
+    return Math.min(s, l);
+  };
+function f(e) {
+  return Math.max(0, Math.min(255, Math.round(e)));
+}
+function g(e) {
+  let s;
+  if (e instanceof D) {
+    const o = e.toRgba();
+    s = [f(o[0]), f(o[1]), f(o[2]), f(o[3] * 255)];
+  } else if (
+    Array.isArray(e) &&
+    e.every((o) => typeof o == "number") &&
+    (e.length === 3 || e.length === 4)
+  ) {
+    const o = e.length >= 4 ? e[3] ?? 255 : 255,
+      t = f(o <= 1 ? o * 255 : o);
+    return [f(e[0] ?? 0), f(e[1] ?? 0), f(e[2] ?? 0), t];
+  }
+  return s;
+}
+function Y(e, s) {
+  const o = {
+      exactN: 100,
+      generated: 10,
+      anyOverlap: 1,
+    },
+    t = (r) => r.join(","),
+    l = (r) => A(r.map(g)),
+    a = (r, n) => N([...r], [...n]).length;
+  let c;
+  if (e?.length) {
+    const r = l(e.map((p) => p.symbol?.color)),
+      n = new Set(r.map(t)),
+      i = r.length,
+      m = s.map((p) => {
+        const u = new Set(
+            l(k({ numberOfClassBreaks: i, selectedColorRamp: p })).map(t)
+          ),
+          h = a(n, u),
+          C =
+            p.colorsForClassBreaks?.find((y) => y.numClasses === i)?.colors ??
+            [],
+          B = new Set(l(C).map(t)),
+          M = a(n, B),
+          v = [
+            ...(p.colors ?? []),
+            ...O(p.colorsForClassBreaks ?? [], (y) => y.colors ?? []),
+          ],
+          I = new Set(l(v).map(t)),
+          w = a(n, I),
+          T = M * o.exactN + h * o.generated + w * o.anyOverlap;
+        return { ramp: p, score: T };
+      }),
+      d = H(m, [
+        (p) => -p.score,
+        // descending score
+        (p) => p.ramp.name,
+        // ascending name
+      ]);
+    d[0]?.score > 0 && (c = d[0].ramp);
+  }
+  return c;
+}
+function ce(e, s) {
+  let o = !0;
+  if (!e?.length || s.length < 2) o = !1;
+  else {
+    const t = e.map(g),
+      l = s.map((a) => a.symbol.color);
+    if (t.length !== l.length) o = !1;
+    else {
+      const a = (n, i) =>
+        !!n && !!i && n.length === i.length && n.every((m, d) => m === i[d]);
+      let c = 0,
+        r = l.length - 1;
+      for (; c < t.length && r >= 0; ) {
+        if (!a(t[c], l[r])) {
+          o = !1;
+          break;
+        }
+        c++, r--;
+      }
+    }
+  }
+  return o;
+}
+function ie(e) {
+  const {
+    numberOfClassBreaks: s,
+    selectedColorRamp: o,
+    existingClassBreakInfos: t,
+    isFlipped: l,
+  } = e;
+  return k({
+    numberOfClassBreaks: s,
+    selectedColorRamp: o,
+    colorRamp: t?.map((a) => a.symbol?.color),
+    isFlipped: l,
+  });
+}
+function me(e) {
+  const { classBreakInfos: s, colors: o } = e,
+    t = [];
+  for (let l = 0; l < s.length; l++) {
+    const a = s[l],
+      c = !!a.symbol,
+      r = o[l] ?? a.symbol?.color,
+      n =
+        c && r
+          ? {
+              ...a,
+              symbol: {
+                ...a.symbol,
+                color: r,
+              },
+            }
+          : a;
+    t.push(n);
+  }
+  return t;
+}
+async function J(e) {
+  const {
+    data: s,
+    breaksCount: o,
+    classificationMethod: t,
+    layer: l,
+    xAxisField: a,
+    colorsForClassBreaks: c,
+  } = e;
+  let r = [];
+  const n = await W({
+    categoryField: a ?? "",
+    categoryType: V.DateAxisFormat,
+    numericFields: [R.valueField],
+    inlineData: s,
+  });
+  if (n.layer && l) {
+    const m = L({ geometryType: "point", theme: "high-to-low" })?.primaryScheme,
+      d = await E({
+        layer: n.layer,
+        field: R.valueField,
+        classificationMethod: t,
+        numClasses: o,
+        colorScheme: m,
+      });
+    if (d?.classBreaksResult?.classBreakInfos?.length) {
+      const p = G(d.classBreaksResult.classBreakInfos.map((u) => u.maxValue));
+      r = d.classBreaksResult.classBreakInfos.map((u, h) => ({
+        classMinValue: u.minValue,
+        classMaxValue: u.maxValue,
+        label: q(u.maxValue, p),
+        symbol: {
+          type: $.SFS,
+          style: K.Solid,
+          color: c?.[h] || [0, 0, 0, 255],
+          outline: {
+            style: P.Solid,
+            width: 0.5,
+            color: [50, 50, 50, 0.6],
+          },
+        },
+      }));
+    }
+  }
+  return r;
+}
+function Q(e) {
+  const {
+    selectedColorRamp: s,
+    existingClassBreakInfos: o,
+    availableColorRamps: t,
+  } = e;
+  if (s) return s;
+  const l = t?.length ? t : F.esriColorRamps;
+  return (o?.length ? Y(o, l) : void 0) ?? F.defaultColorRampForCharts;
+}
+async function pe(e) {
+  const {
+      data: s,
+      breaksCount: o,
+      classificationMethod: t,
+      layer: l,
+      xAxisField: a,
+      selectedColorRamp: c,
+      availableColorRamps: r,
+      existingClassBreakInfos: n,
+      useExistingColors: i,
+      isFlipped: m,
+    } = e,
+    d = Q({
+      selectedColorRamp: c,
+      existingClassBreakInfos: n,
+      availableColorRamps: r,
+    }),
+    p = k({
+      numberOfClassBreaks: o,
+      selectedColorRamp: d,
+      colorRamp: i ? n?.map((u) => u.symbol?.color) : void 0,
+      isFlipped: m,
+    });
+  return await J({
+    data: s,
+    classificationMethod: t,
+    breaksCount: o,
+    layer: l,
+    xAxisField: a,
+    colorsForClassBreaks: p,
+  });
+}
+const b = j.all(),
+  F = {
+    esriColorRamps: b,
+    defaultColorRampForCharts: b.find((e) => e.name === "Blue 3") ?? b[0],
+  };
+export {
+  ne as C,
+  me as a,
+  pe as b,
+  F as c,
+  re as d,
+  le as e,
+  ie as g,
+  ce as i,
+  Y as p,
+  Q as r,
+};