@collabchron/notiq 0.3.0 → 1.0.0

package/dist/chunk-77UA6HYR.mjs

@@ -0,0 +1,165 @@
+import {
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/editor/plugins/SpeechToTextPlugin/index.ts
+init_react_shim();
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import {
+  $getSelection,
+  $isRangeSelection,
+  COMMAND_PRIORITY_EDITOR,
+  createCommand,
+  REDO_COMMAND,
+  UNDO_COMMAND
+} from "lexical";
+import { useEffect as useEffect2, useRef as useRef2, useState } from "react";
+
+// src/hooks/useReport.ts
+init_react_shim();
+import { useCallback, useEffect, useRef } from "react";
+var getElement = () => {
+  let element = document.getElementById("report-container");
+  if (element === null) {
+    element = document.createElement("div");
+    element.id = "report-container";
+    element.style.position = "fixed";
+    element.style.top = "50%";
+    element.style.left = "50%";
+    element.style.fontSize = "32px";
+    element.style.transform = "translate(-50%, -50px)";
+    element.style.padding = "20px";
+    element.style.background = "rgba(240, 240, 240, 0.4)";
+    element.style.borderRadius = "20px";
+    if (document.body) {
+      document.body.appendChild(element);
+    }
+  }
+  return element;
+};
+function useReport() {
+  const timer = useRef(null);
+  const cleanup = useCallback(() => {
+    if (timer.current !== null) {
+      clearTimeout(timer.current);
+      timer.current = null;
+    }
+    if (document.body) {
+      document.body.removeChild(getElement());
+    }
+  }, []);
+  useEffect(() => {
+    return cleanup;
+  }, [cleanup]);
+  return useCallback(
+    (content) => {
+      console.log(content);
+      const element = getElement();
+      if (timer.current !== null) {
+        clearTimeout(timer.current);
+      }
+      element.innerHTML = content;
+      timer.current = setTimeout(cleanup, 1e3);
+      return timer.current;
+    },
+    [cleanup]
+  );
+}
+
+// src/components/editor/plugins/SpeechToTextPlugin/index.ts
+var SPEECH_TO_TEXT_COMMAND = createCommand(
+  "SPEECH_TO_TEXT_COMMAND"
+);
+var VOICE_COMMANDS = {
+  "\n": ({ selection }) => {
+    selection.insertParagraph();
+  },
+  redo: ({ editor }) => {
+    editor.dispatchCommand(REDO_COMMAND, void 0);
+  },
+  undo: ({ editor }) => {
+    editor.dispatchCommand(UNDO_COMMAND, void 0);
+  }
+};
+var SUPPORT_SPEECH_RECOGNITION = typeof window !== "undefined" && ("SpeechRecognition" in window || "webkitSpeechRecognition" in window);
+function SpeechToTextPlugin() {
+  const [editor] = useLexicalComposerContext();
+  const [isEnabled, setIsEnabled] = useState(false);
+  const SpeechRecognition = (
+    // @ts-expect-error missing type
+    window.SpeechRecognition || window.webkitSpeechRecognition
+  );
+  const recognition = useRef2(null);
+  const isRecognizing = useRef2(false);
+  const report = useReport();
+  useEffect2(() => {
+    if (isEnabled && recognition.current === null) {
+      recognition.current = new SpeechRecognition();
+      recognition.current.continuous = true;
+      recognition.current.interimResults = true;
+      recognition.current.onresult = (event) => {
+        const resultItem = event.results.item(event.resultIndex);
+        const { transcript } = resultItem.item(0);
+        report(transcript);
+        if (!resultItem.isFinal) {
+          return;
+        }
+        editor.update(() => {
+          const selection = $getSelection();
+          if ($isRangeSelection(selection)) {
+            const command = VOICE_COMMANDS[transcript.toLowerCase().trim()];
+            if (command) {
+              command({ editor, selection });
+            } else if (transcript.match(/\s*\n\s*/)) {
+              selection.insertParagraph();
+            } else {
+              selection.insertText(transcript);
+            }
+          }
+        });
+      };
+      recognition.current.onstart = () => {
+        isRecognizing.current = true;
+      };
+      recognition.current.onend = () => {
+        var _a;
+        isRecognizing.current = false;
+        if (isEnabled) {
+          (_a = recognition.current) == null ? void 0 : _a.start();
+        }
+      };
+    }
+    if (recognition.current) {
+      if (isEnabled && !isRecognizing.current) {
+        recognition.current.start();
+      } else if (!isEnabled && isRecognizing.current) {
+        recognition.current.stop();
+      }
+    }
+    return () => {
+      if (recognition.current) {
+        recognition.current.stop();
+        recognition.current = null;
+        isRecognizing.current = false;
+      }
+    };
+  }, [SpeechRecognition, editor, isEnabled, report]);
+  useEffect2(() => {
+    return editor.registerCommand(
+      SPEECH_TO_TEXT_COMMAND,
+      (_isEnabled) => {
+        setIsEnabled(_isEnabled);
+        return true;
+      },
+      COMMAND_PRIORITY_EDITOR
+    );
+  }, [editor]);
+  return null;
+}
+var SpeechToTextPlugin_default = SUPPORT_SPEECH_RECOGNITION ? SpeechToTextPlugin : () => null;
+
+export {
+  SPEECH_TO_TEXT_COMMAND,
+  SUPPORT_SPEECH_RECOGNITION,
+  SpeechToTextPlugin_default
+};

package/dist/chunk-7NZAPJ4G.mjs

@@ -0,0 +1,102 @@
+import {
+  __spreadProps,
+  __spreadValues,
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/providers/ToolbarContext.tsx
+init_react_shim();
+import React, {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState
+} from "react";
+var MIN_ALLOWED_FONT_SIZE = 8;
+var MAX_ALLOWED_FONT_SIZE = 72;
+var DEFAULT_FONT_SIZE = 15;
+var blockTypeToBlockName = {
+  bullet: "Bulleted List",
+  check: "Check List",
+  code: "Code Block",
+  h1: "Heading 1",
+  h2: "Heading 2",
+  h3: "Heading 3",
+  h4: "Heading 4",
+  h5: "Heading 5",
+  h6: "Heading 6",
+  number: "Numbered List",
+  paragraph: "Normal",
+  quote: "Quote"
+};
+var INITIAL_TOOLBAR_STATE = {
+  bgColor: "#fff",
+  blockType: "paragraph",
+  canRedo: false,
+  canUndo: false,
+  codeLanguage: "",
+  elementFormat: "left",
+  fontColor: "#000",
+  fontFamily: "Arial",
+  // Current font size in px
+  fontSize: `${DEFAULT_FONT_SIZE}px`,
+  // Font size input value - for controlled input
+  fontSizeInputValue: `${DEFAULT_FONT_SIZE}`,
+  isBold: false,
+  isCode: false,
+  isImageCaption: false,
+  isItalic: false,
+  isLink: false,
+  isRTL: false,
+  isStrikethrough: false,
+  isSubscript: false,
+  isSuperscript: false,
+  isUnderline: false,
+  isLowercase: false,
+  isUppercase: false,
+  isCapitalize: false,
+  rootType: "root"
+};
+var Context = createContext(void 0);
+var ToolbarContext = ({
+  children
+}) => {
+  const [toolbarState, setToolbarState] = useState(INITIAL_TOOLBAR_STATE);
+  const selectionFontSize = toolbarState.fontSize;
+  const updateToolbarState = useCallback(
+    (key, value) => {
+      setToolbarState((prev) => __spreadProps(__spreadValues({}, prev), {
+        [key]: value
+      }));
+    },
+    []
+  );
+  useEffect(() => {
+    updateToolbarState("fontSizeInputValue", selectionFontSize.slice(0, -2));
+  }, [selectionFontSize, updateToolbarState]);
+  const contextValue = useMemo(() => {
+    return {
+      toolbarState,
+      updateToolbarState
+    };
+  }, [toolbarState, updateToolbarState]);
+  return /* @__PURE__ */ React.createElement(Context.Provider, { value: contextValue }, children);
+};
+var useToolbarState = () => {
+  const context = useContext(Context);
+  if (context === void 0) {
+    throw new Error("useToolbarState must be used within a ToolbarProvider");
+  }
+  return context;
+};
+
+export {
+  MIN_ALLOWED_FONT_SIZE,
+  MAX_ALLOWED_FONT_SIZE,
+  DEFAULT_FONT_SIZE,
+  blockTypeToBlockName,
+  ToolbarContext,
+  useToolbarState
+};

package/dist/chunk-7VUMHWWL.mjs

@@ -0,0 +1,152 @@
+import {
+  DropDown
+} from "./chunk-EGMI62PP.mjs";
+import {
+  __spreadProps,
+  __spreadValues,
+  init_react_shim
+} from "./chunk-77KXU36M.mjs";
+
+// src/components/ui/drop-downs/font.tsx
+init_react_shim();
+import { $getSelection } from "lexical";
+import React, { useCallback } from "react";
+import { $patchStyleText } from "@lexical/selection";
+function Font({
+  editor,
+  style,
+  disabled,
+  value,
+  sideOffset,
+  side,
+  ShowChevronsUpDown
+}) {
+  const applyFont = useCallback(
+    (font) => {
+      editor.update(() => {
+        const selection = $getSelection();
+        if (selection !== null) {
+          $patchStyleText(selection, {
+            ["font-family"]: font
+          });
+        }
+      });
+    },
+    [editor, style]
+  );
+  const FONT_FAMILY_OPTIONS = [
+    {
+      label: "Arial",
+      func: () => applyFont("Arial"),
+      style: { fontFamily: "Arial" }
+    },
+    {
+      label: "Courier New",
+      func: () => applyFont("Courier New"),
+      style: { fontFamily: "Courier New" }
+    },
+    {
+      label: "Georgia",
+      func: () => applyFont("Georgia"),
+      style: { fontFamily: "Georgia" }
+    },
+    {
+      label: "Times New Roman",
+      func: () => applyFont("Times New Roman"),
+      style: { fontFamily: "Times New Roman" }
+    },
+    {
+      label: "Trebuchet MS",
+      func: () => applyFont("Trebuchet MS"),
+      style: { fontFamily: "Trebuchet MS" }
+    },
+    {
+      label: "Verdana",
+      func: () => applyFont("Verdana"),
+      style: { fontFamily: "Verdana" }
+    },
+    {
+      label: "Comic Sans MS",
+      func: () => applyFont("Comic Sans MS"),
+      style: { fontFamily: "Comic Sans MS" }
+    },
+    {
+      label: "Calibri",
+      func: () => applyFont("Calibri"),
+      style: { fontFamily: "Calibri" }
+    },
+    {
+      label: "Poppins",
+      func: () => applyFont("Poppins"),
+      style: { fontFamily: "Poppins" }
+    },
+    {
+      label: "Alegreya",
+      func: () => applyFont("Alegreya"),
+      style: { fontFamily: "Alegreya" }
+    },
+    {
+      label: "Bree Serif",
+      func: () => applyFont("Bree Serif"),
+      style: { fontFamily: "Bree Serif" }
+    },
+    {
+      label: "Cambria",
+      func: () => applyFont("Cambria"),
+      style: { fontFamily: "Cambria" }
+    },
+    {
+      label: "Impact",
+      func: () => applyFont("Impact"),
+      style: { fontFamily: "Impact" }
+    },
+    {
+      label: "Lexend",
+      func: () => applyFont("Lexend"),
+      style: { fontFamily: "Lexend" }
+    },
+    {
+      label: "Lobster",
+      func: () => applyFont("Lobster"),
+      style: { fontFamily: "Lobster" }
+    },
+    {
+      label: "Lora",
+      func: () => applyFont("Lora"),
+      style: { fontFamily: "Lora" }
+    },
+    {
+      label: "Permanent Marker",
+      func: () => applyFont("Permanent Marker"),
+      style: { fontFamily: "Permanent Marker" }
+    },
+    {
+      label: "Ultra",
+      func: () => applyFont("Ultra"),
+      style: { fontFamily: "Ultra" }
+    },
+    {
+      label: "Reenie Beanie",
+      func: () => applyFont("Reenie Beanie"),
+      style: { fontFamily: "Reenie Beanie" }
+    }
+  ];
+  return /* @__PURE__ */ React.createElement(
+    DropDown,
+    {
+      ShowChevronsUpDown,
+      side,
+      sideOffset,
+      className: "h-7 min-w-fit w-full px-2 border-none cursor-pointer hover:bg-zinc-100 hover:text-zinc-900",
+      PopoverContentClassName: { minWidth: "80px", width: "150px" },
+      TriggerClassName: __spreadProps(__spreadValues({}, style), { width: "100%" }),
+      disabled,
+      TriggerLabel: value,
+      values: FONT_FAMILY_OPTIONS
+    }
+  );
+}
+
+export {
+  Font
+};