@blocknote/shadcn 0.13.0

package/src/toolbar/Toolbar.tsx

@@ -0,0 +1,153 @@
+import { ComponentProps } from "@blocknote/react";
+import { forwardRef } from "react";
+
+import { assertEmpty } from "@blocknote/core";
+import { useShadCNComponentsContext } from "../ShadCNComponentsContext";
+import { cn } from "../lib/utils";
+
+type ToolbarProps = ComponentProps["FormattingToolbar"]["Root"] &
+  ComponentProps["LinkToolbar"]["Root"];
+
+export const Toolbar = forwardRef<HTMLDivElement, ToolbarProps>(
+  (props, ref) => {
+    const { className, children, onMouseEnter, onMouseLeave, ...rest } = props;
+
+    assertEmpty(rest);
+
+    const ShadCNComponents = useShadCNComponentsContext()!;
+
+    return (
+      <ShadCNComponents.Tooltip.TooltipProvider delayDuration={0}>
+        <div
+          className={cn(
+            className,
+            "flex gap-1 p-1 bg-popover text-popover-foreground border rounded-lg shadow-md"
+          )}
+          ref={ref}
+          onMouseEnter={onMouseEnter}
+          onMouseLeave={onMouseLeave}>
+          {children}
+        </div>
+      </ShadCNComponents.Tooltip.TooltipProvider>
+    );
+  }
+);
+
+type ToolbarButtonProps = ComponentProps["FormattingToolbar"]["Button"] &
+  ComponentProps["LinkToolbar"]["Button"];
+
+export const ToolbarButton = forwardRef<HTMLButtonElement, ToolbarButtonProps>(
+  (props, ref) => {
+    const {
+      className,
+      children,
+      mainTooltip,
+      secondaryTooltip,
+      icon,
+      isSelected,
+      isDisabled,
+      onClick,
+      label,
+      ...rest
+    } = props;
+
+    // false, because rest props can be added by shadcn when button is used as a trigger
+    // assertEmpty in this case is only used at typescript level, not runtime level
+    assertEmpty(rest, false);
+
+    const ShadCNComponents = useShadCNComponentsContext()!;
+
+    const trigger =
+      isSelected === undefined ? (
+        <ShadCNComponents.Button.Button
+          className={className}
+          variant="ghost"
+          disabled={isDisabled}
+          onClick={onClick}
+          ref={ref}
+          aria-label={label}
+          {...rest}>
+          {icon}
+          {children}
+        </ShadCNComponents.Button.Button>
+      ) : (
+        <ShadCNComponents.Toggle.Toggle
+          className={cn(
+            className,
+            "data-[state=open]:bg-accent data-[state=closed]:text-accent-foreground"
+          )}
+          aria-label={label}
+          onClick={onClick}
+          pressed={isSelected}
+          disabled={isDisabled}
+          data-state={isSelected ? "on" : "off"}
+          data-disabled={isDisabled}
+          ref={ref}
+          {...rest}>
+          {icon}
+          {children}
+        </ShadCNComponents.Toggle.Toggle>
+      );
+
+    return (
+      <ShadCNComponents.Tooltip.Tooltip>
+        <ShadCNComponents.Tooltip.TooltipTrigger asChild>
+          {trigger}
+        </ShadCNComponents.Tooltip.TooltipTrigger>
+        <ShadCNComponents.Tooltip.TooltipContent
+          className={"flex flex-col items-center"}>
+          <span>{mainTooltip}</span>
+          {secondaryTooltip && <span>{secondaryTooltip}</span>}
+        </ShadCNComponents.Tooltip.TooltipContent>
+      </ShadCNComponents.Tooltip.Tooltip>
+    );
+  }
+);
+
+export const ToolbarSelect = forwardRef<
+  HTMLDivElement,
+  ComponentProps["FormattingToolbar"]["Select"]
+>((props, ref) => {
+  const { className, items, isDisabled, ...rest } = props;
+
+  assertEmpty(rest);
+
+  const ShadCNComponents = useShadCNComponentsContext()!;
+
+  // TODO?
+  const SelectItemContent = (props: any) => (
+    <div className={"flex gap-1 items-center"}>
+      {props.icon}
+      {props.text}
+    </div>
+  );
+
+  const selectedItem = items.filter((p) => p.isSelected)[0];
+
+  if (!selectedItem) {
+    return null;
+  }
+
+  return (
+    <ShadCNComponents.Select.Select
+      value={selectedItem.text}
+      onValueChange={(value) =>
+        items.find((item) => item.text === value)!.onClick?.()
+      }
+      disabled={isDisabled}>
+      <ShadCNComponents.Select.SelectTrigger className={"border-none"}>
+        <ShadCNComponents.Select.SelectValue />
+      </ShadCNComponents.Select.SelectTrigger>
+      <ShadCNComponents.Select.SelectContent className={className} ref={ref}>
+        {items.map((item) => (
+          <ShadCNComponents.Select.SelectItem
+            disabled={item.isDisabled}
+            key={item.text}
+            value={item.text}>
+            <SelectItemContent {...item} />
+          </ShadCNComponents.Select.SelectItem>
+        ))}
+      </ShadCNComponents.Select.SelectContent>
+    </ShadCNComponents.Select.Select>
+  );
+});

package/types/src/ShadCNComponentsContext.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="react" />
+import * as ShadCNBadge from "./components/ui/badge";
+import * as ShadCNButton from "./components/ui/button";
+import * as ShadCNCard from "./components/ui/card";
+import * as ShadCNDropdownMenu from "./components/ui/dropdown-menu";
+import * as ShadCNForm from "./components/ui/form";
+import * as ShadCNInput from "./components/ui/input";
+import * as ShadCNLabel from "./components/ui/label";
+import * as ShadCNPopover from "./components/ui/popover";
+import * as ShadCNSelect from "./components/ui/select";
+import * as ShadCNTabs from "./components/ui/tabs";
+import * as ShadCNToggle from "./components/ui/toggle";
+import * as ShadCNTooltip from "./components/ui/tooltip";
+export declare const ShadCNDefaultComponents: {
+    Badge: typeof ShadCNBadge;
+    Button: typeof ShadCNButton;
+    Card: typeof ShadCNCard;
+    DropdownMenu: typeof ShadCNDropdownMenu;
+    Form: typeof ShadCNForm;
+    Input: typeof ShadCNInput;
+    Label: typeof ShadCNLabel;
+    Popover: typeof ShadCNPopover;
+    Select: typeof ShadCNSelect;
+    Tabs: typeof ShadCNTabs;
+    Toggle: typeof ShadCNToggle;
+    Tooltip: typeof ShadCNTooltip;
+};
+export type ShadCNComponents = typeof ShadCNDefaultComponents;
+export declare const ShadCNComponentsContext: import("react").Context<{
+    Badge: typeof ShadCNBadge;
+    Button: typeof ShadCNButton;
+    Card: typeof ShadCNCard;
+    DropdownMenu: typeof ShadCNDropdownMenu;
+    Form: typeof ShadCNForm;
+    Input: typeof ShadCNInput;
+    Label: typeof ShadCNLabel;
+    Popover: typeof ShadCNPopover;
+    Select: typeof ShadCNSelect;
+    Tabs: typeof ShadCNTabs;
+    Toggle: typeof ShadCNToggle;
+    Tooltip: typeof ShadCNTooltip;
+} | undefined>;
+export declare function useShadCNComponentsContext(): {
+    Badge: typeof ShadCNBadge;
+    Button: typeof ShadCNButton;
+    Card: typeof ShadCNCard;
+    DropdownMenu: typeof ShadCNDropdownMenu;
+    Form: typeof ShadCNForm;
+    Input: typeof ShadCNInput;
+    Label: typeof ShadCNLabel;
+    Popover: typeof ShadCNPopover;
+    Select: typeof ShadCNSelect;
+    Tabs: typeof ShadCNTabs;
+    Toggle: typeof ShadCNToggle;
+    Tooltip: typeof ShadCNTooltip;
+} | undefined;

package/types/src/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "secondary" | "destructive" | "outline" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/types/src/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "secondary" | "destructive" | "outline" | "link" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/types/src/components/ui/card.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent, };

package/types/src/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/types/src/components/ui/form.d.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+import { ControllerProps, FieldPath, FieldValues } from "react-hook-form";
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues extends FieldValues | undefined = undefined>(props: import("react-hook-form").FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React.JSX.Element;
+declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => import("react/jsx-runtime").JSX.Element;
+declare const useFormField: () => {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: import("react-hook-form").FieldError | undefined;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+declare const FormItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const FormLabel: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & React.RefAttributes<HTMLLabelElement>>;
+declare const FormControl: React.ForwardRefExoticComponent<Omit<import("@radix-ui/react-slot").SlotProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const FormDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const FormMessage: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { useFormField, Form, FormItem, FormLabel, FormControl, FormDescription, FormMessage, FormField, };

package/types/src/components/ui/input.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+export type InputProps = React.InputHTMLAttributes<HTMLInputElement>;
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/types/src/components/ui/label.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as LabelPrimitive from "@radix-ui/react-label";
+import { type VariantProps } from "class-variance-authority";
+declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & VariantProps<(props?: import("class-variance-authority/dist/types").ClassProp | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;
+export { Label };

package/types/src/components/ui/popover.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Popover, PopoverTrigger, PopoverContent };

package/types/src/components/ui/select.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

package/types/src/components/ui/tabs.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/types/src/components/ui/toggle.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import { type VariantProps } from "class-variance-authority";
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { Toggle, toggleVariants };

package/types/src/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/types/src/form/Form.d.ts

@@ -0,0 +1,2 @@
+import { ComponentProps } from "@blocknote/react";
+export declare const Form: (props: ComponentProps["Generic"]["Form"]["Root"]) => import("react/jsx-runtime").JSX.Element;

package/types/src/form/TextInput.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+export declare const TextInput: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    name: string;
+    label?: string | undefined;
+    icon: import("react").ReactNode;
+    autoFocus?: boolean | undefined;
+    placeholder: string;
+    value: string;
+    onKeyDown: (event: import("react").KeyboardEvent<HTMLInputElement>) => void;
+    onChange: (event: import("react").ChangeEvent<HTMLInputElement>) => void;
+    onSubmit?: (() => void) | undefined;
+} & import("react").RefAttributes<unknown>>;

package/types/src/index.d.ts

@@ -0,0 +1,12 @@
+import { InlineContentSchema, StyleSchema } from "@blocknote/core";
+import { BlockNoteViewRaw, Components } from "@blocknote/react";
+import { ComponentProps } from "react";
+import { ShadCNComponents } from "./ShadCNComponentsContext";
+import "./style.css";
+export declare const components: Components;
+export declare const BlockNoteView: <BSchema extends Record<string, import("@blocknote/core").BlockConfig>, ISchema extends InlineContentSchema, SSchema extends StyleSchema>(props: ComponentProps<typeof BlockNoteViewRaw<BSchema, ISchema, SSchema>> & {
+    /**
+     * (optional)Provide your own shadcn component overrides
+     */
+    shadCNComponents?: Partial<ShadCNComponents>;
+}) => import("react/jsx-runtime").JSX.Element;

package/types/src/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/types/src/menu/Menu.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import { ComponentProps } from "@blocknote/react";
+export declare const Menu: (props: ComponentProps["Generic"]["Menu"]["Root"]) => import("react/jsx-runtime").JSX.Element;
+export declare const MenuTrigger: (props: ComponentProps["Generic"]["Menu"]["Trigger"]) => import("react/jsx-runtime").JSX.Element;
+export declare const MenuDropdown: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+    sub?: boolean | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export declare const MenuItem: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+    subTrigger?: boolean | undefined;
+    icon?: import("react").ReactNode;
+    checked?: boolean | undefined;
+    onClick?: (() => void) | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export declare const MenuDivider: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export declare const MenuLabel: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/panel/Panel.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+export declare const Panel: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    tabs: {
+        name: string;
+        tabPanel: import("react").ReactNode;
+    }[];
+    openTab: string;
+    setOpenTab: (name: string) => void;
+    defaultOpenTab: string;
+    loading: boolean;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/panel/PanelButton.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+export declare const PanelButton: import("react").ForwardRefExoticComponent<({
+    className?: string | undefined;
+    onClick: () => void;
+} & ({
+    children: import("react").ReactNode;
+    label?: string | undefined;
+} | {
+    children?: undefined;
+    label: string;
+})) & import("react").RefAttributes<HTMLButtonElement>>;

package/types/src/panel/PanelFileInput.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare const PanelFileInput: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    value: File | null;
+    placeholder: string;
+    onChange: (payload: File | null) => void;
+} & import("react").RefAttributes<HTMLInputElement>>;

package/types/src/panel/PanelTab.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare const PanelTab: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/panel/PanelTextInput.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export declare const PanelTextInput: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    value: string;
+    placeholder: string;
+    onChange: (event: import("react").ChangeEvent<HTMLInputElement>) => void;
+    onKeyDown: (event: import("react").KeyboardEvent<Element>) => void;
+} & import("react").RefAttributes<HTMLInputElement>>;

package/types/src/popover/popover.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { ComponentProps } from "@blocknote/react";
+export declare const Popover: (props: ComponentProps["Generic"]["Popover"]["Root"]) => import("react/jsx-runtime").JSX.Element;
+export declare const PopoverTrigger: import("react").ForwardRefExoticComponent<{
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<unknown>>;
+export declare const PopoverContent: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    variant: "form-popover" | "panel-popover";
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/sideMenu/SideMenu.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare const SideMenu: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/sideMenu/SideMenuButton.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+export declare const SideMenuButton: import("react").ForwardRefExoticComponent<({
+    className?: string | undefined;
+    onClick?: ((e: import("react").MouseEvent<Element, MouseEvent>) => void) | undefined;
+    icon?: import("react").ReactNode;
+    onDragStart?: ((e: import("react").DragEvent<Element>) => void) | undefined;
+    onDragEnd?: ((e: import("react").DragEvent<Element>) => void) | undefined;
+    draggable?: boolean | undefined;
+} & ({
+    children: import("react").ReactNode;
+    label?: string | undefined;
+} | {
+    children?: undefined;
+    label: string;
+})) & import("react").RefAttributes<HTMLButtonElement>>;

package/types/src/suggestionMenu/SuggestionMenu.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export declare const SuggestionMenu: import("react").ForwardRefExoticComponent<{
+    id: string;
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/suggestionMenu/SuggestionMenuEmptyItem.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare const SuggestionMenuEmptyItem: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/suggestionMenu/SuggestionMenuItem.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export declare const SuggestionMenuItem: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    id: string;
+    isSelected: boolean;
+    onClick: () => void;
+    item: import("@blocknote/react").DefaultReactSuggestionItem;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/suggestionMenu/SuggestionMenuLabel.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare const SuggestionMenuLabel: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/suggestionMenu/SuggestionMenuLoader.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare const SuggestionMenuLoader: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/types/src/tableHandle/TableHandle.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+export declare const TableHandle: import("react").ForwardRefExoticComponent<({
+    className?: string | undefined;
+    draggable: boolean;
+    onDragStart: (e: import("react").DragEvent<Element>) => void;
+    onDragEnd: () => void;
+    style?: import("react").CSSProperties | undefined;
+} & ({
+    children: import("react").ReactNode;
+    label?: string | undefined;
+} | {
+    children?: undefined;
+    label: string;
+})) & import("react").RefAttributes<HTMLButtonElement>>;

package/types/src/toolbar/Toolbar.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+import { ComponentProps } from "@blocknote/react";
+export declare const Toolbar: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+} & {
+    className?: string | undefined;
+    children?: import("react").ReactNode;
+    onMouseEnter?: (() => void) | undefined;
+    onMouseLeave?: (() => void) | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;
+type ToolbarButtonProps = ComponentProps["FormattingToolbar"]["Button"] & ComponentProps["LinkToolbar"]["Button"];
+export declare const ToolbarButton: import("react").ForwardRefExoticComponent<ToolbarButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const ToolbarSelect: import("react").ForwardRefExoticComponent<{
+    className?: string | undefined;
+    items: {
+        text: string;
+        icon: import("react").ReactNode;
+        onClick: () => void;
+        isSelected: boolean;
+        isDisabled?: boolean | undefined;
+    }[];
+    isDisabled?: boolean | undefined;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export {};