@bendyline/squisq-editor-react 2.13.16 → 2.13.17

package/dist/{chunk-UQUYPT5P.js → chunk-EJNCUVPU.js}

@@ -482,6 +482,96 @@ function useBlockNavigator(source, setSource, opts) {
   };
 }
 
+// src/markdownParseProtocol.ts
+import { parseMarkdown as parseMarkdown3 } from "@bendyline/squisq/markdown";
+function isMarkdownParseResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const result = value;
+  if (Object.keys(result).length !== 3 || !Number.isSafeInteger(result.id) || typeof result.id !== "number" || result.id < 1)
+    return false;
+  if (result.markdown === null) return typeof result.error === "string";
+  if (result.error !== null || !result.markdown || typeof result.markdown !== "object")
+    return false;
+  const markdown = result.markdown;
+  return markdown.type === "document" && Array.isArray(markdown.children);
+}
+
+// src/backgroundMarkdownParser.ts
+var BackgroundMarkdownParser = class {
+  constructor(createWorker = () => new Worker(new URL("./document-parse-worker/index.js", import.meta.url), {
+    type: "module",
+    name: "squisq-markdown-parser"
+  })) {
+    this.createWorker = createWorker;
+    this.worker = null;
+    this.active = null;
+    this.pending = null;
+    this.serial = 0;
+    this.failed = false;
+    this.disposed = false;
+  }
+  parse(source, done) {
+    if (this.disposed) return;
+    this.pending = { id: ++this.serial, source, done };
+    this.drain();
+  }
+  cancel() {
+    this.serial++;
+    this.pending = null;
+  }
+  dispose() {
+    this.disposed = true;
+    this.cancel();
+    this.stopWorker();
+  }
+  stopWorker() {
+    clearTimeout(this.timeout);
+    this.worker?.terminate();
+    this.worker = null;
+    this.active = null;
+  }
+  fail() {
+    const latest = this.pending ?? this.active;
+    this.failed = true;
+    this.pending = null;
+    this.stopWorker();
+    if (!this.disposed && latest?.id === this.serial) latest.done(null);
+  }
+  drain() {
+    if (this.disposed || this.active || !this.pending) return;
+    const job = this.pending;
+    this.pending = null;
+    if (this.failed) {
+      job.done(null);
+      return;
+    }
+    this.active = job;
+    try {
+      if (!this.worker) {
+        this.worker = this.createWorker();
+        this.worker.onmessage = ({ data }) => {
+          if (this.disposed || !this.active) return;
+          if (!isMarkdownParseResult(data) || data.id !== this.active.id) {
+            this.fail();
+            return;
+          }
+          const completed = this.active;
+          clearTimeout(this.timeout);
+          this.active = null;
+          if (completed.id === this.serial) completed.done(data);
+          this.drain();
+        };
+        this.worker.onerror = () => this.fail();
+        this.worker.onmessageerror = () => this.fail();
+      }
+      this.timeout = setTimeout(() => this.fail(), 3e4);
+      this.worker.postMessage({ id: job.id, source: job.source });
+    } catch {
+      this.fail();
+    }
+  }
+};
+
 // src/EditorContext.tsx
 import {
   createContext as createContext3,
@@ -493,7 +583,7 @@ import {
   useEffect as useEffect3
 } from "react";
 import {
-  parseMarkdown as parseMarkdown3,
+  parseMarkdown as parseMarkdown4,
   stringifyMarkdown,
   resolveWikiLinks
 } from "@bendyline/squisq/markdown";
@@ -1871,10 +1961,17 @@ function EditorProvider({
   }, [initialColorScheme]);
   const parseTimeoutRef = useRef3(null);
   const skipInitialDebouncedParseRef = useRef3(Boolean(initialMarkdown));
-  const doParse = useCallback3((source) => {
+  const backgroundParserRef = useRef3(null);
+  useEffect3(
+    () => () => {
+      backgroundParserRef.current?.dispose();
+      backgroundParserRef.current = null;
+    },
+    []
+  );
+  const doParse = useCallback3((source, background = false) => {
     setIsParsing(true);
-    try {
-      const parsed = parseMarkdown3(source);
+    const applyParsed = (parsed) => {
       setMarkdownDocState(parsed);
       setParseError(null);
       try {
@@ -1887,12 +1984,30 @@ function EditorProvider({
         setDoc(null);
         console.warn("Doc generation failed:", docErr instanceof Error ? docErr.message : docErr);
       }
-    } catch (err) {
-      setParseError(err instanceof Error ? err.message : "Parse error");
+      setIsParsing(false);
+    };
+    const applyError = (error) => {
+      setParseError(error);
       setMarkdownDocState(null);
       setDoc(null);
-    } finally {
       setIsParsing(false);
+    };
+    const synchronous = () => {
+      try {
+        applyParsed(parseMarkdown4(source));
+      } catch (error) {
+        applyError(error instanceof Error ? error.message : "Parse error");
+      }
+    };
+    if (background && source.length >= 32768 && typeof Worker !== "undefined") {
+      backgroundParserRef.current ?? (backgroundParserRef.current = new BackgroundMarkdownParser());
+      backgroundParserRef.current.parse(source, (result) => {
+        if (result === null) synchronous();
+        else if (result.markdown) applyParsed(result.markdown);
+        else applyError(result.error);
+      });
+    } else {
+      synchronous();
     }
   }, []);
   const [wikiProjection, setWikiProjection] = useState3(null);
@@ -1933,14 +2048,15 @@ function EditorProvider({
     }
     setIsParsing(true);
     parseTimeoutRef.current = setTimeout(() => {
-      doParse(markdownSource);
+      doParse(markdownSource, true);
     }, 150);
     return () => {
       if (parseTimeoutRef.current) {
         clearTimeout(parseTimeoutRef.current);
       }
+      backgroundParserRef.current?.cancel();
     };
-  }, [markdownSource, doParse, editorMode]);
+  }, [markdownSource, doParse, editorMode, articleId, fileName]);
   useEffect3(() => {
     if (editorMode !== "markdown") return;
     if (initialMarkdown) {