@uipath/apollo-vertex 0.0.0-stage → 0.3.0

package/dist/registry/form-wizard/use-form-wizard.js

@@ -0,0 +1,82 @@
+"use client";
+import { useLocalStorage } from "@mantine/hooks";
+import { revalidateLogic } from "@tanstack/react-form";
+import { useSelector } from "@tanstack/react-store";
+import { useEffect, useMemo, useState } from "react";
+import { useAppForm } from "../form/index.js";
+import { getVisibleSteps } from "./wizard-schema.js";
+function useFormWizard({ formOptions, schema, steps, persist, onSubmit }) {
+    const persistKey = persist?.key ?? "";
+    const [persisted, setPersisted, removePersisted] = useLocalStorage({
+        key: persistKey,
+        getInitialValueInEffect: false
+    });
+    const [initial] = useState(persistKey ? persisted : null);
+    const [currentStepId, setCurrentStepId] = useState(()=>initial?.stepId ?? steps[0]?.id ?? "");
+    const form = useAppForm({
+        ...formOptions,
+        defaultValues: initial?.values ?? formOptions.defaultValues,
+        validationLogic: revalidateLogic(),
+        validators: {
+            onDynamic: schema
+        },
+        onSubmit: async ({ value })=>{
+            await onSubmit(value);
+            if (persistKey) removePersisted();
+        }
+    });
+    const values = useSelector(form.store, (state)=>state.values);
+    const visibleSteps = useMemo(()=>getVisibleSteps(steps, values), [
+        steps,
+        values
+    ]);
+    const foundIndex = visibleSteps.findIndex((s)=>s.id === currentStepId);
+    const stepIndex = -1 === foundIndex ? 0 : foundIndex;
+    const currentStep = visibleSteps[stepIndex];
+    const activeStepId = currentStep?.id ?? currentStepId;
+    const isFirst = 0 === stepIndex;
+    const isLast = stepIndex === visibleSteps.length - 1;
+    const progress = visibleSteps.length > 0 ? (stepIndex + 1) / visibleSteps.length * 100 : 0;
+    const next = ()=>{
+        const nextStep = visibleSteps[stepIndex + 1];
+        if (nextStep) setCurrentStepId(nextStep.id);
+        else form.handleSubmit();
+    };
+    const back = ()=>{
+        const previous = visibleSteps[stepIndex - 1];
+        if (previous) setCurrentStepId(previous.id);
+    };
+    const goToStep = (id)=>setCurrentStepId(id);
+    const reset = ()=>{
+        form.reset();
+        if (persistKey) removePersisted();
+        setCurrentStepId(steps[0]?.id ?? "");
+    };
+    useEffect(()=>{
+        if (persistKey) setPersisted({
+            values,
+            stepId: activeStepId
+        });
+    }, [
+        persistKey,
+        setPersisted,
+        values,
+        activeStepId
+    ]);
+    return {
+        form,
+        steps: visibleSteps,
+        currentStep,
+        currentStepId: activeStepId,
+        stepIndex,
+        stepCount: visibleSteps.length,
+        isFirst,
+        isLast,
+        progress,
+        next,
+        back,
+        goToStep,
+        reset
+    };
+}
+export { useFormWizard };

package/dist/registry/form-wizard/wizard-schema.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from "react";
+export interface WizardStepDef<TValues> {
+    id: string;
+    title: ReactNode;
+    description?: ReactNode;
+    condition?: (values: TValues) => boolean;
+    optional?: boolean;
+}
+export declare function getVisibleSteps<TValues>(steps: ReadonlyArray<WizardStepDef<TValues>>, values: TValues): Array<WizardStepDef<TValues>>;

package/dist/registry/form-wizard/wizard-schema.js

@@ -0,0 +1,4 @@
+function getVisibleSteps(steps, values) {
+    return steps.filter((step)=>step.condition?.(values) ?? true);
+}
+export { getVisibleSteps };

package/dist/registry/hover-card/hover-card.d.ts

@@ -0,0 +1,6 @@
+import * as HoverCardPrimitive from "@radix-ui/react-hover-card";
+import * as React from "react";
+declare function HoverCard({ ...props }: React.ComponentProps<typeof HoverCardPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function HoverCardTrigger({ ...props }: React.ComponentProps<typeof HoverCardPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function HoverCardContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof HoverCardPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { HoverCard, HoverCardTrigger, HoverCardContent };

package/dist/registry/hover-card/hover-card.js

@@ -0,0 +1,30 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { Content, Portal, Root, Trigger } from "@radix-ui/react-hover-card";
+import "react";
+import { cn } from "../../lib/utils.js";
+function HoverCard({ ...props }) {
+    return /*#__PURE__*/ jsx(Root, {
+        "data-slot": "hover-card",
+        ...props
+    });
+}
+function HoverCardTrigger({ ...props }) {
+    return /*#__PURE__*/ jsx(Trigger, {
+        "data-slot": "hover-card-trigger",
+        ...props
+    });
+}
+function HoverCardContent({ className, align = "center", sideOffset = 4, ...props }) {
+    return /*#__PURE__*/ jsx(Portal, {
+        "data-slot": "hover-card-portal",
+        children: /*#__PURE__*/ jsx(Content, {
+            "data-slot": "hover-card-content",
+            align: align,
+            sideOffset: sideOffset,
+            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 w-64 origin-(--radix-hover-card-content-transform-origin) rounded-md border p-4 shadow-md outline-hidden", className),
+            ...props
+        })
+    });
+}
+export { HoverCard, HoverCardContent, HoverCardTrigger };

package/dist/registry/input/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Input({ className, type, ...props }: React.ComponentProps<"input">): import("react/jsx-runtime").JSX.Element;
+export { Input };

package/dist/registry/input/input.js

@@ -0,0 +1,12 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { cn } from "../../lib/utils.js";
+function Input({ className, type, ...props }) {
+    return /*#__PURE__*/ jsx("input", {
+        type: type,
+        "data-slot": "input",
+        className: cn("file:text-foreground placeholder:text-muted-foreground selection:bg-primary selection:text-primary-foreground dark:bg-input/30 border-input h-9 w-full min-w-0 rounded-lg border bg-background px-3 py-1 text-base transition-[color,box-shadow] outline-none file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm", "focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]", "aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive", className),
+        ...props
+    });
+}
+export { Input };

package/dist/registry/input-group/input-group.d.ts

@@ -0,0 +1,16 @@
+import { type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+import { Button } from "../button/button";
+declare function InputGroup({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare const inputGroupAddonVariants: (props?: ({
+    align?: "inline-end" | "inline-start" | "block-end" | "block-start" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function InputGroupAddon({ className, align, ...props }: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>): import("react/jsx-runtime").JSX.Element;
+declare const inputGroupButtonVariants: (props?: ({
+    size?: "sm" | "icon-xs" | "icon-sm" | "xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function InputGroupButton({ className, type, variant, size, ...props }: Omit<React.ComponentProps<typeof Button>, "size"> & VariantProps<typeof inputGroupButtonVariants>): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupText({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupInput({ className, ...props }: React.ComponentProps<"input">): import("react/jsx-runtime").JSX.Element;
+declare function InputGroupTextarea({ className, ...props }: React.ComponentProps<"textarea">): import("react/jsx-runtime").JSX.Element;
+export { InputGroup, InputGroupAddon, InputGroupButton, InputGroupText, InputGroupInput, InputGroupTextarea, };

package/dist/registry/input-group/input-group.js

@@ -0,0 +1,88 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { Button } from "../button/button.js";
+import { Input } from "../input/input.js";
+import { Textarea } from "../textarea/textarea.js";
+import { cn } from "../../lib/utils.js";
+function InputGroup({ className, ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        "data-slot": "input-group",
+        role: "group",
+        className: cn("group/input-group border-input dark:bg-input/30 relative flex w-full items-center rounded-md border shadow-xs transition-[color,box-shadow] outline-none", "h-9 min-w-0 has-[>textarea]:h-auto", "has-[>[data-align=inline-start]]:[&>input]:pl-2", "has-[>[data-align=inline-end]]:[&>input]:pr-2", "has-[>[data-align=block-start]]:h-auto has-[>[data-align=block-start]]:flex-col has-[>[data-align=block-start]]:[&>input]:pb-3", "has-[>[data-align=block-end]]:h-auto has-[>[data-align=block-end]]:flex-col has-[>[data-align=block-end]]:[&>input]:pt-3", "has-[[data-slot=input-group-control]:focus-visible]:border-ring has-[[data-slot=input-group-control]:focus-visible]:ring-ring/50 has-[[data-slot=input-group-control]:focus-visible]:ring-[3px]", "has-[[data-slot][aria-invalid=true]]:ring-destructive/20 has-[[data-slot][aria-invalid=true]]:border-destructive dark:has-[[data-slot][aria-invalid=true]]:ring-destructive/40", className),
+        ...props
+    });
+}
+const inputGroupAddonVariants = cva("text-muted-foreground flex h-auto cursor-text items-center justify-center gap-2 py-1.5 text-sm font-medium select-none [&>svg:not([class*='size-'])]:size-4 [&>kbd]:rounded-[calc(var(--radius)-5px)] group-data-[disabled=true]/input-group:opacity-50", {
+    variants: {
+        align: {
+            "inline-start": "order-first pl-3 has-[>button]:ml-[-0.45rem] has-[>kbd]:ml-[-0.35rem]",
+            "inline-end": "order-last pr-3 has-[>button]:mr-[-0.45rem] has-[>kbd]:mr-[-0.35rem]",
+            "block-start": "order-first w-full justify-start px-3 pt-3 [.border-b]:pb-3 group-has-[>input]/input-group:pt-2.5",
+            "block-end": "order-last w-full justify-start px-3 pb-3 [.border-t]:pt-3 group-has-[>input]/input-group:pb-2.5"
+        }
+    },
+    defaultVariants: {
+        align: "inline-start"
+    }
+});
+function InputGroupAddon({ className, align = "inline-start", ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        role: "group",
+        "data-slot": "input-group-addon",
+        "data-align": align,
+        className: cn(inputGroupAddonVariants({
+            align
+        }), className),
+        onClick: (e)=>{
+            if (e.target instanceof HTMLElement && e.target.closest("button")) return;
+            e.currentTarget.parentElement?.querySelector("input")?.focus();
+        },
+        ...props
+    });
+}
+const inputGroupButtonVariants = cva("text-sm shadow-none flex gap-2 items-center", {
+    variants: {
+        size: {
+            xs: "h-6 gap-1 px-2 rounded-[calc(var(--radius)-5px)] [&>svg:not([class*='size-'])]:size-3.5 has-[>svg]:px-2",
+            sm: "h-8 px-2.5 gap-1.5 rounded-md has-[>svg]:px-2.5",
+            "icon-xs": "size-6 rounded-[calc(var(--radius)-5px)] p-0 has-[>svg]:p-0",
+            "icon-sm": "size-8 p-0 has-[>svg]:p-0"
+        }
+    },
+    defaultVariants: {
+        size: "xs"
+    }
+});
+function InputGroupButton({ className, type = "button", variant = "ghost", size = "xs", ...props }) {
+    return /*#__PURE__*/ jsx(Button, {
+        type: type,
+        "data-size": size,
+        variant: variant,
+        className: cn(inputGroupButtonVariants({
+            size
+        }), className),
+        ...props
+    });
+}
+function InputGroupText({ className, ...props }) {
+    return /*#__PURE__*/ jsx("span", {
+        className: cn("text-muted-foreground flex items-center gap-2 text-sm [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4", className),
+        ...props
+    });
+}
+function InputGroupInput({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Input, {
+        "data-slot": "input-group-control",
+        className: cn("flex-1 rounded-none border-0 bg-transparent shadow-none focus-visible:ring-0 dark:bg-transparent", className),
+        ...props
+    });
+}
+function InputGroupTextarea({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Textarea, {
+        "data-slot": "input-group-control",
+        className: cn("flex-1 resize-none rounded-none border-0 bg-transparent py-3 shadow-none focus-visible:ring-0 dark:bg-transparent", className),
+        ...props
+    });
+}
+export { InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput, InputGroupText, InputGroupTextarea };

package/dist/registry/input-otp/input-otp.d.ts

@@ -0,0 +1,11 @@
+import { OTPInput } from "input-otp";
+import * as React from "react";
+declare function InputOTP({ className, containerClassName, ...props }: React.ComponentProps<typeof OTPInput> & {
+    containerClassName?: string;
+}): import("react/jsx-runtime").JSX.Element;
+declare function InputOTPGroup({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function InputOTPSlot({ index, className, ...props }: React.ComponentProps<"div"> & {
+    index: number;
+}): import("react/jsx-runtime").JSX.Element;
+declare function InputOTPSeparator({ ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator };

package/dist/registry/input-otp/input-otp.js

@@ -0,0 +1,49 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { OTPInput, OTPInputContext } from "input-otp";
+import { MinusIcon } from "lucide-react";
+import { useContext } from "react";
+import { cn } from "../../lib/utils.js";
+function InputOTP({ className, containerClassName, ...props }) {
+    return /*#__PURE__*/ jsx(OTPInput, {
+        "data-slot": "input-otp",
+        containerClassName: cn("flex items-center gap-2 has-disabled:opacity-50", containerClassName),
+        className: cn("disabled:cursor-not-allowed", className),
+        ...props
+    });
+}
+function InputOTPGroup({ className, ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        "data-slot": "input-otp-group",
+        className: cn("flex items-center", className),
+        ...props
+    });
+}
+function InputOTPSlot({ index, className, ...props }) {
+    const inputOTPContext = useContext(OTPInputContext);
+    const { char, hasFakeCaret, isActive } = inputOTPContext?.slots[index] ?? {};
+    return /*#__PURE__*/ jsxs("div", {
+        "data-slot": "input-otp-slot",
+        "data-active": isActive,
+        className: cn("data-[active=true]:border-ring data-[active=true]:ring-ring/50 data-[active=true]:aria-invalid:ring-destructive/20 dark:data-[active=true]:aria-invalid:ring-destructive/40 aria-invalid:border-destructive data-[active=true]:aria-invalid:border-destructive dark:bg-input/30 border-input relative flex h-9 w-9 items-center justify-center border-y border-r text-sm shadow-xs transition-all outline-none first:rounded-l-md first:border-l last:rounded-r-md data-[active=true]:z-10 data-[active=true]:ring-[3px]", className),
+        ...props,
+        children: [
+            char,
+            hasFakeCaret && /*#__PURE__*/ jsx("div", {
+                className: "pointer-events-none absolute inset-0 flex items-center justify-center",
+                children: /*#__PURE__*/ jsx("div", {
+                    className: "animate-caret-blink bg-foreground h-4 w-px duration-1000"
+                })
+            })
+        ]
+    });
+}
+function InputOTPSeparator({ ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        "data-slot": "input-otp-separator",
+        role: "separator",
+        ...props,
+        children: /*#__PURE__*/ jsx(MinusIcon, {})
+    });
+}
+export { InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot };

package/dist/registry/insights-adapter/adapter.d.ts

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

package/dist/registry/insights-adapter/adapter.js

@@ -0,0 +1,50 @@
+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 { insightsBarChartAdapter } from "./chart-adapters/bar.js";
+import { insightsDistributionChartAdapter } from "./chart-adapters/distribution.js";
+import { insightsKpiChartAdapter } from "./chart-adapters/kpi.js";
+import { insightsLineChartAdapter } from "./chart-adapters/line.js";
+import { insightsMultiLineChartAdapter } from "./chart-adapters/multi-line.js";
+import { insightsTableChartAdapter } from "./chart-adapters/table.js";
+import { insightsContract } from "./contract.js";
+import { insightsQuery } from "./utils/query.js";
+const insightsAdapter = ({ baseUrl, accessToken, sourceType })=>{
+    const client = initClient(insightsContract, {
+        baseUrl,
+        baseHeaders: {
+            Authorization: `Bearer ${accessToken}`
+        }
+    });
+    return {
+        charts: {
+            table: insightsTableChartAdapter(client, sourceType),
+            bar: insightsBarChartAdapter(client, sourceType),
+            distribution: insightsDistributionChartAdapter(client, sourceType),
+            line: insightsLineChartAdapter(client, sourceType),
+            multiLine: insightsMultiLineChartAdapter(client, sourceType),
+            kpi: insightsKpiChartAdapter(client, sourceType)
+        },
+        filters: {
+            list: (filter)=>queryOptions({
+                    queryKey: [
+                        sourceType,
+                        filter.field.id
+                    ],
+                    queryFn: async ()=>{
+                        const response = await insightsQuery(client, sourceType, {
+                            filters: [],
+                            groupBy: [
+                                filter.field.id
+                            ],
+                            aggregates: []
+                        }, "Failed to fetch filter values");
+                        const values = response[filter.field.id]?.values ?? [];
+                        return z.array(PrimitiveValueSchema).parse(values);
+                    }
+                })
+        }
+    };
+};
+export { insightsAdapter };

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

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

package/dist/registry/insights-adapter/chart-adapters/bar.js

@@ -0,0 +1,36 @@
+import { queryOptions } from "@tanstack/react-query";
+import { assertDefined } from "../../../lib/asserts/assert-defined.js";
+import { mapConfigFilterToFilterValues, mapResponseToChartData } from "../../charts-core/charts-core.js";
+import { assertInsightsConfigurationSupported } from "../utils/assert-configuration-supported.js";
+import { mapMetricToInsightsAggregate } from "../utils/metric-aggregate.js";
+import { insightsQuery } from "../utils/query.js";
+import { createInsightsChartQueryOptions } from "../utils/query-options.js";
+const insightsBarChartAdapter = (client, sourceType)=>(configuration, dataModel)=>{
+        assertInsightsConfigurationSupported(configuration);
+        const dimensionIds = configuration.dimensions;
+        const metrics = configuration.metrics.map((id)=>assertDefined(dataModel.metrics.find((m)=>m.id === id), `Metric ${id} not found in dataModel`));
+        const aggregates = metrics.map((m)=>mapMetricToInsightsAggregate(m));
+        const requestBody = createInsightsChartQueryOptions({
+            groupBy: dimensionIds,
+            aggregates,
+            sortBy: null,
+            filters: (configuration.filters ?? []).map((f)=>mapConfigFilterToFilterValues(f)),
+            filterTableId: configuration.filterTableId
+        });
+        return queryOptions({
+            queryKey: [
+                sourceType,
+                "bar",
+                JSON.stringify(requestBody)
+            ],
+            queryFn: async ()=>{
+                const body = await insightsQuery(client, sourceType, requestBody, "Failed to fetch bar chart data");
+                return mapResponseToChartData({
+                    data: body,
+                    dimensions: dimensionIds,
+                    metrics: aggregates.map((a)=>a.id)
+                });
+            }
+        });
+    };
+export { insightsBarChartAdapter };

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

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

package/dist/registry/insights-adapter/chart-adapters/distribution.js

@@ -0,0 +1,107 @@
+import { queryOptions } from "@tanstack/react-query";
+import { DateTime } from "luxon";
+import { z } from "zod";
+import { assert } from "../../../lib/asserts/assert.js";
+import { assertDefined } from "../../../lib/asserts/assert-defined.js";
+import { mapConfigFilterToFilterValues } from "../../charts-core/charts-core.js";
+import { assertInsightsConfigurationSupported } from "../utils/assert-configuration-supported.js";
+import { calculateDatetimeBins, calculateNumericBins, findBinCutoffPoints } from "../utils/binning.js";
+import { mapMetricToInsightsAggregate } from "../utils/metric-aggregate.js";
+import { insightsQuery } from "../utils/query.js";
+import { createInsightsChartQueryOptions } from "../utils/query-options.js";
+const insightsDistributionChartAdapter = (client, sourceType)=>(configuration, dataModel)=>{
+        assertInsightsConfigurationSupported(configuration);
+        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], "Distribution 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 = mapMetricToInsightsAggregate(firstMetric);
+        const filters = (configuration.filters ?? []).map((f)=>mapConfigFilterToFilterValues(f));
+        const filterTableId = configuration.filterTableId;
+        const minMaxRequest = createInsightsChartQueryOptions({
+            groupBy: [],
+            aggregates: [
+                {
+                    id: "min",
+                    expression: {
+                        type: "aggregate",
+                        aggregation: "MIN",
+                        argument: dimensionId
+                    }
+                },
+                {
+                    id: "max",
+                    expression: {
+                        type: "aggregate",
+                        aggregation: "MAX",
+                        argument: dimensionId
+                    }
+                }
+            ],
+            sortBy: null,
+            filters,
+            filterTableId
+        });
+        return queryOptions({
+            queryKey: [
+                sourceType,
+                "distribution",
+                JSON.stringify(minMaxRequest),
+                JSON.stringify(aggregate)
+            ],
+            queryFn: async ()=>{
+                const response = await insightsQuery(client, sourceType, minMaxRequest, "Failed to fetch min/max");
+                const bins = "datetime" === dimension.type ? (()=>{
+                    const minStr = z.string().nullable().parse(response.min?.values?.[0] ?? null);
+                    const maxStr = z.string().nullable().parse(response.max?.values?.[0] ?? null);
+                    if (!minStr || !maxStr) return null;
+                    return calculateDatetimeBins({
+                        min: DateTime.fromISO(minStr, {
+                            zone: "utc"
+                        }),
+                        max: DateTime.fromISO(maxStr, {
+                            zone: "utc"
+                        })
+                    });
+                })() : (()=>{
+                    const minNum = z.number().nullable().parse(response.min?.values?.[0] ?? null);
+                    const maxNum = z.number().nullable().parse(response.max?.values?.[0] ?? null);
+                    if (null == minNum || null == maxNum) return null;
+                    return calculateNumericBins({
+                        min: minNum,
+                        max: maxNum
+                    });
+                })();
+                if (!bins) return {
+                    values: [],
+                    bins: []
+                };
+                const cutoffPoints = findBinCutoffPoints(bins);
+                if (0 === cutoffPoints.length) return {
+                    values: [],
+                    bins: []
+                };
+                const binsRequest = createInsightsChartQueryOptions({
+                    groupBy: [],
+                    aggregates: [
+                        aggregate
+                    ],
+                    sortBy: null,
+                    filters,
+                    filterTableId,
+                    binning: {
+                        bins: cutoffPoints,
+                        dimension: dimensionId
+                    }
+                });
+                const dataResponse = await insightsQuery(client, sourceType, binsRequest, "Failed to fetch distribution data");
+                const values = dataResponse[aggregate.id]?.values?.map((value)=>z.number().nullable().parse(value) ?? 0) ?? [];
+                return {
+                    values,
+                    bins
+                };
+            }
+        });
+    };
+export { insightsDistributionChartAdapter };

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

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

package/dist/registry/insights-adapter/chart-adapters/kpi.js

@@ -0,0 +1,41 @@
+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 { assertInsightsConfigurationSupported } from "../utils/assert-configuration-supported.js";
+import { mapMetricToInsightsAggregate } from "../utils/metric-aggregate.js";
+import { insightsQuery } from "../utils/query.js";
+import { createInsightsChartQueryOptions } from "../utils/query-options.js";
+const insightsKpiChartAdapter = (client, sourceType)=>(configuration, dataModel)=>{
+        assertInsightsConfigurationSupported(configuration);
+        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 = mapMetricToInsightsAggregate(firstMetric);
+        const requestBody = createInsightsChartQueryOptions({
+            groupBy: [],
+            aggregates: [
+                aggregate
+            ],
+            sortBy: null,
+            filters: (configuration.filters ?? []).map((f)=>mapConfigFilterToFilterValues(f)),
+            filterTableId: configuration.filterTableId
+        });
+        return queryOptions({
+            queryKey: [
+                sourceType,
+                "kpi",
+                JSON.stringify(requestBody)
+            ],
+            queryFn: async ()=>{
+                const body = await insightsQuery(client, sourceType, requestBody, "Failed to fetch KPI data");
+                const value = z.number().nullable().parse(body[aggregate.id]?.values?.[0] ?? null) ?? 0;
+                return {
+                    data: [
+                        value
+                    ],
+                    labels: []
+                };
+            }
+        });
+    };
+export { insightsKpiChartAdapter };

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

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