@usefragments/ui 1.0.0

package/dist/editor.cjs

@@ -0,0 +1,572 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const React = require("react");
+const Editor_module = require("./components/Editor/Editor.module.scss.cjs");
+const react = require("@phosphor-icons/react");
+const keyboardShortcuts = require("./utils/keyboard-shortcuts.cjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+let _useEditor = null;
+let _EditorContent = null;
+let _StarterKit = null;
+let _LinkExtension = null;
+let _tiptapLoaded = false;
+let _tiptapFailed = false;
+function loadTipTapDeps() {
+  if (_tiptapLoaded) return;
+  _tiptapLoaded = true;
+  try {
+    const tiptapReact = require("@tiptap/react");
+    const starterKit = require("@tiptap/starter-kit");
+    const linkExt = require("@tiptap/extension-link");
+    _useEditor = tiptapReact.useEditor;
+    _EditorContent = tiptapReact.EditorContent;
+    _StarterKit = starterKit.default ?? starterKit.StarterKit ?? starterKit;
+    _LinkExtension = linkExt.default ?? linkExt.Link ?? linkExt;
+  } catch {
+    _tiptapFailed = true;
+  }
+}
+const FORMAT_META = {
+  bold: { icon: react.TextB, label: "Bold", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_BOLD.label },
+  italic: { icon: react.TextItalic, label: "Italic", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_ITALIC.label },
+  strikethrough: { icon: react.TextStrikethrough, label: "Strikethrough", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_STRIKETHROUGH.label },
+  link: { icon: react.LinkSimple, label: "Link", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_LINK.label },
+  code: { icon: react.Code, label: "Code", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_CODE.label },
+  bulletList: { icon: react.ListBullets, label: "Bullet list", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_BULLET_LIST.label },
+  orderedList: { icon: react.ListNumbers, label: "Ordered list", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_ORDERED_LIST.label },
+  heading1: { icon: react.TextHOne, label: "Heading 1", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_HEADING1.label },
+  heading2: { icon: react.TextHTwo, label: "Heading 2", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_HEADING2.label },
+  heading3: { icon: react.TextHThree, label: "Heading 3", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_HEADING3.label },
+  blockquote: { icon: react.Quotes, label: "Blockquote", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_BLOCKQUOTE.label },
+  undo: { icon: react.ArrowCounterClockwise, label: "Undo", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_UNDO.label },
+  redo: { icon: react.ArrowClockwise, label: "Redo", shortcut: keyboardShortcuts.KEYBOARD_SHORTCUTS.EDITOR_REDO.label }
+};
+const DEFAULT_FORMATS = ["bold", "italic", "strikethrough", "link", "code", "bulletList"];
+const ACTION_FORMATS = /* @__PURE__ */ new Set(["undo", "redo"]);
+const DEFAULT_STATUS_LABELS = {
+  idle: "",
+  saving: "SAVING...",
+  saved: "AUTO-SAVED",
+  error: "SAVE FAILED"
+};
+function getSelection(textarea) {
+  return {
+    start: textarea.selectionStart,
+    end: textarea.selectionEnd,
+    text: textarea.value.substring(textarea.selectionStart, textarea.selectionEnd)
+  };
+}
+function wrapSelection(textarea, prefix, suffix, setValue) {
+  const sel = getSelection(textarea);
+  const before = textarea.value.substring(0, sel.start);
+  const after = textarea.value.substring(sel.end);
+  const wrapped = `${prefix}${sel.text || "text"}${suffix}`;
+  const newValue = `${before}${wrapped}${after}`;
+  setValue(newValue);
+  requestAnimationFrame(() => {
+    textarea.focus();
+    const newStart = sel.start + prefix.length;
+    const newEnd = newStart + (sel.text || "text").length;
+    textarea.setSelectionRange(newStart, newEnd);
+  });
+}
+function applyMarkdownFormat(format, textarea, setValue) {
+  switch (format) {
+    case "bold":
+      wrapSelection(textarea, "**", "**", setValue);
+      break;
+    case "italic":
+      wrapSelection(textarea, "*", "*", setValue);
+      break;
+    case "strikethrough":
+      wrapSelection(textarea, "~~", "~~", setValue);
+      break;
+    case "code":
+      wrapSelection(textarea, "`", "`", setValue);
+      break;
+    case "link": {
+      const sel = getSelection(textarea);
+      const linkText = sel.text || "link text";
+      const before = textarea.value.substring(0, sel.start);
+      const after = textarea.value.substring(sel.end);
+      const newValue = `${before}[${linkText}](url)${after}`;
+      setValue(newValue);
+      requestAnimationFrame(() => {
+        textarea.focus();
+        const urlStart = sel.start + linkText.length + 3;
+        textarea.setSelectionRange(urlStart, urlStart + 3);
+      });
+      break;
+    }
+    case "bulletList": {
+      const sel = getSelection(textarea);
+      const before = textarea.value.substring(0, sel.start);
+      const after = textarea.value.substring(sel.end);
+      const lines = (sel.text || "item").split("\n");
+      const bulleted = lines.map((l) => `- ${l}`).join("\n");
+      const newValue = `${before}${bulleted}${after}`;
+      setValue(newValue);
+      break;
+    }
+    case "orderedList": {
+      const sel = getSelection(textarea);
+      const before = textarea.value.substring(0, sel.start);
+      const after = textarea.value.substring(sel.end);
+      const lines = (sel.text || "item").split("\n");
+      const numbered = lines.map((l, i) => `${i + 1}. ${l}`).join("\n");
+      const newValue = `${before}${numbered}${after}`;
+      setValue(newValue);
+      break;
+    }
+    case "heading1":
+      wrapSelection(textarea, "# ", "", setValue);
+      break;
+    case "heading2":
+      wrapSelection(textarea, "## ", "", setValue);
+      break;
+    case "heading3":
+      wrapSelection(textarea, "### ", "", setValue);
+      break;
+    case "blockquote": {
+      const sel = getSelection(textarea);
+      const before = textarea.value.substring(0, sel.start);
+      const after = textarea.value.substring(sel.end);
+      const lines = (sel.text || "quote").split("\n");
+      const quoted = lines.map((l) => `> ${l}`).join("\n");
+      const newValue = `${before}${quoted}${after}`;
+      setValue(newValue);
+      break;
+    }
+  }
+}
+const EditorContext = React__namespace.createContext(null);
+function useEditorContext() {
+  const context = React__namespace.useContext(EditorContext);
+  if (!context) {
+    throw new Error("Editor compound components must be used within an Editor");
+  }
+  return context;
+}
+function useControllableState(controlledValue, defaultValue, onChange) {
+  const [uncontrolledValue, setUncontrolledValue] = React__namespace.useState(defaultValue);
+  const isControlled = controlledValue !== void 0;
+  const value = isControlled ? controlledValue : uncontrolledValue;
+  const setValue = React__namespace.useCallback(
+    (newValue) => {
+      if (!isControlled) {
+        setUncontrolledValue(newValue);
+      }
+      onChange == null ? void 0 : onChange(newValue);
+    },
+    [isControlled, onChange]
+  );
+  return [value, setValue];
+}
+function countWords(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return 0;
+  return trimmed.split(/\s+/).length;
+}
+function EditorRoot({
+  children,
+  value: controlledValue,
+  defaultValue = "",
+  onValueChange,
+  placeholder = "Start typing...",
+  disabled = false,
+  readOnly = false,
+  formats = DEFAULT_FORMATS,
+  toolbar = true,
+  statusBar = true,
+  onAutoSave,
+  autoSaveInterval = 3e4,
+  size = "md",
+  maxLength,
+  toolbarIcons,
+  className,
+  ...htmlProps
+}) {
+  const contentRef = React__namespace.useRef(null);
+  const [value, setValue] = useControllableState(
+    controlledValue,
+    defaultValue,
+    onValueChange
+  );
+  const [saveStatus, setSaveStatus] = React__namespace.useState("idle");
+  loadTipTapDeps();
+  const hasTipTap = !_tiptapFailed && _useEditor && _EditorContent && _StarterKit;
+  const mode = hasTipTap ? "rich" : "markdown";
+  const tiptapEditor = hasTipTap ? (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _useEditor({
+      extensions: [
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        _StarterKit.configure({
+          heading: { levels: [1, 2, 3] },
+          blockquote: {},
+          codeBlock: false,
+          horizontalRule: false,
+          hardBreak: false
+        }),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        _LinkExtension.configure({
+          openOnClick: false,
+          HTMLAttributes: { rel: "noopener noreferrer", target: "_blank" }
+        })
+      ],
+      editorProps: {
+        attributes: {
+          role: "textbox",
+          "aria-label": placeholder,
+          "aria-multiline": "true"
+        }
+      },
+      content: controlledValue !== void 0 ? controlledValue : defaultValue,
+      editable: !disabled && !readOnly,
+      onUpdate: ({ editor: e }) => {
+        const html = e.getHTML();
+        setValue(html);
+      }
+    })
+  ) : null;
+  React__namespace.useEffect(() => {
+    if (tiptapEditor && controlledValue !== void 0) {
+      const currentContent = tiptapEditor.getHTML();
+      if (currentContent !== controlledValue) {
+        tiptapEditor.commands.setContent(controlledValue, false);
+      }
+    }
+  }, [controlledValue, tiptapEditor]);
+  React__namespace.useEffect(() => {
+    if (tiptapEditor) {
+      tiptapEditor.setEditable(!disabled && !readOnly);
+    }
+  }, [tiptapEditor, disabled, readOnly]);
+  React__namespace.useEffect(() => {
+    if (!onAutoSave || !value) return;
+    let cancelled = false;
+    const timer = setTimeout(() => {
+      setSaveStatus("saving");
+      try {
+        Promise.resolve(onAutoSave(value)).then(() => {
+          if (!cancelled) {
+            setSaveStatus("saved");
+          }
+        }).catch(() => {
+          if (!cancelled) {
+            setSaveStatus("error");
+          }
+        });
+      } catch {
+        if (!cancelled) {
+          setSaveStatus("error");
+        }
+      }
+    }, autoSaveInterval);
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [value, onAutoSave, autoSaveInterval]);
+  const toggleFormat = React__namespace.useCallback(
+    (format) => {
+      if (disabled || readOnly) return;
+      if (tiptapEditor) {
+        switch (format) {
+          case "bold":
+            tiptapEditor.chain().focus().toggleBold().run();
+            break;
+          case "italic":
+            tiptapEditor.chain().focus().toggleItalic().run();
+            break;
+          case "strikethrough":
+            tiptapEditor.chain().focus().toggleStrike().run();
+            break;
+          case "code":
+            tiptapEditor.chain().focus().toggleCode().run();
+            break;
+          case "bulletList":
+            tiptapEditor.chain().focus().toggleBulletList().run();
+            break;
+          case "orderedList":
+            tiptapEditor.chain().focus().toggleOrderedList().run();
+            break;
+          case "heading1":
+            tiptapEditor.chain().focus().toggleHeading({ level: 1 }).run();
+            break;
+          case "heading2":
+            tiptapEditor.chain().focus().toggleHeading({ level: 2 }).run();
+            break;
+          case "heading3":
+            tiptapEditor.chain().focus().toggleHeading({ level: 3 }).run();
+            break;
+          case "blockquote":
+            tiptapEditor.chain().focus().toggleBlockquote().run();
+            break;
+          case "undo":
+            tiptapEditor.chain().focus().undo().run();
+            break;
+          case "redo":
+            tiptapEditor.chain().focus().redo().run();
+            break;
+          case "link": {
+            const previousUrl = tiptapEditor.getAttributes("link").href;
+            if (previousUrl) {
+              tiptapEditor.chain().focus().unsetLink().run();
+            } else {
+              const url = window.prompt("Enter URL");
+              if (url) {
+                tiptapEditor.chain().focus().setLink({ href: url }).run();
+              }
+            }
+            break;
+          }
+        }
+      } else if (contentRef.current) {
+        applyMarkdownFormat(format, contentRef.current, setValue);
+      }
+    },
+    [disabled, readOnly, tiptapEditor, setValue]
+  );
+  const isFormatActive = React__namespace.useCallback(
+    (format) => {
+      if (!tiptapEditor) return false;
+      switch (format) {
+        case "bold":
+          return tiptapEditor.isActive("bold");
+        case "italic":
+          return tiptapEditor.isActive("italic");
+        case "strikethrough":
+          return tiptapEditor.isActive("strike");
+        case "code":
+          return tiptapEditor.isActive("code");
+        case "bulletList":
+          return tiptapEditor.isActive("bulletList");
+        case "orderedList":
+          return tiptapEditor.isActive("orderedList");
+        case "heading1":
+          return tiptapEditor.isActive("heading", { level: 1 });
+        case "heading2":
+          return tiptapEditor.isActive("heading", { level: 2 });
+        case "heading3":
+          return tiptapEditor.isActive("heading", { level: 3 });
+        case "blockquote":
+          return tiptapEditor.isActive("blockquote");
+        case "link":
+          return tiptapEditor.isActive("link");
+        case "undo":
+        case "redo":
+          return false;
+        // Actions don't have active state
+        default:
+          return false;
+      }
+    },
+    [tiptapEditor]
+  );
+  const wordCount = React__namespace.useMemo(() => {
+    var _a;
+    if (tiptapEditor) {
+      const text = ((_a = tiptapEditor.getText) == null ? void 0 : _a.call(tiptapEditor)) ?? "";
+      return countWords(text);
+    }
+    return countWords(value);
+  }, [value, tiptapEditor]);
+  const charCount = React__namespace.useMemo(() => {
+    var _a;
+    if (tiptapEditor) {
+      return (((_a = tiptapEditor.getText) == null ? void 0 : _a.call(tiptapEditor)) ?? "").length;
+    }
+    return value.length;
+  }, [value, tiptapEditor]);
+  const contextValue = {
+    value,
+    setValue,
+    placeholder,
+    disabled,
+    readOnly,
+    formats,
+    editor: tiptapEditor,
+    mode,
+    size,
+    maxLength,
+    toolbarIcons,
+    wordCount,
+    charCount,
+    toggleFormat,
+    isFormatActive,
+    saveStatus,
+    contentRef
+  };
+  const classes = [
+    Editor_module.default.editor,
+    disabled && Editor_module.default.disabled,
+    readOnly && Editor_module.default.readOnly,
+    className
+  ].filter(Boolean).join(" ");
+  const hasCustomChildren = children !== void 0;
+  return /* @__PURE__ */ jsxRuntime.jsx(EditorContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ...htmlProps,
+      className: classes,
+      "data-disabled": disabled || void 0,
+      "data-readonly": readOnly || void 0,
+      "data-size": size,
+      children: hasCustomChildren ? children : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        toolbar && /* @__PURE__ */ jsxRuntime.jsx(EditorToolbar, { children: /* @__PURE__ */ jsxRuntime.jsx(EditorToolbarGroup, { "aria-label": "Text formatting", children: formats.map((f) => /* @__PURE__ */ jsxRuntime.jsx(EditorToolbarButton, { format: f }, f)) }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(EditorContentArea, {}),
+        statusBar && /* @__PURE__ */ jsxRuntime.jsx(EditorStatusBar, { showWordCount: true, showCharCount: true })
+      ] })
+    }
+  ) });
+}
+function EditorToolbar({ children, className }) {
+  const classes = [Editor_module.default.toolbar, className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: classes, role: "toolbar", "aria-label": "Editor formatting", children });
+}
+function EditorToolbarGroup({ children, "aria-label": ariaLabel, className }) {
+  const classes = [Editor_module.default.toolbarGroup, className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: classes, role: "group", "aria-label": ariaLabel, children });
+}
+function EditorToolbarButton({ format, className }) {
+  const { toggleFormat, isFormatActive, disabled, readOnly, editor, mode, toolbarIcons } = useEditorContext();
+  const meta = FORMAT_META[format];
+  const isAction = ACTION_FORMATS.has(format);
+  const active = isAction ? false : isFormatActive(format);
+  const IconComponent = meta.icon;
+  let isDisabled = disabled || readOnly;
+  if (isAction && !isDisabled) {
+    if (mode === "markdown") {
+      isDisabled = true;
+    } else if (editor) {
+      isDisabled = format === "undo" ? !editor.can().undo() : !editor.can().redo();
+    }
+  }
+  const iconState = {
+    format,
+    active,
+    disabled,
+    readOnly,
+    isDisabled,
+    mode
+  };
+  const iconOverride = toolbarIcons == null ? void 0 : toolbarIcons[format];
+  const renderedOverride = typeof iconOverride === "function" ? iconOverride(iconState) : iconOverride;
+  const classes = [
+    Editor_module.default.toolbarButton,
+    active && Editor_module.default.toolbarButtonActive,
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      type: "button",
+      className: classes,
+      onClick: () => toggleFormat(format),
+      disabled: isDisabled,
+      "aria-label": meta.label,
+      title: `${meta.label} (${meta.shortcut})`,
+      ...isAction ? {} : { "aria-pressed": active },
+      children: iconOverride !== void 0 ? renderedOverride : /* @__PURE__ */ jsxRuntime.jsx(IconComponent, { size: 16, weight: active ? "bold" : "regular" })
+    }
+  );
+}
+function EditorSeparator({ className }) {
+  const classes = [Editor_module.default.separator, className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: classes, role: "separator", "aria-orientation": "vertical" });
+}
+function EditorStatusIndicator({ status: statusOverride, labels, className }) {
+  const { saveStatus } = useEditorContext();
+  const status = statusOverride ?? saveStatus;
+  const mergedLabels = { ...DEFAULT_STATUS_LABELS, ...labels };
+  const label = mergedLabels[status];
+  if (!label) return null;
+  const classes = [
+    Editor_module.default.statusIndicator,
+    status === "error" && Editor_module.default.statusError,
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsx("span", { className: classes, "aria-live": "polite", role: "status", children: label });
+}
+function EditorContentArea({ className }) {
+  const { value, setValue, placeholder, disabled, readOnly, editor, mode, contentRef } = useEditorContext();
+  if (mode === "rich" && editor && _EditorContent) {
+    const TipTapContent = _EditorContent;
+    const classes2 = [Editor_module.default.content, Editor_module.default.contentRich, className].filter(Boolean).join(" ");
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: classes2, "data-placeholder": placeholder, children: /* @__PURE__ */ jsxRuntime.jsx(TipTapContent, { editor }) });
+  }
+  const classes = [Editor_module.default.content, className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: classes, children: /* @__PURE__ */ jsxRuntime.jsx(
+    "textarea",
+    {
+      ref: contentRef,
+      className: Editor_module.default.contentTextarea,
+      value,
+      onChange: (e) => setValue(e.target.value),
+      placeholder,
+      disabled,
+      readOnly,
+      "aria-label": placeholder
+    }
+  ) });
+}
+function EditorStatusBar({ showWordCount = true, showCharCount = true, className }) {
+  const { wordCount, charCount, maxLength } = useEditorContext();
+  const classes = [Editor_module.default.statusBar, className].filter(Boolean).join(" ");
+  const isOverLimit = maxLength !== void 0 && charCount > maxLength;
+  const isNearLimit = maxLength !== void 0 && !isOverLimit && charCount >= maxLength * 0.9;
+  const charLimitClasses = [
+    Editor_module.default.statusBarItem,
+    isNearLimit && Editor_module.default.statusBarItemWarning,
+    isOverLimit && Editor_module.default.statusBarItemError
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classes, "aria-label": "Editor statistics", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: Editor_module.default.statusBarLeft }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: Editor_module.default.statusBarRight, children: [
+      showWordCount && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: Editor_module.default.statusBarItem, children: [
+        wordCount,
+        " ",
+        wordCount === 1 ? "Word" : "Words"
+      ] }),
+      showWordCount && showCharCount && /* @__PURE__ */ jsxRuntime.jsx(EditorSeparator, {}),
+      showCharCount && /* @__PURE__ */ jsxRuntime.jsx("span", { className: charLimitClasses, children: maxLength !== void 0 ? `${charCount} / ${maxLength}` : `${charCount} ${charCount === 1 ? "Character" : "Characters"}` })
+    ] })
+  ] });
+}
+const Editor = Object.assign(EditorRoot, {
+  Toolbar: EditorToolbar,
+  ToolbarGroup: EditorToolbarGroup,
+  ToolbarButton: EditorToolbarButton,
+  Separator: EditorSeparator,
+  StatusIndicator: EditorStatusIndicator,
+  Content: EditorContentArea,
+  StatusBar: EditorStatusBar
+});
+exports.Editor = Editor;
+exports.EditorContentArea = EditorContentArea;
+exports.EditorRoot = EditorRoot;
+exports.EditorSeparator = EditorSeparator;
+exports.EditorStatusBar = EditorStatusBar;
+exports.EditorStatusIndicator = EditorStatusIndicator;
+exports.EditorToolbar = EditorToolbar;
+exports.EditorToolbarButton = EditorToolbarButton;
+exports.EditorToolbarGroup = EditorToolbarGroup;
+exports.useEditorContext = useEditorContext;