@uipath/apollo-vertex 0.0.0-stage → 0.3.0

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

@@ -0,0 +1,48 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { Item, Root } from "@radix-ui/react-toggle-group";
+import { createContext, useContext } from "react";
+import { toggleVariants } from "../toggle/toggle.js";
+import { cn } from "../../lib/utils.js";
+const ToggleGroupContext = /*#__PURE__*/ createContext({
+    size: "default",
+    variant: "default",
+    spacing: 0
+});
+function ToggleGroup({ className, variant, size, spacing = 0, children, ...props }) {
+    return /*#__PURE__*/ jsx(Root, {
+        "data-slot": "toggle-group",
+        "data-variant": variant,
+        "data-size": size,
+        "data-spacing": spacing,
+        style: {
+            "--gap": spacing
+        },
+        className: cn("group/toggle-group flex w-fit items-center gap-[--spacing(var(--gap))] rounded-md data-[spacing=default]:data-[variant=outline]:shadow-xs", className),
+        ...props,
+        children: /*#__PURE__*/ jsx(ToggleGroupContext.Provider, {
+            value: {
+                variant,
+                size,
+                spacing
+            },
+            children: children
+        })
+    });
+}
+function ToggleGroupItem({ className, children, variant, size, ...props }) {
+    const context = useContext(ToggleGroupContext);
+    return /*#__PURE__*/ jsx(Item, {
+        "data-slot": "toggle-group-item",
+        "data-variant": context.variant ?? variant,
+        "data-size": context.size ?? size,
+        "data-spacing": context.spacing,
+        className: cn(toggleVariants({
+            variant: context.variant ?? variant,
+            size: context.size ?? size
+        }), "w-auto min-w-0 shrink-0 px-3 focus:z-10 focus-visible:z-10", "data-[spacing=0]:rounded-none data-[spacing=0]:shadow-none data-[spacing=0]:first:rounded-l-md data-[spacing=0]:last:rounded-r-md data-[spacing=0]:data-[variant=outline]:border-l-0 data-[spacing=0]:data-[variant=outline]:first:border-l", className),
+        ...props,
+        children: children
+    });
+}
+export { ToggleGroup, ToggleGroupItem };

package/dist/registry/tooltip/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import * as React from "react";
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/registry/tooltip/tooltip.js

@@ -0,0 +1,43 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Arrow, Content, Portal, Provider, Root, Trigger } from "@radix-ui/react-tooltip";
+import "react";
+import { cn } from "../../lib/utils.js";
+function TooltipProvider({ delayDuration = 0, ...props }) {
+    return /*#__PURE__*/ jsx(Provider, {
+        "data-slot": "tooltip-provider",
+        delayDuration: delayDuration,
+        ...props
+    });
+}
+function Tooltip({ ...props }) {
+    return /*#__PURE__*/ jsx(TooltipProvider, {
+        children: /*#__PURE__*/ jsx(Root, {
+            "data-slot": "tooltip",
+            ...props
+        })
+    });
+}
+function TooltipTrigger({ ...props }) {
+    return /*#__PURE__*/ jsx(Trigger, {
+        "data-slot": "tooltip-trigger",
+        ...props
+    });
+}
+function TooltipContent({ className, sideOffset = 0, children, ...props }) {
+    return /*#__PURE__*/ jsx(Portal, {
+        children: /*#__PURE__*/ jsxs(Content, {
+            "data-slot": "tooltip-content",
+            sideOffset: sideOffset,
+            className: cn("bg-foreground text-background animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-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-fit origin-(--radix-tooltip-content-transform-origin) rounded-md px-3 py-1.5 text-xs text-balance", className),
+            ...props,
+            children: [
+                children,
+                /*#__PURE__*/ jsx(Arrow, {
+                    className: "bg-foreground fill-foreground z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px]"
+                })
+            ]
+        })
+    });
+}
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/dist/registry/use-data-table/types.d.ts

@@ -0,0 +1,26 @@
+import type { ColumnDef } from "@tanstack/react-table";
+export type EntityRecord = Record<string, unknown>;
+export type ColumnDefWithAccessorKey<T> = ColumnDef<T> & {
+    accessorKey: string;
+};
+export interface Column {
+    key: string;
+    label: string;
+}
+export interface VssEntity {
+    id?: string;
+    name: string;
+    fields: Array<{
+        isHiddenField: boolean;
+        name: string;
+        displayName: string;
+        fieldDataType: {
+            name: string;
+        };
+    }>;
+}
+export interface ExtraColumn<TRecord extends EntityRecord = EntityRecord> {
+    column: Column;
+    position: "start" | "end";
+    definition: ColumnDefWithAccessorKey<TRecord>;
+}

package/dist/registry/use-data-table/useColumnVisibility.d.ts

@@ -0,0 +1,10 @@
+import type { OnChangeFn, VisibilityState } from "@tanstack/react-table";
+export interface UseColumnVisibilityOptions {
+    storageKey: string;
+    allColumnKeys: string[];
+    defaultVisibleColumns: string[];
+}
+export declare function useColumnVisibility({ storageKey, allColumnKeys, defaultVisibleColumns, }: UseColumnVisibilityOptions): {
+    columnVisibility: VisibilityState;
+    onColumnVisibilityChange: OnChangeFn<VisibilityState>;
+};

package/dist/registry/use-data-table/useColumnVisibility.js

@@ -0,0 +1,25 @@
+"use client";
+import { usePersistedColumns } from "./usePersistedColumns.js";
+const visibleColumnsToVisibilityState = (visibleColumns, allColumnKeys)=>{
+    const state = {};
+    for (const key of allColumnKeys)if (!visibleColumns.includes(key)) state[key] = false;
+    return state;
+};
+const visibilityStateToVisibleColumns = (visibilityState, allColumnKeys)=>allColumnKeys.filter((key)=>false !== visibilityState[key]);
+function useColumnVisibility({ storageKey, allColumnKeys, defaultVisibleColumns }) {
+    const [visibleColumns, setVisibleColumns] = usePersistedColumns({
+        storageKey,
+        defaultColumns: defaultVisibleColumns,
+        availableColumns: allColumnKeys
+    });
+    const columnVisibility = visibleColumnsToVisibilityState(visibleColumns, allColumnKeys);
+    const onColumnVisibilityChange = (updaterOrValue)=>{
+        const newVisibility = "function" == typeof updaterOrValue ? updaterOrValue(columnVisibility) : updaterOrValue;
+        setVisibleColumns(visibilityStateToVisibleColumns(newVisibility, allColumnKeys));
+    };
+    return {
+        columnVisibility,
+        onColumnVisibilityChange
+    };
+}
+export { useColumnVisibility };

package/dist/registry/use-data-table/useDataTable.d.ts

@@ -0,0 +1,28 @@
+import type { ColumnDef, ColumnFiltersState, RowSelectionState } from "@tanstack/react-table";
+export interface UseDataTableOptions<TData> {
+    data: TData[];
+    columns: ColumnDef<TData>[];
+    isLoading?: boolean;
+    storageKey: string;
+    defaultColumnOrder?: string[];
+    defaultVisibleColumns?: string[];
+}
+export declare function useDataTable<TData>({ data, columns, isLoading, storageKey, defaultColumnOrder: defaultColumnOrderProp, defaultVisibleColumns: defaultVisibleColumnsProp, }: UseDataTableOptions<TData>): {
+    data: TData[];
+    isLoading: boolean;
+    columns: ColumnDef<TData>[];
+    sorting: import("@tanstack/react-table").SortingState;
+    onSortingChange: import("@tanstack/react-table").OnChangeFn<import("@tanstack/react-table").SortingState>;
+    columnVisibility: import("@tanstack/react-table").VisibilityState;
+    onColumnVisibilityChange: import("@tanstack/react-table").OnChangeFn<import("@tanstack/react-table").VisibilityState>;
+    columnOrder: string[];
+    onColumnOrderChange: import("@tanstack/react-table").OnChangeFn<string[]>;
+    columnFilters: ColumnFiltersState;
+    onColumnFiltersChange: import("react").Dispatch<import("react").SetStateAction<ColumnFiltersState>>;
+    rowSelection: RowSelectionState;
+    onRowSelectionChange: import("react").Dispatch<import("react").SetStateAction<RowSelectionState>>;
+    globalFilter: string;
+    onGlobalFilterChange: import("react").Dispatch<import("react").SetStateAction<string>>;
+    pagination: import("@tanstack/react-table").PaginationState;
+    onPaginationChange: import("@tanstack/react-table").OnChangeFn<import("@tanstack/react-table").PaginationState>;
+};

package/dist/registry/use-data-table/useDataTable.js

@@ -0,0 +1,49 @@
+"use client";
+import { useState } from "react";
+import { useColumnVisibility } from "./useColumnVisibility.js";
+import { usePersistedColumnOrder } from "./usePersistedColumnOrder.js";
+import { usePersistedPageSize } from "./usePersistedPageSize.js";
+import { usePersistedSorting } from "./usePersistedSorting.js";
+function useDataTable({ data, columns, isLoading = false, storageKey, defaultColumnOrder: defaultColumnOrderProp, defaultVisibleColumns: defaultVisibleColumnsProp }) {
+    const allColumnKeys = columns.map((col)=>"accessorKey" in col ? col.accessorKey : col.id).filter((key)=>null != key);
+    const defaultColumnOrder = defaultColumnOrderProp ?? allColumnKeys;
+    const defaultVisibleColumns = defaultVisibleColumnsProp ?? allColumnKeys;
+    const { columnVisibility, onColumnVisibilityChange } = useColumnVisibility({
+        storageKey,
+        allColumnKeys,
+        defaultVisibleColumns
+    });
+    const { sorting, onSortingChange } = usePersistedSorting({
+        storageKey
+    });
+    const { columnOrder, onColumnOrderChange } = usePersistedColumnOrder({
+        storageKey,
+        defaultColumnOrder
+    });
+    const [columnFilters, setColumnFilters] = useState([]);
+    const [rowSelection, setRowSelection] = useState({});
+    const [globalFilter, setGlobalFilter] = useState("");
+    const { pagination, onPaginationChange } = usePersistedPageSize({
+        storageKey
+    });
+    return {
+        data,
+        isLoading,
+        columns,
+        sorting,
+        onSortingChange,
+        columnVisibility,
+        onColumnVisibilityChange,
+        columnOrder,
+        onColumnOrderChange,
+        columnFilters,
+        onColumnFiltersChange: setColumnFilters,
+        rowSelection,
+        onRowSelectionChange: setRowSelection,
+        globalFilter,
+        onGlobalFilterChange: setGlobalFilter,
+        pagination,
+        onPaginationChange
+    };
+}
+export { useDataTable };

package/dist/registry/use-data-table/useEntityColumns.d.ts

@@ -0,0 +1,14 @@
+import type { ColumnDef } from "@tanstack/react-table";
+import type { Column, ColumnDefWithAccessorKey, EntityRecord, ExtraColumn, VssEntity } from "./types";
+export interface UseEntityColumnsOptions<TRecord extends EntityRecord = EntityRecord> {
+    entity: VssEntity;
+    systemFields?: string[];
+    columnOrder?: string[];
+    extraColumns?: ExtraColumn<TRecord>[];
+    columnOverrides?: Record<string, (baseDef: ColumnDefWithAccessorKey<TRecord>) => ColumnDefWithAccessorKey<TRecord>>;
+}
+export declare function useEntityColumns<TRecord extends EntityRecord = EntityRecord>({ entity, systemFields, columnOrder: columnOrderProp, extraColumns, columnOverrides, }: UseEntityColumnsOptions<TRecord>): {
+    allColumns: Column[];
+    allColumnKeys: string[];
+    columns: ColumnDef<TRecord>[];
+};

package/dist/registry/use-data-table/useEntityColumns.js

@@ -0,0 +1,69 @@
+import { jsx } from "react/jsx-runtime";
+import { DataTableColumnHeader } from "../data-table/index.js";
+import { FORMAT_TYPE_MAP } from "../../lib/constants.js";
+import { renderValueOrEmptyState } from "../../lib/renderValueOrEmptyState.js";
+function mergeExtraColumns(columns, extraColumns) {
+    if (!extraColumns || 0 === extraColumns.length) return columns;
+    const start = extraColumns.filter((ec)=>"start" === ec.position).map((ec)=>ec.column);
+    const end = extraColumns.filter((ec)=>"end" === ec.position).map((ec)=>ec.column);
+    return [
+        ...start,
+        ...columns,
+        ...end
+    ];
+}
+function useEntityColumns({ entity, systemFields = [
+    "Id"
+], columnOrder: columnOrderProp, extraColumns, columnOverrides }) {
+    const visibleFields = entity.fields?.filter((field)=>!field.isHiddenField && !systemFields.includes(field.name)) ?? [];
+    const baseColumns = visibleFields.map((field)=>({
+            key: field.name,
+            label: field.displayName
+        }));
+    const orderedColumns = columnOrderProp && columnOrderProp.length > 0 ? [
+        ...columnOrderProp.map((key)=>baseColumns.find((col)=>col.key === key)).filter((col)=>null != col),
+        ...baseColumns.filter((col)=>!columnOrderProp.includes(col.key))
+    ] : baseColumns;
+    const allColumns = mergeExtraColumns(orderedColumns, extraColumns);
+    const allColumnKeys = allColumns.map((col)=>col.key);
+    const baseDefs = entity.fields?.filter((field)=>!field.isHiddenField && !systemFields.includes(field.name)).map((field)=>{
+        const accessorKey = field.name;
+        const formatType = FORMAT_TYPE_MAP[field.fieldDataType.name];
+        const formatValue = formatType ? (value)=>renderValueOrEmptyState(value, {
+                type: formatType
+            }) : (value)=>renderValueOrEmptyState(value);
+        return {
+            accessorKey,
+            enableColumnFilter: true,
+            header: ({ column })=>/*#__PURE__*/ jsx(DataTableColumnHeader, {
+                    column: column,
+                    title: field.displayName
+                }),
+            meta: {
+                displayName: field.displayName,
+                ...formatType ? {
+                    getFilterValue: formatValue
+                } : {}
+            },
+            cell: ({ getValue })=>/*#__PURE__*/ jsx("div", {
+                    className: "max-w-[200px] truncate",
+                    children: formatValue(getValue())
+                })
+        };
+    }) ?? [];
+    const overriddenDefs = columnOverrides ? baseDefs.map((def)=>{
+        const override = columnOverrides[def.accessorKey];
+        return override ? override(def) : def;
+    }) : baseDefs;
+    const extraDefs = extraColumns?.map((ec)=>ec.definition) ?? [];
+    const columns = [
+        ...overriddenDefs,
+        ...extraDefs
+    ];
+    return {
+        allColumns,
+        allColumnKeys,
+        columns
+    };
+}
+export { useEntityColumns };

package/dist/registry/use-data-table/useEntityDataTable.d.ts

@@ -0,0 +1,30 @@
+import type { ColumnFiltersState, RowSelectionState } from "@tanstack/react-table";
+import type { ColumnDefWithAccessorKey, EntityRecord, ExtraColumn, VssEntity } from "./types";
+export interface UseEntityDataTableOptions<TRecord extends EntityRecord = EntityRecord> {
+    entity: VssEntity;
+    storageKey?: string;
+    systemFields?: string[];
+    columnOrder?: string[];
+    initialVisibleColumnCount?: number;
+    extraColumns?: ExtraColumn<TRecord>[];
+    columnOverrides?: Record<string, (baseDef: ColumnDefWithAccessorKey<TRecord>) => ColumnDefWithAccessorKey<TRecord>>;
+}
+export declare function useEntityDataTable<TRecord extends EntityRecord = EntityRecord>({ entity, storageKey: storageKeyProp, initialVisibleColumnCount, systemFields, columnOrder: columnOrderProp, extraColumns, columnOverrides, }: UseEntityDataTableOptions<TRecord>): {
+    data: Record<string, unknown>[];
+    isLoading: boolean;
+    columns: import("@tanstack/react-table").ColumnDef<TRecord>[];
+    sorting: import("@tanstack/react-table").SortingState;
+    onSortingChange: import("@tanstack/react-table").OnChangeFn<import("@tanstack/react-table").SortingState>;
+    columnVisibility: import("@tanstack/react-table").VisibilityState;
+    onColumnVisibilityChange: import("@tanstack/react-table").OnChangeFn<import("@tanstack/react-table").VisibilityState>;
+    columnOrder: string[];
+    onColumnOrderChange: import("@tanstack/react-table").OnChangeFn<string[]>;
+    columnFilters: ColumnFiltersState;
+    onColumnFiltersChange: import("react").Dispatch<import("react").SetStateAction<ColumnFiltersState>>;
+    rowSelection: RowSelectionState;
+    onRowSelectionChange: import("react").Dispatch<import("react").SetStateAction<RowSelectionState>>;
+    globalFilter: string;
+    onGlobalFilterChange: (val: string | ((prevState: string) => string)) => void;
+    pagination: import("@tanstack/react-table").PaginationState;
+    onPaginationChange: import("@tanstack/react-table").OnChangeFn<import("@tanstack/react-table").PaginationState>;
+};

package/dist/registry/use-data-table/useEntityDataTable.js

@@ -0,0 +1,71 @@
+"use client";
+import { useLiveQuery } from "@tanstack/react-db";
+import { useSolution } from "@uipath/vs-core";
+import { useState } from "react";
+import { ENTITY_TABLE_STORAGE_PREFIX } from "../../lib/constants.js";
+import { useLocalStorage } from "@mantine/hooks";
+import { useColumnVisibility } from "./useColumnVisibility.js";
+import { useEntityColumns } from "./useEntityColumns.js";
+import { usePersistedColumnOrder } from "./usePersistedColumnOrder.js";
+import { usePersistedPageSize } from "./usePersistedPageSize.js";
+import { usePersistedSorting } from "./usePersistedSorting.js";
+function useEntityDataTable({ entity, storageKey: storageKeyProp, initialVisibleColumnCount = 8, systemFields = [
+    "Id"
+], columnOrder: columnOrderProp, extraColumns, columnOverrides }) {
+    const solution = useSolution();
+    const collection = solution?.api.collections.entities[entity.name];
+    const storageKey = storageKeyProp ?? `entity-${entity.name ?? entity.id}`;
+    const { data = [], isLoading } = useLiveQuery((q)=>q.from({
+            entities: collection
+        }));
+    const { allColumns, allColumnKeys, columns } = useEntityColumns({
+        entity,
+        systemFields,
+        columnOrder: columnOrderProp,
+        extraColumns,
+        columnOverrides
+    });
+    const defaultVisibleColumns = columnOrderProp && columnOrderProp.length > 0 ? columnOrderProp.filter((key)=>allColumns.some((col)=>col.key === key)) : allColumns.slice(0, initialVisibleColumnCount).map((col)=>col.key);
+    const { columnVisibility, onColumnVisibilityChange } = useColumnVisibility({
+        storageKey,
+        allColumnKeys,
+        defaultVisibleColumns
+    });
+    const { sorting, onSortingChange } = usePersistedSorting({
+        storageKey
+    });
+    const defaultColumnOrder = allColumns.map((col)=>col.key);
+    const { columnOrder, onColumnOrderChange } = usePersistedColumnOrder({
+        storageKey,
+        defaultColumnOrder
+    });
+    const [columnSearchTerm, setColumnSearchTerm] = useState([]);
+    const [rowSelection, setRowSelection] = useState({});
+    const [globalFilter, setGlobalFilter] = useLocalStorage({
+        key: `${ENTITY_TABLE_STORAGE_PREFIX}global-filter-${storageKey}`,
+        defaultValue: ""
+    });
+    const { pagination, onPaginationChange } = usePersistedPageSize({
+        storageKey
+    });
+    return {
+        data,
+        isLoading,
+        columns,
+        sorting,
+        onSortingChange,
+        columnVisibility,
+        onColumnVisibilityChange,
+        columnOrder,
+        onColumnOrderChange,
+        columnFilters: columnSearchTerm,
+        onColumnFiltersChange: setColumnSearchTerm,
+        rowSelection,
+        onRowSelectionChange: setRowSelection,
+        globalFilter,
+        onGlobalFilterChange: setGlobalFilter,
+        pagination,
+        onPaginationChange
+    };
+}
+export { useEntityDataTable };

package/dist/registry/use-data-table/usePersistedColumnOrder.d.ts

@@ -0,0 +1,9 @@
+import type { OnChangeFn } from "@tanstack/react-table";
+export interface UsePersistedColumnOrderOptions {
+    storageKey: string;
+    defaultColumnOrder: string[];
+}
+export declare function usePersistedColumnOrder({ storageKey, defaultColumnOrder, }: UsePersistedColumnOrderOptions): {
+    columnOrder: string[];
+    onColumnOrderChange: OnChangeFn<string[]>;
+};

package/dist/registry/use-data-table/usePersistedColumnOrder.js

@@ -0,0 +1,18 @@
+"use client";
+import { ENTITY_TABLE_STORAGE_PREFIX } from "../../lib/constants.js";
+import { useLocalStorage } from "@mantine/hooks";
+function usePersistedColumnOrder({ storageKey, defaultColumnOrder }) {
+    const [columnOrder, setColumnOrder] = useLocalStorage({
+        key: `${ENTITY_TABLE_STORAGE_PREFIX}order-${storageKey}`,
+        defaultValue: defaultColumnOrder
+    });
+    const onColumnOrderChange = (updaterOrValue)=>{
+        const newOrder = "function" == typeof updaterOrValue ? updaterOrValue(columnOrder) : updaterOrValue;
+        setColumnOrder(newOrder);
+    };
+    return {
+        columnOrder,
+        onColumnOrderChange
+    };
+}
+export { usePersistedColumnOrder };

package/dist/registry/use-data-table/usePersistedColumns.d.ts

@@ -0,0 +1,6 @@
+export interface UsePersistedColumnsProps {
+    storageKey: string;
+    defaultColumns: string[];
+    availableColumns?: string[];
+}
+export declare function usePersistedColumns({ storageKey, defaultColumns, availableColumns, }: UsePersistedColumnsProps): [string[], (columns: string[]) => void];

package/dist/registry/use-data-table/usePersistedColumns.js

@@ -0,0 +1,16 @@
+"use client";
+import { useLocalStorage } from "@mantine/hooks";
+import { ENTITY_TABLE_COLUMNS_STORAGE_PREFIX } from "../../lib/constants.js";
+function usePersistedColumns({ storageKey, defaultColumns, availableColumns }) {
+    const fullKey = `${ENTITY_TABLE_COLUMNS_STORAGE_PREFIX}${storageKey}`;
+    const [rawColumns, setRawColumns] = useLocalStorage({
+        key: fullKey,
+        defaultValue: defaultColumns
+    });
+    const visibleColumns = availableColumns ? rawColumns.filter((key)=>availableColumns.includes(key)) : rawColumns;
+    return [
+        visibleColumns,
+        setRawColumns
+    ];
+}
+export { usePersistedColumns };

package/dist/registry/use-data-table/usePersistedPageSize.d.ts

@@ -0,0 +1,8 @@
+import type { OnChangeFn, PaginationState } from "@tanstack/react-table";
+export interface UsePersistedPageSizeOptions {
+    storageKey: string;
+}
+export declare function usePersistedPageSize({ storageKey, }: UsePersistedPageSizeOptions): {
+    pagination: PaginationState;
+    onPaginationChange: OnChangeFn<PaginationState>;
+};

package/dist/registry/use-data-table/usePersistedPageSize.js

@@ -0,0 +1,25 @@
+"use client";
+import { useState } from "react";
+import { ENTITY_TABLE_STORAGE_PREFIX } from "../../lib/constants.js";
+import { useLocalStorage } from "@mantine/hooks";
+function usePersistedPageSize({ storageKey }) {
+    const [pageSize, setPageSize] = useLocalStorage({
+        key: `${ENTITY_TABLE_STORAGE_PREFIX}page-size-${storageKey}`,
+        defaultValue: 10
+    });
+    const [pageIndex, setPageIndex] = useState(0);
+    const pagination = {
+        pageIndex,
+        pageSize
+    };
+    const onPaginationChange = (updaterOrValue)=>{
+        const newPagination = "function" == typeof updaterOrValue ? updaterOrValue(pagination) : updaterOrValue;
+        setPageIndex(newPagination.pageIndex);
+        if (newPagination.pageSize !== pageSize) setPageSize(newPagination.pageSize);
+    };
+    return {
+        pagination,
+        onPaginationChange
+    };
+}
+export { usePersistedPageSize };

package/dist/registry/use-data-table/usePersistedSorting.d.ts

@@ -0,0 +1,8 @@
+import type { OnChangeFn, SortingState } from "@tanstack/react-table";
+export interface UsePersistedSortingOptions {
+    storageKey: string;
+}
+export declare function usePersistedSorting({ storageKey, }: UsePersistedSortingOptions): {
+    sorting: SortingState;
+    onSortingChange: OnChangeFn<SortingState>;
+};

package/dist/registry/use-data-table/usePersistedSorting.js

@@ -0,0 +1,18 @@
+"use client";
+import { ENTITY_TABLE_STORAGE_PREFIX } from "../../lib/constants.js";
+import { useLocalStorage } from "@mantine/hooks";
+function usePersistedSorting({ storageKey }) {
+    const [sorting, setSorting] = useLocalStorage({
+        key: `${ENTITY_TABLE_STORAGE_PREFIX}sorting-${storageKey}`,
+        defaultValue: []
+    });
+    const onSortingChange = (updaterOrValue)=>{
+        const newSorting = "function" == typeof updaterOrValue ? updaterOrValue(sorting) : updaterOrValue;
+        setSorting(newSorting);
+    };
+    return {
+        sorting,
+        onSortingChange
+    };
+}
+export { usePersistedSorting };

package/dist/registry/use-data-table/useReactTableCompat.d.ts

@@ -0,0 +1,13 @@
+import { type Table, useReactTable } from "@tanstack/react-table";
+/**
+ * React Compiler compatibility wrapper for useReactTable.
+ *
+ * useReactTable returns a mutable object with a stable reference. The React
+ * Compiler caches values by reference, so child components that receive the
+ * table instance never see a "change" and skip re-renders. Spreading into a
+ * new object on every render gives children a fresh reference while keeping
+ * all methods intact (they are closures, not prototype methods).
+ *
+ * @see https://github.com/facebook/react/pull/31820
+ */
+export declare function useReactTableCompat<TData>(options: Parameters<typeof useReactTable<TData>>[0]): Table<TData>;

package/dist/registry/use-data-table/useReactTableCompat.js

@@ -0,0 +1,9 @@
+"use client";
+import { useReactTable } from "@tanstack/react-table";
+function useReactTableCompat(options) {
+    "use no memo";
+    return {
+        ...useReactTable(options)
+    };
+}
+export { useReactTableCompat };

package/dist/registry/use-feature-flag/use-feature-flag.d.ts

@@ -0,0 +1 @@
+export declare function useFeatureFlag(key: string): boolean;

package/dist/registry/use-feature-flag/use-feature-flag.js

@@ -0,0 +1,20 @@
+import { useEffect, useState } from "react";
+import { useFeatureFlagProvider } from "../feature-flag-provider/feature-flag-provider.js";
+function useFeatureFlag(key) {
+    const provider = useFeatureFlagProvider();
+    const [value, setValue] = useState(()=>provider.getFeatureFlagValue(key));
+    useEffect(()=>{
+        const listener = (newValue)=>{
+            setValue(newValue);
+        };
+        provider.on(key, listener);
+        return ()=>{
+            provider.off(key, listener);
+        };
+    }, [
+        key,
+        provider
+    ]);
+    return value;
+}
+export { useFeatureFlag };

package/dist/registry/use-mobile/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;

package/dist/registry/use-mobile/use-mobile.js

@@ -0,0 +1,23 @@
+import { useSyncExternalStore } from "react";
+const MOBILE_BREAKPOINT = 768;
+const MOBILE_QUERY = `(max-width: ${MOBILE_BREAKPOINT - 1}px)`;
+let mediaQuery;
+function mobileQuery() {
+    mediaQuery ??= window.matchMedia(MOBILE_QUERY);
+    return mediaQuery;
+}
+function subscribe(onStoreChange) {
+    const mql = mobileQuery();
+    mql.addEventListener("change", onStoreChange);
+    return ()=>mql.removeEventListener("change", onStoreChange);
+}
+function getSnapshot() {
+    return mobileQuery().matches;
+}
+function getServerSnapshot() {
+    return false;
+}
+function useIsMobile() {
+    return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+export { useIsMobile };