@choice-ui/react 1.4.3 → 1.4.6

package/dist/components/rich-input/src/hooks/use-mouse-events.js

@@ -1,113 +0,0 @@
-import { useEffect } from "react";
-import { Editor } from "slate";
-const useMouseEvents = (props) => {
-  const {
-    editor,
-    charactersRefs,
-    paragraphCollapsedRefs,
-    paragraphExpandedRefs,
-    urlRefs,
-    slateRef,
-    setIsCharactersStyleOpen,
-    setIsParagraphStyleOpen,
-    setIsUrlOpen,
-    setCharactersUrl,
-    isParagraphExpanded
-  } = props;
-  useEffect(() => {
-    function handleMouseUp(event) {
-      var _a;
-      if ((_a = charactersRefs.floating.current) == null ? void 0 : _a.contains(event.target)) {
-        return;
-      }
-      const selection = window.getSelection();
-      const marks = Editor.marks(editor);
-      const range = typeof (selection == null ? void 0 : selection.rangeCount) === "number" && selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
-      setIsCharactersStyleOpen(false);
-      if (selection == null ? void 0 : selection.isCollapsed) {
-        if (range) {
-          const referenceElement = {
-            getBoundingClientRect: () => {
-              var _a2;
-              const rect = (_a2 = slateRef.current) == null ? void 0 : _a2.getBoundingClientRect();
-              const rangeRect = range.getBoundingClientRect();
-              if (!rect || !rangeRect) {
-                return new DOMRect();
-              }
-              return {
-                ...rangeRect,
-                x: rect.x,
-                left: rect.left
-              };
-            },
-            getClientRects: () => {
-              var _a2;
-              const slateRects = (_a2 = slateRef.current) == null ? void 0 : _a2.getClientRects();
-              const rects = range.getClientRects();
-              if (slateRects && rects[0]) {
-                rects[0].x = slateRects[0].x;
-              }
-              return rects;
-            }
-          };
-          paragraphCollapsedRefs.setReference(referenceElement);
-          paragraphExpandedRefs.setReference(referenceElement);
-          urlRefs.setReference({
-            getBoundingClientRect: () => range.getBoundingClientRect(),
-            getClientRects: () => range.getClientRects()
-          });
-          setIsParagraphStyleOpen(true);
-          if (marks == null ? void 0 : marks.link) {
-            setIsUrlOpen(true);
-            setCharactersUrl(marks["link"] ?? "");
-          } else {
-            setIsUrlOpen(false);
-          }
-        } else {
-          setIsParagraphStyleOpen(false);
-          setIsUrlOpen(false);
-        }
-        return;
-      } else {
-        setIsParagraphStyleOpen(false);
-      }
-      if (range && !(selection == null ? void 0 : selection.isCollapsed)) {
-        charactersRefs.setReference({
-          getBoundingClientRect: () => range.getBoundingClientRect(),
-          getClientRects: () => range.getClientRects()
-        });
-        setIsCharactersStyleOpen(true);
-      }
-    }
-    function handleMouseDown(event) {
-      var _a, _b;
-      if ((_a = charactersRefs.floating.current) == null ? void 0 : _a.contains(event.target)) {
-        return;
-      }
-      if ((_b = window.getSelection()) == null ? void 0 : _b.isCollapsed) {
-        setIsCharactersStyleOpen(false);
-      }
-    }
-    window.addEventListener("mouseup", handleMouseUp);
-    window.addEventListener("mousedown", handleMouseDown);
-    return () => {
-      window.removeEventListener("mouseup", handleMouseUp);
-      window.removeEventListener("mousedown", handleMouseDown);
-    };
-  }, [
-    charactersRefs,
-    editor,
-    paragraphCollapsedRefs,
-    paragraphExpandedRefs,
-    urlRefs,
-    slateRef,
-    setIsCharactersStyleOpen,
-    setIsParagraphStyleOpen,
-    setIsUrlOpen,
-    setCharactersUrl,
-    isParagraphExpanded
-  ]);
-};
-export {
-  useMouseEvents
-};

package/dist/components/rich-input/src/hooks/use-validation.js

@@ -1,80 +0,0 @@
-import { useMemo, useCallback, useEffect } from "react";
-import { Node, Text, Element } from "slate";
-function useValidation({
-  displayValue,
-  setDisplayValue,
-  setValue,
-  setValidationMessage,
-  validation
-}) {
-  const countCharacters = (nodes) => {
-    return nodes.map((n) => Node.string(n)).join("").length;
-  };
-  const charCount = useMemo(() => countCharacters(displayValue), [displayValue]);
-  const handleValidationChange = useCallback(
-    (newValue) => {
-      setDisplayValue(newValue);
-    },
-    [setDisplayValue]
-  );
-  useEffect(() => {
-    if ((validation == null ? void 0 : validation.maxLength) && charCount > validation.maxLength) {
-      if (setValidationMessage) {
-        setValidationMessage(`Maximum length is ${validation.maxLength} characters`);
-      }
-      const limitedValue = trimSlateValueToMaxLength({
-        value: displayValue,
-        maxLength: validation.maxLength
-      });
-      if (setValue) {
-        setValue(limitedValue);
-      }
-    } else if ((validation == null ? void 0 : validation.minLength) && charCount < validation.minLength) {
-      if (setValidationMessage) {
-        setValidationMessage(`Minimum length is ${validation.minLength} characters`);
-      }
-      if (setValue) {
-        setValue([]);
-      }
-    } else {
-      if (setValidationMessage) {
-        setValidationMessage(null);
-      }
-      if (setValue) {
-        setValue(displayValue);
-      }
-    }
-  }, [charCount, validation == null ? void 0 : validation.maxLength, validation == null ? void 0 : validation.minLength]);
-  return {
-    handleValidationChange
-  };
-}
-function trimSlateValueToMaxLength({
-  value,
-  maxLength
-}) {
-  const trimmedValue = [];
-  let lengthSoFar = 0;
-  for (const node of value) {
-    if (lengthSoFar >= maxLength) break;
-    if (Text.isText(node)) {
-      const remainingLength = maxLength - lengthSoFar;
-      const text = node.text.slice(0, remainingLength);
-      trimmedValue.push({ ...node, text });
-      lengthSoFar += text.length;
-    } else if (Element.isElement(node)) {
-      const children = trimSlateValueToMaxLength({
-        value: node.children,
-        maxLength: maxLength - lengthSoFar
-      });
-      trimmedValue.push({ ...node, children });
-      lengthSoFar += Node.string(node).length;
-    } else {
-      trimmedValue.push(node);
-    }
-  }
-  return trimmedValue;
-}
-export {
-  useValidation
-};

package/dist/components/rich-input/src/utils/markdown-to-slate.js

@@ -1,219 +0,0 @@
-function markdownToSlate(markdown) {
-  const lines = markdown.split("\n");
-  const nodes = [];
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i];
-    if (!line.trim()) {
-      i++;
-      continue;
-    }
-    const headingMatch = line.match(/^(#{1,6})\s+(.*)$/);
-    if (headingMatch) {
-      const level = headingMatch[1].length;
-      const text = headingMatch[2];
-      nodes.push({
-        type: `h${level}`,
-        children: parseInlineElements(text)
-      });
-      i++;
-      continue;
-    }
-    if (line.startsWith("> ")) {
-      const quoteLines = [];
-      while (i < lines.length && lines[i].startsWith("> ")) {
-        quoteLines.push(lines[i].substring(2));
-        i++;
-      }
-      nodes.push({
-        type: "block_quote",
-        children: [
-          {
-            type: "paragraph",
-            children: parseInlineElements(quoteLines.join("\n"))
-          }
-        ]
-      });
-      continue;
-    }
-    if (line.startsWith("```")) {
-      const codeLines = [];
-      i++;
-      while (i < lines.length && !lines[i].startsWith("```")) {
-        codeLines.push(lines[i]);
-        i++;
-      }
-      i++;
-      nodes.push({
-        type: "code",
-        children: [{ text: codeLines.join("\n") }]
-      });
-      continue;
-    }
-    if (line.match(/^[-*+]\s+/)) {
-      const listItems = [];
-      while (i < lines.length && lines[i].match(/^[-*+]\s+/)) {
-        const itemText = lines[i].replace(/^[-*+]\s+/, "");
-        listItems.push({
-          type: "list_item",
-          children: parseInlineElements(itemText)
-        });
-        i++;
-      }
-      nodes.push({
-        type: "bulleted_list",
-        children: listItems
-      });
-      continue;
-    }
-    if (line.match(/^\d+\.\s+/)) {
-      const listItems = [];
-      while (i < lines.length && lines[i].match(/^\d+\.\s+/)) {
-        const itemText = lines[i].replace(/^\d+\.\s+/, "");
-        listItems.push({
-          type: "list_item",
-          children: parseInlineElements(itemText)
-        });
-        i++;
-      }
-      nodes.push({
-        type: "numbered_list",
-        children: listItems
-      });
-      continue;
-    }
-    if (line.match(/^-\s+\[[x\s]\]\s+/)) {
-      const checkItems = [];
-      while (i < lines.length && lines[i].match(/^-\s+\[[x\s]\]\s+/)) {
-        const isChecked = lines[i].includes("[x]");
-        const itemText = lines[i].replace(/^-\s+\[[x\s]\]\s+/, "");
-        checkItems.push({
-          type: "check_item",
-          checked: isChecked,
-          children: parseInlineElements(itemText)
-        });
-        i++;
-      }
-      nodes.push({
-        type: "check_list",
-        children: checkItems
-      });
-      continue;
-    }
-    nodes.push({
-      type: "paragraph",
-      children: parseInlineElements(line)
-    });
-    i++;
-  }
-  if (nodes.length === 0) {
-    nodes.push({
-      type: "paragraph",
-      children: [{ text: "" }]
-    });
-  }
-  return nodes;
-}
-function parseInlineElements(text) {
-  const elements = [];
-  const segments = [];
-  const boldItalicRegex = /\*\*\*([^*]+)\*\*\*/g;
-  let match;
-  while ((match = boldItalicRegex.exec(text)) !== null) {
-    segments.push({
-      start: match.index,
-      end: match.index + match[0].length,
-      node: { text: match[1], bold: true, italic: true }
-    });
-  }
-  const boldRegex = /\*\*([^*]+)\*\*/g;
-  while ((match = boldRegex.exec(text)) !== null) {
-    if (!isOverlapping(segments, match.index, match.index + match[0].length)) {
-      segments.push({
-        start: match.index,
-        end: match.index + match[0].length,
-        node: { text: match[1], bold: true }
-      });
-    }
-  }
-  const italicRegex = /\*([^*]+)\*/g;
-  while ((match = italicRegex.exec(text)) !== null) {
-    if (!isOverlapping(segments, match.index, match.index + match[0].length)) {
-      segments.push({
-        start: match.index,
-        end: match.index + match[0].length,
-        node: { text: match[1], italic: true }
-      });
-    }
-  }
-  const strikethroughRegex = /~~([^~]+)~~/g;
-  while ((match = strikethroughRegex.exec(text)) !== null) {
-    if (!isOverlapping(segments, match.index, match.index + match[0].length)) {
-      segments.push({
-        start: match.index,
-        end: match.index + match[0].length,
-        node: { text: match[1], strikethrough: true }
-      });
-    }
-  }
-  const codeRegex = /`([^`]+)`/g;
-  while ((match = codeRegex.exec(text)) !== null) {
-    if (!isOverlapping(segments, match.index, match.index + match[0].length)) {
-      segments.push({
-        start: match.index,
-        end: match.index + match[0].length,
-        node: { text: match[1], code: true }
-      });
-    }
-  }
-  const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
-  while ((match = linkRegex.exec(text)) !== null) {
-    if (!isOverlapping(segments, match.index, match.index + match[0].length)) {
-      segments.push({
-        start: match.index,
-        end: match.index + match[0].length,
-        node: { text: match[1], link: match[2] }
-      });
-    }
-  }
-  const underlineRegex = /<u>([^<]+)<\/u>/g;
-  while ((match = underlineRegex.exec(text)) !== null) {
-    if (!isOverlapping(segments, match.index, match.index + match[0].length)) {
-      segments.push({
-        start: match.index,
-        end: match.index + match[0].length,
-        node: { text: match[1], underlined: true }
-      });
-    }
-  }
-  segments.sort((a, b) => a.start - b.start);
-  let currentIndex = 0;
-  for (const segment of segments) {
-    if (currentIndex < segment.start) {
-      const plainText = text.substring(currentIndex, segment.start);
-      if (plainText) {
-        elements.push({ text: plainText });
-      }
-    }
-    elements.push(segment.node);
-    currentIndex = segment.end;
-  }
-  if (currentIndex < text.length) {
-    const remainingText = text.substring(currentIndex);
-    if (remainingText) {
-      elements.push({ text: remainingText });
-    }
-  }
-  if (elements.length === 0) {
-    elements.push({ text });
-  }
-  return elements;
-}
-function isOverlapping(segments, start, end) {
-  return segments.some(
-    (segment) => start >= segment.start && start < segment.end || end > segment.start && end <= segment.end || start <= segment.start && end >= segment.end
-  );
-}
-export {
-  markdownToSlate
-};