@geoscene/charts-components 5.0.19

package/dist/chunks/model-setter.js

@@ -0,0 +1,162 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import {
+  fetchT9nStringsBundle as p,
+  getElementLocale as d,
+} from "@geoscene/toolkit/intl";
+import { g as h } from "./runtime.js";
+import { bM as r, bO as c, bR as g, aX as f } from "./index.js";
+import { c as l } from "./index2.js";
+import "lodash-es";
+import "luxon";
+import "d3-array";
+import "@geoscene/toolkit/type";
+import "./series-types.js";
+import "@geoscene/core/core/promiseUtils.js";
+import "@geoscene/core/request.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/geoscene-html-sanitizer";
+import "@geoscene/toolkit/dom";
+import "@geoscene/core/intl.js";
+import "@geoscene/core/Graphic.js";
+import "@geoscene/core/renderers/support/jsonUtils.js";
+import "@geoscene/core/symbols/support/symbolUtils.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/core/sql.js";
+import "@geoscene/core/AttributeBinsGraphic.js";
+class G extends EventTarget {
+  /**
+   * @param args
+   * @privateRemarks This "any" constructor is needed for TypeScript to merge
+   * the base class and mixin classes types together smoothly.
+   */
+  constructor(...i) {
+    super(),
+      (this.dirtyAsyncSetters = []),
+      (this.asyncConfigUpdateInProgress = !1),
+      (this.pendingUpdates = 0),
+      (this.dataStore = {}),
+      (this.asyncUpdatesPromise = new Promise((t) => {
+        this.resolveSetup = t;
+      })),
+      (this.emitConfigUpdate = (t) => {
+        this.dispatchEvent(
+          new CustomEvent("geosceneChartsModelConfigChange", {
+            detail: { config: this._config, setterName: t },
+          })
+        );
+      }),
+      (this.guardSetterFromAsyncOverwrite = async (t) => {
+        t(),
+          this.asyncConfigUpdateInProgress &&
+            (await this.asyncUpdatesPromise, t());
+      });
+  }
+  /**
+   * The chart type.
+   */
+  get chartType() {
+    return this._chartType;
+  }
+  /**
+   * Checks if the current chart model is for the same chart as another chart model.
+   *
+   * @param otherModel - The other chart model to compare to.
+   */
+  isSameChartAs(i) {
+    const t = i?.layer;
+    return (
+      t !== void 0 &&
+      this._config.id === i?.chartId &&
+      this.layerInfo?.layer.id === t.id
+    );
+  }
+  /**
+   * Can be awaited to allow any pending async updates to complete.
+   * @public
+   */
+  async update() {
+    await this.asyncUpdatesPromise;
+  }
+  /**
+   * A function that loads the config based on the provided props.
+   *
+   * @param params.layer - The layer to be used as the data source for the chart.
+   * @param params.iLayer - The layer description to use if the layer is not provided.
+   * @param params.config - The config object to be loaded.
+   * @private
+   */
+  async loadConfigFromLayer(i) {
+    const { layer: t, iLayer: s, config: a } = i;
+    this.commonStrings = await p(
+      d(document.documentElement).t9nLocale,
+      h("./assets/common/t9n"),
+      "messages."
+    );
+    let e = t;
+    if (
+      (!e && s ? (e = await r(s)) : !e && a?.iLayer && (e = await r(a.iLayer)),
+      e)
+    ) {
+      const o = await c(e, !0),
+        m = g(e).idField;
+      this.layerInfo = {
+        layer: e,
+        layerFieldsInfo: o,
+        objectIdField: m,
+      };
+    }
+    (this._config = a ? await l(a) : this.generateDefaultConfig()),
+      this._config.legend !== void 0 &&
+        this._config.legend?.title === void 0 &&
+        (this._config.legend.title = f().title),
+      s && (this._config.iLayer = s);
+  }
+  /**
+   * Manually block the async guard to queue up config updates until unblocked.
+   * @private
+   */
+  startAsyncUpdate() {
+    this.pendingUpdates === 0 &&
+      ((this.asyncConfigUpdateInProgress = !0),
+      (this.asyncUpdatesPromise = new Promise((i) => {
+        this.resolveSetup = i;
+      }))),
+      (this.pendingUpdates += 1);
+  }
+  /**
+   * Manually unblock the async guard to allow queued config updates to proceed.
+   * @private
+   */
+  finishAsyncUpdate() {
+    (this.pendingUpdates -= 1),
+      this.pendingUpdates === 0 &&
+        ((this.asyncConfigUpdateInProgress = !1), this.resolveSetup?.());
+  }
+  // #endregion
+}
+function H(n, i, t) {
+  const s = t.set,
+    a = t.value;
+  return (
+    s &&
+      (t.set = function (e) {
+        this.guardSetterFromAsyncOverwrite(() => {
+          s.call(this, e), this.emitConfigUpdate(i);
+        });
+      }),
+    a &&
+      (t.value = function (...e) {
+        this.guardSetterFromAsyncOverwrite(() => {
+          a.apply(this, e), this.emitConfigUpdate(i);
+        });
+      }),
+    t
+  );
+}
+export { G as C, H as m };

package/dist/chunks/model-with-guides.js

@@ -0,0 +1,330 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { C as f, m as a } from "./model-setter.js";
+import { k as b, s as m, a as _ } from "./utils.js";
+import { e as h, f as S } from "./utils2.js";
+import { C as L } from "./chart-model.js";
+import { cloneDeep as T } from "lodash-es";
+import "@geoscene/toolkit/type";
+import { W as x } from "./series-types.js";
+import { f as c } from "./rest-js-object-literals.js";
+import "@geoscene/toolkit/intl";
+import "luxon";
+import "d3-array";
+import { aO as C, aN as X, bI as p, aQ as B, i as A } from "./index.js";
+import "@geoscene/geoscene-html-sanitizer";
+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 "@geoscene/core/request.js";
+import "./runtime.js";
+import { c as M, b as O } from "./index4.js";
+import "@geoscene/toolkit/dom";
+import "@geoscene/core/intl.js";
+import { G as g } from "./common.js";
+var P = Object.defineProperty,
+  D = Object.getOwnPropertyDescriptor,
+  V = (t, e, i, s) => {
+    for (var o = D(e, i), n = t.length - 1, d; n >= 0; n--)
+      (d = t[n]) && (o = d(e, i, o) || o);
+    return o && P(e, i, o), o;
+  };
+const R = (t) => b({ config: t, axisIndex: 0, isMax: !0 }),
+  E = (t, e) => {
+    m({ config: t, value: e, axisIndex: 0, isMax: !0 });
+  };
+class y extends f {
+  /**
+   * Maximum bound set for the x-axis.
+   *
+   * `null` indicates no explicit maximum.
+   */
+  get maxXBound() {
+    return R(this._config);
+  }
+  set maxXBound(e) {
+    E(this._config, e);
+  }
+}
+V([a], y.prototype, "maxXBound");
+var W = Object.defineProperty,
+  w = Object.getOwnPropertyDescriptor,
+  F = (t, e, i, s) => {
+    for (var o = w(e, i), n = t.length - 1, d; n >= 0; n--)
+      (d = t[n]) && (o = d(e, i, o) || o);
+    return o && W(e, i, o), o;
+  };
+const j = (t) => b({ config: t, axisIndex: 0, isMax: !1 }),
+  N = (t, e) => {
+    m({ config: t, value: e, axisIndex: 0, isMax: !1 });
+  };
+class v extends f {
+  /**
+   * Minimum bound set for the x-axis.
+   *
+   * `null` indicates no explicit minimum.
+   */
+  get minXBound() {
+    return j(this._config);
+  }
+  set minXBound(e) {
+    N(this._config, e);
+  }
+}
+F([a], v.prototype, "minXBound");
+class $ extends f {}
+_($, [y, v]);
+class De extends f {
+  /**
+   * Whether the x-axis labels are visible.
+   */
+  get xAxisLabelsVisibility() {
+    return h(0, this._config);
+  }
+  set xAxisLabelsVisibility(e) {
+    this.guardSetterFromAsyncOverwrite(() => {
+      S(e, 0, this._config), this.emitConfigUpdate("xAxisLabelsVisibility");
+    });
+  }
+}
+const I = (t) => {
+    for (const e of t.axes ?? [])
+      for (const i of e?.guides ?? []) if (i.label !== void 0) return i.label;
+  },
+  Q = (t, e) => {
+    for (const i of e.axes ?? [])
+      for (const s of i?.guides ?? []) {
+        const o = s.label?.text ?? "";
+        (s.label = T(t)), s.label !== void 0 && (s.label.text = o);
+      }
+  };
+function r(t) {
+  return {
+    ...t,
+    axis: t.orientation === g.X ? t.config.axes?.[0] : t.config.axes?.[1],
+    index: t.index ?? 0,
+    orientation: t.orientation ?? g.Y,
+  };
+}
+const U = (t) => {
+    const { axis: e, index: i } = r(t);
+    return e?.guides?.[i]?.visible ?? !0;
+  },
+  Y = (t) => {
+    const { visible: e, axis: i, index: s } = r(t);
+    i?.guides?.[s] !== void 0 && (i.guides[s].visible = e);
+  },
+  G = (t) => {
+    const e = A(t.start, t.end);
+    M(t.style) && e === c.SFS
+      ? (t.style = { type: c.SFS, color: t.style.color })
+      : O(t.style) &&
+        e === c.SLS &&
+        (t.style = { type: c.SLS, color: t.style.color });
+  },
+  q = (t) => {
+    const { axis: e, index: i } = r(t);
+    return e?.guides?.[i]?.start ?? null;
+  },
+  z = (t) => {
+    const { start: e, axis: i, index: s } = r(t);
+    i?.guides?.[s] !== void 0 && ((i.guides[s].start = e), G(i.guides[s]));
+  },
+  H = (t) => {
+    const { axis: e, index: i } = r(t);
+    return e?.guides?.[i]?.end;
+  },
+  J = (t) => {
+    const { end: e, axis: i, index: s } = r(t);
+    i?.guides?.[s] !== void 0 && ((i.guides[s].end = e), G(i.guides[s]));
+  },
+  K = (t) => {
+    const { axis: e, index: i } = r(t);
+    return e?.guides?.[i]?.name;
+  },
+  Z = (t) => {
+    const { name: e, axis: i, index: s } = r(t);
+    i?.guides?.[s] !== void 0 && (i.guides[s].name = e);
+  },
+  k = (t) => {
+    const { axis: e, index: i } = r(t);
+    return e?.guides?.[i]?.label?.text;
+  },
+  ee = (t) => {
+    const { labelText: e, axis: i, index: s } = r(t),
+      o = i?.guides?.[s]?.label ?? C(e, X(p.GuideLabel), p.GuideLabel);
+    i?.guides?.[s] !== void 0 && (i.guides[s].label = { ...o, text: e });
+  },
+  ie = (t) => {
+    const { axis: e, index: i } = r(t);
+    return e?.guides?.[i]?.above ?? !1;
+  },
+  te = (t) => {
+    const { above: e, axis: i, index: s } = r(t);
+    i?.guides?.[s] !== void 0 && (i.guides[s].above = e);
+  },
+  se = (t) => {
+    const { axis: e, index: i } = r(t);
+    return e?.guides?.[i]?.style;
+  },
+  oe = (t) => {
+    const { style: e, axis: i, index: s } = r(t);
+    i?.guides?.[s] !== void 0 && (i.guides[s].style = e);
+  },
+  Ve = (t) => {
+    const { config: e, name: i, index: s, orientation: o } = t,
+      n = o === g.X ? e.axes?.[0] : e.axes?.[1];
+    if (n !== void 0) {
+      n.guides = n.guides ?? [];
+      const d = {
+        type: x.Guide,
+        name: i,
+        start: n.valueFormat.type === x.DateAxisFormat ? "" : 0,
+        style: B(),
+      };
+      s !== void 0 && s < n.guides.length
+        ? n.guides.splice(s, 0, d)
+        : n.guides.push(d);
+    }
+  },
+  Re = (t) => {
+    const { config: e, index: i, orientation: s } = t,
+      o = s === g.X ? e.axes?.[0] : e.axes?.[1];
+    o?.guides !== void 0 &&
+      (i !== void 0 && i < o.guides.length
+        ? o.guides.splice(i, 1)
+        : o.guides.pop());
+  },
+  ne = (t) => {
+    const { axis: e, index: i } = r(t);
+    return e?.guides?.[i]?.tooltipReverseColor ?? !1;
+  },
+  re = (t) => {
+    const { reverseColor: e, axis: i, index: s } = r(t);
+    i?.guides?.[s] !== void 0 && (i.guides[s].tooltipReverseColor = e);
+  };
+var de = Object.defineProperty,
+  ae = Object.getOwnPropertyDescriptor,
+  u = (t, e, i, s) => {
+    for (var o = ae(e, i), n = t.length - 1, d; n >= 0; n--)
+      (d = t[n]) && (o = d(e, i, o) || o);
+    return o && de(e, i, o), o;
+  };
+class l extends L {
+  /**
+   * The guide labels text symbol (font, color, style).
+   */
+  get guideLabelsSymbol() {
+    return I(this._config);
+  }
+  set guideLabelsSymbol(e) {
+    Q(e, this._config);
+  }
+  /**
+   * Gets whether a guide is visible.
+   *
+   * @param index - Default `0`. The index of the guide in the list of guides for the given axis orientation.
+   * @param orientation - Default `y`. The axis orientation of the guide.
+   */
+  getGuideVisibility(e, i) {
+    return U({ config: this._config, index: e, orientation: i });
+  }
+  setGuideVisibility(e, i, s) {
+    Y({ visible: e, config: this._config, index: i, orientation: s });
+  }
+  /**
+   * Gets the start value of a guide.
+   *
+   * @param index - Default `0`. The index of the guide in the list of guides for the given axis orientation.
+   * @param orientation - Default `y`. The axis orientation of the guide.
+   */
+  getGuideStart(e, i) {
+    return q({ config: this._config, index: e, orientation: i });
+  }
+  setGuideStart(e, i, s) {
+    z({ start: e, config: this._config, index: i, orientation: s });
+  }
+  /**
+   * Gets the end value of a guide.
+   *
+   * @param index - Default `0`. The index of the guide in the list of guides for the given axis orientation.
+   * @param orientation - Default `y`. The axis orientation of the guide.
+   */
+  getGuideEnd(e, i) {
+    return H({ config: this._config, index: e, orientation: i });
+  }
+  setGuideEnd(e, i, s) {
+    J({ end: e, config: this._config, index: i, orientation: s });
+  }
+  /**
+   * Gets the name of a guide.
+   *
+   * @param index - Default `0`. The index of the guide in the list of guides for the given axis orientation.
+   * @param orientation - Default `y`. The axis orientation of the guide.
+   */
+  getGuideName(e, i) {
+    return K({ config: this._config, index: e, orientation: i });
+  }
+  setGuideName(e, i, s) {
+    Z({ name: e, config: this._config, index: i, orientation: s });
+  }
+  /**
+   * Gets the guide label text.
+   *
+   * @param index - Default `0`. The index of the guide in the list of guides for the given axis orientation.
+   * @param orientation - Default `y`. The axis orientation of the guide.
+   */
+  getGuideLabelText(e, i) {
+    return k({ config: this._config, index: e, orientation: i });
+  }
+  setGuideLabelText(e, i, s) {
+    ee({ labelText: e, config: this._config, index: i, orientation: s });
+  }
+  /**
+   * Gets whether the guide should be rendered above the other chart elements.
+   *
+   * @param index - Default `0`. The index of the guide in the list of guides for the given axis orientation.
+   * @param orientation - Default `y`. The axis orientation of the guide.
+   */
+  getGuideAbove(e, i) {
+    return ie({ config: this._config, index: e, orientation: i });
+  }
+  setGuideAbove(e, i, s) {
+    te({ above: e, config: this._config, index: i, orientation: s });
+  }
+  /**
+   * Gets the guide style.
+   *
+   * @param index - Default `0`. The index of the guide in the list of guides for the given axis orientation.
+   * @param orientation - Default `y`. The axis orientation of the guide.
+   */
+  getGuideStyle(e, i) {
+    return se({ config: this._config, index: e, orientation: i });
+  }
+  setGuideStyle(e, i, s) {
+    oe({ style: e, config: this._config, index: i, orientation: s });
+  }
+  /**
+   * Gets whether the tooltip text color should be reversed for a guide.
+   *
+   * @param index - The index of the guide in the list of guides for the given axis orientation.
+   * @param orientation - The axis orientation of the guide.
+   */
+  getTooltipReverseColor(e, i) {
+    return ne({ config: this._config, index: e, orientation: i });
+  }
+  setTooltipReverseColor(e, i, s) {
+    re({ reverseColor: e, config: this._config, index: i, orientation: s });
+  }
+}
+u([a], l.prototype, "guideLabelsSymbol");
+u([a], l.prototype, "setGuideVisibility");
+u([a], l.prototype, "setGuideStart");
+u([a], l.prototype, "setGuideEnd");
+u([a], l.prototype, "setGuideName");
+u([a], l.prototype, "setGuideLabelText");
+u([a], l.prototype, "setGuideAbove");
+u([a], l.prototype, "setGuideStyle");
+u([a], l.prototype, "setTooltipReverseColor");
+export { l as M, De as W, Ve as a, $ as b, Re as d };

package/dist/chunks/model-with-line-marker-styling.js

@@ -0,0 +1,178 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+import { C as S } from "./chart-model.js";
+import { s as c } from "./serial-chart-model.js";
+import {
+  g as f,
+  a as h,
+  e as p,
+  b as _,
+  f as M,
+  s as k,
+  h as y,
+  c as L,
+  i as C,
+  d,
+  j as m,
+  k as b,
+  l as u,
+  m as V,
+  n as A,
+  o as l,
+  p as v,
+  q as W,
+  r as z,
+} from "./negative-values-stacked-to-baseline.js";
+import { m as i } from "./model-setter.js";
+var O = Object.defineProperty,
+  P = Object.getOwnPropertyDescriptor,
+  r = (n, e, t, j) => {
+    for (var o = P(e, t), a = n.length - 1, g; a >= 0; a--)
+      (g = n[a]) && (o = g(e, t, o) || o);
+    return o && O(e, t, o), o;
+  };
+class s extends S {
+  /**
+   * Gets the line style of the series based on the series index. If the index is out of bounds, it will return `undefined`.
+   *
+   * @param seriesIndex - The index of the series.
+   */
+  getSeriesLineStyle(e) {
+    return f(e, this._config);
+  }
+  setSeriesLineStyle(e, t) {
+    h(e, t, this._config);
+  }
+  /**
+   * Gets the line width of the series based on the series index. If the index is out of bounds, it will return `undefined`.
+   *
+   * @param seriesIndex - The index of the series.
+   */
+  getSeriesLineWidth(e) {
+    return p(e, this._config);
+  }
+  setSeriesLineWidth(e, t) {
+    _(e, t, this._config);
+  }
+  /**
+   * Gets the marker color of the series based on the series index. If the index is out of bounds, it will return `undefined`.
+   *
+   * @param seriesIndex - The index of the series.
+   * @returns Color | undefined
+   */
+  getSeriesMarkerColor(e) {
+    return M(e, this._config);
+  }
+  setSeriesMarkerColor(e, t) {
+    k(e, t, this._config);
+  }
+  /**
+   * Gets the marker style of the series based on the series index. If the index is out of bounds, it will return `undefined`.
+   *
+   * @param seriesIndex - The index of the series.
+   */
+  getSeriesMarkerStyle(e) {
+    return y(e, this._config);
+  }
+  setSeriesMarkerStyle(e, t) {
+    L(e, t, this._config);
+  }
+  /**
+   * Gets the marker size of the series based on the series index. If the index is out of bounds, it will return `undefined`.
+   *
+   * @param seriesIndex - The index of the series.
+   */
+  getSeriesMarkerSize(e) {
+    return C(e, this._config);
+  }
+  setSeriesMarkerSize(e, t) {
+    d(e, t, this._config);
+  }
+  /**
+   * Specify whether line segments of the series should be smoothed.
+   *
+   * @param seriesIndex - The index of the series.
+   */
+  isLineSmoothed(e) {
+    return m(e, this._config);
+  }
+  setLineSmoothed(e, t) {
+    b({
+      smoothed: e,
+      seriesIndex: t,
+      config: this._config,
+    });
+  }
+  /**
+   * Specify the color of the filled area for line chart.
+   *
+   * @param seriesIndex - The index of the series.
+   */
+  getConnectLines(e) {
+    return u(e, this._config);
+  }
+  setConnectLines(e, t) {
+    V({
+      connect: e,
+      seriesIndex: t,
+      config: this._config,
+    });
+  }
+  /**
+   * Specify whether the line series should show area.
+   *
+   * @param seriesIndex - The index of the series.
+   */
+  isAreaVisible(e) {
+    return A(e, this._config);
+  }
+  setAreaVisible(e, t) {
+    l({
+      visible: e,
+      seriesIndex: t,
+      config: this._config,
+    });
+  }
+  /**
+   * Indicate whether to show or hide the markers/bullets of the line series.
+   *
+   * @param seriesIndex - The index of the series.
+   */
+  isMarkerVisible(e) {
+    return v(e, this._config);
+  }
+  setMarkerVisible(e, t) {
+    W({
+      visible: e,
+      seriesIndex: t,
+      config: this._config,
+    });
+  }
+  /**
+   * Specify the color of the filled area for line chart.
+   * **Note:** `areaColor` will be applied only if `showArea` is true, and is defaulted to the line color if not provided.
+   *
+   * @param seriesIndex - The index of the series.
+   */
+  getAreaColor(e) {
+    return z(e, this._config);
+  }
+  setAreaColor(e, t) {
+    l({
+      visible: !0,
+      seriesIndex: t,
+      config: this._config,
+    }),
+      c(e, t, this._config);
+  }
+}
+r([i], s.prototype, "setSeriesLineStyle");
+r([i], s.prototype, "setSeriesLineWidth");
+r([i], s.prototype, "setSeriesMarkerColor");
+r([i], s.prototype, "setSeriesMarkerStyle");
+r([i], s.prototype, "setSeriesMarkerSize");
+r([i], s.prototype, "setLineSmoothed");
+r([i], s.prototype, "setConnectLines");
+r([i], s.prototype, "setAreaVisible");
+r([i], s.prototype, "setMarkerVisible");
+r([i], s.prototype, "setAreaColor");
+export { s as M };