@uipath/apollo-vertex 0.0.0-stage → 0.1.0

package/dist/registry/confidence-signal/confidence-signal.d.ts

@@ -0,0 +1,30 @@
+import * as React from "react";
+import { SignalBars } from "./confidence-signal-bars";
+import { type ConfidenceCta, type ConfidenceFactor } from "./confidence-signal-levels";
+interface ConfidenceSignalBaseProps extends Omit<React.ComponentProps<"button">, "children"> {
+    /** icon only ("min"), icon + short label ("med"), icon + full label ("max") */
+    variant?: "min" | "med" | "max";
+    /** Explanation shown on hover and in the popover. Defaults to a per-level explanation. */
+    explanation?: string;
+    /** Factor breakdown shown in the popover body. */
+    factors?: ConfidenceFactor[];
+    /** Link to an audit trail / source. Appears at any confidence level. */
+    explainCta?: ConfidenceCta;
+    /** Play the one-time "acquire" bar animation when the value first resolves. */
+    animateIn?: boolean;
+}
+export type ConfidenceSignalProps = ConfidenceSignalBaseProps & ({
+    level: "high" | "unknown";
+    nextStep?: ConfidenceCta;
+} | {
+    level: "medium" | "low";
+    nextStep: ConfidenceCta;
+});
+/**
+ * The explanation is a Tooltip so hovering stays cheap and consistent with the
+ * rest of the system. Factors and CTAs need a Popover instead: they are
+ * interactive, and a tooltip's contents are not reachable by keyboard.
+ */
+declare function ConfidenceSignal({ level, variant, explanation, factors, explainCta, nextStep, animateIn, className, ...props }: ConfidenceSignalProps): import("react/jsx-runtime").JSX.Element;
+export { ConfidenceSignal, SignalBars };
+export type { ConfidenceCta, ConfidenceFactor, ConfidenceLevel, } from "./confidence-signal-levels";

package/dist/registry/confidence-signal/confidence-signal.js

@@ -0,0 +1,107 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import { Popover, PopoverContent, PopoverTrigger } from "../popover/popover.js";
+import { Tooltip, TooltipContent, TooltipTrigger } from "../tooltip/tooltip.js";
+import { SignalBars } from "./confidence-signal-bars.js";
+import { ConfidenceSignalChip } from "./confidence-signal-chip.js";
+import { ConfidenceSignalCta } from "./confidence-signal-cta.js";
+import { ConfidenceSignalFactors } from "./confidence-signal-factors.js";
+import { LEVEL_CONFIG } from "./confidence-signal-levels.js";
+function ConfidenceSignal({ level, variant = "med", explanation, factors, explainCta, nextStep, animateIn = false, className, ...props }) {
+    const { t } = useTranslation();
+    const [tooltipOpen, setTooltipOpen] = useState(false);
+    const [detailsOpen, setDetailsOpen] = useState(false);
+    const config = LEVEL_CONFIG[level];
+    const accessibleLabel = t(config.labelKey, {
+        defaultValue: config.labelText
+    });
+    const resolvedExplanation = explanation ?? t(config.explanationKey, {
+        defaultValue: config.explanationText
+    });
+    const label = {
+        min: "",
+        med: t(config.shortLabelKey, {
+            defaultValue: config.shortLabelText
+        }),
+        max: accessibleLabel
+    }[variant];
+    const hasDetails = Boolean(factors && factors.length > 0) || Boolean(explainCta) || Boolean(nextStep);
+    const chip = /*#__PURE__*/ jsx(ConfidenceSignalChip, {
+        level: level,
+        label: label,
+        accessibleLabel: accessibleLabel,
+        animateIn: animateIn,
+        interactive: hasDetails,
+        className: className,
+        ...props
+    });
+    const tooltip = /*#__PURE__*/ jsxs(Tooltip, {
+        open: tooltipOpen && !detailsOpen,
+        onOpenChange: setTooltipOpen,
+        children: [
+            /*#__PURE__*/ jsx(TooltipTrigger, {
+                asChild: true,
+                children: hasDetails ? /*#__PURE__*/ jsx(PopoverTrigger, {
+                    asChild: true,
+                    children: chip
+                }) : chip
+            }),
+            /*#__PURE__*/ jsx(TooltipContent, {
+                className: "max-w-56",
+                children: resolvedExplanation
+            })
+        ]
+    });
+    if (!hasDetails) return tooltip;
+    const handleDetailsOpenChange = (open)=>{
+        setDetailsOpen(open);
+        if (!open) setTooltipOpen(false);
+    };
+    return /*#__PURE__*/ jsxs(Popover, {
+        open: detailsOpen,
+        onOpenChange: handleDetailsOpenChange,
+        children: [
+            tooltip,
+            /*#__PURE__*/ jsxs(PopoverContent, {
+                align: "start",
+                className: "flex w-64 flex-col gap-3",
+                children: [
+                    /*#__PURE__*/ jsxs("div", {
+                        className: "flex items-center gap-2",
+                        children: [
+                            /*#__PURE__*/ jsx("span", {
+                                className: "shrink-0 text-muted-foreground",
+                                children: /*#__PURE__*/ jsx(SignalBars, {
+                                    level: level
+                                })
+                            }),
+                            /*#__PURE__*/ jsx("span", {
+                                className: "text-sm font-medium text-foreground",
+                                children: accessibleLabel
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx("p", {
+                        className: "text-xs leading-relaxed text-muted-foreground",
+                        children: resolvedExplanation
+                    }),
+                    factors && factors.length > 0 && /*#__PURE__*/ jsx(ConfidenceSignalFactors, {
+                        factors: factors
+                    }),
+                    explainCta && /*#__PURE__*/ jsx(ConfidenceSignalCta, {
+                        cta: explainCta
+                    }),
+                    nextStep && /*#__PURE__*/ jsx("div", {
+                        className: explainCta ? "border-t border-border pt-3" : "",
+                        children: /*#__PURE__*/ jsx(ConfidenceSignalCta, {
+                            cta: nextStep
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+export { ConfidenceSignal, SignalBars };

package/dist/registry/context-menu/context-menu.d.ts

@@ -0,0 +1,25 @@
+import * as ContextMenuPrimitive from "@radix-ui/react-context-menu";
+import * as React from "react";
+declare function ContextMenu({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuTrigger({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuGroup({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuPortal({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuSub({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Sub>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuRadioGroup({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.RadioGroup>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuSubContent({ className, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.SubContent>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuContent({ className, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.CheckboxItem>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.RadioItem>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Label> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuSeparator({ className, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuShortcut({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export { ContextMenu, ContextMenuTrigger, ContextMenuContent, ContextMenuItem, ContextMenuCheckboxItem, ContextMenuRadioItem, ContextMenuLabel, ContextMenuSeparator, ContextMenuShortcut, ContextMenuGroup, ContextMenuPortal, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuRadioGroup, };

package/dist/registry/context-menu/context-menu.js

@@ -0,0 +1,141 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { CheckboxItem, Content, Group, Item, ItemIndicator, Label, Portal, RadioGroup, RadioItem, Root, Separator, Sub, SubContent, SubTrigger, Trigger } from "@radix-ui/react-context-menu";
+import { CheckIcon, ChevronRightIcon, CircleIcon } from "lucide-react";
+import "react";
+import { cn } from "../../lib/utils.js";
+function ContextMenu({ ...props }) {
+    return /*#__PURE__*/ jsx(Root, {
+        "data-slot": "context-menu",
+        ...props
+    });
+}
+function ContextMenuTrigger({ ...props }) {
+    return /*#__PURE__*/ jsx(Trigger, {
+        "data-slot": "context-menu-trigger",
+        ...props
+    });
+}
+function ContextMenuGroup({ ...props }) {
+    return /*#__PURE__*/ jsx(Group, {
+        "data-slot": "context-menu-group",
+        ...props
+    });
+}
+function ContextMenuPortal({ ...props }) {
+    return /*#__PURE__*/ jsx(Portal, {
+        "data-slot": "context-menu-portal",
+        ...props
+    });
+}
+function ContextMenuSub({ ...props }) {
+    return /*#__PURE__*/ jsx(Sub, {
+        "data-slot": "context-menu-sub",
+        ...props
+    });
+}
+function ContextMenuRadioGroup({ ...props }) {
+    return /*#__PURE__*/ jsx(RadioGroup, {
+        "data-slot": "context-menu-radio-group",
+        ...props
+    });
+}
+function ContextMenuSubTrigger({ className, inset, children, ...props }) {
+    return /*#__PURE__*/ jsxs(SubTrigger, {
+        "data-slot": "context-menu-sub-trigger",
+        "data-inset": inset,
+        className: cn("focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground flex cursor-default items-center rounded-sm px-2 py-1.5 text-sm outline-hidden select-none data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", className),
+        ...props,
+        children: [
+            children,
+            /*#__PURE__*/ jsx(ChevronRightIcon, {
+                className: "ml-auto"
+            })
+        ]
+    });
+}
+function ContextMenuSubContent({ className, ...props }) {
+    return /*#__PURE__*/ jsx(SubContent, {
+        "data-slot": "context-menu-sub-content",
+        className: cn("bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 min-w-[8rem] origin-(--radix-context-menu-content-transform-origin) overflow-hidden rounded-md border p-1 shadow-lg", className),
+        ...props
+    });
+}
+function ContextMenuContent({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Portal, {
+        children: /*#__PURE__*/ jsx(Content, {
+            "data-slot": "context-menu-content",
+            className: cn("bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 max-h-(--radix-context-menu-content-available-height) min-w-[8rem] origin-(--radix-context-menu-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border p-1 shadow-md", className),
+            ...props
+        })
+    });
+}
+function ContextMenuItem({ className, inset, variant = "default", ...props }) {
+    return /*#__PURE__*/ jsx(Item, {
+        "data-slot": "context-menu-item",
+        "data-inset": inset,
+        "data-variant": variant,
+        className: cn("focus:bg-accent focus:text-accent-foreground data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 dark:data-[variant=destructive]:focus:bg-destructive/20 data-[variant=destructive]:focus:text-destructive data-[variant=destructive]:*:[svg]:!text-destructive [&_svg:not([class*='text-'])]:text-muted-foreground relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", className),
+        ...props
+    });
+}
+function ContextMenuCheckboxItem({ className, children, checked, ...props }) {
+    return /*#__PURE__*/ jsxs(CheckboxItem, {
+        "data-slot": "context-menu-checkbox-item",
+        className: cn("focus:bg-accent focus:text-accent-foreground relative flex cursor-default items-center gap-2 rounded-sm py-1.5 pr-2 pl-8 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", className),
+        checked: checked,
+        ...props,
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                className: "pointer-events-none absolute left-2 flex size-3.5 items-center justify-center",
+                children: /*#__PURE__*/ jsx(ItemIndicator, {
+                    children: /*#__PURE__*/ jsx(CheckIcon, {
+                        className: "size-4"
+                    })
+                })
+            }),
+            children
+        ]
+    });
+}
+function ContextMenuRadioItem({ className, children, ...props }) {
+    return /*#__PURE__*/ jsxs(RadioItem, {
+        "data-slot": "context-menu-radio-item",
+        className: cn("focus:bg-accent focus:text-accent-foreground relative flex cursor-default items-center gap-2 rounded-sm py-1.5 pr-2 pl-8 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", className),
+        ...props,
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                className: "pointer-events-none absolute left-2 flex size-3.5 items-center justify-center",
+                children: /*#__PURE__*/ jsx(ItemIndicator, {
+                    children: /*#__PURE__*/ jsx(CircleIcon, {
+                        className: "size-2 fill-current"
+                    })
+                })
+            }),
+            children
+        ]
+    });
+}
+function ContextMenuLabel({ className, inset, ...props }) {
+    return /*#__PURE__*/ jsx(Label, {
+        "data-slot": "context-menu-label",
+        "data-inset": inset,
+        className: cn("text-foreground px-2 py-1.5 text-sm font-medium data-[inset]:pl-8", className),
+        ...props
+    });
+}
+function ContextMenuSeparator({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Separator, {
+        "data-slot": "context-menu-separator",
+        className: cn("bg-border -mx-1 my-1 h-px", className),
+        ...props
+    });
+}
+function ContextMenuShortcut({ className, ...props }) {
+    return /*#__PURE__*/ jsx("span", {
+        "data-slot": "context-menu-shortcut",
+        className: cn("text-muted-foreground ml-auto text-xs tracking-widest", className),
+        ...props
+    });
+}
+export { ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger };

package/dist/registry/data-fabric-adapter/adapter.d.ts

@@ -0,0 +1,8 @@
+import { type DataAdapter } from "../charts-core/charts-core";
+interface DataFabricAdapterProps {
+    baseUrl: string;
+    accessToken: string;
+    entityName: string;
+}
+export declare const dataFabricAdapter: ({ baseUrl, accessToken, entityName, }: DataFabricAdapterProps) => DataAdapter;
+export {};

package/dist/registry/data-fabric-adapter/adapter.js

@@ -0,0 +1,51 @@
+import { queryOptions } from "@tanstack/react-query";
+import { initClient } from "@ts-rest/core";
+import { z } from "zod";
+import { PrimitiveValueSchema } from "../charts-core/charts-core.js";
+import { dataFabricBarChartAdapter } from "./chart-adapters/bar.js";
+import { dataFabricDistributionChartAdapter } from "./chart-adapters/distribution.js";
+import { dataFabricKpiChartAdapter } from "./chart-adapters/kpi.js";
+import { dataFabricLineChartAdapter } from "./chart-adapters/line.js";
+import { dataFabricMultiLineChartAdapter } from "./chart-adapters/multi-line.js";
+import { dataFabricTableChartAdapter } from "./chart-adapters/table.js";
+import { dataFabricContract } from "./contract.js";
+import { dataFabricQuery } from "./utils/query.js";
+const dataFabricAdapter = ({ baseUrl, accessToken, entityName })=>{
+    const client = initClient(dataFabricContract, {
+        baseUrl,
+        baseHeaders: {
+            Authorization: `Bearer ${accessToken}`
+        }
+    });
+    return {
+        charts: {
+            table: dataFabricTableChartAdapter(client, entityName),
+            bar: dataFabricBarChartAdapter(client, entityName),
+            distribution: dataFabricDistributionChartAdapter(client, entityName),
+            line: dataFabricLineChartAdapter(client, entityName),
+            multiLine: dataFabricMultiLineChartAdapter(client, entityName),
+            kpi: dataFabricKpiChartAdapter(client, entityName)
+        },
+        filters: {
+            list: (filter)=>queryOptions({
+                    queryKey: [
+                        entityName,
+                        filter.field.id
+                    ],
+                    queryFn: async ()=>{
+                        const response = await dataFabricQuery(client, entityName, {
+                            selectedFields: [
+                                filter.field.id
+                            ],
+                            top: 1000
+                        }, "Failed to fetch filter values");
+                        const values = [
+                            ...new Set(response.value.map((row)=>row[filter.field.id]))
+                        ];
+                        return z.array(PrimitiveValueSchema).parse(values);
+                    }
+                })
+        }
+    };
+};
+export { dataFabricAdapter };

package/dist/registry/data-fabric-adapter/chart-adapters/bar.d.ts

@@ -0,0 +1,3 @@
+import { type DataAdapter } from "../../charts-core/charts-core";
+import { type DataFabricClient } from "../utils/query";
+export declare const dataFabricBarChartAdapter: (client: DataFabricClient, entityName: string) => DataAdapter["charts"]["bar"];

package/dist/registry/data-fabric-adapter/chart-adapters/bar.js

@@ -0,0 +1,46 @@
+import { queryOptions } from "@tanstack/react-query";
+import { assertDefined } from "../../../lib/asserts/assert-defined.js";
+import { mapConfigFilterToFilterValues, mapResponseToChartData } from "../../charts-core/charts-core.js";
+import { mapMetricToDataFabricAggregate } from "../utils/metric-aggregate.js";
+import { dataFabricQuery } from "../utils/query.js";
+import { createDataFabricChartQueryOptions } from "../utils/query-options.js";
+import { mapDataFabricResponseToChartData } from "../utils/response-data-mapper.js";
+const dataFabricBarChartAdapter = (client, entityName)=>(configuration, dataModel)=>{
+        const dimensionIds = configuration.dimensions;
+        const metricIds = configuration.metrics;
+        const metrics = metricIds.map((id)=>assertDefined(dataModel.metrics.find((m)=>m.id === id), `Metric ${id} not found in dataModel`));
+        const aggregates = metrics.map((m)=>mapMetricToDataFabricAggregate(m));
+        const baseRequestBody = createDataFabricChartQueryOptions({
+            selectedFields: dimensionIds,
+            sortBy: null,
+            filters: (configuration.filters ?? []).map((f)=>mapConfigFilterToFilterValues(f))
+        });
+        const requestBody = {
+            ...baseRequestBody,
+            groupBy: dimensionIds,
+            aggregates,
+            joins: configuration.joins,
+            from: configuration.from
+        };
+        return queryOptions({
+            queryKey: [
+                entityName,
+                "query",
+                JSON.stringify(requestBody)
+            ],
+            queryFn: async ()=>{
+                const body = await dataFabricQuery(client, entityName, requestBody, "Failed to fetch bar chart data");
+                const allFieldIds = [
+                    ...dimensionIds,
+                    ...aggregates.map((a)=>a.alias)
+                ];
+                const columnOriented = mapDataFabricResponseToChartData(body, allFieldIds);
+                return mapResponseToChartData({
+                    data: columnOriented,
+                    dimensions: dimensionIds,
+                    metrics: aggregates.map((a)=>a.alias)
+                });
+            }
+        });
+    };
+export { dataFabricBarChartAdapter };

package/dist/registry/data-fabric-adapter/chart-adapters/distribution.d.ts

@@ -0,0 +1,3 @@
+import { type DataAdapter } from "../../charts-core/charts-core";
+import { type DataFabricClient } from "../utils/query";
+export declare const dataFabricDistributionChartAdapter: (client: DataFabricClient, entityName: string) => DataAdapter["charts"]["distribution"];

package/dist/registry/data-fabric-adapter/chart-adapters/distribution.js

@@ -0,0 +1,131 @@
+import { queryOptions } from "@tanstack/react-query";
+import { z } from "zod";
+import { assert } from "../../../lib/asserts/assert.js";
+import { assertDefined } from "../../../lib/asserts/assert-defined.js";
+import { mapConfigFilterToFilterValues, niceNumbers } from "../../charts-core/charts-core.js";
+import { buildNumericBins, createNumericBinning } from "../utils/binning-utils.js";
+import { fetchDateBinnedData } from "../utils/fetch-date-binned-data.js";
+import { mapFilterValuesToDataFabricFilterGroup } from "../utils/filter-group.js";
+import { mapMetricToDataFabricAggregate } from "../utils/metric-aggregate.js";
+import { dataFabricQuery } from "../utils/query.js";
+const dataFabricDistributionChartAdapter = (client, entityName)=>(configuration, dataModel)=>{
+        const dimensionId = assertDefined(configuration.dimensions[0], "Distribution chart must have at least one dimension");
+        const dimension = assertDefined(dataModel.dimensions.find((d)=>d.id === dimensionId), `Dimension ${dimensionId} not found in dataModel`);
+        assert("datetime" === dimension.type || "numeric" === dimension.type, "Dimension type must be datetime or numeric");
+        const firstMetricId = assertDefined(configuration.metrics[0], "At least one metric is required");
+        const firstMetric = assertDefined(dataModel.metrics.find((m)=>m.id === firstMetricId), `Metric ${firstMetricId} not found in dataModel`);
+        const aggregate = mapMetricToDataFabricAggregate(firstMetric);
+        const filters = (configuration.filters ?? []).map((f)=>mapConfigFilterToFilterValues(f));
+        return queryOptions({
+            queryKey: [
+                entityName,
+                "distribution",
+                dimensionId,
+                JSON.stringify(filters),
+                JSON.stringify(aggregate),
+                JSON.stringify(configuration.joins),
+                JSON.stringify(configuration.from)
+            ],
+            queryFn: async ()=>{
+                if ("datetime" === dimension.type) {
+                    const result = await fetchDateBinnedData({
+                        client,
+                        entityName,
+                        dimensionId,
+                        aggregates: [
+                            aggregate
+                        ],
+                        filters,
+                        joins: configuration.joins,
+                        from: configuration.from
+                    });
+                    if (!result) return {
+                        values: [],
+                        bins: []
+                    };
+                    const values = result.rows.map((r)=>z.number().nullable().parse(r[aggregate.alias] ?? null) ?? 0);
+                    return {
+                        values,
+                        bins: result.bins
+                    };
+                }
+                const baseFilterGroup = mapFilterValuesToDataFabricFilterGroup(filters);
+                const minMaxBody = {
+                    aggregates: [
+                        {
+                            function: "MIN",
+                            field: dimensionId,
+                            alias: "min"
+                        },
+                        {
+                            function: "MAX",
+                            field: dimensionId,
+                            alias: "max"
+                        }
+                    ],
+                    filterGroup: baseFilterGroup,
+                    joins: configuration.joins,
+                    from: configuration.from
+                };
+                const minMaxBodyResult = await dataFabricQuery(client, entityName, minMaxBody, "Failed to fetch min/max");
+                const row = minMaxBodyResult.value[0];
+                const minVal = z.number().nullable().parse(row?.min ?? null);
+                const maxVal = z.number().nullable().parse(row?.max ?? null);
+                if (null == minVal || null == maxVal || minVal === maxVal) return {
+                    values: [],
+                    bins: []
+                };
+                const { binSize } = niceNumbers({
+                    min: minVal,
+                    max: maxVal
+                });
+                const existingFilters = baseFilterGroup?.queryFilters ?? [];
+                const requestBody = {
+                    selectedFields: [
+                        dimensionId
+                    ],
+                    aggregates: [
+                        aggregate
+                    ],
+                    binnings: [
+                        createNumericBinning(dimensionId, binSize)
+                    ],
+                    joins: configuration.joins,
+                    from: configuration.from,
+                    filterGroup: {
+                        logicalOperator: "and",
+                        queryFilters: [
+                            ...existingFilters,
+                            {
+                                fieldName: dimensionId,
+                                operator: ">=",
+                                value: String(minVal)
+                            },
+                            {
+                                fieldName: dimensionId,
+                                operator: "<=",
+                                value: String(maxVal)
+                            }
+                        ]
+                    },
+                    sortOptions: [
+                        {
+                            fieldName: dimensionId,
+                            isDescending: false
+                        }
+                    ],
+                    top: 1000,
+                    skip: 0
+                };
+                const dataResult = await dataFabricQuery(client, entityName, requestBody, "Failed to fetch distribution data");
+                const rows = dataResult.value;
+                const numericBinValues = rows.map((r)=>z.number().parse(r[dimensionId]));
+                const values = rows.map((r)=>z.number().nullable().parse(r[aggregate.alias] ?? null) ?? 0);
+                return {
+                    values,
+                    bins: buildNumericBins(numericBinValues, binSize)
+                };
+            }
+        });
+    };
+export { dataFabricDistributionChartAdapter };

package/dist/registry/data-fabric-adapter/chart-adapters/kpi.d.ts

@@ -0,0 +1,3 @@
+import { type DataAdapter } from "../../charts-core/charts-core";
+import { type DataFabricClient } from "../utils/query";
+export declare const dataFabricKpiChartAdapter: (client: DataFabricClient, entityName: string) => DataAdapter["charts"]["kpi"];

package/dist/registry/data-fabric-adapter/chart-adapters/kpi.js

@@ -0,0 +1,44 @@
+import { queryOptions } from "@tanstack/react-query";
+import { z } from "zod";
+import { assertDefined } from "../../../lib/asserts/assert-defined.js";
+import { mapConfigFilterToFilterValues } from "../../charts-core/charts-core.js";
+import { mapMetricToDataFabricAggregate } from "../utils/metric-aggregate.js";
+import { dataFabricQuery } from "../utils/query.js";
+import { createDataFabricChartQueryOptions } from "../utils/query-options.js";
+const dataFabricKpiChartAdapter = (client, entityName)=>(configuration, dataModel)=>{
+        const firstMetricId = assertDefined(configuration.metrics[0], "KPI chart must have at least one metric");
+        const firstMetric = assertDefined(dataModel.metrics.find((m)=>m.id === firstMetricId), `Metric ${firstMetricId} not found in dataModel`);
+        const aggregate = mapMetricToDataFabricAggregate(firstMetric);
+        const baseRequestBody = createDataFabricChartQueryOptions({
+            selectedFields: [],
+            sortBy: null,
+            filters: (configuration.filters ?? []).map((f)=>mapConfigFilterToFilterValues(f))
+        });
+        const { selectedFields: _ignored, ...rest } = baseRequestBody;
+        const requestBody = {
+            ...rest,
+            aggregates: [
+                aggregate
+            ],
+            joins: configuration.joins,
+            from: configuration.from
+        };
+        return queryOptions({
+            queryKey: [
+                entityName,
+                "kpi",
+                JSON.stringify(requestBody)
+            ],
+            queryFn: async ()=>{
+                const body = await dataFabricQuery(client, entityName, requestBody, "Failed to fetch KPI data");
+                const value = z.number().nullable().parse(body.value[0]?.[aggregate.alias] ?? null) ?? 0;
+                return {
+                    data: [
+                        value
+                    ],
+                    labels: []
+                };
+            }
+        });
+    };
+export { dataFabricKpiChartAdapter };

package/dist/registry/data-fabric-adapter/chart-adapters/line.d.ts

@@ -0,0 +1,3 @@
+import { type DataAdapter } from "../../charts-core/charts-core";
+import type { DataFabricClient } from "../utils/query";
+export declare const dataFabricLineChartAdapter: (client: DataFabricClient, entityName: string) => DataAdapter["charts"]["line"];