@geoscene/charts-components 5.0.19

package/dist/utils/components/event-payloads.d.ts

@@ -0,0 +1,82 @@
+import type MapView from "@geoscene/core/views/MapView.js";
+import type SceneView from "@geoscene/core/views/SceneView.js";
+import type { DOMContainerAria } from "@geoscene/core/views/DOMContainer.js";
+import type { JsxNode } from "@geoscene/lumina";
+import type { ChartModel } from "../../model/chart-model/chart-model.js";
+import type {
+  PieSlicesSymbols,
+  SelectionData,
+  SeriesSymbolsMap,
+} from "../misc/interfaces.js";
+import type { WebChartDataTypes } from "../../spec/data-source.js";
+import type {
+  CalculatedMinMaxBoundsPayload,
+  LegendItemVisibility,
+} from "../../spec/events.js";
+import type { WebChartLegendPositions } from "../../spec/chart-object-literals.js";
+import type { DefaultChartActions } from "../types/index.js";
+
+/** @internal */
+export type PanelNumberChangePayload = {
+  panelNumber: number;
+  modelList: ChartModel[];
+};
+
+/** @internal */
+export type DataChangeErrorPayload = {
+  error: Error;
+  model: ChartModel;
+};
+
+/** @internal */
+export type PopoverChangePayload = {
+  open?: boolean;
+  element: JsxNode;
+};
+
+export type ModelListChangePayload = {
+  modelList: ChartModel[];
+};
+
+export type DataProcessCompletePayload = {
+  chartData: WebChartDataTypes;
+  model?: ChartModel;
+};
+
+export type AxesMinMaxChangePayload = {
+  bounds: CalculatedMinMaxBoundsPayload[];
+  model?: ChartModel;
+};
+
+export type SeriesColorChangePayload = {
+  data: PieSlicesSymbols | SeriesSymbolsMap;
+  colorMatchApplied: boolean;
+  model?: ChartModel;
+};
+
+export type NoRenderPropChangePayload = {
+  propName: string;
+  value?:
+    | DOMContainerAria
+    | MapView
+    | SceneView
+    | WebChartLegendPositions
+    | boolean
+    | number;
+  model?: ChartModel;
+};
+
+export type LegendItemVisibilityChangePayload = {
+  legendItemVisibility: LegendItemVisibility;
+  model?: ChartModel;
+};
+
+export type SelectionCompletePayload = {
+  selectionData: SelectionData;
+  model?: ChartModel;
+};
+
+export type DefaultActionSelectPayload = {
+  actionId: DefaultChartActions;
+  actionActive: boolean;
+};

package/dist/utils/components/interfaces.d.ts

@@ -0,0 +1,14 @@
+import type { WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartLineChartSeries, WebChartRadarChartSeries } from "../../spec/web-chart.js";
+
+export interface MissingSplitBySeriesProps {
+  addMissingSeries: boolean;
+  seriesTemplate?: WebChartBarChartSeries | WebChartBoxPlotSeries | WebChartLineChartSeries | WebChartRadarChartSeries;
+}
+
+export const DownloadableChartImagesTypes: {
+    readonly PNG: "png";
+    readonly JPEG: "jpeg";
+    readonly SVG: "svg";
+};
+
+export type DownloadableChartImagesTypes = (typeof DownloadableChartImagesTypes)[keyof typeof DownloadableChartImagesTypes];

package/dist/utils/cursor/interfaces.d.ts

@@ -0,0 +1,17 @@
+export const ActionModes: {
+    readonly MonoSelection: "monoSelection";
+    readonly MultiSelection: "multiSelection";
+    readonly MultiSelectionWithCtrlKey: "multiSelectionWithCtrlKey";
+    readonly Zoom: "zoom";
+    readonly None: "none";
+};
+
+export type ActionModes = (typeof ActionModes)[keyof typeof ActionModes];
+
+export const CursorRange: {
+    readonly MultiAxes: "multi-axes";
+    readonly XAxis: "x-axis";
+    readonly YAxis: "y-axis";
+};
+
+export type CursorRange = (typeof CursorRange)[keyof typeof CursorRange];

package/dist/utils/data/categorical-data/index.d.ts

@@ -0,0 +1,27 @@
+import type { ChartElementLimit } from "../../defaults/interfaces.js";
+import type { QueryObject } from "../../layer/interfaces.js";
+import type { AbortControllerKeyType } from "../../layer/query-features/interfaces.js";
+import type { WebChartQuery } from "../../../spec/web-chart.js";
+
+/**
+ * Fetches the unique values from a given field.
+ * /!\ Currently the results for a same split-by field might differ from a category field to another.
+ * This is due to the server not being able to make a distinction in some cases between values having for
+ * only difference trailing spaces (e.g. `value` and `value ` and `value  `). It means it will aggregate the
+ * stats for those similar values.
+ * Given the stats for the similar values will be later aggregated, we also want the unique value list to carry
+ * the same approximation.
+ * To get a list of unique values that will match the chart's data, we simulate the data query and retain the unique
+ * values for given the split-by field.
+ *
+ * @param props - The object used to query the features (layer or feature layer view)
+ * @internal
+ */
+export function uniqueValues(props: {
+    queryObject?: QueryObject;
+    queryConfig: WebChartQuery;
+    category: string;
+    splitByField?: string;
+    chartLimits?: ChartElementLimit;
+    abortKey?: AbortControllerKeyType;
+}): Promise<(number | string)[]>;

package/dist/utils/data/index.d.ts

@@ -0,0 +1,149 @@
+import type { ChartSubType } from "../misc/interfaces.js";
+import type { BoxPlotYValueProps, DataMinMax, BoxPlotYFieldKeys } from "./interfaces.js";
+import type { WebChart, WebChartSeriesType, WebGaugeChart } from "../../spec/web-chart.js";
+import type { WebChartBin, WebChartDataItem, WebChartDataTypes } from "../../spec/data-source.js";
+
+/**
+ * Generates the y field names for box plot
+ *
+ * @param y
+ * @internal
+ */
+export function getBoxPlotStatisticFieldNames(y?: string): Record<BoxPlotYFieldKeys, string>;
+
+/**
+ * Check the `subType` in the chart config to determine whether the chart is a gauge by feature.
+ * If `subType` is not defined, the chart is defaulted to be a statistic gauge.
+ *
+ * @param config - the chart config
+ * @internal
+ */
+export function isGaugeByFeature(config: WebChart): boolean;
+
+/**
+ * From fetched data (type: WebChartDataTypes) returns the part containing the data that
+ * is to be assigned to the chart (WebChartDataItem[] | WebChartBin[])
+ *
+ * @param fetchedData - The fetched finished data
+ * @internal
+ */
+export function extractChartDataFromFetchedData(fetchedData?: WebChartDataTypes): WebChartBin[] | WebChartDataItem[] | undefined;
+
+/**
+ * Determine whether the current box plot has multi-fields or not based on its query type
+ *
+ * @param chartSubType - Box plot sub type
+ * @internal
+ */
+export function isMultiFieldsBoxPlot(chartSubType?: ChartSubType): boolean;
+
+/**
+ * Compute Y value for given Box Plot Y field key based on the provided config
+ *
+ * @param props - The BoxPlotYFieldKeys related to the stat
+ * @internal
+ */
+export function getBoxPlotYValue(props: BoxPlotYValueProps): string;
+
+/**
+ * Check if the Box-plot data item has valid open or close (first quartile/third quartile) values since those values are considered as necessary.
+ *
+ * @param props - The WebChartDataItem to check for valid values
+ * @internal
+ */
+export function doesBoxPlotItemHaveValidQuartiles(props: {
+    dataItem: WebChartDataItem;
+    y?: string;
+    splitBy?: string;
+    showOutliers?: boolean;
+}): boolean;
+
+/**
+ * Gathers the list of `y` values used by a chart from the series configs.
+ * For non-aggregated split-by bar/line charts, the y values are constructed from the series's where clauses.
+ *
+ * Notes:
+ * 1. If the list of visible series id is provided it will be used to filter out the series, otherwise they will all be considered.
+ * 2. The returned y list should be independently from any prefix or suffix that are used for other features like
+ * color match, selection, tooltips, etc.
+ *
+ * @param seriesConfig - The array of configs for the chart series.
+ * @param filteredSeriesIds - List of series ids to use as a filter.
+ * @internal
+ */
+export function getYList(seriesConfig: WebChartSeriesType[], filteredSeriesIds?: string[]): string[];
+
+/**
+ * Gathers the list of `y` values used by a box plot from the series configs.
+ *
+ * @param props - Whether the box plot mean lines are shown
+ * @internal
+ */
+export function getBoxPlotYList(props: {
+    showMean?: boolean;
+    seriesConfig: WebChartSeriesType[];
+    filteredSeriesIds?: string[];
+}): string[];
+
+/**
+ * validate the individual bar chart data item using its x and y values
+ *
+ * @param props - The bar/line chart data item
+ * @internal
+ */
+export function validateBarNLineChartDataItem(props: {
+    dataItem: WebChartDataItem;
+    x: string;
+    y: string;
+    nullAsValid?: boolean;
+}): boolean;
+
+/**
+ * Indicates whether a data set is empty (no bar, no slice, etc.) and contains at least one valid item.
+ *
+ * @param props - The chart's config
+ * @returns A boolean
+ * @internal
+ */
+export function isEmptyDataset(props: {
+    chartConfig?: WebChart | WebGaugeChart;
+    nullAsValid?: boolean;
+    dataSet?: WebChartDataItem[];
+}): boolean;
+
+/**
+ * Gets the data min and max values for a stacked series; also an indicator whether the data has negative values.
+ *
+ * @param props - The config for the series
+ * @internal
+ */
+export function getDataMinMaxFromStackedSeries(props: {
+    seriesConfig: WebChartSeriesType[];
+    filteredSeriesIds?: string[];
+    filteredData: WebChartDataItem[];
+}): {
+    stackedMinY: number;
+    stackedMaxY: number;
+    dataHasNegativeValues: boolean;
+};
+
+/**
+ * Looks for the min and max values from a data set, considering only the visible series.
+ *
+ * @param props - The chart config
+ * @internal
+ */
+export function getDataMinMaxFromSeries(props: {
+    chartConfig: WebChart;
+    chartData: WebChartDataItem[];
+    filteredSeriesIds?: string[];
+}): DataMinMax;
+
+/**
+ * Rounds a number to a given number of decimals
+ *
+ * @param num - The number to round
+ * @param dec - The number of decimals
+ * @internal
+ */
+export function roundToDecimals(num: number, dec: number): number;

package/dist/utils/data/interfaces.d.ts

@@ -0,0 +1,75 @@
+import type { WebChartDataTypes } from "../../spec/data-source.js";
+import type { WebChartQuery } from "../../spec/web-chart.js";
+import type { DataWarningKeywords } from "../chart-config/validator/interfaces.js";
+import type { ChartSubType } from "../misc/interfaces.js";
+
+/** @internal */
+export interface DataMinMax {
+  minY: number;
+  maxY: number;
+  minX?: number;
+  maxX?: number;
+}
+
+/** @internal */
+export interface DataInfo {
+  valid: boolean;
+  invalidType?: DataWarningKeywords;
+  count?: number;
+  data?: WebChartDataTypes;
+  queryConfig?: WebChartQuery;
+}
+
+/** @internal */
+export const BoxPlotYFieldKeys: {
+    Min: string;
+    FirstQuartile: string;
+    Median: string;
+    ThirdQuartile: string;
+    Max: string;
+    IQR: string;
+    Average: string;
+    StandardDeviation: string;
+    Outlier: string;
+};
+
+/** @internal */
+export type BoxPlotYFieldKeys = (typeof BoxPlotYFieldKeys)[keyof typeof BoxPlotYFieldKeys];
+
+/** @internal */
+export interface BoxPlotYValueProps {
+  key: BoxPlotYFieldKeys;
+  y?: string;
+  chartSubType?: ChartSubType;
+  splitBy?: string;
+  splitByValue?: number | string | null;
+  showOutliers?: boolean;
+  standardizeValues?: boolean;
+}
+
+/** @internal */
+export interface DataUpdateDetails {
+  common?: {
+      layerChanged?: boolean;
+      queryChanged?: boolean;
+      xOrYChanged?: boolean;
+      numberOfSeriesChanged?: boolean;
+      configFiltersChanged?: boolean;
+      filterBySelectionChanged?: boolean;
+      dataForFilterBySelectionChanged?: boolean;
+      binTemporalDataChanged?: boolean;
+      timeBinningChanged?: boolean;
+      timeIntervalUnitChanged?: boolean;
+      newTimeBinningWillBeCalculated?: boolean;
+      valueFormatChangeRequiresNewData?: boolean;
+  };
+  histogram?: { dataPropsChanged?: boolean; };
+  gauge?: { valueConversionChanged?: boolean; };
+  boxPlot?: { showMeanChanged?: boolean; };
+  heatChart?: {
+      binningChanged?: boolean;
+      hideEmptyRowsAndColumnsChanged?: boolean;
+      includeLeapDay?: boolean;
+  };
+  scatterPlot?: { tooltipFieldsChanged?: boolean; };
+}

package/dist/utils/data/time-binning/interfaces.d.ts

@@ -0,0 +1,38 @@
+import type { WebChartTemporalBinningUnits } from "../../../spec/chart-object-literals.js";
+import type { TimeIntervalInfo, WebChartDataItem } from "../../../spec/data-source.js";
+
+/** @internal */
+export interface DateRange {
+  dateMinTimestamp?: number | null;
+  dateMaxTimestamp?: number | null;
+}
+
+/** @internal */
+export interface IntervalUnitHelper {
+  unit: WebChartTemporalBinningUnits;
+  threshold: number;
+  unitMs: number;
+  preferredIntervalSize: number[];
+}
+
+/** @internal */
+export const timeUnitHelper: IntervalUnitHelper[];
+
+/** @internal */
+export interface TimeBinningStatistics {
+  dateRange: DateRange;
+  numberOfFeatures: number;
+}
+
+/** @internal */
+export interface GroupProps {
+  binFirstOrLastIndex: number;
+  data: WebChartDataItem[];
+  x: string;
+  timeIntervalInfo: TimeIntervalInfo;
+  newDateMin: number;
+  newDateMax: number;
+}
+
+/** @internal */
+export const groupByWhenCaseForMedianTimeBinning: `{ groupByFieldsForStatistics } WHEN { dateField }>='{ startDate }' AND { dateField }{ endDateOperand }'{ endDate }' THEN '{ y }|{ binIndex}'`;