ritext 1.0.19 → 1.0.25

package/dist/extension/table.mjs

@@ -0,0 +1,324 @@
+import {
+  DropdownComponent_default
+} from "../chunk-FJQ4FZRS.mjs";
+import {
+  TabelIcon
+} from "../chunk-EN4BPI7N.mjs";
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-WNQUEZJF.mjs";
+
+// src/extension/Table.tsx
+import { Fragment } from "react";
+import { TableKit } from "@tiptap/extension-table";
+
+// src/lib/components/TableMenu.tsx
+import { useEffect, useMemo, useRef, useState } from "react";
+import { autoUpdate, flip, offset, shift, useDismiss, useFloating, useInteractions, FloatingPortal } from "@floating-ui/react";
+import { ColorPicker } from "@siamf/react-color-pick";
+import { jsx, jsxs } from "react/jsx-runtime";
+var getClosestCell = (target) => {
+  var _a, _b;
+  const el = target;
+  if (!el) return null;
+  return (_b = (_a = el.closest) == null ? void 0 : _a.call(el, "td,th")) != null ? _b : null;
+};
+var isTableResizeHandle = (target) => {
+  var _a;
+  const el = target;
+  if (!el) return false;
+  if ((_a = el.closest) == null ? void 0 : _a.call(el, ".column-resize-handle")) return true;
+  const cursor = window.getComputedStyle(el).cursor;
+  if (cursor === "col-resize" || cursor === "ew-resize") return true;
+  return false;
+};
+var TableMenu = ({ editor }) => {
+  const [open, setOpen] = useState(false);
+  const [refCell, setRefCell] = useState(null);
+  const [bg, setBg] = useState("#FFF2CC");
+  const [pickerOpen, setPickerOpen] = useState(false);
+  const resizingRef = useRef(false);
+  const { refs, floatingStyles, context, update } = useFloating({
+    open,
+    onOpenChange: (o) => {
+      setOpen(o);
+      if (!o) setPickerOpen(false);
+    },
+    placement: "bottom-start",
+    strategy: "fixed",
+    whileElementsMounted: autoUpdate,
+    middleware: [offset(8), flip({ padding: 8 }), shift({ padding: 8 })]
+  });
+  const dismiss = useDismiss(context, { outsidePressEvent: "pointerdown", escapeKey: true });
+  const { getFloatingProps } = useInteractions([dismiss]);
+  const pickerFloating = useFloating({
+    open: pickerOpen,
+    onOpenChange: (o) => setPickerOpen(o),
+    placement: "right-start",
+    strategy: "fixed",
+    whileElementsMounted: autoUpdate,
+    middleware: [offset(8), flip({ padding: 8 }), shift({ padding: 8 })]
+  });
+  const pickerDismiss = useDismiss(pickerFloating.context, { outsidePressEvent: "pointerdown", escapeKey: true });
+  const pickerInteractions = useInteractions([pickerDismiss]);
+  useEffect(() => {
+    const onUp = () => {
+      resizingRef.current = false;
+    };
+    window.addEventListener("pointerup", onUp, true);
+    window.addEventListener("pointercancel", onUp, true);
+    return () => {
+      window.removeEventListener("pointerup", onUp, true);
+      window.removeEventListener("pointercancel", onUp, true);
+    };
+  }, []);
+  useEffect(() => {
+    if (!editor) return;
+    const root = editor.view.dom;
+    const onPointerDownCapture = (e) => {
+      if (isTableResizeHandle(e.target)) {
+        resizingRef.current = true;
+        setPickerOpen(false);
+        return;
+      }
+      if (resizingRef.current) return;
+      const cell = getClosestCell(e.target);
+      if (!cell) {
+        setOpen(false);
+        setRefCell(null);
+        setPickerOpen(false);
+        return;
+      }
+      refs.setReference(cell);
+      setRefCell(cell);
+      setOpen(true);
+      requestAnimationFrame(() => {
+        update();
+      });
+    };
+    root.addEventListener("pointerdown", onPointerDownCapture, true);
+    return () => root.removeEventListener("pointerdown", onPointerDownCapture, true);
+  }, [editor, refs, update]);
+  useEffect(() => {
+    if (!editor) return;
+    const onSelectionUpdate = () => {
+      if (!editor.isActive("table")) {
+        setOpen(false);
+        setRefCell(null);
+        setPickerOpen(false);
+      }
+    };
+    editor.on("selectionUpdate", onSelectionUpdate);
+    return () => {
+      editor.off("selectionUpdate", onSelectionUpdate);
+    };
+  }, [editor]);
+  const run = useMemo(() => {
+    return (fn, close = true) => {
+      if (!editor) return;
+      fn(editor);
+      if (close) {
+        setOpen(false);
+        setPickerOpen(false);
+      }
+    };
+  }, [editor]);
+  if (!editor || !open || !refCell) return null;
+  return /* @__PURE__ */ jsx(FloatingPortal, { children: /* @__PURE__ */ jsx(
+    "div",
+    __spreadProps(__spreadValues({
+      ref: refs.setFloating,
+      style: floatingStyles,
+      className: "z-9999999 min-w-65 rounded-xl border border-gray-200 bg-white shadow-lg p-2"
+    }, getFloatingProps({
+      onPointerDownCapture: (e) => {
+        e.stopPropagation();
+      }
+    })), {
+      children: /* @__PURE__ */ jsxs("div", { className: "grid gap-1 text-sm", children: [
+        /* @__PURE__ */ jsx("div", { className: "px-2 py-1 text-xs font-semibold text-gray-500", children: "Columns" }),
+        /* @__PURE__ */ jsx("button", { className: "rounded-md px-2 py-1 hover:bg-gray-100 text-left", onClick: () => run((ed) => ed.chain().focus().addColumnBefore().run()), children: "Insert column before" }),
+        /* @__PURE__ */ jsx("button", { className: "rounded-md px-2 py-1 hover:bg-gray-100 text-left", onClick: () => run((ed) => ed.chain().focus().addColumnAfter().run()), children: "Insert column after" }),
+        /* @__PURE__ */ jsx("button", { className: "rounded-md px-2 py-1 hover:bg-gray-100 text-left", onClick: () => run((ed) => ed.chain().focus().deleteColumn().run()), children: "Delete column" }),
+        /* @__PURE__ */ jsx("div", { className: "mt-1 px-2 py-1 text-xs font-semibold text-gray-500", children: "Rows" }),
+        /* @__PURE__ */ jsx("button", { className: "rounded-md px-2 py-1 hover:bg-gray-100 text-left", onClick: () => run((ed) => ed.chain().focus().addRowBefore().run()), children: "Insert row above" }),
+        /* @__PURE__ */ jsx("button", { className: "rounded-md px-2 py-1 hover:bg-gray-100 text-left", onClick: () => run((ed) => ed.chain().focus().addRowAfter().run()), children: "Insert row below" }),
+        /* @__PURE__ */ jsx("button", { className: "rounded-md px-2 py-1 hover:bg-gray-100 text-left", onClick: () => run((ed) => ed.chain().focus().deleteRow().run()), children: "Delete row" }),
+        /* @__PURE__ */ jsx("div", { className: "mt-1 px-2 py-1 text-xs font-semibold text-gray-500", children: "Cells" }),
+        /* @__PURE__ */ jsx("button", { className: "rounded-md px-2 py-1 hover:bg-gray-100 text-left", onClick: () => run((ed) => ed.chain().focus().mergeCells().run()), children: "Merge cells" }),
+        /* @__PURE__ */ jsx("button", { className: "rounded-md px-2 py-1 hover:bg-gray-100 text-left", onClick: () => run((ed) => ed.chain().focus().splitCell().run()), children: "Split cell" }),
+        /* @__PURE__ */ jsx("div", { className: "mt-1 px-2 py-1 text-xs font-semibold text-gray-500", children: "Cell background" }),
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 px-2 py-1", children: [
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              ref: pickerFloating.refs.setReference,
+              type: "button",
+              className: "h-6 w-8 rounded border border-gray-200 cursor-pointer p-0",
+              style: { background: bg },
+              title: "Pick color",
+              onClick: () => setPickerOpen((v) => !v)
+            }
+          ),
+          /* @__PURE__ */ jsx("button", { className: "flex-1 rounded-md px-2 py-1 hover:bg-gray-100 text-left", onClick: () => run((ed) => ed.chain().focus().setCellAttribute("backgroundColor", bg).run()), children: "Apply background" }),
+          /* @__PURE__ */ jsx("button", { className: "rounded-md px-2 py-1 hover:bg-gray-100", title: "Clear", onClick: () => run((ed) => ed.chain().focus().setCellAttribute("backgroundColor", null).run()), children: "\u2715" })
+        ] }),
+        pickerOpen && /* @__PURE__ */ jsx(FloatingPortal, { children: /* @__PURE__ */ jsx(
+          "div",
+          __spreadProps(__spreadValues({
+            ref: pickerFloating.refs.setFloating,
+            style: pickerFloating.floatingStyles,
+            className: "z-99999999 rounded-xl border border-gray-200 bg-white shadow-lg p-2"
+          }, pickerInteractions.getFloatingProps({
+            onPointerDownCapture: (e) => {
+              e.stopPropagation();
+            }
+          })), {
+            children: /* @__PURE__ */ jsx(ColorPicker, { value: bg, onChange: setBg })
+          })
+        ) }),
+        /* @__PURE__ */ jsx("div", { className: "mt-1 border-t border-gray-200 pt-1" }),
+        /* @__PURE__ */ jsx("button", { className: "rounded-md px-2 py-1 hover:bg-red-50 text-left text-red-600", onClick: () => run((ed) => ed.chain().focus().deleteTable().run()), children: "Delete table" })
+      ] })
+    })
+  ) });
+};
+
+// src/lib/components/TableInsertComponent.tsx
+import { useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var MAX = 10;
+var clamp = (v, min, max) => Math.max(min, Math.min(max, v));
+var TableInsertComponent = ({ editor, onClose, open }) => {
+  const gridRef = useRef2(null);
+  const [hover, setHover] = useState2({ rows: 0, cols: 0 });
+  useEffect2(() => {
+    if (open) setHover({ rows: 0, cols: 0 });
+  }, [open]);
+  const label = useMemo2(() => {
+    if (!hover.rows || !hover.cols) return "Select size";
+    return `${hover.rows} \xD7 ${hover.cols}`;
+  }, [hover]);
+  const canInsert = !!editor && typeof (editor == null ? void 0 : editor.chain) === "function";
+  const insert = (rows, cols) => {
+    if (!canInsert || rows < 1 || cols < 1) return;
+    editor.chain().focus().insertTable({ rows, cols, withHeaderRow: false }).run();
+    onClose == null ? void 0 : onClose();
+    setHover({ rows: 0, cols: 0 });
+  };
+  const updateFromPointer = (clientX, clientY) => {
+    const el = gridRef.current;
+    if (!el) return;
+    const rect = el.getBoundingClientRect();
+    const x = clientX - rect.left;
+    const y = clientY - rect.top;
+    if (x < 0 || y < 0 || x > rect.width || y > rect.height) {
+      setHover((s) => s.rows || s.cols ? { rows: 0, cols: 0 } : s);
+      return;
+    }
+    const col = clamp(Math.floor(x / rect.width * MAX) + 1, 1, MAX);
+    const row = clamp(Math.floor(y / rect.height * MAX) + 1, 1, MAX);
+    setHover((s) => s.rows === row && s.cols === col ? s : { rows: row, cols: col });
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: "w-full p-2", children: [
+    /* @__PURE__ */ jsx2("div", { className: "mb-2 flex items-center justify-between", children: /* @__PURE__ */ jsx2("span", { className: "text-xs text-gray-600", children: label }) }),
+    /* @__PURE__ */ jsx2(
+      "div",
+      {
+        ref: gridRef,
+        className: "grid gap-1 cursor-pointer select-none",
+        style: { gridTemplateColumns: `repeat(${MAX}, minmax(0, 1fr))` },
+        onMouseMove: (e) => updateFromPointer(e.clientX, e.clientY),
+        onMouseLeave: () => setHover({ rows: 0, cols: 0 }),
+        onClick: () => hover.rows && hover.cols ? insert(hover.rows, hover.cols) : null,
+        children: Array.from({ length: MAX * MAX }).map((_, i) => {
+          const r = Math.floor(i / MAX) + 1;
+          const c = i % MAX + 1;
+          const active = r <= hover.rows && c <= hover.cols;
+          return /* @__PURE__ */ jsx2(
+            "button",
+            {
+              type: "button",
+              className: [
+                "h-5 w-5 rounded-sm border transition",
+                active ? "border-gray-500 bg-gray-300" : "border-gray-200 bg-white hover:bg-gray-50"
+              ].join(" "),
+              "aria-label": `Insert ${r} by ${c} table`,
+              disabled: !canInsert,
+              tabIndex: -1
+            },
+            i
+          );
+        })
+      }
+    ),
+    !canInsert && /* @__PURE__ */ jsx2("p", { className: "mt-2 text-xs text-red-500", children: "Editor is not ready to insert a table." })
+  ] });
+};
+var TableInsertComponent_default = TableInsertComponent;
+
+// src/extension/Table.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var Table = TableKit.extend({
+  addExtensions() {
+    var _a, _b;
+    const parentExts = (_b = (_a = this.parent) == null ? void 0 : _a.call(this)) != null ? _b : [];
+    return parentExts.map((ext) => {
+      if ((ext == null ? void 0 : ext.name) === "tableCell" || (ext == null ? void 0 : ext.name) === "tableHeader") {
+        return ext.extend({
+          addAttributes() {
+            var _a2, _b2;
+            const parentAttrs = (_b2 = (_a2 = this.parent) == null ? void 0 : _a2.call(this)) != null ? _b2 : {};
+            return __spreadProps(__spreadValues({}, parentAttrs), {
+              backgroundColor: {
+                default: null,
+                parseHTML: (el) => el.getAttribute("data-bg") || el.style.backgroundColor || null,
+                renderHTML: (attrs) => {
+                  if (!attrs.backgroundColor) return {};
+                  return {
+                    "data-bg": attrs.backgroundColor,
+                    style: `background-color: ${attrs.backgroundColor};`
+                  };
+                }
+              }
+            });
+          }
+        });
+      }
+      return ext;
+    });
+  },
+  addOptions() {
+    var _a;
+    const parent = (_a = this.parent) == null ? void 0 : _a.call(this);
+    return __spreadProps(__spreadValues({}, parent != null ? parent : {}), {
+      table: {
+        resizable: true
+      },
+      component: ({ options, editor, dropdownContainerClassName }) => /* @__PURE__ */ jsxs3(Fragment, { children: [
+        /* @__PURE__ */ jsx3(
+          DropdownComponent_default,
+          {
+            className: options.className,
+            showArrow: options.showArrow || false,
+            content: options.content,
+            dropdownClassName: options.dropdownClassName,
+            style: options.style,
+            tooltip: options.tooltip,
+            tooltipClassName: options.tooltipClassName,
+            tooltipPlacement: options.tooltipPlacement,
+            _tooltipContent: "Table",
+            _internalContent: /* @__PURE__ */ jsx3(TabelIcon, {}),
+            _dropdownClassName: "w-70 " + dropdownContainerClassName,
+            children: /* @__PURE__ */ jsx3(TableInsertComponent_default, { editor })
+          }
+        ),
+        /* @__PURE__ */ jsx3(TableMenu, { editor })
+      ] })
+    });
+  }
+});
+export {
+  Table
+};

package/dist/extension/tasklist.d.mts

@@ -0,0 +1,10 @@
+import { TaskListOptions } from '@tiptap/extension-list';
+import { Node } from '@tiptap/react';
+import { E as ExtButtonOptions } from '../tiptap-ext.type-B3TtT7-J.mjs';
+import 'react';
+import '@floating-ui/react';
+
+type ExtTaskListOptions = ExtButtonOptions<TaskListOptions>;
+declare const TaskList: Node<ExtTaskListOptions>;
+
+export { TaskList };

package/dist/extension/tasklist.d.ts

@@ -0,0 +1,10 @@
+import { TaskListOptions } from '@tiptap/extension-list';
+import { Node } from '@tiptap/react';
+import { E as ExtButtonOptions } from '../tiptap-ext.type-B3TtT7-J.js';
+import 'react';
+import '@floating-ui/react';
+
+type ExtTaskListOptions = ExtButtonOptions<TaskListOptions>;
+declare const TaskList: Node<ExtTaskListOptions>;
+
+export { TaskList };

package/dist/extension/tasklist.js

@@ -0,0 +1,246 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/extension/TaskList.tsx
+var TaskList_exports = {};
+__export(TaskList_exports, {
+  TaskList: () => TaskList
+});
+module.exports = __toCommonJS(TaskList_exports);
+var import_extension_list = require("@tiptap/extension-list");
+
+// src/lib/icons/index.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var TaskListIcon = (_a) => {
+  var _b = _a, { size = 17, className } = _b, props = __objRest(_b, ["size", "className"]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+    "svg",
+    __spreadProps(__spreadValues({
+      xmlns: "http://www.w3.org/2000/svg",
+      width: size,
+      height: size,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }, props), {
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "M13 5h8" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "M13 12h8" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "M13 19h8" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "m3 17 2 2 4-4" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("rect", { x: "3", y: "4", width: "6", height: "6", rx: "1" })
+      ]
+    })
+  );
+};
+
+// src/lib/components/ButtonComponent.tsx
+var import_react5 = require("react");
+var import_tailwind_merge2 = require("tailwind-merge");
+
+// src/lib/components/_com/Tooltip.tsx
+var import_react = require("react");
+var import_react2 = require("@floating-ui/react");
+var import_react3 = require("motion/react");
+var import_tailwind_merge = require("tailwind-merge");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var Tooltip = ({ placement = "top", children, content, className }) => {
+  const [open, setOpen] = (0, import_react.useState)(false);
+  const { x, y, refs, strategy, context, placement: resolvedPlacement } = (0, import_react2.useFloating)({
+    open,
+    onOpenChange: setOpen,
+    placement,
+    middleware: [(0, import_react2.offset)(8), (0, import_react2.flip)(), (0, import_react2.shift)({ padding: 8 })],
+    whileElementsMounted: import_react2.autoUpdate
+  });
+  const hover = (0, import_react2.useHover)(context);
+  const dismiss = (0, import_react2.useDismiss)(context);
+  const { getReferenceProps, getFloatingProps } = (0, import_react2.useInteractions)([hover, dismiss]);
+  const id = (0, import_react.useId)();
+  function mergeRefs(...refsToMerge) {
+    return (node) => {
+      for (const r of refsToMerge) {
+        if (!r) continue;
+        if (typeof r === "function") r(node);
+        else r.current = node;
+      }
+    };
+  }
+  const side = resolvedPlacement.split("-")[0];
+  const enterOffset = 6;
+  const getInitial = () => {
+    switch (side) {
+      case "top":
+        return { opacity: 0, y: enterOffset };
+      case "bottom":
+        return { opacity: 0, y: -enterOffset };
+      case "left":
+        return { opacity: 0, x: enterOffset };
+      case "right":
+        return { opacity: 0, x: -enterOffset };
+      default:
+        return { opacity: 0 };
+    }
+  };
+  const getExit = () => __spreadProps(__spreadValues({}, getInitial()), { opacity: 0 });
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react.Fragment, { children: [
+    (0, import_react.isValidElement)(children) ? (0, import_react.cloneElement)(children, __spreadProps(__spreadValues({}, getReferenceProps({
+      onFocus: () => setOpen(true),
+      onBlur: () => setOpen(false),
+      "aria-describedby": open ? id : void 0
+      /* eslint-disable @typescript-eslint/no-explicit-any */
+    })), {
+      /* eslint-disable @typescript-eslint/no-explicit-any */
+      ref: mergeRefs(children.props.ref, refs.setReference)
+    })) : children,
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react2.FloatingPortal, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react3.AnimatePresence, { children: open && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      import_react3.motion.div,
+      __spreadProps(__spreadValues({
+        ref: refs.setFloating
+      }, getFloatingProps({
+        role: "tooltip",
+        id,
+        style: {
+          position: strategy,
+          top: y != null ? y : 0,
+          left: x != null ? x : 0,
+          pointerEvents: "none"
+        }
+      })), {
+        initial: getInitial(),
+        animate: { opacity: 1, x: 0, y: 0, scale: 1 },
+        exit: getExit(),
+        transition: { type: "spring", stiffness: 420, damping: 30, mass: 0.6 },
+        className: (0, import_tailwind_merge.twMerge)("bg-white border border-solid border-gray-200/50 py-1 px-3 rounded-lg text-sm shadow-lg shadow-gray-50 text-center", className),
+        children: content
+      }),
+      "tooltip"
+    ) }) })
+  ] });
+};
+var Tooltip_default = Tooltip;
+
+// src/lib/context/editor.context.tsx
+var import_react4 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var EditorContext = (0, import_react4.createContext)({ editor: null });
+var useEditor = () => {
+  const ctx = (0, import_react4.useContext)(EditorContext);
+  if (!ctx) throw new Error("<Toolbar/> & <Content/> component must be used inside <Editor>...</Editor/>");
+  return ctx;
+};
+
+// src/lib/components/ButtonComponent.tsx
+var import_react6 = require("@tiptap/react");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var ButtonComponent = ({ className, activeClassName, icon, style, tooltip = true, tooltipClassName, tooltipPlacement, _extName, _internalIcon, _tooltipContent, _onToggle, _interShortcut, _buttonClassName }) => {
+  const { editor } = useEditor();
+  const editorState = (0, import_react6.useEditorState)({
+    editor,
+    selector: ({ editor: editor2 }) => ({ isActive: (editor2 == null ? void 0 : editor2.isActive(_extName)) || false })
+  });
+  const shortcutText = (0, import_react5.useMemo)(() => {
+    if (!_interShortcut) return "";
+    return (0, import_react6.isMacOS)() ? _interShortcut.mac : _interShortcut.win;
+  }, [_interShortcut]);
+  const tooltipContent = /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("p", { children: [
+    typeof tooltip === "string" ? tooltip : _tooltipContent,
+    shortcutText ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("br", {}),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { className: "opacity-70", children: shortcutText })
+    ] }) : null
+  ] });
+  const btn = /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("button", { onClick: _onToggle, className: (0, import_tailwind_merge2.twMerge)("py-1.5 px-2.5 rounded-md", _buttonClassName, (editorState == null ? void 0 : editorState.isActive) ? "bg-gray-200/60" : "hover:bg-gray-100", className, (editorState == null ? void 0 : editorState.isActive) ? activeClassName : "hover:bg-gray-100"), style, children: icon != null ? icon : _internalIcon });
+  if (tooltip === false) return btn;
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Tooltip_default, { content: tooltipContent, className: tooltipClassName, placement: tooltipPlacement, children: btn });
+};
+var ButtonComponent_default = ButtonComponent;
+
+// src/extension/TaskList.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var TaskList = import_extension_list.TaskList.extend({
+  addOptions() {
+    var _a;
+    return __spreadProps(__spreadValues({}, (_a = this.parent) == null ? void 0 : _a.call(this)), {
+      HTMLAttributes: {
+        class: "task-list"
+      },
+      itemTypeName: "taskItem",
+      component: ({ editor, options, buttonClassName }) => {
+        return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          ButtonComponent_default,
+          {
+            className: options.className,
+            icon: options.icon,
+            style: options.style,
+            activeClassName: options.activeClassName,
+            tooltip: options.tooltip,
+            tooltipClassName: options.tooltipClassName,
+            tooltipPlacement: options.tooltipPlacement,
+            _internalIcon: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(TaskListIcon, {}),
+            _extName: "taskList",
+            _onToggle: () => editor.chain().focus().toggleTaskList().run(),
+            _interShortcut: { win: "Ctrl + \u21E7 +9", mac: "\u2318 + \u21E7 + 9" },
+            _tooltipContent: "Task List",
+            _buttonClassName: buttonClassName
+          }
+        );
+      }
+    });
+  },
+  addExtensions() {
+    return [import_extension_list.TaskItem];
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TaskList
+});

package/dist/extension/tasklist.mjs

@@ -0,0 +1,52 @@
+import {
+  ButtonComponent_default
+} from "../chunk-SJFT7WNM.mjs";
+import "../chunk-VYDH6BZE.mjs";
+import {
+  TaskListIcon
+} from "../chunk-EN4BPI7N.mjs";
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-WNQUEZJF.mjs";
+
+// src/extension/TaskList.tsx
+import { TaskList as TiptapTaskList, TaskItem } from "@tiptap/extension-list";
+import { jsx } from "react/jsx-runtime";
+var TaskList = TiptapTaskList.extend({
+  addOptions() {
+    var _a;
+    return __spreadProps(__spreadValues({}, (_a = this.parent) == null ? void 0 : _a.call(this)), {
+      HTMLAttributes: {
+        class: "task-list"
+      },
+      itemTypeName: "taskItem",
+      component: ({ editor, options, buttonClassName }) => {
+        return /* @__PURE__ */ jsx(
+          ButtonComponent_default,
+          {
+            className: options.className,
+            icon: options.icon,
+            style: options.style,
+            activeClassName: options.activeClassName,
+            tooltip: options.tooltip,
+            tooltipClassName: options.tooltipClassName,
+            tooltipPlacement: options.tooltipPlacement,
+            _internalIcon: /* @__PURE__ */ jsx(TaskListIcon, {}),
+            _extName: "taskList",
+            _onToggle: () => editor.chain().focus().toggleTaskList().run(),
+            _interShortcut: { win: "Ctrl + \u21E7 +9", mac: "\u2318 + \u21E7 + 9" },
+            _tooltipContent: "Task List",
+            _buttonClassName: buttonClassName
+          }
+        );
+      }
+    });
+  },
+  addExtensions() {
+    return [TaskItem];
+  }
+});
+export {
+  TaskList
+};

package/dist/extension/textalign.d.mts

@@ -0,0 +1,15 @@
+import { Extension } from '@tiptap/react';
+import { TextAlignOptions } from '@tiptap/extension-text-align';
+import { a as ExtDropdownOptions } from '../tiptap-ext.type-B3TtT7-J.mjs';
+import 'react';
+import '@floating-ui/react';
+
+type ExtTextAlignmentOptions = ExtDropdownOptions<TextAlignOptions & {
+    showInBubbleMenu?: boolean;
+    bubbleMenuPosition?: number;
+}, {
+    dropdownContainerClassName: string;
+}>;
+declare const TextAlign: Extension<ExtTextAlignmentOptions>;
+
+export { TextAlign };

package/dist/extension/textalign.d.ts

@@ -0,0 +1,15 @@
+import { Extension } from '@tiptap/react';
+import { TextAlignOptions } from '@tiptap/extension-text-align';
+import { a as ExtDropdownOptions } from '../tiptap-ext.type-B3TtT7-J.js';
+import 'react';
+import '@floating-ui/react';
+
+type ExtTextAlignmentOptions = ExtDropdownOptions<TextAlignOptions & {
+    showInBubbleMenu?: boolean;
+    bubbleMenuPosition?: number;
+}, {
+    dropdownContainerClassName: string;
+}>;
+declare const TextAlign: Extension<ExtTextAlignmentOptions>;
+
+export { TextAlign };