@uipath/apollo-vertex 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,62 @@
+import { Interval } from "luxon";
+import { niceDurationNumbers, niceNumbers } from "../../charts-core/charts-core.js";
+function findHighestUnit(duration) {
+    if (duration.years > 0) return "year";
+    if (duration.months > 0) return "month";
+    if (duration.days > 0) return "day";
+    if (duration.hours > 0) return "hour";
+    if (duration.minutes > 0) return "minute";
+    if (duration.seconds > 0) return "second";
+    return "millisecond";
+}
+function createDatetimeBins({ start, end, highestUnit, bestBinSize }) {
+    const bins = [];
+    let currentStart = start;
+    let currentEnd = currentStart.startOf(highestUnit).plus(bestBinSize);
+    while(currentEnd < end){
+        bins.push(Interval.fromDateTimes(currentStart, currentEnd));
+        currentStart = currentEnd;
+        currentEnd = currentStart.plus(bestBinSize);
+    }
+    bins.push(Interval.fromDateTimes(currentStart, end));
+    return bins;
+}
+function calculateDatetimeBins({ min, max }) {
+    if (min.equals(max)) return [
+        Interval.fromDateTimes(min, max)
+    ];
+    const bestBinSize = niceDurationNumbers({
+        min,
+        max
+    });
+    const highestUnit = findHighestUnit(bestBinSize);
+    return createDatetimeBins({
+        start: min,
+        end: max,
+        highestUnit,
+        bestBinSize
+    });
+}
+function calculateNumericBins({ min, max }) {
+    if (min === max) return [
+        {
+            start: min,
+            end: max
+        }
+    ];
+    const { min: niceMin, binSize } = niceNumbers({
+        min,
+        max
+    });
+    const binCount = Math.ceil((max - niceMin) / binSize);
+    return Array.from({
+        length: binCount
+    }, (_, idx)=>({
+            start: niceMin + binSize * idx,
+            end: niceMin + binSize * (idx + 1)
+        }));
+}
+function findBinCutoffPoints(bins) {
+    return bins.filter((_, idx)=>idx < bins.length - 1).map(({ end })=>"number" == typeof end ? end : end.toMillis());
+}
+export { calculateDatetimeBins, calculateNumericBins, findBinCutoffPoints };

package/dist/registry/insights-adapter/utils/filter-request.d.ts

@@ -0,0 +1,5 @@
+import type { FilterValues } from "../../charts-core/charts-core";
+import type { FilterFragment } from "../schemas/filter-fragment-schema";
+import type { FilterRequest } from "../schemas/filter-request-schema";
+export declare function mapFilterValuesToFragments(filterValues: FilterValues[]): FilterFragment[];
+export declare function mapFilterValuesToFilterRequest(filterValues: FilterValues[], filterTableId?: string): FilterRequest[][];

package/dist/registry/insights-adapter/utils/filter-request.js

@@ -0,0 +1,67 @@
+function mapFilterValueToFragment(filterValue) {
+    switch(filterValue.type){
+        case "list":
+            return {
+                values: filterValue.values,
+                kind: "values",
+                dimension: filterValue.field,
+                type: "number" === filterValue.valueType ? "numeric" : filterValue.valueType,
+                invert: filterValue.invert ?? false
+            };
+        case "search":
+            return {
+                pattern: filterValue.pattern,
+                filterType: filterValue.searchFilterType,
+                kind: "search",
+                dimension: filterValue.field,
+                type: "string",
+                invert: false
+            };
+        case "period":
+            return {
+                kind: "range",
+                dimension: filterValue.field,
+                type: "datetime",
+                range: {
+                    inclusive: filterValue.range.inclusive ?? false,
+                    start: filterValue.range.min.toISO() ?? "",
+                    end: filterValue.range.max.toISO() ?? ""
+                }
+            };
+        case "range":
+            return {
+                kind: "range",
+                dimension: filterValue.field,
+                type: "numeric",
+                range: {
+                    inclusive: filterValue.range.inclusive ?? false,
+                    ...null != filterValue.range.min && {
+                        start: filterValue.range.min
+                    },
+                    ...null != filterValue.range.max && {
+                        end: filterValue.range.max
+                    }
+                }
+            };
+    }
+}
+function mapFilterValuesToFragments(filterValues) {
+    return filterValues.map((f)=>mapFilterValueToFragment(f));
+}
+function mapFilterValuesToFilterRequest(filterValues, filterTableId) {
+    const filters = mapFilterValuesToFragments(filterValues);
+    if (0 === filters.length) return [];
+    if (!filterTableId) return [
+        filters
+    ];
+    return [
+        [
+            {
+                kind: "tableWith",
+                table: filterTableId,
+                filters
+            }
+        ]
+    ];
+}
+export { mapFilterValuesToFilterRequest, mapFilterValuesToFragments };

package/dist/registry/insights-adapter/utils/metric-aggregate.d.ts

@@ -0,0 +1,3 @@
+import type { DataModelMetric } from "../../charts-core/charts-core";
+import type { AggregateFragment } from "../schemas/aggregate-fragment-schema";
+export declare function mapMetricToInsightsAggregate(metric: DataModelMetric): AggregateFragment;

package/dist/registry/insights-adapter/utils/metric-aggregate.js

@@ -0,0 +1,17 @@
+import { mapFilterValuesToFragments } from "./filter-request.js";
+function mapMetricToInsightsAggregate(metric) {
+    const expr = metric.expression;
+    const hasFilters = null != expr.filters && expr.filters.length > 0;
+    return {
+        id: metric.id,
+        expression: {
+            type: "aggregate",
+            aggregation: expr.aggregation,
+            argument: expr.argument.id,
+            ...hasFilters && expr.filters && {
+                filters: mapFilterValuesToFragments(expr.filters)
+            }
+        }
+    };
+}
+export { mapMetricToInsightsAggregate };

package/dist/registry/insights-adapter/utils/query-options.d.ts

@@ -0,0 +1,19 @@
+import type { FilterValues } from "../../charts-core/charts-core";
+import type { AggregateFragment } from "../schemas/aggregate-fragment-schema";
+import type { InsightsQueryRequest } from "../schemas/query-schema";
+interface InsightsChartQueryOptions {
+    groupBy: string[];
+    aggregates?: AggregateFragment[];
+    sortBy: {
+        field: string;
+        direction: "asc" | "desc";
+    } | null;
+    filters?: FilterValues[];
+    filterTableId?: string;
+    binning?: {
+        dimension: string;
+        bins: number[];
+    };
+}
+export declare function createInsightsChartQueryOptions({ groupBy, aggregates, sortBy, filters, filterTableId, binning, }: InsightsChartQueryOptions): InsightsQueryRequest;
+export {};

package/dist/registry/insights-adapter/utils/query-options.js

@@ -0,0 +1,22 @@
+import { mapFilterValuesToFilterRequest } from "./filter-request.js";
+function createInsightsChartQueryOptions({ groupBy, aggregates = [], sortBy, filters = [], filterTableId, binning }) {
+    return {
+        filters: mapFilterValuesToFilterRequest(filters, filterTableId),
+        groupBy,
+        aggregates,
+        ...binning && {
+            binning: {
+                bins: binning.bins,
+                dimension: binning.dimension,
+                extraBins: "none"
+            }
+        },
+        sort: sortBy ? [
+            {
+                field: sortBy.field,
+                direction: sortBy.direction
+            }
+        ] : []
+    };
+}
+export { createInsightsChartQueryOptions };

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

@@ -0,0 +1,8 @@
+import type { InitClientReturn } from "@ts-rest/core";
+import type { DataQueryResponse } from "../../charts-core/charts-core";
+import type { insightsContract } from "../contract";
+import type { InsightsQueryRequest } from "../schemas/query-schema";
+export type InsightsClient = InitClientReturn<typeof insightsContract, {
+    baseUrl: string;
+}>;
+export declare function insightsQuery(client: InsightsClient, sourceType: string, body: InsightsQueryRequest, errorMessage: string): Promise<DataQueryResponse>;

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

@@ -0,0 +1,12 @@
+import { throwInsightsError } from "./throw-error.js";
+async function insightsQuery(client, sourceType, body, errorMessage) {
+    const result = await client.query({
+        params: {
+            sourceType
+        },
+        body
+    });
+    if (200 !== result.status) throwInsightsError(result, errorMessage);
+    return result.body;
+}
+export { insightsQuery };

package/dist/registry/insights-adapter/utils/throw-error.d.ts

@@ -0,0 +1,6 @@
+export declare function throwInsightsError(result: {
+    status: 400;
+    body: {
+        error: string;
+    };
+}, fallback: string): never;

package/dist/registry/insights-adapter/utils/throw-error.js

@@ -0,0 +1,4 @@
+function throwInsightsError(result, fallback) {
+    throw new Error(result.body.error || fallback);
+}
+export { throwInsightsError };

package/dist/registry/item/item.d.ts

@@ -0,0 +1,23 @@
+import { type VariantProps } from "class-variance-authority";
+import type * as React from "react";
+import { Separator } from "../separator/separator";
+declare function ItemGroup({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function ItemSeparator({ className, ...props }: React.ComponentProps<typeof Separator>): import("react/jsx-runtime").JSX.Element;
+declare const itemVariants: (props?: ({
+    variant?: "outline" | "default" | "muted" | null | undefined;
+    size?: "default" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Item({ className, variant, size, asChild, ...props }: React.ComponentProps<"div"> & VariantProps<typeof itemVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare const itemMediaVariants: (props?: ({
+    variant?: "image" | "default" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function ItemMedia({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof itemMediaVariants>): import("react/jsx-runtime").JSX.Element;
+declare function ItemContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function ItemTitle({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function ItemDescription({ className, ...props }: React.ComponentProps<"p">): import("react/jsx-runtime").JSX.Element;
+declare function ItemActions({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function ItemHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function ItemFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Item, ItemMedia, ItemContent, ItemActions, ItemGroup, ItemSeparator, ItemTitle, ItemDescription, ItemHeader, ItemFooter, };

package/dist/registry/item/item.js

@@ -0,0 +1,118 @@
+import { jsx } from "react/jsx-runtime";
+import { Slot } from "@radix-ui/react-slot";
+import { cva } from "class-variance-authority";
+import { Separator } from "../separator/separator.js";
+import { cn } from "../../lib/utils.js";
+function ItemGroup({ className, ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        role: "list",
+        "data-slot": "item-group",
+        className: cn("group/item-group flex flex-col", className),
+        ...props
+    });
+}
+function ItemSeparator({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Separator, {
+        "data-slot": "item-separator",
+        orientation: "horizontal",
+        className: cn("my-0", className),
+        ...props
+    });
+}
+const itemVariants = cva("group/item flex items-center border border-transparent text-sm rounded-md transition-colors [a]:hover:bg-accent/50 [a]:transition-colors duration-100 flex-wrap outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]", {
+    variants: {
+        variant: {
+            default: "bg-transparent",
+            outline: "border-border",
+            muted: "bg-muted/50"
+        },
+        size: {
+            default: "p-4 gap-4 ",
+            sm: "py-3 px-4 gap-2.5"
+        }
+    },
+    defaultVariants: {
+        variant: "default",
+        size: "default"
+    }
+});
+function Item({ className, variant = "default", size = "default", asChild = false, ...props }) {
+    const Comp = asChild ? Slot : "div";
+    return /*#__PURE__*/ jsx(Comp, {
+        "data-slot": "item",
+        "data-variant": variant,
+        "data-size": size,
+        className: cn(itemVariants({
+            variant,
+            size,
+            className
+        })),
+        ...props
+    });
+}
+const itemMediaVariants = cva("flex shrink-0 items-center justify-center gap-2 group-has-[[data-slot=item-description]]/item:self-start [&_svg]:pointer-events-none group-has-[[data-slot=item-description]]/item:translate-y-0.5", {
+    variants: {
+        variant: {
+            default: "bg-transparent",
+            icon: "size-8 border rounded-sm bg-muted [&_svg:not([class*='size-'])]:size-4",
+            image: "size-10 rounded-sm overflow-hidden [&_img]:size-full [&_img]:object-cover"
+        }
+    },
+    defaultVariants: {
+        variant: "default"
+    }
+});
+function ItemMedia({ className, variant = "default", ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        "data-slot": "item-media",
+        "data-variant": variant,
+        className: cn(itemMediaVariants({
+            variant,
+            className
+        })),
+        ...props
+    });
+}
+function ItemContent({ className, ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        "data-slot": "item-content",
+        className: cn("flex flex-1 flex-col gap-1 [&+[data-slot=item-content]]:flex-none", className),
+        ...props
+    });
+}
+function ItemTitle({ className, ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        "data-slot": "item-title",
+        className: cn("flex w-fit items-center gap-2 text-sm leading-snug font-medium", className),
+        ...props
+    });
+}
+function ItemDescription({ className, ...props }) {
+    return /*#__PURE__*/ jsx("p", {
+        "data-slot": "item-description",
+        className: cn("text-muted-foreground line-clamp-2 text-sm leading-normal font-normal text-balance", "[&>a:hover]:text-primary [&>a]:underline [&>a]:underline-offset-4", className),
+        ...props
+    });
+}
+function ItemActions({ className, ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        "data-slot": "item-actions",
+        className: cn("flex items-center gap-2", className),
+        ...props
+    });
+}
+function ItemHeader({ className, ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        "data-slot": "item-header",
+        className: cn("flex basis-full items-center justify-between gap-2", className),
+        ...props
+    });
+}
+function ItemFooter({ className, ...props }) {
+    return /*#__PURE__*/ jsx("div", {
+        "data-slot": "item-footer",
+        className: cn("flex basis-full items-center justify-between gap-2", className),
+        ...props
+    });
+}
+export { Item, ItemActions, ItemContent, ItemDescription, ItemFooter, ItemGroup, ItemHeader, ItemMedia, ItemSeparator, ItemTitle };

package/dist/registry/kbd/kbd.d.ts

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

package/dist/registry/kbd/kbd.js

@@ -0,0 +1,17 @@
+import { jsx } from "react/jsx-runtime";
+import { cn } from "../../lib/utils.js";
+function Kbd({ className, ...props }) {
+    return /*#__PURE__*/ jsx("kbd", {
+        "data-slot": "kbd",
+        className: cn("bg-muted text-muted-foreground pointer-events-none inline-flex h-5 w-fit min-w-5 items-center justify-center gap-1 rounded-sm px-1 font-sans text-xs font-medium select-none", "[&_svg:not([class*='size-'])]:size-3", "[[data-slot=tooltip-content]_&]:bg-background/20 [[data-slot=tooltip-content]_&]:text-background dark:[[data-slot=tooltip-content]_&]:bg-background/10", className),
+        ...props
+    });
+}
+function KbdGroup({ className, ...props }) {
+    return /*#__PURE__*/ jsx("kbd", {
+        "data-slot": "kbd-group",
+        className: cn("inline-flex items-center gap-1", className),
+        ...props
+    });
+}
+export { Kbd, KbdGroup };

package/dist/registry/kpi-chart/kpi-chart-view.d.ts

@@ -0,0 +1,5 @@
+export interface KpiChartProps {
+    label: string;
+    value: string;
+}
+export declare function KpiChart({ label, value }: KpiChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/registry/kpi-chart/kpi-chart-view.js

@@ -0,0 +1,20 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+function KpiChart({ label, value }) {
+    return /*#__PURE__*/ jsxs("div", {
+        className: "flex h-full w-full flex-col items-stretch justify-between p-10",
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                className: "text-left text-base font-semibold text-foreground",
+                children: label
+            }),
+            /*#__PURE__*/ jsx("div", {
+                className: "flex justify-end",
+                children: /*#__PURE__*/ jsx("span", {
+                    className: "text-3xl font-semibold tabular-nums text-foreground",
+                    children: value
+                })
+            })
+        ]
+    });
+}
+export { KpiChart };

package/dist/registry/kpi-chart/kpi-chart-with-adapter.d.ts

@@ -0,0 +1,7 @@
+import { type DataAdapter, type KpiChartConfiguration, type KpiDataModel } from "../charts-core/charts-core";
+export interface KpiChartWithAdapterProps {
+    configuration: KpiChartConfiguration;
+    dataModel: KpiDataModel;
+    dataAdapter: DataAdapter;
+}
+export declare function KpiChartWithAdapter({ configuration, dataModel, dataAdapter, }: KpiChartWithAdapterProps): import("react/jsx-runtime").JSX.Element;

package/dist/registry/kpi-chart/kpi-chart-with-adapter.js

@@ -0,0 +1,42 @@
+import { jsx } from "react/jsx-runtime";
+import { useIsFetching, useSuspenseQuery } from "@tanstack/react-query";
+import { useDeferredValue } from "react";
+import { useTranslation } from "react-i18next";
+import { assertNumber } from "../../lib/asserts/assert-number.js";
+import { ChartLoadingBoundary, SpinnerWithChildren, formatMetricValue } from "../charts-core/charts-core.js";
+import { KpiChart } from "./kpi-chart-view.js";
+function KpiChartWithAdapter({ configuration, dataModel, dataAdapter }) {
+    return /*#__PURE__*/ jsx(ChartLoadingBoundary, {
+        configuration: configuration,
+        dataModel: dataModel,
+        children: /*#__PURE__*/ jsx(KpiChartResolver, {
+            configuration: configuration,
+            dataModel: dataModel,
+            dataAdapter: dataAdapter
+        })
+    });
+}
+function KpiChartResolver({ configuration, dataModel, dataAdapter }) {
+    const { i18n: { language } } = useTranslation();
+    const deferrableProps = useDeferredValue({
+        configuration,
+        dataModel
+    });
+    const query = dataAdapter.charts.kpi(configuration, dataModel);
+    const deferredQuery = dataAdapter.charts.kpi(deferrableProps.configuration, deferrableProps.dataModel);
+    const isFetching = useIsFetching(query) > 0;
+    const data = useSuspenseQuery(deferredQuery).data;
+    const metricId = configuration.metrics[0];
+    const metric = metricId ? dataModel.metrics.find((m)=>m.id === metricId) : null;
+    const rawValue = Array.isArray(data.data) ? data.data[0] : data.data;
+    const numericValue = null == rawValue ? 0 : assertNumber(rawValue, "KPI numeric value");
+    const valueText = metric ? formatMetricValue(language, numericValue, metric.expression) : "";
+    return /*#__PURE__*/ jsx(SpinnerWithChildren, {
+        loading: isFetching,
+        children: /*#__PURE__*/ jsx(KpiChart, {
+            label: metric?.display ?? "",
+            value: valueText
+        })
+    });
+}
+export { KpiChartWithAdapter };

package/dist/registry/kpi-chart/kpi-chart.d.ts

@@ -0,0 +1,2 @@
+export { KpiChart, type KpiChartProps } from "./kpi-chart-view";
+export { KpiChartWithAdapter, type KpiChartWithAdapterProps, } from "./kpi-chart-with-adapter";

package/dist/registry/kpi-chart/kpi-chart.js

@@ -0,0 +1,3 @@
+import { KpiChart } from "./kpi-chart-view.js";
+import { KpiChartWithAdapter } from "./kpi-chart-with-adapter.js";
+export { KpiChart, KpiChartWithAdapter };

package/dist/registry/label/label.d.ts

@@ -0,0 +1,4 @@
+import * as LabelPrimitive from "@radix-ui/react-label";
+import * as React from "react";
+declare function Label({ className, ...props }: React.ComponentProps<typeof LabelPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Label };

package/dist/registry/label/label.js

@@ -0,0 +1,13 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { Root } from "@radix-ui/react-label";
+import "react";
+import { cn } from "../../lib/utils.js";
+function Label({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Root, {
+        "data-slot": "label",
+        className: cn("flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50", className),
+        ...props
+    });
+}
+export { Label };

package/dist/registry/line-chart/line-chart-view.d.ts

@@ -0,0 +1,10 @@
+export interface LineChartProps {
+    data: Array<{
+        x: string;
+        y: number;
+    }>;
+    seriesLabel: string;
+    formatValue: (value: number) => string;
+    color?: string;
+}
+export declare function LineChart({ data, seriesLabel, formatValue, color, }: LineChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/registry/line-chart/line-chart-view.js

@@ -0,0 +1,90 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Line, LineChart, XAxis, YAxis } from "recharts";
+import { ChartContainer, ChartTooltip, ChartTooltipContent } from "../chart/chart.js";
+function line_chart_view_LineChart({ data, seriesLabel, formatValue, color = "var(--color-primary)" }) {
+    const config = {
+        y: {
+            label: seriesLabel,
+            color
+        }
+    };
+    return /*#__PURE__*/ jsx(ChartContainer, {
+        config: config,
+        className: "aspect-auto h-full w-full",
+        children: /*#__PURE__*/ jsxs(LineChart, {
+            data: data,
+            margin: {
+                top: 16,
+                right: 16,
+                bottom: 16,
+                left: 0
+            },
+            children: [
+                /*#__PURE__*/ jsx(XAxis, {
+                    dataKey: "x",
+                    tickLine: false,
+                    tickMargin: 8,
+                    minTickGap: 32,
+                    axisLine: true,
+                    tick: {
+                        fontSize: 12
+                    }
+                }),
+                /*#__PURE__*/ jsx(YAxis, {
+                    type: "number",
+                    domain: [
+                        "auto",
+                        "auto"
+                    ],
+                    tickLine: false,
+                    axisLine: false,
+                    tickFormatter: (value)=>formatValue(Number(value)),
+                    tick: {
+                        fontSize: 14
+                    }
+                }),
+                /*#__PURE__*/ jsx(ChartTooltip, {
+                    content: /*#__PURE__*/ jsx(ChartTooltipContent, {
+                        className: "w-[200px] border-0",
+                        nameKey: "y",
+                        labelFormatter: String,
+                        formatter: (value)=>/*#__PURE__*/ jsxs("div", {
+                                className: "flex w-full flex-wrap gap-2 items-center",
+                                children: [
+                                    /*#__PURE__*/ jsx("div", {
+                                        className: "shrink-0 rounded-[2px] border h-2.5 w-2.5",
+                                        style: {
+                                            backgroundColor: color,
+                                            borderColor: color
+                                        }
+                                    }),
+                                    /*#__PURE__*/ jsxs("div", {
+                                        className: "flex flex-1 justify-between leading-none items-center",
+                                        children: [
+                                            /*#__PURE__*/ jsx("span", {
+                                                className: "text-muted-foreground",
+                                                children: seriesLabel
+                                            }),
+                                            /*#__PURE__*/ jsx("span", {
+                                                className: "text-foreground font-mono font-medium tabular-nums",
+                                                children: formatValue(Number(value))
+                                            })
+                                        ]
+                                    })
+                                ]
+                            })
+                    })
+                }),
+                /*#__PURE__*/ jsx(Line, {
+                    type: "monotone",
+                    dataKey: "y",
+                    name: seriesLabel,
+                    stroke: color,
+                    strokeWidth: 2,
+                    dot: false
+                })
+            ]
+        })
+    });
+}
+export { line_chart_view_LineChart as LineChart };

package/dist/registry/line-chart/line-chart-with-adapter.d.ts

@@ -0,0 +1,7 @@
+import { type ChartDataModel, type DataAdapter, type DatetimeModelField, type LineChartConfiguration } from "../charts-core/charts-core";
+export interface LineChartWithAdapterProps {
+    configuration: LineChartConfiguration;
+    dataModel: ChartDataModel<DatetimeModelField>;
+    dataAdapter: DataAdapter;
+}
+export declare function LineChartWithAdapter({ configuration, dataModel, dataAdapter, }: LineChartWithAdapterProps): import("react/jsx-runtime").JSX.Element;