next-data-kit 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 muhgholy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,478 @@
+# next-data-kit
+
+A powerful table utility for server-side pagination, filtering, and sorting with React hooks and components.
+
+## Features
+
+-    🚀 **Server-side pagination** - Efficient data fetching with page-based navigation
+-    🔍 **Flexible filtering** - Support for regex, exact match, and custom filters
+-    📊 **Multi-column sorting** - Sort by multiple columns with customizable order
+-    ⚛️ **React hooks** - `useDataKit`, `useSelection`, `usePagination` for state management
+-    🎨 **Components** - `DataKitTable` for tables, `DataKit` for custom layouts
+-    📝 **TypeScript** - Fully typed with generics support
+-    🔌 **Framework agnostic** - Works with any database ORM/ODM (Mongoose, Prisma, etc.)
+-    📦 **Tree-shakeable** - Import only what you need
+
+## Installation
+
+```bash
+npm install next-data-kit
+# or
+yarn add next-data-kit
+# or
+pnpm add next-data-kit
+```
+
+## Quick Start
+
+### Server-side (Next.js Server Action)
+
+```typescript
+"use server";
+
+import { dataKitServerAction, createSearchFilter } from "next-data-kit/server";
+import type { TDataKitInput } from "next-data-kit/types";
+import UserModel from "@/models/User";
+
+export async function fetchUsers(input: TDataKitInput) {
+	return dataKitServerAction({
+		model: UserModel,
+		input,
+		item: async (user) => ({
+			id: user._id.toString(),
+			name: user.name,
+			email: user.email,
+		}),
+		filter: () => ({
+			active: true,
+		}),
+		filterCustom: {
+			search: createSearchFilter(["name", "email"]),
+            age: (value) => ({
+                age: {
+                    $gte: value,
+                }
+            })
+		},
+	});
+}
+```
+
+### Client-side (DataKitTable Component)
+
+Ready-to-use table with built-in filtering, sorting, and selection:
+
+```tsx
+"use client";
+
+import { DataKitTable } from "next-data-kit/client";
+import { fetchUsers } from "@/actions/users";
+
+export function UsersTable() {
+	return (
+		<DataKitTable
+			action={fetchUsers}
+			limit={{ default: 10 }}
+			filters={[
+				{ id: "search", label: "Search", type: "TEXT", placeholder: "Search..." },
+				{
+					id: "role",
+					label: "Role",
+					type: "SELECT",
+					dataset: [
+						{ id: "admin", name: "admin", label: "Admin" },
+						{ id: "user", name: "user", label: "User" },
+					],
+				},
+			]}
+			selectable={{
+				enabled: true,
+				actions: {
+					delete: {
+						name: "Delete Selected",
+						function: async (items) => {
+							await deleteUsers(items.map((i) => i.id));
+							return [true, { deselectAll: true }];
+						},
+					},
+				},
+			}}
+			table={[
+				{
+					head: <DataKitTable.Head>Name</DataKitTable.Head>,
+					body: ({ item }) => <DataKitTable.Cell>{item.name}</DataKitTable.Cell>,
+					sortable: { path: "name", default: 0 },
+				},
+				{
+					head: <DataKitTable.Head>Email</DataKitTable.Head>,
+					body: ({ item }) => <DataKitTable.Cell>{item.email}</DataKitTable.Cell>,
+				},
+			]}
+		/>
+	);
+}
+```
+
+### Client-side (DataKit Component - Custom Layout)
+
+Use `DataKit` for grids, cards, or any custom layout. It provides toolbar/pagination but lets you render content:
+
+```tsx
+"use client";
+
+import { DataKit } from "next-data-kit/client";
+import { fetchUsers } from "@/actions/users";
+
+export function UsersGrid() {
+	return (
+		<DataKit
+			action={fetchUsers}
+			limit={{ default: 12 }}
+			filters={[{ id: "search", label: "Search", type: "TEXT" }]}
+		>
+			{(dataKit) => (
+				<div className="grid grid-cols-4 gap-4">
+					{dataKit.items.map((user) => (
+						<div key={user.id} className="rounded-lg border p-4">
+							<h3>{user.name}</h3>
+							<p>{user.email}</p>
+						</div>
+					))}
+				</div>
+			)}
+		</DataKit>
+	);
+}
+```
+
+**Manual mode** - handle loading/empty states yourself:
+
+```tsx
+<DataKit action={fetchUsers} manual>
+	{(dataKit) => (
+		<>
+			{dataKit.state.isLoading && <Spinner />}
+			{dataKit.items.map((user) => <Card key={user.id} user={user} />)}
+		</>
+	)}
+</DataKit>
+```
+
+### Client-side (useDataKit Hook)
+
+For fully custom implementations:
+
+```tsx
+"use client";
+
+import { useDataKit } from "next-data-kit/client";
+import { fetchUsers } from "@/actions/users";
+
+export function UsersTable() {
+	const {
+		items,
+		page,
+		total,
+		state: { isLoading },
+		actions: { setPage, setFilter, setSort, refresh },
+	} = useDataKit({
+		action: fetchUsers,
+		initial: {
+			limit: 10,
+		},
+	});
+
+	return (
+		<div>
+			<input placeholder="Search..." onChange={(e) => setFilter("search", e.target.value)} />
+
+			{isLoading ? (
+				<p>Loading...</p>
+			) : (
+				<table>
+					<thead>
+						<tr>
+							<th onClick={() => setSort("name", 1)}>Name</th>
+							<th onClick={() => setSort("email", 1)}>Email</th>
+						</tr>
+					</thead>
+					<tbody>
+						{items.map((user) => (
+							<tr key={user.id}>
+								<td>{user.name}</td>
+								<td>{user.email}</td>
+							</tr>
+						))}
+					</tbody>
+				</table>
+			)}
+
+			<button disabled={page === 1} onClick={() => setPage(page - 1)}>
+				Previous
+			</button>
+			<span>Page {page}</span>
+			<button onClick={() => setPage(page + 1)}>Next</button>
+		</div>
+	);
+}
+```
+
+## API Reference
+
+### Server
+
+#### `dataKitServerAction(options)`
+
+Main server function for handling table data fetching.
+
+```typescript
+type TDataKitServerActionOptions<T, R> = {
+	input: TDataKitInput<T>;
+	model: TMongoModel<T>;
+	item: (item: T) => Promise<R> | R;
+	filter?: (filterInput?: Record<string, unknown>) => TMongoFilterQuery<T>;
+	filterCustom?: TFilterCustomConfigWithFilter<T, TMongoFilterQuery<T>>;
+	defaultSort?: TSortOptions<T>;
+};
+```
+
+#### `createSearchFilter(fields)`
+
+Create a search filter for multiple fields.
+
+```typescript
+filterCustom: {
+	search: createSearchFilter(["name", "email", "phone"]);
+}
+```
+
+#### `escapeRegex(str)`
+
+Escape regex special characters in a string.
+
+#### Custom Filter Implementation
+
+You can implement custom filters manually without using `createSearchFilter`. This gives you full control over the database query.
+
+```typescript
+import { escapeRegex } from "next-data-kit/server";
+
+// ... inside dataKitServerAction options
+filterCustom: {
+  // Manual search implementation
+  search: (value) => {
+    if (typeof value !== 'string') return {};
+    const term = escapeRegex(value);
+    return {
+      $or: [
+        { name: { $regex: term, $options: "i" } },
+        { email: { $regex: term, $options: "i" } },
+      ],
+    };
+  },
+  // Filter by range
+  priceRange: (value: { min: number; max: number }) => ({
+    price: { $gte: value.min, $lte: value.max },
+  }),
+}
+```
+
+**Client Usage:**
+
+```tsx
+const {
+	actions: { setFilter },
+} = useDataKit({
+	/* ... */
+});
+
+// Trigger the manual search
+setFilter("search", "query string");
+
+// Trigger the range filter
+setFilter("priceRange", { min: 10, max: 100 });
+```
+
+### Client
+
+#### `<DataKitTable>` Component
+
+Full-featured table component with built-in UI.
+
+| Prop | Type | Description |
+|------|------|-------------|
+| `action` | `(input) => Promise<Result>` | Server action function |
+| `table` | `Column[]` | Column definitions |
+| `filters` | `FilterItem[]` | Filter configurations |
+| `selectable` | `{ enabled, actions? }` | Selection & bulk actions |
+| `limit` | `{ default: number }` | Items per page |
+| `controller` | `Ref<Controller>` | External control ref |
+| `className` | `string` | Container class |
+| `bordered` | `boolean \| 'rounded'` | Border style |
+| `refetchInterval` | `number` | Auto-refresh interval (ms) |
+
+#### `<DataKit>` Component
+
+Headless component for custom layouts (grids, cards, etc).
+
+| Prop | Type | Description |
+|------|------|-------------|
+| `action` | `(input) => Promise<Result>` | Server action function |
+| `filters` | `FilterItem[]` | Filter configurations |
+| `limit` | `{ default: number }` | Items per page |
+| `manual` | `boolean` | Skip loading/empty state handling |
+| `children` | `(dataKit) => ReactNode` | Render function |
+
+#### `useDataKit(options)`
+
+React hook for managing next-data-kit state.
+
+```typescript
+interface TDataKitControllerOptions<T, R> {
+	action: (input: TDataKitInput<T>) => Promise<TDataKitResult<R>>;
+	initial?: {
+		page?: number;
+		limit?: number;
+		sorts?: TSortEntry[];
+		filter?: Record<string, unknown>;
+		query?: Record<string, unknown>;
+	};
+	filterConfig?: TFilterConfig;
+	onSuccess?: (result: TDataKitResult<R>) => void;
+	onError?: (error: Error) => void;
+	autoFetch?: boolean;
+}
+```
+
+Returns:
+
+-    `items` - Current page items
+-    `page` - Current page number
+-    `limit` - Items per page
+-    `total` - Total document count
+-    `sorts` - Current sort configuration
+-    `filter` - Current filter values
+-    `state`
+     -    `isLoading` - Loading state
+     -    `error` - Error state
+-    `actions`
+     -    `setPage(page)` - Go to a specific page
+     -    `setLimit(limit)` - Set items per page
+     -    `setSort(path, value)` - Set sort for a column
+     -    `setFilter(key, value)` - Set a filter value
+     -    `clearFilters()` - Clear all filters
+     -    `refresh()` - Refresh the table data
+     -    `reset()` - Reset to initial state
+
+#### `useSelection<T>()`
+
+React hook for managing table row selection.
+
+```typescript
+const { selectedIds, toggle, selectAll, deselectAll, isSelected, getSelectedArray } = useSelection<string>();
+```
+
+#### `usePagination(options)`
+
+React hook for calculating pagination state.
+
+```typescript
+const { pages, hasNextPage, hasPrevPage, totalPages } = usePagination({
+	page: 1,
+	limit: 10,
+	total: 100,
+});
+```
+
+## Types
+
+### Filter Types (Discriminated Union)
+
+```typescript
+// TEXT - text input
+{ id: "name", label: "Name", type: "TEXT", placeholder?: "..." }
+
+// SELECT - dropdown (dataset required!)
+{ id: "role", label: "Role", type: "SELECT", dataset: [{ id, name, label }] }
+
+// BOOLEAN - toggle switch
+{ id: "active", label: "Active", type: "BOOLEAN" }
+```
+
+### `TDataKitInput<T>`
+
+```typescript
+interface TDataKitInput<T = unknown> {
+	action?: "FETCH";
+	page?: number;
+	limit?: number;
+	sort?: TSortOptions<T>;
+	sorts?: TSortEntry[];
+	query?: Record<string, unknown>;
+	filter?: Record<string, unknown>;
+	filterConfig?: TFilterConfig;
+}
+```
+
+### `TDataKitResult<R>`
+
+```typescript
+interface TDataKitResult<R> {
+	type: "ITEMS";
+	items: R[];
+	documentTotal: number;
+}
+```
+
+### `TFilterConfig`
+
+```typescript
+interface TFilterConfig {
+	[key: string]: {
+		type: "regex" | "exact";
+		field?: string;
+	};
+}
+```
+
+## Working with Custom Models
+
+The package provides generic database types that work with any ORM/ODM:
+
+```typescript
+import type { TModel, TMongoFilterQuery, TQueryBuilder } from "next-data-kit/types";
+
+// Your model just needs to implement the Model interface
+interface MyModel extends TModel<MyDocument> {
+	countDocuments(filter?: TMongoFilterQuery<MyDocument>): Promise<number>;
+	find(filter?: TMongoFilterQuery<MyDocument>): TQueryBuilder<MyDocument[]>;
+}
+```
+
+## License
+
+MIT © muhgholy
+
+## Dev Playground (Live Server + Temp MongoDB)
+
+This repo includes a **dev-only** playground you can open in the browser to preview components and validate end-to-end behavior against a **temporary in-memory MongoDB**.
+
+-    It is **not exported** in `package.json#exports`.
+-    It is **not published** to npm because `package.json#files` only includes `dist`.
+
+### Run
+
+```bash
+npm run playground:dev
+```
+
+Then open:
+
+-    Web UI: http://localhost:5173
+-    API health: http://127.0.0.1:8787/api/health
+
+### Reset seed data
+
+```bash
+curl -X POST http://127.0.0.1:8787/api/seed/reset
+```

package/dist/client/components/data-kit-table.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { TableCell, TableHead } from './ui';
+import type { TDataKitInput, TDataKitResult, TDataKitComponentColumn, TDataKitFilterItem, TDataKitBulkAction, TDataKitComponentController, TDataKitSelectableItem, TDataKitStateMode, TExtractDataKitItemType, TFilterConfig } from '../../types';
+export declare const DataKitTable: (<TAction extends (input: TDataKitInput<unknown>) => Promise<TDataKitResult<TDataKitSelectableItem>>, TRowState = unknown>(props: Readonly<{
+    action: TAction;
+    query?: Record<string, unknown>;
+    filterConfig?: TFilterConfig;
+    table: TDataKitComponentColumn<TExtractDataKitItemType<TAction>, TRowState>[];
+    filters?: TDataKitFilterItem[];
+    selectable?: {
+        enabled: boolean;
+        actions?: Record<string, TDataKitBulkAction<TExtractDataKitItemType<TAction>>>;
+    };
+    initialState?: TRowState;
+    limit?: {
+        default: number;
+    };
+    className?: string;
+    autoFetch?: boolean;
+    debounce?: number;
+    bordered?: boolean | "rounded";
+    refetchInterval?: number;
+    state?: TDataKitStateMode;
+    controller?: React.MutableRefObject<TDataKitComponentController<TExtractDataKitItemType<TAction>> | null>;
+}>) => import("react/jsx-runtime").JSX.Element) & {
+    Cell: typeof TableCell;
+    Head: typeof TableHead;
+};
+//# sourceMappingURL=data-kit-table.d.ts.map

package/dist/client/components/data-kit.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { TDataKitInput, TDataKitResult, TDataKitFilterItem, TDataKitSelectableItem, TDataKitStateMode, TExtractDataKitItemType, TFilterConfig, TUseDataKitReturn } from '../../types';
+export declare const DataKit: <TAction extends (input: TDataKitInput<unknown>) => Promise<TDataKitResult<TDataKitSelectableItem>>>(props: Readonly<{
+    action: TAction;
+    query?: Record<string, unknown>;
+    filterConfig?: TFilterConfig;
+    filters?: TDataKitFilterItem[];
+    limit?: {
+        default: number;
+    };
+    className?: string;
+    autoFetch?: boolean;
+    debounce?: number;
+    refetchInterval?: number;
+    state?: TDataKitStateMode;
+    manual?: boolean;
+    children: (dataKit: TUseDataKitReturn<unknown, TExtractDataKitItemType<TAction>>) => React.ReactNode;
+}>) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=data-kit.d.ts.map

package/dist/client/components/index.d.ts

@@ -0,0 +1,3 @@
+export { DataKitTable } from './data-kit-table';
+export { DataKit } from './data-kit';
+//# sourceMappingURL=index.d.ts.map

package/dist/client/components/ui/button.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare const Button: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };
+//# sourceMappingURL=button.d.ts.map

package/dist/client/components/ui/checkbox.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+declare function Checkbox({ className, ...props }: React.ComponentProps<typeof CheckboxPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Checkbox };
+//# sourceMappingURL=checkbox.d.ts.map

package/dist/client/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuContent({ className, sideOffset, container, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content> & {
+    container?: HTMLElement | null;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): import("react/jsx-runtime").JSX.Element;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };
+//# sourceMappingURL=dropdown-menu.d.ts.map

package/dist/client/components/ui/index.d.ts

@@ -0,0 +1,9 @@
+export { Table, TableHeader, TableBody, TableFooter, TableRow, TableHead, TableCell, TableCaption, } from './table';
+export { Checkbox } from './checkbox';
+export { Popover, PopoverAnchor, PopoverContent, PopoverTrigger } from './popover';
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, } from './dropdown-menu';
+export { Switch } from './switch';
+export { Button, buttonVariants } from './button';
+export { Pagination, PaginationContent, PaginationItem, PaginationLink, PaginationPrevious, PaginationNext, PaginationEllipsis, } from './pagination';
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, } from './select';
+//# sourceMappingURL=index.d.ts.map

package/dist/client/components/ui/pagination.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { type Button } from './button';
+declare function Pagination({ className, ...props }: React.ComponentProps<'nav'>): import("react/jsx-runtime").JSX.Element;
+declare function PaginationContent({ className, ...props }: React.ComponentProps<'ul'>): import("react/jsx-runtime").JSX.Element;
+declare function PaginationItem({ ...props }: React.ComponentProps<'li'>): import("react/jsx-runtime").JSX.Element;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<React.ComponentProps<typeof Button>, 'size' | 'disabled' | 'onClick' | 'type'> & Omit<React.ComponentProps<'button'>, 'type' | 'onClick' | 'disabled'>;
+declare function PaginationLink({ className, isActive, size, type, ...props }: PaginationLinkProps): import("react/jsx-runtime").JSX.Element;
+declare function PaginationPrevious({ className, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+declare function PaginationNext({ className, ...props }: React.ComponentProps<typeof PaginationLink>): import("react/jsx-runtime").JSX.Element;
+declare function PaginationEllipsis({ className, ...props }: React.ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
+export { Pagination, PaginationContent, PaginationItem, PaginationLink, PaginationPrevious, PaginationNext, PaginationEllipsis, };
+//# sourceMappingURL=pagination.d.ts.map

package/dist/client/components/ui/popover.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+declare function Popover(props: React.ComponentProps<typeof PopoverPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverTrigger(props: React.ComponentProps<typeof PopoverPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, container, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content> & {
+    container?: HTMLElement | null;
+}): import("react/jsx-runtime").JSX.Element;
+declare function PopoverAnchor(props: React.ComponentProps<typeof PopoverPrimitive.Anchor>): import("react/jsx-runtime").JSX.Element;
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor };
+//# sourceMappingURL=popover.d.ts.map

package/dist/client/components/ui/select.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function SelectGroup({ ...props }: React.ComponentProps<typeof SelectPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+    size?: "sm" | "default";
+}): import("react/jsx-runtime").JSX.Element;
+declare function SelectContent({ className, children, position, align, container, ...props }: React.ComponentProps<typeof SelectPrimitive.Content> & {
+    container?: HTMLElement | null;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
+declare function SelectItem({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): import("react/jsx-runtime").JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };
+//# sourceMappingURL=select.d.ts.map

package/dist/client/components/ui/switch.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+declare function Switch({ className, ...props }: React.ComponentProps<typeof SwitchPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Switch };
+//# sourceMappingURL=switch.d.ts.map