@bendyline/squisq-editor-react 2.13.16 → 2.13.18

package/dist/{chunk-LDU3AWER.js → chunk-6GHLTJNG.js}

@@ -3,11 +3,11 @@ import {
   AlignedTableHeader,
   MarkdownEscape,
   PlainTextClipboard
-} from "./chunk-4MBH7MMU.js";
+} from "./chunk-F6URHAW6.js";
 import {
   markdownToTiptap,
   tiptapToMarkdown
-} from "./chunk-ZLKINE4Y.js";
+} from "./chunk-SSEE55FT.js";
 
 // src/jsonEditor/JsonEditorContext.tsx
 import { createContext, useContext, useEffect, useMemo } from "react";

package/dist/{chunk-4MBH7MMU.js → chunk-F6URHAW6.js}

@@ -1,6 +1,6 @@
 import {
   MARKDOWN_ESCAPE_ATTR
-} from "./chunk-ZLKINE4Y.js";
+} from "./chunk-SSEE55FT.js";
 
 // src/MarkdownEscape.ts
 import { Mark, mergeAttributes } from "@tiptap/core";

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

@@ -5,7 +5,7 @@ import {
 import {
   markdownToTiptap,
   tiptapToMarkdown
-} from "./chunk-ZLKINE4Y.js";
+} from "./chunk-SSEE55FT.js";
 
 // src/InsertMenuItems.tsx
 import { createContext, useContext, useEffect, useMemo, useRef } from "react";
@@ -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) {

package/dist/{chunk-ZLKINE4Y.js → chunk-SSEE55FT.js}

@@ -704,14 +704,12 @@ function tiptapToMarkdown(html) {
         const cellRegex = /<(th|td)([^>]*)>(.*?)<\/\1>/gs;
         let cellExec;
         while ((cellExec = cellRegex.exec(rowHtml)) !== null) {
-          const tag = cellExec[1];
           const attrs = cellExec[2];
           const content = htmlToTableCell(cellExec[3]);
           const alignExec = attrs.match(/text-align:\s*(left|center|right)/);
           cells.push({
             content,
-            align: alignExec ? alignExec[1] : null,
-            isHeader: tag === "th"
+            align: alignExec ? alignExec[1] : null
           });
         }
         if (cells.length > 0) {
@@ -719,10 +717,7 @@ function tiptapToMarkdown(html) {
         }
       }
       if (rows.length > 0) {
-        const headerIdx = rows.findIndex((r) => r.some((c) => c.isHeader));
-        const hIdx = headerIdx >= 0 ? headerIdx : 0;
-        const headerRow = rows[hIdx];
-        const dataRows = rows.filter((_, i) => i !== hIdx);
+        const [headerRow, ...dataRows] = rows;
         const aligns = headerRow.map((c) => c.align);
         lines.push("| " + headerRow.map((c) => c.content || " ").join(" | ") + " |");
         lines.push(