@uipath/apollo-vertex 0.0.0-stage → 0.3.0

package/dist/registry/chart/chart.js

@@ -0,0 +1,165 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { createContext, useContext, useId } from "react";
+import { Legend, ResponsiveContainer, Tooltip } from "recharts";
+import { cn } from "../../lib/utils.js";
+const THEMES = {
+    light: "",
+    dark: ".dark"
+};
+const ChartContext = /*#__PURE__*/ createContext(null);
+function useChart() {
+    const context = useContext(ChartContext);
+    if (!context) throw new Error("useChart must be used within a <ChartContainer />");
+    return context;
+}
+function ChartContainer({ id, className, children, config, ...props }) {
+    const uniqueId = useId();
+    const chartId = `chart-${id ?? uniqueId.replaceAll(":", "")}`;
+    return /*#__PURE__*/ jsx(ChartContext.Provider, {
+        value: {
+            config
+        },
+        children: /*#__PURE__*/ jsxs("div", {
+            "data-slot": "chart",
+            "data-chart": chartId,
+            className: cn("[&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground [&_.recharts-cartesian-grid_line[stroke='#ccc']]:stroke-border/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-border [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border [&_.recharts-radial-bar-background-sector]:fill-muted [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted [&_.recharts-reference-line_[stroke='#ccc']]:stroke-border flex aspect-video justify-center text-xs [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-hidden [&_.recharts-sector]:outline-hidden [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-surface]:outline-hidden", className),
+            ...props,
+            children: [
+                /*#__PURE__*/ jsx(ChartStyle, {
+                    id: chartId,
+                    config: config
+                }),
+                /*#__PURE__*/ jsx(ResponsiveContainer, {
+                    children: children
+                })
+            ]
+        })
+    });
+}
+const ChartStyle = ({ id, config })=>{
+    const colorConfig = Object.entries(config).filter(([, itemConfig])=>itemConfig.theme ?? itemConfig.color);
+    if (0 === colorConfig.length) return null;
+    return /*#__PURE__*/ jsx("style", {
+        dangerouslySetInnerHTML: {
+            __html: Object.entries(THEMES).map(([theme, prefix])=>`
+${prefix} [data-chart=${id}] {
+${colorConfig.map(([key, itemConfig])=>{
+                    const color = itemConfig.theme?.[theme] ?? itemConfig.color;
+                    return color ? `  --color-${key}: ${color};` : null;
+                }).join("\n")}
+}
+`).join("\n")
+        }
+    });
+};
+const ChartTooltip = Tooltip;
+function ChartTooltipContent({ active, payload, className, indicator = "dot", hideLabel = false, hideIndicator = false, label, labelFormatter, labelClassName, formatter, color, nameKey, labelKey }) {
+    const { config } = useChart();
+    function getTooltipLabel() {
+        if (hideLabel || !payload?.length) return null;
+        const [item] = payload;
+        const key = `${(labelKey ?? item?.dataKey) || (item?.name ?? "value")}`;
+        const itemConfig = getPayloadConfigFromPayload(config, item, key);
+        const value = labelKey || "string" != typeof label ? itemConfig?.label : config[label]?.label ?? label;
+        if (labelFormatter) return /*#__PURE__*/ jsx("div", {
+            className: cn("font-medium", labelClassName),
+            children: labelFormatter(value, payload)
+        });
+        if (!value) return null;
+        return /*#__PURE__*/ jsx("div", {
+            className: cn("font-medium", labelClassName),
+            children: value
+        });
+    }
+    const tooltipLabel = getTooltipLabel();
+    if (!active || !payload?.length) return null;
+    const nestLabel = 1 === payload.length && "dot" !== indicator;
+    return /*#__PURE__*/ jsxs("div", {
+        className: cn("border-border/50 bg-background grid min-w-[8rem] items-start gap-1.5 rounded-lg border px-2.5 py-1.5 text-xs shadow-xl", className),
+        children: [
+            nestLabel ? null : tooltipLabel,
+            /*#__PURE__*/ jsx("div", {
+                className: "grid gap-1.5",
+                children: payload.filter((item)=>"none" !== item.type).map((item, index)=>{
+                    const key = `${(nameKey ?? item.name) || (item.dataKey ?? "value")}`;
+                    const itemConfig = getPayloadConfigFromPayload(config, item, key);
+                    const indicatorColor = color ?? item.payload.fill ?? item.color;
+                    return /*#__PURE__*/ jsx("div", {
+                        className: cn("[&>svg]:text-muted-foreground flex w-full flex-wrap items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5", "dot" === indicator && "items-center"),
+                        children: formatter && item?.value != null && item.name ? formatter(item.value, item.name, item, index, item.payload) : /*#__PURE__*/ jsxs(Fragment, {
+                            children: [
+                                itemConfig?.icon ? /*#__PURE__*/ jsx(itemConfig.icon, {}) : !hideIndicator && /*#__PURE__*/ jsx("div", {
+                                    className: cn("shrink-0 rounded-[2px] border-(--color-border) bg-(--color-bg)", {
+                                        "h-2.5 w-2.5": "dot" === indicator,
+                                        "w-1": "line" === indicator,
+                                        "w-0 border-[1.5px] border-dashed bg-transparent": "dashed" === indicator,
+                                        "my-0.5": nestLabel && "dashed" === indicator
+                                    }),
+                                    style: {
+                                        "--color-bg": indicatorColor,
+                                        "--color-border": indicatorColor
+                                    }
+                                }),
+                                /*#__PURE__*/ jsxs("div", {
+                                    className: cn("flex flex-1 justify-between leading-none", nestLabel ? "items-end" : "items-center"),
+                                    children: [
+                                        /*#__PURE__*/ jsxs("div", {
+                                            className: "grid gap-1.5",
+                                            children: [
+                                                nestLabel ? tooltipLabel : null,
+                                                /*#__PURE__*/ jsx("span", {
+                                                    className: "text-muted-foreground",
+                                                    children: itemConfig?.label ?? item.name
+                                                })
+                                            ]
+                                        }),
+                                        item.value && /*#__PURE__*/ jsx("span", {
+                                            className: "text-foreground font-mono font-medium tabular-nums",
+                                            children: item.value.toLocaleString()
+                                        })
+                                    ]
+                                })
+                            ]
+                        })
+                    }, item.dataKey);
+                })
+            })
+        ]
+    });
+}
+const ChartLegend = Legend;
+function ChartLegendContent({ className, hideIcon = false, payload, verticalAlign = "bottom", nameKey }) {
+    const { config } = useChart();
+    if (!payload?.length) return null;
+    return /*#__PURE__*/ jsx("div", {
+        className: cn("flex items-center justify-center gap-4", "top" === verticalAlign ? "pb-3" : "pt-3", className),
+        children: payload.filter((item)=>"none" !== item.type).map((item)=>{
+            const key = String(nameKey ?? item.dataKey ?? "value");
+            const itemConfig = getPayloadConfigFromPayload(config, item, key);
+            return /*#__PURE__*/ jsxs("div", {
+                className: cn("[&>svg]:text-muted-foreground flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3"),
+                children: [
+                    itemConfig?.icon && !hideIcon ? /*#__PURE__*/ jsx(itemConfig.icon, {}) : /*#__PURE__*/ jsx("div", {
+                        className: "h-2 w-2 shrink-0 rounded-[2px]",
+                        style: {
+                            backgroundColor: item.color
+                        }
+                    }),
+                    itemConfig?.label
+                ]
+            }, item.value);
+        })
+    });
+}
+function getPayloadConfigFromPayload(config, payload, key) {
+    if ("object" != typeof payload || null === payload) return;
+    const payloadPayload = "payload" in payload && "object" == typeof payload.payload && null !== payload.payload ? payload.payload : null;
+    let configLabelKey = key;
+    const payloadRecord = payload;
+    const nestedRecord = payloadPayload;
+    if (key in payloadRecord && "string" == typeof payloadRecord[key]) configLabelKey = payloadRecord[key];
+    else if (nestedRecord && key in nestedRecord && "string" == typeof nestedRecord[key]) configLabelKey = nestedRecord[key];
+    return configLabelKey in config ? config[configLabelKey] : config[key];
+}
+export { ChartContainer, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent };

package/dist/registry/charts-core/chart-data-mapper.d.ts

@@ -0,0 +1,11 @@
+import type { DataQueryResponse } from "./data-query-response-schema";
+import type { PrimitiveValue } from "./models/primitive-value";
+interface ChartDataMappingOptions {
+    dimensions: string[];
+    metrics?: string[];
+}
+type ChartDataRow = Record<string, PrimitiveValue>;
+export declare function mapResponseToChartData({ dimensions, metrics, data, }: ChartDataMappingOptions & {
+    data: DataQueryResponse;
+}): ChartDataRow[];
+export {};

package/dist/registry/charts-core/chart-data-mapper.js

@@ -0,0 +1,25 @@
+import { assertDefined } from "../../lib/asserts/assert-defined.js";
+function mapResponseToChartData({ dimensions, metrics = [], data }) {
+    const [firstKey] = dimensions;
+    if (!firstKey) return [];
+    const rows = data[firstKey]?.values ?? [];
+    const rowCount = rows.length;
+    const dimensionValues = dimensions.map((dimension)=>assertDefined(data[dimension], `Dimension data: ${dimension}`).values);
+    const metricValues = metrics.map((metric)=>assertDefined(data[metric], `Metric data: ${metric}`).values);
+    return Array.from({
+        length: rowCount
+    }, (_, rowIdx)=>{
+        const entries = [
+            ...dimensions.map((dimension, dimensionIdx)=>[
+                    dimension,
+                    assertDefined(dimensionValues[dimensionIdx], `Dimension ${dimensionIdx}`)[rowIdx]
+                ]),
+            ...metrics.map((metric, metricIdx)=>[
+                    metric,
+                    assertDefined(metricValues[metricIdx], `Metric ${metricIdx}`)[rowIdx]
+                ])
+        ];
+        return Object.fromEntries(entries);
+    });
+}
+export { mapResponseToChartData };

package/dist/registry/charts-core/chart-loading-boundary.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+interface ChartLoadingBoundaryProps<TConfiguration, TDataModel> {
+    configuration: TConfiguration;
+    dataModel: TDataModel;
+    children: ReactNode;
+}
+export declare function ChartLoadingBoundary<TConfiguration, TDataModel>({ configuration, dataModel, children, }: ChartLoadingBoundaryProps<TConfiguration, TDataModel>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/registry/charts-core/chart-loading-boundary.js

@@ -0,0 +1,22 @@
+import { jsx } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { Spinner } from "../spinner/spinner.js";
+import { ErrorBoundaryWithFallback } from "./error-boundary.js";
+function ChartLoadingBoundary({ configuration, dataModel, children }) {
+    return /*#__PURE__*/ jsx(ErrorBoundaryWithFallback, {
+        resetKeys: [
+            JSON.stringify(configuration),
+            JSON.stringify(dataModel)
+        ],
+        children: /*#__PURE__*/ jsx(Suspense, {
+            fallback: /*#__PURE__*/ jsx("div", {
+                className: "flex h-full min-h-[200px] w-full items-center justify-center",
+                children: /*#__PURE__*/ jsx(Spinner, {
+                    className: "size-8"
+                })
+            }),
+            children: children
+        })
+    });
+}
+export { ChartLoadingBoundary };

package/dist/registry/charts-core/chart-models.d.ts

@@ -0,0 +1,41 @@
+import type { Interval } from "luxon";
+import type { MetricExpression } from "./models/expression";
+import type { DatetimeModelField, DataModelField, DataModelFieldType, NumericOrDatetimeModelField, StringModelField } from "./models/field";
+import type { PrimitiveValue } from "./models/primitive-value";
+export type { DataModelField, DataModelFieldType, DatetimeModelField, NumericOrDatetimeModelField, StringModelField, };
+export type DimensionType = DataModelFieldType;
+export interface DataModelMetric {
+    id: string;
+    display: string;
+    expression: MetricExpression;
+}
+export interface ChartDataModel<TField extends DataModelField = DataModelField> {
+    id: string;
+    dimensions: TField[];
+    metrics: DataModelMetric[];
+}
+export interface KpiDataModel {
+    id: string;
+    metrics: DataModelMetric[];
+}
+export interface KpiChartData<_TMetaData = unknown> {
+    data: number | number[];
+    labels?: string[];
+}
+export type LineChartData = {
+    values: number[];
+    bins: Interval[];
+};
+export type DistributionChartData = {
+    values: number[];
+    bins: Interval[] | {
+        start: number;
+        end: number;
+    }[];
+};
+export type TableChartData = Record<string, PrimitiveValue>[];
+export type BarChartData = Record<string, PrimitiveValue>[];
+export type MultiLineChartData = {
+    seriesByMetricId: Record<string, number[]>;
+    bins: Interval[];
+};

package/dist/registry/charts-core/charts-core.d.ts

@@ -0,0 +1,33 @@
+export { mapResponseToChartData } from "./chart-data-mapper";
+export { ChartLoadingBoundary } from "./chart-loading-boundary";
+export type { BarChartData, ChartDataModel, DatetimeModelField, DimensionType, DistributionChartData, DataModelField, DataModelFieldType, KpiChartData, KpiDataModel, LineChartData, DataModelMetric, MultiLineChartData, NumericOrDatetimeModelField, StringModelField, TableChartData, } from "./chart-models";
+export type { DataAdapter } from "./data-adapter";
+export { type DataQueryResponse, DataQueryResponseSchema, PrimitiveValueSchema, } from "./data-query-response-schema";
+export { mapConfigFilterToFilterValues } from "./map-filter-config";
+export { type BarChartConfiguration, BarChartConfigurationSchema, } from "./models/configurations/bar-chart-configuration";
+export { BaseChartConfigurationSchema } from "./models/configurations/base-chart-configuration";
+export { type TableChartState, TableChartStateSchema, } from "./models/configurations/chart-properties";
+export { ChartTypeSchema } from "./models/configurations/chart-type-schema";
+export { type DistributionChartConfiguration, DistributionChartConfigurationSchema, } from "./models/configurations/distribution-chart-configuration";
+export { FilterValuesSchema } from "./models/configurations/filter-values-schema";
+export { type KpiChartConfiguration, KpiChartConfigurationSchema, } from "./models/configurations/kpi-chart-configuration";
+export { type LineChartConfiguration, LineChartConfigurationSchema, } from "./models/configurations/line-chart-configuration";
+export { type MultiLineChartConfiguration, MultiLineChartConfigurationSchema, } from "./models/configurations/multi-line-chart-configuration";
+export { type TableChartConfiguration, TableChartConfigurationSchema, } from "./models/configurations/table-chart-configuration";
+export type { DataModelAggregate, AggregationKind, MetricExpression, } from "./models/expression";
+export type { ListFilter } from "./models/filter";
+export type { FilterValues } from "./models/filter-values";
+export { type FromConfig, FromConfigSchema, type JoinConfig, JoinConfigSchema, } from "./models/join-schema";
+export type { PrimitiveValue } from "./models/primitive-value";
+export { SpinnerWithChildren } from "./spinner-with-children";
+export type { TableDataModel, TableDataModelField } from "./table-data-model";
+export { niceDurationNumbers } from "./util/binning/nice-duration-numbers";
+export { niceNumbers } from "./util/binning/nice-numbers";
+export { dataTypeAlignment } from "./util/data-type-alignment";
+export { binLabel } from "./util/format/bin-label";
+export { buildField } from "./util/build-field";
+export { format } from "./util/format/format";
+export { formatMetricValue } from "./util/format/format-metric-value";
+export { formatPercentage } from "./util/format/format-percentage";
+export { getChartRange } from "./util/format/get-chart-range";
+export { getMetricFieldType } from "./util/get-metric-field-type";

package/dist/registry/charts-core/charts-core.js

@@ -0,0 +1,27 @@
+import { mapResponseToChartData } from "./chart-data-mapper.js";
+import { ChartLoadingBoundary } from "./chart-loading-boundary.js";
+import { DataQueryResponseSchema, PrimitiveValueSchema } from "./data-query-response-schema.js";
+import { mapConfigFilterToFilterValues } from "./map-filter-config.js";
+import { BarChartConfigurationSchema } from "./models/configurations/bar-chart-configuration.js";
+import { BaseChartConfigurationSchema } from "./models/configurations/base-chart-configuration.js";
+import { TableChartStateSchema } from "./models/configurations/chart-properties.js";
+import { ChartTypeSchema } from "./models/configurations/chart-type-schema.js";
+import { DistributionChartConfigurationSchema } from "./models/configurations/distribution-chart-configuration.js";
+import { FilterValuesSchema } from "./models/configurations/filter-values-schema.js";
+import { KpiChartConfigurationSchema } from "./models/configurations/kpi-chart-configuration.js";
+import { LineChartConfigurationSchema } from "./models/configurations/line-chart-configuration.js";
+import { MultiLineChartConfigurationSchema } from "./models/configurations/multi-line-chart-configuration.js";
+import { TableChartConfigurationSchema } from "./models/configurations/table-chart-configuration.js";
+import { FromConfigSchema, JoinConfigSchema } from "./models/join-schema.js";
+import { SpinnerWithChildren } from "./spinner-with-children.js";
+import { niceDurationNumbers } from "./util/binning/nice-duration-numbers.js";
+import { niceNumbers } from "./util/binning/nice-numbers.js";
+import { dataTypeAlignment } from "./util/data-type-alignment.js";
+import { binLabel } from "./util/format/bin-label.js";
+import { buildField } from "./util/build-field.js";
+import { format } from "./util/format/format.js";
+import { formatMetricValue } from "./util/format/format-metric-value.js";
+import { formatPercentage } from "./util/format/format-percentage.js";
+import { getChartRange } from "./util/format/get-chart-range.js";
+import { getMetricFieldType } from "./util/get-metric-field-type.js";
+export { BarChartConfigurationSchema, BaseChartConfigurationSchema, ChartLoadingBoundary, ChartTypeSchema, DataQueryResponseSchema, DistributionChartConfigurationSchema, FilterValuesSchema, FromConfigSchema, JoinConfigSchema, KpiChartConfigurationSchema, LineChartConfigurationSchema, MultiLineChartConfigurationSchema, PrimitiveValueSchema, SpinnerWithChildren, TableChartConfigurationSchema, TableChartStateSchema, binLabel, buildField, dataTypeAlignment, format, formatMetricValue, formatPercentage, getChartRange, getMetricFieldType, mapConfigFilterToFilterValues, mapResponseToChartData, niceDurationNumbers, niceNumbers };

package/dist/registry/charts-core/data-adapter.d.ts

@@ -0,0 +1,27 @@
+import type { QueryOptions, UseSuspenseQueryOptions } from "@tanstack/react-query";
+import type { BarChartData, ChartDataModel, DatetimeModelField, DistributionChartData, KpiChartData, KpiDataModel, LineChartData, MultiLineChartData, NumericOrDatetimeModelField, StringModelField, TableChartData } from "./chart-models";
+import type { BarChartConfiguration } from "./models/configurations/bar-chart-configuration";
+import type { TableChartState } from "./models/configurations/chart-properties";
+import type { DistributionChartConfiguration } from "./models/configurations/distribution-chart-configuration";
+import type { KpiChartConfiguration } from "./models/configurations/kpi-chart-configuration";
+import type { LineChartConfiguration } from "./models/configurations/line-chart-configuration";
+import type { MultiLineChartConfiguration } from "./models/configurations/multi-line-chart-configuration";
+import type { TableChartConfiguration } from "./models/configurations/table-chart-configuration";
+import type { ListFilter } from "./models/filter";
+import type { PrimitiveValue } from "./models/primitive-value";
+import type { TableDataModel } from "./table-data-model";
+export interface DataAdapter {
+    charts: {
+        table: (configuration: TableChartConfiguration, dataModel: TableDataModel, state: TableChartState) => UseSuspenseQueryOptions<TableChartData, Error, TableChartData, string[]>;
+        bar: (configuration: BarChartConfiguration, dataModel: ChartDataModel<StringModelField>) => UseSuspenseQueryOptions<BarChartData, Error, BarChartData, string[]>;
+        distribution: (configuration: DistributionChartConfiguration, dataModel: ChartDataModel<NumericOrDatetimeModelField>) => UseSuspenseQueryOptions<DistributionChartData, Error, DistributionChartData, string[]>;
+        line: (configuration: LineChartConfiguration, dataModel: ChartDataModel<DatetimeModelField>) => UseSuspenseQueryOptions<LineChartData, Error, LineChartData, string[]>;
+        multiLine: (configuration: MultiLineChartConfiguration, dataModel: ChartDataModel<DatetimeModelField>) => UseSuspenseQueryOptions<MultiLineChartData, Error, MultiLineChartData, string[]>;
+        kpi: (configuration: KpiChartConfiguration, dataModel: KpiDataModel) => UseSuspenseQueryOptions<KpiChartData, Error, KpiChartData, string[]>;
+    };
+    filters: {
+        list: (filter: ListFilter) => QueryOptions<PrimitiveValue[], Error, PrimitiveValue[]> & {
+            queryKey: readonly unknown[];
+        };
+    };
+}

package/dist/registry/charts-core/data-query-response-schema.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const PrimitiveValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNullable<z.ZodNumber>]>;
+export declare const DataQueryResponseSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    stackValues: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNullable<z.ZodNumber>]>, z.ZodObject<{
+        type: z.ZodLiteral<"rest">;
+    }, z.core.$strip>]>>>>>;
+    ungrouped: z.ZodDefault<z.ZodUnion<readonly [z.ZodNullable<z.ZodNumber>, z.ZodArray<z.ZodNullable<z.ZodNumber>>]>>;
+    values: z.ZodNullable<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNullable<z.ZodNumber>]>, z.ZodArray<z.ZodNullable<z.ZodNumber>>]>>>;
+}, z.core.$strip>>;
+export type DataQueryResponse = z.infer<typeof DataQueryResponseSchema>;

package/dist/registry/charts-core/data-query-response-schema.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+const PrimitiveValueSchema = z.union([
+    z.string(),
+    z.boolean(),
+    z.number().nullable()
+]);
+const StackValuesDataSchema = z.array(z.union([
+    PrimitiveValueSchema,
+    z.object({
+        type: z.literal("rest")
+    })
+]));
+const DataQueryResponseEntrySchema = z.union([
+    PrimitiveValueSchema,
+    z.array(z.number().nullable())
+]);
+const DataQueryResponseMetricSchema = z.object({
+    stackValues: z.array(StackValuesDataSchema).nullable().default(null),
+    ungrouped: z.union([
+        z.number().nullable(),
+        z.array(z.number().nullable())
+    ]).default(null),
+    values: z.array(DataQueryResponseEntrySchema).nullable()
+});
+const DataQueryResponseSchema = z.record(z.string(), DataQueryResponseMetricSchema);
+export { DataQueryResponseSchema, PrimitiveValueSchema };

package/dist/registry/charts-core/error-boundary.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from "react";
+interface ErrorBoundaryWithFallbackProps {
+    children: ReactNode;
+    resetKeys?: string[];
+}
+export declare const ErrorBoundaryWithFallback: ({ children, resetKeys, }: ErrorBoundaryWithFallbackProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/registry/charts-core/error-boundary.js

@@ -0,0 +1,32 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { ErrorBoundary } from "react-error-boundary";
+import { useVertexTranslation } from "../../lib/vertex-translation.js";
+function Fallback({ error, resetErrorBoundary }) {
+    const { t } = useVertexTranslation();
+    const message = error instanceof Error ? error.message : String(error);
+    return /*#__PURE__*/ jsxs("div", {
+        role: "alert",
+        children: [
+            /*#__PURE__*/ jsx("p", {
+                children: t("chart_render_failed_title")
+            }),
+            /*#__PURE__*/ jsx("pre", {
+                style: {
+                    color: "red"
+                },
+                children: message
+            }),
+            /*#__PURE__*/ jsx("button", {
+                type: "button",
+                onClick: resetErrorBoundary,
+                children: t("try_again")
+            })
+        ]
+    });
+}
+const ErrorBoundaryWithFallback = ({ children, resetKeys })=>/*#__PURE__*/ jsx(ErrorBoundary, {
+        FallbackComponent: Fallback,
+        resetKeys: resetKeys,
+        children: children
+    });
+export { ErrorBoundaryWithFallback };

package/dist/registry/charts-core/map-filter-config.d.ts

@@ -0,0 +1,5 @@
+import type { z } from "zod";
+import type { BaseChartConfigurationSchema } from "./models/configurations/base-chart-configuration";
+import type { FilterValues } from "./models/filter-values";
+export type ConfigFilter = NonNullable<z.infer<typeof BaseChartConfigurationSchema>["filters"]>[number];
+export declare function mapConfigFilterToFilterValues(filter: ConfigFilter): FilterValues;

package/dist/registry/charts-core/map-filter-config.js

@@ -0,0 +1,20 @@
+function mapConfigFilterToFilterValues(filter) {
+    if ("range" === filter.type && "valueType" in filter && "datetime" === filter.valueType) return {
+        type: "period",
+        field: filter.field,
+        range: filter.range
+    };
+    if ("range" === filter.type) return {
+        type: "range",
+        field: filter.field,
+        range: filter.range
+    };
+    if ("search" === filter.type) return {
+        type: "search",
+        field: filter.field,
+        pattern: filter.pattern,
+        searchFilterType: filter.searchFilterType
+    };
+    return filter;
+}
+export { mapConfigFilterToFilterValues };

package/dist/registry/charts-core/models/configurations/bar-chart-configuration.d.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+export declare const BarChartConfigurationSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    filters: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        valueType: z.ZodLiteral<"datetime">;
+        type: z.ZodLiteral<"range">;
+        field: z.ZodString;
+        range: z.ZodObject<{
+            min: z.ZodCustom<import("luxon").DateTime<true>, import("luxon").DateTime<true>>;
+            max: z.ZodCustom<import("luxon").DateTime<true>, import("luxon").DateTime<true>>;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        valueType: z.ZodLiteral<"number">;
+        type: z.ZodLiteral<"range">;
+        field: z.ZodString;
+        range: z.ZodUnion<readonly [z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodOptional<z.ZodNumber>;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodNumber;
+            inclusive: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        valueType: z.ZodLiteral<"string">;
+        type: z.ZodLiteral<"search">;
+        field: z.ZodString;
+        pattern: z.ZodString;
+        searchFilterType: z.ZodEnum<{
+            endsWith: "endsWith";
+            startsWith: "startsWith";
+            default: "default";
+        }>;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        valueType: z.ZodLiteral<"string">;
+        type: z.ZodLiteral<"list">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        field: z.ZodString;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        valueType: z.ZodLiteral<"boolean">;
+        type: z.ZodLiteral<"list">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNull]>>;
+        field: z.ZodString;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        valueType: z.ZodLiteral<"number">;
+        type: z.ZodLiteral<"list">;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+        field: z.ZodString;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>]>]>>>;
+    joins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            INNER: "INNER";
+            LEFT: "LEFT";
+        }>;
+        entity: z.ZodString;
+        alias: z.ZodOptional<z.ZodString>;
+        on: z.ZodObject<{
+            left: z.ZodString;
+            right: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    from: z.ZodOptional<z.ZodObject<{
+        entity: z.ZodString;
+        alias: z.ZodString;
+    }, z.core.$strip>>;
+    filterTableId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"bar">;
+    dimensions: z.ZodArray<z.ZodString>;
+    metrics: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type BarChartConfiguration = z.infer<typeof BarChartConfigurationSchema>;

package/dist/registry/charts-core/models/configurations/bar-chart-configuration.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { BaseChartConfigurationSchema } from "./base-chart-configuration.js";
+const BarChartConfigurationSchema = BaseChartConfigurationSchema.extend({
+    type: z.literal("bar"),
+    dimensions: z.array(z.string()),
+    metrics: z.array(z.string())
+});
+export { BarChartConfigurationSchema };