@alexgorbatchev/shadcn 0.0.20 → 0.0.21

package/dist/components/data-grid/index.js

@@ -0,0 +1,228 @@
+import"../../chunk-cp2m7y7v.js";
+import {
+  Button2
+} from "../../chunk-73rkr9ct.js";
+import {
+  Table2,
+  TableHeader2,
+  TableBody2,
+  TableRow2,
+  TableHead2,
+  TableCell2
+} from "../../chunk-0y0kqaqj.js";
+import {
+  NativeSelect2,
+  NativeSelectOption2
+} from "../../chunk-r9qrb6b6.js";
+import {
+  Input2
+} from "../../chunk-59p19t57.js";
+
+// src/components/data-grid/DataGrid.tsx
+import {
+  columnFilteringFeature,
+  columnVisibilityFeature,
+  createFilteredRowModel,
+  createPaginatedRowModel,
+  createSortedRowModel,
+  filterFn_includesString,
+  rowPaginationFeature,
+  rowSelectionFeature,
+  rowSortingFeature,
+  sortFn_alphanumeric,
+  sortFn_basic,
+  tableFeatures
+} from "@tanstack/react-table";
+import { ArrowDownIcon, ArrowUpIcon, ChevronsUpDownIcon } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var dataGridFeatures = tableFeatures({
+  columnFilteringFeature,
+  columnVisibilityFeature,
+  rowPaginationFeature,
+  rowSelectionFeature,
+  rowSortingFeature,
+  filteredRowModel: createFilteredRowModel(),
+  sortedRowModel: createSortedRowModel(),
+  paginatedRowModel: createPaginatedRowModel(),
+  filterFns: { includesString: filterFn_includesString },
+  sortFns: { alphanumeric: sortFn_alphanumeric, basic: sortFn_basic }
+});
+function DataGrid({
+  table,
+  label,
+  toolbar,
+  empty = "No results.",
+  loading = false,
+  pagination = true,
+  density
+}) {
+  const rows = table.getRowModel().rows;
+  return /* @__PURE__ */ jsxs("div", {
+    "data-density": density,
+    "data-scroll": "none",
+    className: "grid min-w-0 gap-3",
+    "aria-busy": loading,
+    children: [
+      toolbar,
+      /* @__PURE__ */ jsx("div", {
+        className: "min-w-0 rounded-sm border border-border",
+        children: /* @__PURE__ */ jsxs(Table2, {
+          "aria-label": label,
+          children: [
+            /* @__PURE__ */ jsx(TableHeader2, {
+              children: table.getHeaderGroups().map((group) => /* @__PURE__ */ jsx(TableRow2, {
+                children: group.headers.map((header) => /* @__PURE__ */ jsx(TableHead2, {
+                  colSpan: header.colSpan,
+                  "aria-sort": header.column.getCanSort() ? header.column.getIsSorted() === "asc" ? "ascending" : header.column.getIsSorted() === "desc" ? "descending" : "none" : undefined,
+                  children: header.isPlaceholder ? null : /* @__PURE__ */ jsx(table.FlexRender, {
+                    header
+                  })
+                }, header.id))
+              }, group.id))
+            }),
+            /* @__PURE__ */ jsx(TableBody2, {
+              children: loading ? /* @__PURE__ */ jsx(TableRow2, {
+                children: /* @__PURE__ */ jsx(TableCell2, {
+                  colSpan: table.getVisibleLeafColumns().length,
+                  children: /* @__PURE__ */ jsxs("p", {
+                    role: "status",
+                    children: [
+                      "Loading ",
+                      label,
+                      "…"
+                    ]
+                  })
+                })
+              }) : rows.length ? rows.map((row) => /* @__PURE__ */ jsx(TableRow2, {
+                "data-state": row.getIsSelected() ? "selected" : undefined,
+                children: row.getVisibleCells().map((cell) => /* @__PURE__ */ jsx(TableCell2, {
+                  children: /* @__PURE__ */ jsx(table.FlexRender, {
+                    cell
+                  })
+                }, cell.id))
+              }, row.id)) : /* @__PURE__ */ jsx(TableRow2, {
+                children: /* @__PURE__ */ jsx(TableCell2, {
+                  colSpan: table.getVisibleLeafColumns().length,
+                  children: /* @__PURE__ */ jsx("p", {
+                    role: "status",
+                    children: empty
+                  })
+                })
+              })
+            })
+          ]
+        })
+      }),
+      pagination && /* @__PURE__ */ jsx(DataGridPagination, {
+        table
+      })
+    ]
+  });
+}
+function DataGridColumnHeader({
+  column,
+  children
+}) {
+  const sorted = column.getIsSorted();
+  return column.getCanSort() ? /* @__PURE__ */ jsxs(Button2, {
+    type: "button",
+    variant: "ghost",
+    size: "sm",
+    onClick: column.getToggleSortingHandler(),
+    children: [
+      children,
+      sorted === "asc" ? /* @__PURE__ */ jsx(ArrowUpIcon, {
+        "aria-hidden": "true"
+      }) : sorted === "desc" ? /* @__PURE__ */ jsx(ArrowDownIcon, {
+        "aria-hidden": "true"
+      }) : /* @__PURE__ */ jsx(ChevronsUpDownIcon, {
+        "aria-hidden": "true"
+      })
+    ]
+  }) : /* @__PURE__ */ jsx("span", {
+    children
+  });
+}
+function DataGridFilter({
+  table,
+  columnId,
+  label
+}) {
+  const column = table.getColumn(columnId);
+  if (!column)
+    throw new Error(`Unknown filter column: ${columnId}`);
+  const value = column.getFilterValue();
+  return /* @__PURE__ */ jsx(Input2, {
+    "aria-label": label,
+    placeholder: label,
+    value: typeof value === "string" ? value : "",
+    onChange: (event) => column.setFilterValue(event.target.value)
+  });
+}
+function DataGridPagination({ table }) {
+  return /* @__PURE__ */ jsxs("div", {
+    className: "flex flex-wrap items-center justify-between gap-3 text-sm",
+    children: [
+      /* @__PURE__ */ jsxs("span", {
+        role: "status",
+        children: [
+          table.getSelectedRowModel().rows.length,
+          " selected · Page ",
+          table.state.pagination.pageIndex + 1,
+          " of",
+          " ",
+          Math.max(1, table.getPageCount())
+        ]
+      }),
+      /* @__PURE__ */ jsxs("div", {
+        className: "flex items-center gap-2",
+        children: [
+          /* @__PURE__ */ jsxs(NativeSelect2, {
+            "aria-label": "Rows per page",
+            value: table.state.pagination.pageSize,
+            onChange: (event) => table.setPageSize(Number(event.target.value)),
+            children: [
+              [10, 20, 50, 100].map((size) => /* @__PURE__ */ jsxs(NativeSelectOption2, {
+                value: size,
+                children: [
+                  size,
+                  " rows"
+                ]
+              }, size)),
+              ![10, 20, 50, 100].includes(table.state.pagination.pageSize) && /* @__PURE__ */ jsxs(NativeSelectOption2, {
+                value: table.state.pagination.pageSize,
+                children: [
+                  table.state.pagination.pageSize,
+                  " rows"
+                ]
+              })
+            ]
+          }),
+          /* @__PURE__ */ jsx(Button2, {
+            type: "button",
+            variant: "outline",
+            size: "sm",
+            disabled: !table.getCanPreviousPage(),
+            onClick: () => table.previousPage(),
+            children: "Previous"
+          }),
+          /* @__PURE__ */ jsx(Button2, {
+            type: "button",
+            variant: "outline",
+            size: "sm",
+            disabled: !table.getCanNextPage(),
+            onClick: () => table.nextPage(),
+            children: "Next"
+          })
+        ]
+      })
+    ]
+  });
+}
+export {
+  DataGrid,
+  DataGridColumnHeader,
+  DataGridFilter,
+  DataGridPagination,
+  dataGridFeatures
+};

package/dist/components/editor/RichTextEditor.d.ts

@@ -0,0 +1,14 @@
+import { type Editor } from "@tiptap/react";
+import type { ReactElement } from "react";
+import type { IDensityProps } from "../../density/types.js";
+type RichTextEditorProps = IDensityProps & {
+    editor: Editor | null;
+    label: string;
+};
+/** The caller owns a native Tiptap editor and its extensions, content, and persistence. */
+declare function RichTextEditor({ editor, label, density }: RichTextEditorProps): ReactElement;
+export { RichTextEditor };
+export type { RichTextEditorProps };
+export { useEditor, useEditorState, EditorContent } from "@tiptap/react";
+export type { Editor, JSONContent, Content, Extensions } from "@tiptap/core";
+export { default as StarterKit } from "@tiptap/starter-kit";

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

@@ -0,0 +1,2 @@
+export { RichTextEditor, useEditor, useEditorState, EditorContent, StarterKit } from "./RichTextEditor.js";
+export type { RichTextEditorProps, Editor, JSONContent, Content, Extensions } from "./RichTextEditor.js";

package/dist/components/editor/index.js

@@ -0,0 +1,108 @@
+import"../../chunk-cp2m7y7v.js";
+import"../../chunk-73rkr9ct.js";
+import {
+  Toolbar2,
+  ToolbarButton2,
+  ToolbarGroup2,
+  ToolbarSeparator2
+} from "../../chunk-21wbz345.js";
+
+// src/components/editor/RichTextEditor.tsx
+import { EditorContent, useEditorState } from "@tiptap/react";
+import { BoldIcon, ItalicIcon, ListIcon, ListOrderedIcon, RedoIcon, UndoIcon } from "lucide-react";
+import { useEditor, useEditorState as useEditorState2, EditorContent as EditorContent2 } from "@tiptap/react";
+import { default as default2 } from "@tiptap/starter-kit";
+import { jsx, jsxs } from "react/jsx-runtime";
+function RichTextEditor({ editor, label, density }) {
+  const state = useEditorState({
+    editor,
+    selector: ({ editor: current }) => ({
+      bold: current?.isActive("bold") ?? false,
+      italic: current?.isActive("italic") ?? false,
+      bulletList: current?.isActive("bulletList") ?? false,
+      orderedList: current?.isActive("orderedList") ?? false,
+      undo: current?.can().undo() ?? false,
+      redo: current?.can().redo() ?? false,
+      editable: current?.isEditable ?? false
+    })
+  });
+  return /* @__PURE__ */ jsxs("div", {
+    "data-density": density,
+    "data-scroll": "none",
+    className: "min-w-0 rounded-sm border border-input bg-background",
+    children: [
+      /* @__PURE__ */ jsxs(Toolbar2, {
+        "aria-label": `${label} formatting`,
+        className: "rounded-b-none border-0 border-b border-border",
+        children: [
+          /* @__PURE__ */ jsxs(ToolbarGroup2, {
+            children: [
+              /* @__PURE__ */ jsx(ToolbarButton2, {
+                "aria-label": "Bold",
+                "aria-pressed": state?.bold,
+                disabled: !state?.editable,
+                onClick: () => editor?.chain().focus().toggleBold().run(),
+                children: /* @__PURE__ */ jsx(BoldIcon, {})
+              }),
+              /* @__PURE__ */ jsx(ToolbarButton2, {
+                "aria-label": "Italic",
+                "aria-pressed": state?.italic,
+                disabled: !state?.editable,
+                onClick: () => editor?.chain().focus().toggleItalic().run(),
+                children: /* @__PURE__ */ jsx(ItalicIcon, {})
+              })
+            ]
+          }),
+          /* @__PURE__ */ jsx(ToolbarSeparator2, {}),
+          /* @__PURE__ */ jsxs(ToolbarGroup2, {
+            children: [
+              /* @__PURE__ */ jsx(ToolbarButton2, {
+                "aria-label": "Bullet list",
+                "aria-pressed": state?.bulletList,
+                disabled: !state?.editable,
+                onClick: () => editor?.chain().focus().toggleBulletList().run(),
+                children: /* @__PURE__ */ jsx(ListIcon, {})
+              }),
+              /* @__PURE__ */ jsx(ToolbarButton2, {
+                "aria-label": "Numbered list",
+                "aria-pressed": state?.orderedList,
+                disabled: !state?.editable,
+                onClick: () => editor?.chain().focus().toggleOrderedList().run(),
+                children: /* @__PURE__ */ jsx(ListOrderedIcon, {})
+              })
+            ]
+          }),
+          /* @__PURE__ */ jsx(ToolbarSeparator2, {}),
+          /* @__PURE__ */ jsxs(ToolbarGroup2, {
+            children: [
+              /* @__PURE__ */ jsx(ToolbarButton2, {
+                "aria-label": "Undo",
+                disabled: !state?.editable || !state.undo,
+                onClick: () => editor?.chain().focus().undo().run(),
+                children: /* @__PURE__ */ jsx(UndoIcon, {})
+              }),
+              /* @__PURE__ */ jsx(ToolbarButton2, {
+                "aria-label": "Redo",
+                disabled: !state?.editable || !state.redo,
+                onClick: () => editor?.chain().focus().redo().run(),
+                children: /* @__PURE__ */ jsx(RedoIcon, {})
+              })
+            ]
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsx(EditorContent, {
+        editor,
+        "aria-label": label,
+        className: "max-h-96 overflow-auto p-3 [&_.tiptap]:min-h-32 [&_.tiptap]:outline-none [&_ul]:list-disc [&_ul]:pl-6 [&_ol]:list-decimal [&_ol]:pl-6 [&_blockquote]:border-l-2 [&_blockquote]:border-border [&_blockquote]:pl-3"
+      })
+    ]
+  });
+}
+export {
+  EditorContent2 as EditorContent,
+  RichTextEditor,
+  default2 as StarterKit,
+  useEditor,
+  useEditorState2 as useEditorState
+};

package/dist/components/event-calendar/EventCalendar.d.ts

@@ -0,0 +1,16 @@
+import { type CalendarProps, type ToolbarProps } from "react-big-calendar";
+import { type ReactElement } from "react";
+import type { IDensityProps } from "../../density/types.js";
+declare const eventCalendarLocalizer: import("react-big-calendar").DateLocalizer;
+declare function EventCalendarToolbar<T extends object, R extends object>({ label, view, views, onNavigate, onView, localizer, }: ToolbarProps<T, R>): ReactElement;
+type EventCalendarProps<T extends object, R extends object = object> = Omit<CalendarProps<T, R>, "className" | "style" | "popup" | "popupOffset" | "localizer"> & IDensityProps & {
+    label: string;
+    height?: number | string;
+    localizer?: CalendarProps<T, R>["localizer"];
+};
+/** Import @alexgorbatchev/shadcn/event-calendar.css. Native localizer and event APIs are preserved. */
+declare function EventCalendar<T extends object, R extends object = object>({ label, height, density, components, localizer, ...props }: EventCalendarProps<T, R>): ReactElement;
+export { EventCalendar, EventCalendarToolbar, eventCalendarLocalizer };
+export type { EventCalendarProps };
+export { dateFnsLocalizer } from "react-big-calendar";
+export type { Event, View, SlotInfo, DateLocalizer, CalendarProps, ToolbarProps } from "react-big-calendar";

package/dist/components/event-calendar/EventForm.d.ts

@@ -0,0 +1,18 @@
+import { type ReactElement } from "react";
+import type { IDensityProps } from "../../density/types.js";
+type EventDraft = {
+    title: string;
+    start: Date;
+    end: Date;
+    allDay: boolean;
+};
+type EventFormProps = IDensityProps & {
+    label: string;
+    initialValue: EventDraft;
+    onSave: (value: EventDraft) => void | Promise<void>;
+    onCancel?: () => void;
+    disabled?: boolean;
+};
+declare function EventForm({ label, initialValue, onSave, onCancel, disabled, density }: EventFormProps): ReactElement;
+export { EventForm };
+export type { EventFormProps, EventDraft };

package/dist/components/event-calendar/index.d.ts

@@ -0,0 +1,4 @@
+export { EventCalendar, EventCalendarToolbar, eventCalendarLocalizer, dateFnsLocalizer } from "./EventCalendar.js";
+export type { EventCalendarProps, Event, View, SlotInfo, DateLocalizer, CalendarProps, ToolbarProps, } from "./EventCalendar.js";
+export { EventForm } from "./EventForm.js";
+export type { EventFormProps, EventDraft } from "./EventForm.js";

package/dist/components/event-calendar/index.js

@@ -0,0 +1,266 @@
+import {
+  cn2
+} from "../../chunk-cp2m7y7v.js";
+import {
+  Button2
+} from "../../chunk-73rkr9ct.js";
+import"../../chunk-jcxxjkqx.js";
+import"../../chunk-rajgnfbr.js";
+import {
+  FieldGroup2,
+  Field2,
+  FieldLabel2
+} from "../../chunk-6jpz5geq.js";
+import {
+  Input2
+} from "../../chunk-59p19t57.js";
+import {
+  Checkbox2,
+  Spinner2
+} from "../../chunk-eehfrrdz.js";
+
+// src/components/event-calendar/EventCalendar.tsx
+import {
+  Calendar as NativeCalendar,
+  dateFnsLocalizer
+} from "react-big-calendar";
+import { format, parse, startOfWeek, getDay } from "date-fns";
+import { enUS } from "date-fns/locale";
+import { createElement, isValidElement } from "react";
+import { dateFnsLocalizer as dateFnsLocalizer2 } from "react-big-calendar";
+import { jsx, jsxs } from "react/jsx-runtime";
+var eventCalendarLocalizer = dateFnsLocalizer({ format, parse, startOfWeek, getDay, locales: { "en-US": enUS } });
+function EventCalendarToolbar({
+  label,
+  view,
+  views,
+  onNavigate,
+  onView,
+  localizer
+}) {
+  const names = Array.isArray(views) ? views : Object.keys(views ?? {});
+  return /* @__PURE__ */ jsxs("div", {
+    className: "mb-3 flex flex-wrap items-center justify-between gap-2",
+    children: [
+      /* @__PURE__ */ jsxs("div", {
+        className: "flex gap-1",
+        children: [
+          /* @__PURE__ */ jsx(Button2, {
+            type: "button",
+            variant: "outline",
+            size: "sm",
+            onClick: () => onNavigate("PREV"),
+            children: localizer.messages.previous
+          }),
+          /* @__PURE__ */ jsx(Button2, {
+            type: "button",
+            variant: "outline",
+            size: "sm",
+            onClick: () => onNavigate("TODAY"),
+            children: localizer.messages.today
+          }),
+          /* @__PURE__ */ jsx(Button2, {
+            type: "button",
+            variant: "outline",
+            size: "sm",
+            onClick: () => onNavigate("NEXT"),
+            children: localizer.messages.next
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsx("h2", {
+        "aria-live": "polite",
+        className: "text-sm font-semibold",
+        children: label
+      }),
+      /* @__PURE__ */ jsx("div", {
+        className: "flex flex-wrap gap-1",
+        "aria-label": "Calendar views",
+        role: "group",
+        children: names.map((name) => {
+          if (name !== "month" && name !== "week" && name !== "work_week" && name !== "day" && name !== "agenda")
+            return null;
+          return /* @__PURE__ */ jsx(Button2, {
+            type: "button",
+            size: "sm",
+            variant: view === name ? "default" : "outline",
+            "aria-pressed": view === name,
+            onClick: () => onView(name),
+            children: localizer.messages[name] ?? name
+          }, name);
+        })
+      })
+    ]
+  });
+}
+function EventButton({ children }) {
+  if (!isValidElement(children))
+    throw new Error("An event wrapper requires one event element.");
+  return createElement("button", { ...children.props, type: "button" }, children.props.children);
+}
+function EventCalendar({
+  label,
+  height = 640,
+  density,
+  components,
+  localizer = eventCalendarLocalizer,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx("section", {
+    "aria-label": label,
+    "data-density": density,
+    "data-scroll": "none",
+    className: "min-w-0 rounded-sm border border-border bg-card p-3",
+    children: /* @__PURE__ */ jsx(NativeCalendar, {
+      ...props,
+      localizer,
+      popup: false,
+      className: cn2("ag-event-calendar"),
+      style: { height },
+      components: { toolbar: EventCalendarToolbar, eventWrapper: EventButton, ...components }
+    })
+  });
+}
+// src/components/event-calendar/EventForm.tsx
+import { useId, useState } from "react";
+import { format as format2 } from "date-fns";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function EventForm({ label, initialValue, onSave, onCancel, disabled, density }) {
+  const id = useId();
+  const [start, setStart] = useState(format2(initialValue.start, "yyyy-MM-dd'T'HH:mm"));
+  const [pending, setPending] = useState(false);
+  const [error, setError] = useState("");
+  return /* @__PURE__ */ jsx2("form", {
+    "aria-label": label,
+    "data-density": density,
+    "aria-busy": pending,
+    onSubmit: async (event) => {
+      event.preventDefault();
+      const data = new FormData(event.currentTarget);
+      const value = {
+        title: String(data.get("title")),
+        start: new Date(String(data.get("start"))),
+        end: new Date(String(data.get("end"))),
+        allDay: data.has("allDay")
+      };
+      setPending(true);
+      setError("");
+      try {
+        await onSave(value);
+      } catch (error) {
+        setError(error instanceof Error ? error.message : "Unable to save the event.");
+      } finally {
+        setPending(false);
+      }
+    },
+    children: /* @__PURE__ */ jsxs2("fieldset", {
+      disabled: disabled || pending,
+      className: "min-w-0",
+      children: [
+        /* @__PURE__ */ jsx2("legend", {
+          className: "sr-only",
+          children: label
+        }),
+        /* @__PURE__ */ jsxs2(FieldGroup2, {
+          children: [
+            /* @__PURE__ */ jsxs2(Field2, {
+              children: [
+                /* @__PURE__ */ jsx2(FieldLabel2, {
+                  htmlFor: `${id}-title`,
+                  children: "Title"
+                }),
+                /* @__PURE__ */ jsx2(Input2, {
+                  id: `${id}-title`,
+                  name: "title",
+                  required: true,
+                  defaultValue: initialValue.title
+                })
+              ]
+            }),
+            /* @__PURE__ */ jsxs2("div", {
+              className: "grid gap-3 sm:grid-cols-2",
+              children: [
+                /* @__PURE__ */ jsxs2(Field2, {
+                  children: [
+                    /* @__PURE__ */ jsx2(FieldLabel2, {
+                      htmlFor: `${id}-start`,
+                      children: "Start"
+                    }),
+                    /* @__PURE__ */ jsx2(Input2, {
+                      id: `${id}-start`,
+                      name: "start",
+                      type: "datetime-local",
+                      required: true,
+                      value: start,
+                      onChange: (event) => setStart(event.target.value)
+                    })
+                  ]
+                }),
+                /* @__PURE__ */ jsxs2(Field2, {
+                  children: [
+                    /* @__PURE__ */ jsx2(FieldLabel2, {
+                      htmlFor: `${id}-end`,
+                      children: "End"
+                    }),
+                    /* @__PURE__ */ jsx2(Input2, {
+                      id: `${id}-end`,
+                      name: "end",
+                      type: "datetime-local",
+                      required: true,
+                      min: start,
+                      defaultValue: format2(initialValue.end, "yyyy-MM-dd'T'HH:mm")
+                    })
+                  ]
+                })
+              ]
+            }),
+            /* @__PURE__ */ jsxs2(Field2, {
+              orientation: "horizontal",
+              children: [
+                /* @__PURE__ */ jsx2(Checkbox2, {
+                  id: `${id}-all-day`,
+                  name: "allDay",
+                  defaultChecked: initialValue.allDay
+                }),
+                /* @__PURE__ */ jsx2(FieldLabel2, {
+                  htmlFor: `${id}-all-day`,
+                  children: "All day"
+                })
+              ]
+            }),
+            error && /* @__PURE__ */ jsx2("p", {
+              role: "alert",
+              className: "text-sm text-destructive",
+              children: error
+            }),
+            /* @__PURE__ */ jsxs2("div", {
+              className: "flex flex-wrap justify-end gap-2",
+              children: [
+                onCancel && /* @__PURE__ */ jsx2(Button2, {
+                  type: "button",
+                  variant: "outline",
+                  onClick: onCancel,
+                  children: "Cancel"
+                }),
+                /* @__PURE__ */ jsxs2(Button2, {
+                  type: "submit",
+                  children: [
+                    pending && /* @__PURE__ */ jsx2(Spinner2, {}),
+                    "Save event"
+                  ]
+                })
+              ]
+            })
+          ]
+        })
+      ]
+    })
+  });
+}
+export {
+  EventCalendar,
+  EventCalendarToolbar,
+  EventForm,
+  dateFnsLocalizer2 as dateFnsLocalizer,
+  eventCalendarLocalizer
+};

package/dist/components/file-upload/FileUpload.d.ts

@@ -0,0 +1,14 @@
+import { type ReactElement, type ReactNode } from "react";
+import { type DropzoneOptions } from "react-dropzone";
+import type { IDensityProps } from "../../density/types.js";
+type FileUploadProps = IDensityProps & Pick<DropzoneOptions, "accept" | "maxSize" | "minSize" | "maxFiles" | "multiple" | "disabled" | "validator" | "onDrop" | "onDropRejected" | "onError"> & {
+    label: string;
+    description?: ReactNode;
+    children?: ReactNode;
+    name?: string;
+};
+/** Native file selection and validation. Consumers own storage and upload requests. */
+declare function FileUpload({ label, description, children, name, density, ...options }: FileUploadProps): ReactElement;
+export { FileUpload };
+export type { FileUploadProps };
+export type { FileRejection, FileError, DropEvent, Accept } from "react-dropzone";

package/dist/components/file-upload/index.d.ts

@@ -0,0 +1,2 @@
+export { FileUpload } from "./FileUpload.js";
+export type { FileUploadProps, FileRejection, FileError, DropEvent, Accept } from "./FileUpload.js";