@collabchron/notiq 0.3.0 → 1.0.0

package/{src/components/editor/utils/editorFormatting.ts → dist/chunk-PZSUSXQG.mjs}

@@ -1,282 +1,238 @@
-
-import { DEFAULT_FONT_SIZE, MAX_ALLOWED_FONT_SIZE, MIN_ALLOWED_FONT_SIZE } from '@/components/providers/ToolbarContext';
-import {$createCodeNode} from '@lexical/code';
-import {
-  INSERT_CHECK_LIST_COMMAND,
-  INSERT_ORDERED_LIST_COMMAND,
-  INSERT_UNORDERED_LIST_COMMAND,
-} from '@lexical/list';
-import {$isDecoratorBlockNode} from '@lexical/react/LexicalDecoratorBlockNode';
-import {
-  $createHeadingNode,
-  $createQuoteNode,
-  $isHeadingNode,
-  $isQuoteNode,
-  HeadingTagType,
-} from '@lexical/rich-text';
-import {$patchStyleText, $setBlocksType} from '@lexical/selection';
-import { $isTableSelection} from '@lexical/table';
-import {$getNearestBlockElementAncestorOrThrow} from '@lexical/utils';
-import {
-  $createParagraphNode,
-  $getSelection,
-  $isRangeSelection,
-  $isTextNode,
-  LexicalEditor,
-} from 'lexical';
-
-
-// eslint-disable-next-line no-shadow
-export enum UpdateFontSizeType {
-  increment = 1,
-  decrement,
-}
-
-/**
- * Calculates the new font size based on the update type.
- * @param currentFontSize - The current font size
- * @param updateType - The type of change, either increment or decrement
- * @returns the next font size
- */
-export const calculateNextFontSize = (
-  currentFontSize: number,
-  updateType: UpdateFontSizeType | null,
-) => {
-  if (!updateType) {
-    return currentFontSize;
-  }
-
-  let updatedFontSize: number = currentFontSize;
-  switch (updateType) {
-    case UpdateFontSizeType.decrement:
-      switch (true) {
-        case currentFontSize > MAX_ALLOWED_FONT_SIZE:
-          updatedFontSize = MAX_ALLOWED_FONT_SIZE;
-          break;
-        case currentFontSize >= 48:
-          updatedFontSize -= 12;
-          break;
-        case currentFontSize >= 24:
-          updatedFontSize -= 4;
-          break;
-        case currentFontSize >= 14:
-          updatedFontSize -= 2;
-          break;
-        case currentFontSize >= 9:
-          updatedFontSize -= 1;
-          break;
-        default:
-          updatedFontSize = MIN_ALLOWED_FONT_SIZE;
-          break;
-      }
-      break;
-
-    case UpdateFontSizeType.increment:
-      switch (true) {
-        case currentFontSize < MIN_ALLOWED_FONT_SIZE:
-          updatedFontSize = MIN_ALLOWED_FONT_SIZE;
-          break;
-        case currentFontSize < 12:
-          updatedFontSize += 1;
-          break;
-        case currentFontSize < 20:
-          updatedFontSize += 2;
-          break;
-        case currentFontSize < 36:
-          updatedFontSize += 4;
-          break;
-        case currentFontSize <= 60:
-          updatedFontSize += 12;
-          break;
-        default:
-          updatedFontSize = MAX_ALLOWED_FONT_SIZE;
-          break;
-      }
-      break;
-
-    default:
-      break;
-  }
-  return updatedFontSize;
-};
-
-/**
- * Patches the selection with the updated font size.
- */
-export const updateFontSizeInSelection = (
-  editor: LexicalEditor,
-  newFontSize: string | null,
-  updateType: UpdateFontSizeType | null,
-) => {
-  const getNextFontSize = (prevFontSize: string | null): string => {
-    if (!prevFontSize) {
-      prevFontSize = `${DEFAULT_FONT_SIZE}px`;
-    }
-    prevFontSize = prevFontSize.slice(0, -2);
-    const nextFontSize = calculateNextFontSize(
-      Number(prevFontSize),
-      updateType,
-    );
-    return `${nextFontSize}px`;
-  };
-
-  editor.update(() => {
-    if (editor.isEditable()) {
-      const selection = $getSelection();
-      if (selection !== null) {
-        $patchStyleText(selection, {
-          'font-size': newFontSize || getNextFontSize,
-        });
-      }
-    }
-  });
-};
-
-export const updateFontSize = (
-  editor: LexicalEditor,
-  updateType: UpdateFontSizeType,
-  inputValue: string,
-) => {
-  if (inputValue !== '') {
-    const nextFontSize = calculateNextFontSize(Number(inputValue), updateType);
-    updateFontSizeInSelection(editor, String(nextFontSize) + 'px', null);
-  } else {
-    updateFontSizeInSelection(editor, null, updateType);
-  }
-};
-
-export const formatParagraph = (editor: LexicalEditor) => {
-  editor.update(() => {
-    const selection = $getSelection();
-    if ($isRangeSelection(selection)) {
-      $setBlocksType(selection, () => $createParagraphNode());
-    }
-  });
-};
-
-export const formatHeading = (
-  editor: LexicalEditor,
-  blockType: string,
-  headingSize: HeadingTagType,
-) => {
-  if (blockType !== headingSize) {
-    editor.update(() => {
-      const selection = $getSelection();
-      $setBlocksType(selection, () => $createHeadingNode(headingSize));
-    });
-  }
-};
-
-export const formatBulletList = (editor: LexicalEditor, blockType: string) => {
-  if (blockType !== 'bullet') {
-    editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined);
-  } else {
-    formatParagraph(editor);
-  }
-};
-
-export const formatCheckList = (editor: LexicalEditor, blockType: string) => {
-  if (blockType !== 'check') {
-    editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, undefined);
-  } else {
-    formatParagraph(editor);
-  }
-};
-
-export const formatNumberedList = (
-  editor: LexicalEditor,
-  blockType: string,
-) => {
-  if (blockType !== 'number') {
-    editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, undefined);
-  } else {
-    formatParagraph(editor);
-  }
-};
-
-export const formatQuote = (editor: LexicalEditor, blockType: string) => {
-  if (blockType !== 'quote') {
-    editor.update(() => {
-      const selection = $getSelection();
-      $setBlocksType(selection, () => $createQuoteNode());
-    });
-  }
-};
-
-export const formatCode = (editor: LexicalEditor, blockType: string) => {
-  if (blockType !== 'code') {
-    editor.update(() => {
-      let selection = $getSelection();
-
-      if (selection !== null) {
-        if (selection.isCollapsed()) {
-          $setBlocksType(selection, () => $createCodeNode());
-        } else {
-          const textContent = selection.getTextContent();
-          const codeNode = $createCodeNode();
-          selection.insertNodes([codeNode]);
-          selection = $getSelection();
-          if ($isRangeSelection(selection)) {
-            selection.insertRawText(textContent);
-          }
-        }
-      }
-    });
-  }
-};
-
-export const clearFormatting = (editor: LexicalEditor) => {
-  editor.update(() => {
-    const selection = $getSelection();
-    if ($isRangeSelection(selection) || $isTableSelection(selection)) {
-      const anchor = selection.anchor;
-      const focus = selection.focus;
-      const nodes = selection.getNodes();
-      const extractedNodes = selection.extract();
-
-      if (anchor.key === focus.key && anchor.offset === focus.offset) {
-        return;
-      }
-
-      nodes.forEach((node, idx) => {
-        // We split the first and last node by the selection
-        // So that we don't format unselected text inside those nodes
-        if ($isTextNode(node)) {
-          // Use a separate variable to ensure TS does not lose the refinement
-          let textNode = node;
-          if (idx === 0 && anchor.offset !== 0) {
-            textNode = textNode.splitText(anchor.offset)[1] || textNode;
-          }
-          if (idx === nodes.length - 1) {
-            textNode = textNode.splitText(focus.offset)[0] || textNode;
-          }
-          /**
-           * If the selected text has one format applied
-           * selecting a portion of the text, could
-           * clear the format to the wrong portion of the text.
-           *
-           * The cleared text is based on the length of the selected text.
-           */
-          // We need this in case the selected text only has one format
-          const extractedTextNode = extractedNodes[0];
-          if (nodes.length === 1 && $isTextNode(extractedTextNode)) {
-            textNode = extractedTextNode;
-          }
-
-          if (textNode.__style !== '') {
-            textNode.setStyle('');
-          }
-          if (textNode.__format !== 0) {
-            textNode.setFormat(0);
-            $getNearestBlockElementAncestorOrThrow(textNode).setFormat('');
-          }
-          node = textNode;
-        } else if ($isHeadingNode(node) || $isQuoteNode(node)) {
-          node.replace($createParagraphNode(), true);
-        } else if ($isDecoratorBlockNode(node)) {
-          node.setFormat('');
-        }
-      });
-    }
-  });
-};
+import {
+  DEFAULT_FONT_SIZE,
+  MAX_ALLOWED_FONT_SIZE,
+  MIN_ALLOWED_FONT_SIZE
+} from "./chunk-7NZAPJ4G.mjs";
+import {
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/editor/utils/editorFormatting.ts
+init_react_shim();
+import { $createCodeNode } from "@lexical/code";
+import {
+  INSERT_CHECK_LIST_COMMAND,
+  INSERT_ORDERED_LIST_COMMAND,
+  INSERT_UNORDERED_LIST_COMMAND
+} from "@lexical/list";
+import { $isDecoratorBlockNode } from "@lexical/react/LexicalDecoratorBlockNode";
+import {
+  $createHeadingNode,
+  $createQuoteNode,
+  $isHeadingNode,
+  $isQuoteNode
+} from "@lexical/rich-text";
+import { $patchStyleText, $setBlocksType } from "@lexical/selection";
+import { $isTableSelection } from "@lexical/table";
+import { $getNearestBlockElementAncestorOrThrow } from "@lexical/utils";
+import {
+  $createParagraphNode,
+  $getSelection,
+  $isRangeSelection,
+  $isTextNode
+} from "lexical";
+var calculateNextFontSize = (currentFontSize, updateType) => {
+  if (!updateType) {
+    return currentFontSize;
+  }
+  let updatedFontSize = currentFontSize;
+  switch (updateType) {
+    case 2 /* decrement */:
+      switch (true) {
+        case currentFontSize > MAX_ALLOWED_FONT_SIZE:
+          updatedFontSize = MAX_ALLOWED_FONT_SIZE;
+          break;
+        case currentFontSize >= 48:
+          updatedFontSize -= 12;
+          break;
+        case currentFontSize >= 24:
+          updatedFontSize -= 4;
+          break;
+        case currentFontSize >= 14:
+          updatedFontSize -= 2;
+          break;
+        case currentFontSize >= 9:
+          updatedFontSize -= 1;
+          break;
+        default:
+          updatedFontSize = MIN_ALLOWED_FONT_SIZE;
+          break;
+      }
+      break;
+    case 1 /* increment */:
+      switch (true) {
+        case currentFontSize < MIN_ALLOWED_FONT_SIZE:
+          updatedFontSize = MIN_ALLOWED_FONT_SIZE;
+          break;
+        case currentFontSize < 12:
+          updatedFontSize += 1;
+          break;
+        case currentFontSize < 20:
+          updatedFontSize += 2;
+          break;
+        case currentFontSize < 36:
+          updatedFontSize += 4;
+          break;
+        case currentFontSize <= 60:
+          updatedFontSize += 12;
+          break;
+        default:
+          updatedFontSize = MAX_ALLOWED_FONT_SIZE;
+          break;
+      }
+      break;
+    default:
+      break;
+  }
+  return updatedFontSize;
+};
+var updateFontSizeInSelection = (editor, newFontSize, updateType) => {
+  const getNextFontSize = (prevFontSize) => {
+    if (!prevFontSize) {
+      prevFontSize = `${DEFAULT_FONT_SIZE}px`;
+    }
+    prevFontSize = prevFontSize.slice(0, -2);
+    const nextFontSize = calculateNextFontSize(
+      Number(prevFontSize),
+      updateType
+    );
+    return `${nextFontSize}px`;
+  };
+  editor.update(() => {
+    if (editor.isEditable()) {
+      const selection = $getSelection();
+      if (selection !== null) {
+        $patchStyleText(selection, {
+          "font-size": newFontSize || getNextFontSize
+        });
+      }
+    }
+  });
+};
+var updateFontSize = (editor, updateType, inputValue) => {
+  if (inputValue !== "") {
+    const nextFontSize = calculateNextFontSize(Number(inputValue), updateType);
+    updateFontSizeInSelection(editor, String(nextFontSize) + "px", null);
+  } else {
+    updateFontSizeInSelection(editor, null, updateType);
+  }
+};
+var formatParagraph = (editor) => {
+  editor.update(() => {
+    const selection = $getSelection();
+    if ($isRangeSelection(selection)) {
+      $setBlocksType(selection, () => $createParagraphNode());
+    }
+  });
+};
+var formatHeading = (editor, blockType, headingSize) => {
+  if (blockType !== headingSize) {
+    editor.update(() => {
+      const selection = $getSelection();
+      $setBlocksType(selection, () => $createHeadingNode(headingSize));
+    });
+  }
+};
+var formatBulletList = (editor, blockType) => {
+  if (blockType !== "bullet") {
+    editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, void 0);
+  } else {
+    formatParagraph(editor);
+  }
+};
+var formatCheckList = (editor, blockType) => {
+  if (blockType !== "check") {
+    editor.dispatchCommand(INSERT_CHECK_LIST_COMMAND, void 0);
+  } else {
+    formatParagraph(editor);
+  }
+};
+var formatNumberedList = (editor, blockType) => {
+  if (blockType !== "number") {
+    editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, void 0);
+  } else {
+    formatParagraph(editor);
+  }
+};
+var formatQuote = (editor, blockType) => {
+  if (blockType !== "quote") {
+    editor.update(() => {
+      const selection = $getSelection();
+      $setBlocksType(selection, () => $createQuoteNode());
+    });
+  }
+};
+var formatCode = (editor, blockType) => {
+  if (blockType !== "code") {
+    editor.update(() => {
+      let selection = $getSelection();
+      if (selection !== null) {
+        if (selection.isCollapsed()) {
+          $setBlocksType(selection, () => $createCodeNode());
+        } else {
+          const textContent = selection.getTextContent();
+          const codeNode = $createCodeNode();
+          selection.insertNodes([codeNode]);
+          selection = $getSelection();
+          if ($isRangeSelection(selection)) {
+            selection.insertRawText(textContent);
+          }
+        }
+      }
+    });
+  }
+};
+var clearFormatting = (editor) => {
+  editor.update(() => {
+    const selection = $getSelection();
+    if ($isRangeSelection(selection) || $isTableSelection(selection)) {
+      const anchor = selection.anchor;
+      const focus = selection.focus;
+      const nodes = selection.getNodes();
+      const extractedNodes = selection.extract();
+      if (anchor.key === focus.key && anchor.offset === focus.offset) {
+        return;
+      }
+      nodes.forEach((node, idx) => {
+        if ($isTextNode(node)) {
+          let textNode = node;
+          if (idx === 0 && anchor.offset !== 0) {
+            textNode = textNode.splitText(anchor.offset)[1] || textNode;
+          }
+          if (idx === nodes.length - 1) {
+            textNode = textNode.splitText(focus.offset)[0] || textNode;
+          }
+          const extractedTextNode = extractedNodes[0];
+          if (nodes.length === 1 && $isTextNode(extractedTextNode)) {
+            textNode = extractedTextNode;
+          }
+          if (textNode.__style !== "") {
+            textNode.setStyle("");
+          }
+          if (textNode.__format !== 0) {
+            textNode.setFormat(0);
+            $getNearestBlockElementAncestorOrThrow(textNode).setFormat("");
+          }
+          node = textNode;
+        } else if ($isHeadingNode(node) || $isQuoteNode(node)) {
+          node.replace($createParagraphNode(), true);
+        } else if ($isDecoratorBlockNode(node)) {
+          node.setFormat("");
+        }
+      });
+    }
+  });
+};
+
+export {
+  updateFontSizeInSelection,
+  updateFontSize,
+  formatParagraph,
+  formatHeading,
+  formatBulletList,
+  formatCheckList,
+  formatNumberedList,
+  formatQuote,
+  formatCode,
+  clearFormatting
+};

package/dist/chunk-QEIFVK5M.mjs

@@ -0,0 +1,29 @@
+import {
+  cn
+} from "./chunk-YHPNOWFH.mjs";
+import {
+  React,
+  __objRest,
+  __spreadValues,
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/ui/skeleton.tsx
+init_react_shim();
+function Skeleton(_a) {
+  var _b = _a, {
+    className
+  } = _b, props = __objRest(_b, [
+    "className"
+  ]);
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    __spreadValues({
+      className: cn("animate-pulse rounded-md bg-primary/10", className)
+    }, props)
+  );
+}
+
+export {
+  Skeleton
+};