@dooherceg/tiptap-controlled-editor-with-table 0.0.1

package/dist/components/tiptap-ui/text-align-button/use-text-align.d.ts

@@ -0,0 +1,101 @@
+import { ChainedCommands, Editor } from '@tiptap/react';
+export type TextAlign = "left" | "center" | "right" | "justify";
+/**
+ * Configuration for the text align functionality
+ */
+export interface UseTextAlignConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The text alignment to apply.
+     */
+    align: TextAlign;
+    /**
+     * Whether the button should hide when alignment is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful alignment change.
+     */
+    onAligned?: () => void;
+}
+export declare const TEXT_ALIGN_SHORTCUT_KEYS: Record<TextAlign, string>;
+export declare const textAlignIcons: {
+    left: import('react').MemoExoticComponent<({ className, ...props }: React.SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element>;
+    center: import('react').MemoExoticComponent<({ className, ...props }: Omit<import('react').SVGProps<SVGSVGElement>, "ref">) => import("react/jsx-runtime").JSX.Element>;
+    right: import('react').MemoExoticComponent<({ className, ...props }: React.SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element>;
+    justify: import('react').MemoExoticComponent<({ className, ...props }: Omit<import('react').SVGProps<SVGSVGElement>, "ref">) => import("react/jsx-runtime").JSX.Element>;
+};
+export declare const textAlignLabels: Record<TextAlign, string>;
+/**
+ * Checks if text alignment can be performed in the current editor state
+ */
+export declare function canSetTextAlign(editor: Editor | null, align: TextAlign): boolean;
+export declare function hasSetTextAlign(commands: ChainedCommands): commands is ChainedCommands & {
+    setTextAlign: (align: TextAlign) => ChainedCommands;
+};
+/**
+ * Checks if the text alignment is currently active
+ */
+export declare function isTextAlignActive(editor: Editor | null, align: TextAlign): boolean;
+/**
+ * Sets text alignment in the editor
+ */
+export declare function setTextAlign(editor: Editor | null, align: TextAlign): boolean;
+/**
+ * Determines if the text align button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+    align: TextAlign;
+}): boolean;
+/**
+ * Custom hook that provides text align functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MySimpleAlignButton() {
+ *   const { isVisible, handleTextAlign } = useTextAlign({ align: "center" })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleTextAlign}>Align Center</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedAlignButton() {
+ *   const { isVisible, handleTextAlign, label, isActive } = useTextAlign({
+ *     editor: myEditor,
+ *     align: "right",
+ *     hideWhenUnavailable: true,
+ *     onAligned: () => console.log('Text aligned!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleTextAlign}
+ *       aria-pressed={isActive}
+ *       aria-label={label}
+ *     >
+ *       Align Right
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useTextAlign(config: UseTextAlignConfig): {
+    isVisible: boolean;
+    isActive: boolean;
+    handleTextAlign: () => boolean;
+    canAlign: boolean;
+    label: string;
+    shortcutKeys: string;
+    Icon: import('react').MemoExoticComponent<({ className, ...props }: React.SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element> | import('react').MemoExoticComponent<({ className, ...props }: Omit<import('react').SVGProps<SVGSVGElement>, "ref">) => import("react/jsx-runtime").JSX.Element> | import('react').MemoExoticComponent<({ className, ...props }: React.SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element> | import('react').MemoExoticComponent<({ className, ...props }: Omit<import('react').SVGProps<SVGSVGElement>, "ref">) => import("react/jsx-runtime").JSX.Element>;
+};

package/dist/components/tiptap-ui/text-align-button/use-text-align.js

@@ -0,0 +1,84 @@
+import { useState as h, useEffect as m, useCallback as d } from "react";
+import "@tiptap/react";
+import { useTiptapEditor as p } from "../../../hooks/use-tiptap-editor.js";
+import { isExtensionAvailable as f, isNodeTypeSelected as x } from "../../../lib/tiptap-utils.js";
+import { AlignCenterIcon as T } from "../../tiptap-icons/align-center-icon.js";
+import { AlignJustifyIcon as b } from "../../tiptap-icons/align-justify-icon.js";
+import { AlignLeftIcon as E } from "../../tiptap-icons/align-left-icon.js";
+import { AlignRightIcon as v } from "../../tiptap-icons/align-right-icon.js";
+const I = {
+  left: "mod+shift+l",
+  center: "mod+shift+e",
+  right: "mod+shift+r",
+  justify: "mod+shift+j"
+}, S = {
+  left: E,
+  center: T,
+  right: v,
+  justify: b
+}, y = {
+  left: "Align left",
+  center: "Align center",
+  right: "Align right",
+  justify: "Align justify"
+};
+function r(t, e) {
+  return !t || !t.isEditable || !f(t, "textAlign") || x(t, ["image", "horizontalRule"]) ? !1 : t.can().setTextAlign(e);
+}
+function U(t) {
+  return "setTextAlign" in t;
+}
+function j(t, e) {
+  return !t || !t.isEditable ? !1 : t.isActive({ textAlign: e });
+}
+function C(t, e) {
+  if (!t || !t.isEditable || !r(t, e)) return !1;
+  const n = t.chain().focus();
+  return U(n) ? n.setTextAlign(e).run() : !1;
+}
+function L(t) {
+  const { editor: e, hideWhenUnavailable: n, align: l } = t;
+  return !e || !e.isEditable || !f(e, "textAlign") ? !1 : n && !e.isActive("code") ? r(e, l) : !0;
+}
+function z(t) {
+  const {
+    editor: e,
+    align: n,
+    hideWhenUnavailable: l = !1,
+    onAligned: o
+  } = t, { editor: i } = p(e), [c, u] = h(!0), a = r(i, n), g = j(i, n);
+  m(() => {
+    if (!i) return;
+    const s = () => {
+      u(L({ editor: i, align: n, hideWhenUnavailable: l }));
+    };
+    return s(), i.on("selectionUpdate", s), () => {
+      i.off("selectionUpdate", s);
+    };
+  }, [i, l, n]);
+  const A = d(() => {
+    if (!i) return !1;
+    const s = C(i, n);
+    return s && o?.(), s;
+  }, [i, n, o]);
+  return {
+    isVisible: c,
+    isActive: g,
+    handleTextAlign: A,
+    canAlign: a,
+    label: y[n],
+    shortcutKeys: I[n],
+    Icon: S[n]
+  };
+}
+export {
+  I as TEXT_ALIGN_SHORTCUT_KEYS,
+  r as canSetTextAlign,
+  U as hasSetTextAlign,
+  j as isTextAlignActive,
+  C as setTextAlign,
+  L as shouldShowButton,
+  S as textAlignIcons,
+  y as textAlignLabels,
+  z as useTextAlign
+};

package/dist/components/tiptap-ui/undo-redo-button/index.d.ts

@@ -0,0 +1,2 @@
+export * from './undo-redo-button';
+export * from './use-undo-redo';

package/dist/components/tiptap-ui/undo-redo-button/index.js

@@ -0,0 +1,13 @@
+import { HistoryShortcutBadge as e, UndoRedoButton as n } from "./undo-redo-button.js";
+import { UNDO_REDO_SHORTCUT_KEYS as c, canExecuteUndoRedoAction as r, executeUndoRedoAction as s, historyActionLabels as u, historyIcons as i, shouldShowButton as R, useUndoRedo as U } from "./use-undo-redo.js";
+export {
+  e as HistoryShortcutBadge,
+  c as UNDO_REDO_SHORTCUT_KEYS,
+  n as UndoRedoButton,
+  r as canExecuteUndoRedoAction,
+  s as executeUndoRedoAction,
+  u as historyActionLabels,
+  i as historyIcons,
+  R as shouldShowButton,
+  U as useUndoRedo
+};

package/dist/components/tiptap-ui/undo-redo-button/undo-redo-button.d.ts

@@ -0,0 +1,23 @@
+import { UndoRedoAction, UseUndoRedoConfig } from '.';
+import { ButtonProps } from '../../tiptap-ui-primitive/button';
+export interface UndoRedoButtonProps extends Omit<ButtonProps, "type">, UseUndoRedoConfig {
+    /**
+     * Optional text to display alongside the icon.
+     */
+    text?: string;
+    /**
+     * Optional show shortcut keys in the button.
+     * @default false
+     */
+    showShortcut?: boolean;
+}
+export declare function HistoryShortcutBadge({ action, shortcutKeys, }: {
+    action: UndoRedoAction;
+    shortcutKeys?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Button component for triggering undo/redo actions in a Tiptap editor.
+ *
+ * For custom button implementations, use the `useHistory` hook instead.
+ */
+export declare const UndoRedoButton: import('react').ForwardRefExoticComponent<UndoRedoButtonProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/components/tiptap-ui/undo-redo-button/undo-redo-button.js

@@ -0,0 +1,70 @@
+import { jsx as t, jsxs as B, Fragment as U } from "react/jsx-runtime";
+import { forwardRef as g, useCallback as E } from "react";
+import { parseShortcutKeys as N } from "../../../lib/tiptap-utils.js";
+import { useTiptapEditor as S } from "../../../hooks/use-tiptap-editor.js";
+import { useUndoRedo as C, UNDO_REDO_SHORTCUT_KEYS as K } from "./use-undo-redo.js";
+import { Button as O } from "../../tiptap-ui-primitive/button/button.js";
+import { Badge as T } from "../../tiptap-ui-primitive/badge/badge.js";
+function _({
+  action: e,
+  shortcutKeys: o = K[e]
+}) {
+  return /* @__PURE__ */ t(T, { children: N({ shortcutKeys: o }) });
+}
+const j = g(
+  ({
+    editor: e,
+    action: o,
+    text: r,
+    hideWhenUnavailable: l = !1,
+    onExecuted: u,
+    showShortcut: c = !1,
+    onClick: a,
+    children: p,
+    ...m
+  }, f) => {
+    const { editor: b } = S(e), { isVisible: h, handleAction: n, label: i, canExecute: s, Icon: y, shortcutKeys: R } = C({
+      editor: b,
+      action: o,
+      hideWhenUnavailable: l,
+      onExecuted: u
+    }), x = E(
+      (d) => {
+        a?.(d), !d.defaultPrevented && n();
+      },
+      [n, a]
+    );
+    return h ? /* @__PURE__ */ t(
+      O,
+      {
+        type: "button",
+        disabled: !s,
+        "data-style": "ghost",
+        "data-disabled": !s,
+        role: "button",
+        tabIndex: -1,
+        "aria-label": i,
+        tooltip: i,
+        onClick: x,
+        ...m,
+        ref: f,
+        children: p ?? /* @__PURE__ */ B(U, { children: [
+          /* @__PURE__ */ t(y, { className: "tiptap-button-icon" }),
+          r && /* @__PURE__ */ t("span", { className: "tiptap-button-text", children: r }),
+          c && /* @__PURE__ */ t(
+            _,
+            {
+              action: o,
+              shortcutKeys: R
+            }
+          )
+        ] })
+      }
+    ) : null;
+  }
+);
+j.displayName = "UndoRedoButton";
+export {
+  _ as HistoryShortcutBadge,
+  j as UndoRedoButton
+};

package/dist/components/tiptap-ui/undo-redo-button/use-undo-redo.d.ts

@@ -0,0 +1,90 @@
+import { Editor } from '@tiptap/react';
+export type UndoRedoAction = "undo" | "redo";
+/**
+ * Configuration for the history functionality
+ */
+export interface UseUndoRedoConfig {
+    /**
+     * The Tiptap editor instance.
+     */
+    editor?: Editor | null;
+    /**
+     * The history action to perform (undo or redo).
+     */
+    action: UndoRedoAction;
+    /**
+     * Whether the button should hide when action is not available.
+     * @default false
+     */
+    hideWhenUnavailable?: boolean;
+    /**
+     * Callback function called after a successful action execution.
+     */
+    onExecuted?: () => void;
+}
+export declare const UNDO_REDO_SHORTCUT_KEYS: Record<UndoRedoAction, string>;
+export declare const historyActionLabels: Record<UndoRedoAction, string>;
+export declare const historyIcons: {
+    undo: import('react').MemoExoticComponent<({ className, ...props }: React.SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element>;
+    redo: import('react').MemoExoticComponent<({ className, ...props }: React.SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element>;
+};
+/**
+ * Checks if a history action can be executed
+ */
+export declare function canExecuteUndoRedoAction(editor: Editor | null, action: UndoRedoAction): boolean;
+/**
+ * Executes a history action on the editor
+ */
+export declare function executeUndoRedoAction(editor: Editor | null, action: UndoRedoAction): boolean;
+/**
+ * Determines if the history button should be shown
+ */
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+    action: UndoRedoAction;
+}): boolean;
+/**
+ * Custom hook that provides history functionality for Tiptap editor
+ *
+ * @example
+ * ```tsx
+ * // Simple usage
+ * function MySimpleUndoButton() {
+ *   const { isVisible, handleAction } = useHistory({ action: "undo" })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return <button onClick={handleAction}>Undo</button>
+ * }
+ *
+ * // Advanced usage with configuration
+ * function MyAdvancedRedoButton() {
+ *   const { isVisible, handleAction, label } = useHistory({
+ *     editor: myEditor,
+ *     action: "redo",
+ *     hideWhenUnavailable: true,
+ *     onExecuted: () => console.log('Action executed!')
+ *   })
+ *
+ *   if (!isVisible) return null
+ *
+ *   return (
+ *     <MyButton
+ *       onClick={handleAction}
+ *       aria-label={label}
+ *     >
+ *       Redo
+ *     </MyButton>
+ *   )
+ * }
+ * ```
+ */
+export declare function useUndoRedo(config: UseUndoRedoConfig): {
+    isVisible: boolean;
+    handleAction: () => boolean;
+    canExecute: boolean;
+    label: string;
+    shortcutKeys: string;
+    Icon: import('react').MemoExoticComponent<({ className, ...props }: React.SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element> | import('react').MemoExoticComponent<({ className, ...props }: React.SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element>;
+};

package/dist/components/tiptap-ui/undo-redo-button/use-undo-redo.js

@@ -0,0 +1,67 @@
+import { useState as l, useEffect as h, useCallback as m } from "react";
+import "@tiptap/react";
+import { useTiptapEditor as p } from "../../../hooks/use-tiptap-editor.js";
+import { isNodeTypeSelected as E } from "../../../lib/tiptap-utils.js";
+import { Redo2Icon as b } from "../../tiptap-icons/redo2-icon.js";
+import { Undo2Icon as U } from "../../tiptap-icons/undo2-icon.js";
+const R = {
+  undo: "mod+z",
+  redo: "mod+shift+z"
+}, x = {
+  undo: "Undo",
+  redo: "Redo"
+}, A = {
+  undo: U,
+  redo: b
+};
+function s(n, o) {
+  return !n || !n.isEditable || E(n, ["image"]) ? !1 : o === "undo" ? n.can().undo() : n.can().redo();
+}
+function I(n, o) {
+  if (!n || !n.isEditable || !s(n, o)) return !1;
+  const e = n.chain().focus();
+  return o === "undo" ? e.undo().run() : e.redo().run();
+}
+function S(n) {
+  const { editor: o, hideWhenUnavailable: e, action: i } = n;
+  return !o || !o.isEditable ? !1 : e && !o.isActive("code") ? s(o, i) : !0;
+}
+function C(n) {
+  const {
+    editor: o,
+    action: e,
+    hideWhenUnavailable: i = !1,
+    onExecuted: c
+  } = n, { editor: t } = p(o), [u, a] = l(!0), d = s(t, e);
+  h(() => {
+    if (!t) return;
+    const r = () => {
+      a(S({ editor: t, hideWhenUnavailable: i, action: e }));
+    };
+    return r(), t.on("transaction", r), () => {
+      t.off("transaction", r);
+    };
+  }, [t, i, e]);
+  const f = m(() => {
+    if (!t) return !1;
+    const r = I(t, e);
+    return r && c?.(), r;
+  }, [t, e, c]);
+  return {
+    isVisible: u,
+    handleAction: f,
+    canExecute: d,
+    label: x[e],
+    shortcutKeys: R[e],
+    Icon: A[e]
+  };
+}
+export {
+  R as UNDO_REDO_SHORTCUT_KEYS,
+  s as canExecuteUndoRedoAction,
+  I as executeUndoRedoAction,
+  x as historyActionLabels,
+  A as historyIcons,
+  S as shouldShowButton,
+  C as useUndoRedo
+};

package/dist/components/tiptap-ui-primitive/badge/badge.d.ts

@@ -0,0 +1,8 @@
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: "ghost" | "white" | "gray" | "green" | "default";
+    size?: "default" | "small";
+    appearance?: "default" | "subdued" | "emphasized";
+    trimText?: boolean;
+}
+export declare const Badge: import('react').ForwardRefExoticComponent<BadgeProps & import('react').RefAttributes<HTMLDivElement>>;
+export default Badge;

package/dist/components/tiptap-ui-primitive/badge/badge.js

@@ -0,0 +1,30 @@
+import { jsx as p } from "react/jsx-runtime";
+import { forwardRef as i } from "react";
+import '../../../assets/badge.css';const l = i(
+  ({
+    variant: a,
+    size: t = "default",
+    appearance: e = "default",
+    trimText: d = !1,
+    className: r,
+    children: f,
+    ...o
+  }, s) => /* @__PURE__ */ p(
+    "div",
+    {
+      ref: s,
+      className: `tiptap-badge ${r || ""}`,
+      "data-style": a,
+      "data-size": t,
+      "data-appearance": e,
+      "data-text-trim": d ? "on" : "off",
+      ...o,
+      children: f
+    }
+  )
+);
+l.displayName = "Badge";
+export {
+  l as Badge,
+  l as default
+};

package/dist/components/tiptap-ui-primitive/badge/index.d.ts

@@ -0,0 +1 @@
+export * from './badge';

package/dist/components/tiptap-ui-primitive/badge/index.js

@@ -0,0 +1,4 @@
+import { Badge as r } from "./badge.js";
+export {
+  r as Badge
+};

package/dist/components/tiptap-ui-primitive/button/button.d.ts

@@ -0,0 +1,14 @@
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    className?: string;
+    showTooltip?: boolean;
+    tooltip?: React.ReactNode;
+    shortcutKeys?: string;
+}
+export declare const ShortcutDisplay: React.FC<{
+    shortcuts: string[];
+}>;
+export declare const Button: import('react').ForwardRefExoticComponent<ButtonProps & import('react').RefAttributes<HTMLButtonElement>>;
+export declare const ButtonGroup: import('react').ForwardRefExoticComponent<Omit<import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement> & {
+    orientation?: "horizontal" | "vertical";
+}, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+export default Button;

package/dist/components/tiptap-ui-primitive/button/button.js

@@ -0,0 +1,69 @@
+import { jsx as o, jsxs as i } from "react/jsx-runtime";
+import { forwardRef as s, useMemo as d, Fragment as b } from "react";
+import { parseShortcutKeys as f, cn as l } from "../../../lib/tiptap-utils.js";
+import { Tooltip as h, TooltipTrigger as g, TooltipContent as y } from "../tooltip/tooltip.js";
+import '../../../assets/button.css';const B = ({
+  shortcuts: t
+}) => t.length === 0 ? null : /* @__PURE__ */ o("div", { children: t.map((a, r) => /* @__PURE__ */ i(b, { children: [
+  r > 0 && /* @__PURE__ */ o("kbd", { children: "+" }),
+  /* @__PURE__ */ o("kbd", { children: a })
+] }, r)) }), N = s(
+  ({
+    className: t,
+    children: a,
+    tooltip: r,
+    showTooltip: n = !0,
+    shortcutKeys: e,
+    "aria-label": u,
+    ...p
+  }, m) => {
+    const c = d(
+      () => f({ shortcutKeys: e }),
+      [e]
+    );
+    return !r || !n ? /* @__PURE__ */ o(
+      "button",
+      {
+        className: l("tiptap-button", t),
+        ref: m,
+        "aria-label": u,
+        ...p,
+        children: a
+      }
+    ) : /* @__PURE__ */ i(h, { delay: 200, children: [
+      /* @__PURE__ */ o(
+        g,
+        {
+          className: l("tiptap-button", t),
+          ref: m,
+          "aria-label": u,
+          ...p,
+          children: a
+        }
+      ),
+      /* @__PURE__ */ i(y, { children: [
+        r,
+        /* @__PURE__ */ o(B, { shortcuts: c })
+      ] })
+    ] });
+  }
+);
+N.displayName = "Button";
+const T = s(({ className: t, children: a, orientation: r = "vertical", ...n }, e) => /* @__PURE__ */ o(
+  "div",
+  {
+    ref: e,
+    className: l("tiptap-button-group", t),
+    "data-orientation": r,
+    role: "group",
+    ...n,
+    children: a
+  }
+));
+T.displayName = "ButtonGroup";
+export {
+  N as Button,
+  T as ButtonGroup,
+  B as ShortcutDisplay,
+  N as default
+};

package/dist/components/tiptap-ui-primitive/button/index.d.ts

@@ -0,0 +1 @@
+export * from './button';

package/dist/components/tiptap-ui-primitive/button/index.js

@@ -0,0 +1,6 @@
+import { Button as r, ButtonGroup as u, ShortcutDisplay as p } from "./button.js";
+export {
+  r as Button,
+  u as ButtonGroup,
+  p as ShortcutDisplay
+};

package/dist/components/tiptap-ui-primitive/card/card.d.ts

@@ -0,0 +1,9 @@
+declare const Card: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+declare const CardHeader: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+declare const CardBody: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+declare const CardItemGroup: import('react').ForwardRefExoticComponent<Omit<import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement> & {
+    orientation?: "horizontal" | "vertical";
+}, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+declare const CardGroupLabel: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+declare const CardFooter: import('react').ForwardRefExoticComponent<Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardBody, CardItemGroup, CardGroupLabel };

package/dist/components/tiptap-ui-primitive/card/card.js

@@ -0,0 +1,62 @@
+import { jsx as t } from "react/jsx-runtime";
+import { forwardRef as e } from "react";
+import { cn as o } from "../../../lib/tiptap-utils.js";
+import '../../../assets/card.css';const i = e(
+  ({ className: a, ...r }, d) => /* @__PURE__ */ t("div", { ref: d, className: o("tiptap-card", a), ...r })
+);
+i.displayName = "Card";
+const s = e(
+  ({ className: a, ...r }, d) => /* @__PURE__ */ t(
+    "div",
+    {
+      ref: d,
+      className: o("tiptap-card-header", a),
+      ...r
+    }
+  )
+);
+s.displayName = "CardHeader";
+const m = e(
+  ({ className: a, ...r }, d) => /* @__PURE__ */ t("div", { ref: d, className: o("tiptap-card-body", a), ...r })
+);
+m.displayName = "CardBody";
+const c = e(({ className: a, orientation: r = "vertical", ...d }, p) => /* @__PURE__ */ t(
+  "div",
+  {
+    ref: p,
+    "data-orientation": r,
+    className: o("tiptap-card-item-group", a),
+    ...d
+  }
+));
+c.displayName = "CardItemGroup";
+const l = e(
+  ({ className: a, ...r }, d) => /* @__PURE__ */ t(
+    "div",
+    {
+      ref: d,
+      className: o("tiptap-card-group-label", a),
+      ...r
+    }
+  )
+);
+l.displayName = "CardGroupLabel";
+const n = e(
+  ({ className: a, ...r }, d) => /* @__PURE__ */ t(
+    "div",
+    {
+      ref: d,
+      className: o("tiptap-card-footer", a),
+      ...r
+    }
+  )
+);
+n.displayName = "CardFooter";
+export {
+  i as Card,
+  m as CardBody,
+  n as CardFooter,
+  l as CardGroupLabel,
+  s as CardHeader,
+  c as CardItemGroup
+};

package/dist/components/tiptap-ui-primitive/card/index.d.ts

@@ -0,0 +1 @@
+export * from './card';