@geoscene/charts-components 5.0.19

package/dist/chunks/index3.js

@@ -0,0 +1,279 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { cloneDeep as w } from "lodash-es";
+import { bM as V } from "./index.js";
+import { f as D, c as y, a as p, R as $ } from "./rest-js-object-literals.js";
+function L(i) {
+  let r;
+  switch (i.length) {
+    case 4: {
+      const e = i.match(/^#?([\da-f]{1})([\da-f]{1})([\da-f]{1})$/iu);
+      e &&
+        (r = [
+          Number.parseInt(`${e[1]}${e[1]}`, 16),
+          Number.parseInt(`${e[2]}${e[2]}`, 16),
+          Number.parseInt(`${e[3]}${e[3]}`, 16),
+          255,
+        ]);
+      break;
+    }
+    case 5: {
+      const e = i.match(
+        /^#?([\da-f]{1})([\da-f]{1})([\da-f]{1})([\da-f]{1})$/iu
+      );
+      e &&
+        (r = [
+          Number.parseInt(`${e[1]}${e[1]}`, 16),
+          Number.parseInt(`${e[2]}${e[2]}`, 16),
+          Number.parseInt(`${e[3]}${e[3]}`, 16),
+          Number.parseInt(`${e[4]}${e[4]}`, 16),
+        ]);
+      break;
+    }
+    case 7: {
+      const e = i.match(/^#?([\da-f]{2})([\da-f]{2})([\da-f]{2})$/iu);
+      e &&
+        (r = [
+          Number.parseInt(e[1], 16),
+          Number.parseInt(e[2], 16),
+          Number.parseInt(e[3], 16),
+          255,
+        ]);
+      break;
+    }
+    case 9: {
+      const e = i.match(
+        /^#?([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})$/iu
+      );
+      e &&
+        (r = [
+          Number.parseInt(e[1], 16),
+          Number.parseInt(e[2], 16),
+          Number.parseInt(e[3], 16),
+          Number.parseInt(e[4], 16),
+        ]);
+      break;
+    }
+  }
+  return r;
+}
+function N(i) {
+  let r;
+  if (typeof i == "string" && i.startsWith("#")) {
+    const e = L(i);
+    e && (r = e);
+  } else
+    Array.isArray(i) &&
+      i.every((e) => typeof e == "number") &&
+      (i.length === 4 ? (r = i) : i.length === 3 && (r = [...i, 255]));
+  return r;
+}
+function R(i) {
+  return (
+    i === y.BackwardDiagonal ||
+    i === y.Cross ||
+    i === y.DiagonalCross ||
+    i === y.ForwardDiagonal ||
+    i === y.Horizontal ||
+    i === y.Null ||
+    i === y.Solid ||
+    i === y.Vertical
+  );
+}
+function I(i) {
+  return (
+    i === p.Dash ||
+    i === p.DashDot ||
+    i === p.DashDotDot ||
+    i === p.Dot ||
+    i === p.Null ||
+    i === p.Solid
+  );
+}
+function W(i) {
+  const {
+    categoryField: r,
+    numericFields: e,
+    configFields: n,
+    inlineData: s,
+  } = i;
+  let u = {};
+  return (
+    n &&
+      Object.keys(n).length > 0 &&
+      "dataItems" in s &&
+      ((u = {
+        type: "uniqueValue",
+        field1: r,
+        uniqueValueInfos: [],
+      }),
+      s.dataItems.forEach((l) => {
+        const a = l[r];
+        if (a != null) {
+          let t = { value: a };
+          e.forEach((o) => {
+            const c = N(l[`${n.fillColor}_${o}`]),
+              b = l[`${n.fillOpacity}_${o}`],
+              S = l[`${n.fillStyle}_${o}`],
+              m = l[`${n.markerSize}_${o}`],
+              F = N(l[`${n.outlineColor}_${o}`]),
+              O = l[`${n.outlineOpacity}_${o}`],
+              h = l[`${n.outlineWidth}_${o}`],
+              k = l[`${n.outlineStyle}_${o}`],
+              g = N(l[`${n.lineColor}_${o}`]),
+              v = l[`${n.lineOpacity}_${o}`],
+              d = l[`${n.lineWidth}_${o}`],
+              _ = l[`${n.lineStyle}_${o}`],
+              C = l[`${n.displayLabel}_${o}`];
+            if (
+              (typeof C == "string" &&
+                (t = {
+                  ...t,
+                  label: C,
+                }),
+              m != null)
+            ) {
+              const f = { type: D.SMS };
+              m && typeof m == "number" && (f.size = m), (t.symbol = f);
+            }
+            if (c || R(S)) {
+              const f =
+                t.symbol && t.symbol.type === D.SMS
+                  ? t.symbol
+                  : {
+                      type: D.SFS,
+                    };
+              if (
+                (c && (b && typeof b == "number" && (c[3] = b), (f.color = c)),
+                R(S) && (f.style = S),
+                (t.symbol = f),
+                F || h != null || I(k))
+              ) {
+                const T = { type: D.SLS };
+                F && (O && typeof O == "number" && (F[3] = O), (T.color = F)),
+                  I(k) && (T.style = k),
+                  h && typeof h == "number" && (T.width = h),
+                  (t.symbol.outline = T);
+              }
+            } else if (g || d != null || I(_)) {
+              const f = { type: D.SLS };
+              g && (v && typeof v == "number" && (g[3] = v), (f.color = g)),
+                I(_) && (f.style = _),
+                d != null && typeof d == "number" && (f.width = d),
+                (t.symbol = f);
+            }
+          }),
+            (t.label || t.symbol) && u.uniqueValueInfos.push(t);
+        }
+      })),
+    u
+  );
+}
+function E(i) {
+  const { numericFields: r, configFields: e, inlineData: n } = i,
+    s = n;
+  return (
+    "dataItems" in n &&
+      Object.entries(e).forEach(([u, l]) => {
+        r.forEach((a) => {
+          const t = `${l}_${a}`;
+          n.dataItems.forEach((o) => {
+            t in o && delete o[t];
+          });
+        });
+      }),
+    s
+  );
+}
+function j(i) {
+  const {
+    categoryField: r,
+    categoryType: e,
+    numericFields: n,
+    inlineData: s,
+  } = i;
+  let u;
+  if ("dataItems" in s) {
+    const { dataItems: l } = s,
+      a = [];
+    let t = "OBJECTID";
+    const o = l.map((b, S) => {
+      const m = { ...b };
+      return (
+        "FID" in b ? (t = "FID") : "ObjectId" in b && (t = "ObjectId"),
+        m[t] || (m[t] = S),
+        { attributes: m }
+      );
+    });
+    a.push({ type: "esriFieldTypeOID", name: t });
+    let c;
+    switch (e) {
+      case "dateOnly":
+        c = $.DateOnly;
+        break;
+      case "timeStampOffset":
+        c = $.TimestampOffset;
+        break;
+      case "date":
+        c = $.Date;
+        break;
+      case "number":
+        c = $.Double;
+        break;
+      case "string":
+      default:
+        c = $.String;
+        break;
+    }
+    a.push({ type: c, name: r }),
+      n.forEach((b) => {
+        a.push({ type: $.Double, name: b });
+      }),
+      (u = {
+        id: "",
+        layerType: "ArcGISFeatureLayer",
+        featureCollection: {
+          layers: [
+            { layerDefinition: { fields: a }, featureSet: { features: o } },
+          ],
+        },
+      });
+  }
+  return u;
+}
+async function A(i) {
+  const {
+    categoryField: r,
+    categoryType: e,
+    numericFields: n,
+    configFields: s,
+    inlineData: u,
+  } = i;
+  let l,
+    a,
+    t = w(u);
+  s &&
+    ((l = W({
+      categoryField: r,
+      numericFields: n,
+      configFields: s,
+      inlineData: t,
+    })),
+    (t = E({
+      numericFields: n,
+      configFields: s,
+      inlineData: t,
+    })));
+  const o = j({
+    categoryField: r,
+    categoryType: e,
+    numericFields: n,
+    inlineData: t,
+  });
+  return o && (a = await V(o)), { chartRenderer: l, iLayer: o, layer: a };
+}
+const B = {
+  hexToRGB: L,
+  convertColor: N,
+  removeConfigFieldsFromData: E,
+};
+export { j as a, A as b, W as c, B as i };

package/dist/chunks/index4.js

@@ -0,0 +1,98 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { W as r, w as s } from "./series-types.js";
+import { f as n } from "./rest-js-object-literals.js";
+function S(e) {
+  const t = [
+      r.BarSeries,
+      r.LineSeries,
+      r.ComboLineAndBarSeries,
+      r.BoxPlotSeries,
+    ],
+    i = s(e?.series);
+  return i !== void 0 ? t.includes(i) : !1;
+}
+function c(e) {
+  const t = [r.BarSeries, r.LineSeries, r.ComboLineAndBarSeries, r.RadarSeries],
+    i = s(e?.series);
+  return i !== void 0 ? t.includes(i) : !1;
+}
+function p(e) {
+  return e?.type === n.SFS;
+}
+function y(e) {
+  return e?.type === n.SLS;
+}
+function d(e) {
+  return e?.type === n.SMS;
+}
+function h(e) {
+  return e?.type === n.TS;
+}
+function f(e) {
+  return e && "iLayer" in e && e.iLayer;
+}
+function T(e, t) {
+  return e !== void 0 && t !== void 0 && e.series[0]?.type === t;
+}
+function a(e) {
+  return e?.type === r.BoxPlotSeries;
+}
+function m(e) {
+  return e?.type === r.LineSeries;
+}
+function C(e) {
+  return e?.type === r.RadarSeries;
+}
+function b(e) {
+  return e?.type === r.BarSeries;
+}
+function l(e) {
+  return e?.type === r.HeatSeries;
+}
+const L = (e) => s(e) === r.BarSeries,
+  B = (e) => s(e) === r.LineSeries,
+  v = (e) => s(e) === r.RadarSeries,
+  A = (e) => s(e) === r.HeatSeries;
+function x(e) {
+  return e.every(a);
+}
+function I(e) {
+  return e !== void 0 && e.type === r.NumberAxisFormat;
+}
+function R(e) {
+  return e === void 0 || "bins" in e;
+}
+function W(e) {
+  return e === void 0 || "dataItems" in e;
+}
+function H(e) {
+  return e === void 0 || ("dataItems" in e && "r2" in e);
+}
+function O(e) {
+  return "value" in e;
+}
+export {
+  c as a,
+  p as b,
+  y as c,
+  d,
+  h as e,
+  T as f,
+  a as g,
+  f as h,
+  S as i,
+  m as j,
+  C as k,
+  b as l,
+  l as m,
+  L as n,
+  B as o,
+  v as p,
+  A as q,
+  x as r,
+  I as s,
+  R as t,
+  W as u,
+  H as v,
+  O as w,
+};

package/dist/chunks/index5.js

@@ -0,0 +1,76 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+const a = {
+    DataProcessComplete: "geosceneDataProcessComplete",
+    DataFetchComplete: "geosceneDataFetchComplete",
+    DataProcessError: "geosceneDataProcessError",
+    LegendItemVisibilityChange: "geosceneLegendItemVisibilityChange",
+    UpdateComplete: "geosceneUpdateComplete",
+    SeriesColorChange: "geosceneSeriesColorChange",
+    AxesMinMaxChange: "geosceneAxesMinMaxChange",
+    DefaultActionSelect: "geosceneDefaultActionSelect",
+    SelectionComplete: "geosceneSelectionComplete",
+    ActionBarToggle: "geosceneActionBarToggle",
+    NoRenderPropChange: "geosceneNoRenderPropChange",
+    BadDataWarningRaise: "geosceneBadDataWarningRaise",
+    InvalidConfigRaise: "geosceneInvalidConfigWarningRaise",
+    SeriesOrder: "geosceneSeriesOrder",
+    RuntimeError: "geosceneRuntimeError",
+    ConfigChange: "geosceneConfigChange",
+    RenderingComplete: "geosceneRenderingComplete",
+  },
+  t = {
+    FilterBySelection: "filterBySelection",
+    FilterByExtent: "filterByExtent",
+    Legend: "legend",
+    RotateChart: "rotateChart",
+    Selection: "selection",
+    ClearSelection: "clearSelection",
+    SwitchSelection: "switchSelection",
+    Zoom: "zoom",
+    FullExtent: "fullExtent",
+    EditChart: "editChart",
+    ExportAsImage: "exportAsImage",
+    ExportAsCSV: "exportAsCSV",
+  },
+  i = {
+    Active: "active",
+    Inactive: "inactive",
+  },
+  n = {
+    Enabled: "enabled",
+    Disabled: "disabled",
+  },
+  r = {
+    Ignore: "ignore",
+    Throw: "throw",
+  },
+  e = {
+    Ignore: "ignore",
+    Refresh: "refresh",
+  },
+  o = e,
+  s = e,
+  c = e,
+  l = e,
+  g = {
+    /**
+     * Enable syncing selections between chart and layer view
+     */
+    Enabled: "enabled",
+    /**
+     * Disable syncing selections between chart and layer view
+     */
+    Disabled: "disabled",
+  };
+export {
+  i as A,
+  a as C,
+  t as D,
+  r as E,
+  o as L,
+  g as S,
+  l as V,
+  n as a,
+  s as b,
+  c,
+};

package/dist/chunks/interfaces.js

@@ -0,0 +1,123 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import "@geoscene/toolkit/type";
+import { a as e } from "./series-types.js";
+const i = {
+    actionBar: "action-bar",
+    customActionTop: "custom-action-top",
+    customActionBelow: "custom-action-below",
+  },
+  n = {
+    Mean: "mean",
+    Median: "median",
+    StandardDev: "standardDev",
+    NormalDist: "normalDist",
+  },
+  o = {
+    Mean: "mean",
+    Median: "median",
+    StandardDev: "standardDev",
+    Count: e.Count,
+    CountExcludingNulls: "countExcludingNulls",
+    Min: e.Minimum,
+    Max: e.Maximum,
+    Sum: e.Sum,
+    Nulls: "nulls",
+  },
+  r = {
+    Data: "data",
+    Series: "series",
+    Slices: "slices",
+    Axes: "axes",
+    Guides: "guides",
+    Format: "format",
+    General: "general",
+  },
+  s = {
+    Title: "title",
+    Text: "text",
+    Label: "label",
+    Palette: "palette",
+  },
+  l = {
+    xAxisField: "xAxisField",
+    aggregation: "aggregation",
+    numericFields: "numericField",
+    splitByField: "splitByField",
+    interval: "interval",
+    intervalAlignment: "intervalAlignment",
+  },
+  d = {
+    category: "category",
+    aggregation: "aggregation",
+    numericFields: "numericField",
+    splitByField: "splitByField",
+    sortOrder: "sortOrder",
+    interval: "interval",
+    intervalAlignment: "intervalAlignment",
+  },
+  c = {
+    category: "category",
+    aggregation: "aggregation",
+    numericFields: "numericFields",
+    sortOrder: "sortOrder",
+  },
+  m = {
+    numericFields: "numericField",
+    transformation: "transformation",
+    fillSymbol: "fillSymbol",
+    lineSymbol: "lineSymbol",
+  },
+  g = {
+    xAxisField: "xAxis",
+    yAxisField: "yAxis",
+    sizeVariable: "sizeVariable",
+    symbol: "symbol",
+    trendLine: "trendLine",
+    additionalTooltipFields: "additionalTooltipFields",
+    none: "none",
+  },
+  y = {
+    category: "category",
+    numericFields: "numericField",
+    splitByField: "splitByField",
+    sortOrder: "sortOrder",
+  },
+  u = {
+    xAxisField: "xAxisField",
+    aggregation: "aggregation",
+    numericFields: "numericField",
+    calendarType: "calendarType",
+    calendarViewType: "calendarViewType",
+    classBreakMethod: "classBreakMethod",
+    colorScheme: "colorScheme",
+    null: "null",
+  },
+  p = {
+    WeekByDayOfWeekAndHourOfDay: "weekByDayOfWeekAndHourOfDay",
+    YearByMonthAndDayOfMonth: "yearByMonthAndDayOfMonth",
+  },
+  F = {
+    Fixed: "fixed",
+    Proportional: "proportional",
+  },
+  x = {
+    Up: "up",
+    Down: "down",
+  };
+export {
+  d as B,
+  r as C,
+  s as F,
+  m as H,
+  l as L,
+  c as P,
+  g as S,
+  p as W,
+  y as a,
+  o as b,
+  x as c,
+  u as d,
+  n as e,
+  F as f,
+  i as g,
+};

package/dist/chunks/line-chart-model.js

@@ -0,0 +1,134 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import {
+  s as m,
+  a as S,
+  b as d,
+  c,
+  d as y,
+  W as g,
+} from "./negative-values-stacked-to-baseline.js";
+import { S as u, s as p, a as b } from "./serial-chart-model.js";
+import { g as n } from "./serial-chart-data.js";
+import { a as I } from "./utils.js";
+import { m as v } from "./model-setter.js";
+import { W as _ } from "./series-types.js";
+import { bm as C, ba as f, bR as a, aJ as L, ar as M } from "./index.js";
+import { M as k } from "./model-with-line-marker-styling.js";
+var D = Object.defineProperty,
+  F = Object.getOwnPropertyDescriptor,
+  x = (o, e, s, t) => {
+    for (var i = F(e, s), r = o.length - 1, l; r >= 0; r--)
+      (l = o[r]) && (i = l(e, s, i) || i);
+    return i && D(e, s, i), i;
+  };
+class h extends u {
+  constructor() {
+    super(...arguments), (this._chartType = _.LineSeries);
+  }
+  async setup(e) {
+    await this.loadConfigFromLayer(e),
+      this.setupLocalProps(),
+      e.config !== void 0 && (await this.updateSeriesFromLayerFilter()),
+      this.initDefaultSeries(),
+      typeof this.resolveSetup == "function" && this.resolveSetup();
+  }
+  // #end region
+  // ---------------------------------------------------------------------------------------------
+  // #region Protected methods
+  // ---------------------------------------------------------------------------------------------
+  /** @private */
+  generateDefaultConfig() {
+    const e = C(this.commonStrings);
+    return (
+      (e.series = [
+        f({
+          commonStrings: this.commonStrings,
+          objectIDField: a(this.layerInfo.layer).idField,
+        }),
+      ]),
+      e
+    );
+  }
+  /**
+   * Initializes the default series for the line chart. Used in resetting the series styling.
+   * @private
+   */
+  initDefaultSeries() {
+    this.defaultSeries = f({
+      commonStrings: this.commonStrings,
+      objectIDField: a(this.layerInfo.layer).idField,
+    });
+  }
+  resetSeriesStyling() {
+    for (let e = 0; e < this.seriesLength; e += 1) {
+      const s = L({
+        colorIndex: e,
+        opacity: M,
+      });
+      if (
+        (p(s, e, this._config),
+        m(s, e, this._config),
+        this.layerInfo !== void 0)
+      ) {
+        const t = this.getSeriesId(e),
+          i = n({
+            config: this._config,
+            seriesIndex: e,
+            layerInfo: this.layerInfo,
+            commonStrings: this.commonStrings,
+          });
+        i !== a(this.layerInfo.layer).idField && b(i ?? t, e, this._config);
+      }
+      S(this.defaultSeries?.lineSymbol?.style, e, this._config),
+        d(this.defaultSeries?.lineSymbol?.width, e, this._config),
+        c(this.defaultSeries?.markerSymbol?.style, e, this._config),
+        y(this.defaultSeries?.markerSymbol?.size, e, this._config);
+    }
+    this._config.colorMatch = !0;
+  }
+  /**
+   * Returns whether the series styling is able to be reset.
+   */
+  resetAvailable() {
+    const e = !this.colorMatch;
+    let s = !1;
+    if (!e)
+      for (let t = 0; t < this.seriesLength; t += 1) {
+        if (this.layerInfo !== void 0) {
+          const i = n({
+              config: this._config,
+              seriesIndex: t,
+              layerInfo: this.layerInfo,
+              commonStrings: this.commonStrings,
+            }),
+            r = this.getSeriesName(t);
+          i !== void 0 &&
+            i !== this.layerInfo.objectIdField &&
+            i !== r &&
+            (s = !0);
+        }
+        if (
+          (this.defaultSeries?.lineSymbol?.style !== void 0 &&
+            this.defaultSeries?.lineSymbol.style !==
+              this.getSeriesLineStyle(t)) ||
+          (this.defaultSeries?.lineSymbol?.width !== void 0 &&
+            this.defaultSeries?.lineSymbol.width !==
+              this.getSeriesLineWidth(t)) ||
+          (this.defaultSeries?.markerSymbol?.style !== void 0 &&
+            this.defaultSeries?.markerSymbol?.style !==
+              this.getSeriesMarkerStyle(t)) ||
+          (this.defaultSeries?.markerSymbol?.size !== void 0 &&
+            this.defaultSeries?.markerSymbol?.size !==
+              this.getSeriesMarkerSize(t))
+        ) {
+          s = !0;
+          break;
+        }
+      }
+    return e || s;
+  }
+}
+x([v], h.prototype, "resetSeriesStyling");
+const w = [g, k];
+I(h, w);
+export { h as LineChartModel };