ocean-brain 0.6.2 → 0.7.0

package/server/dist/modules/blocknote.js

@@ -4,6 +4,8 @@ import models from "../models.js";
 const UNSUPPORTED_MARKDOWN_BLOCK_TYPES = /* @__PURE__ */ new Set(["tableOfContents"]);
 const TAG_PLACEHOLDER_PREFIX = "OCEAN_BRAIN_TAG_";
 const TAG_PLACEHOLDER_SUFFIX = "_TOKEN";
+const REFERENCE_PLACEHOLDER_PREFIX = "OCEAN_BRAIN_REFERENCE_";
+const REFERENCE_PLACEHOLDER_SUFFIX = "_TOKEN";
 const defaultMarkdownImportDeps = {
   ensureTag: async (name) => ensureTagByName(name),
   findNotesByTitle: async (title) => {
@@ -20,6 +22,23 @@ const defaultMarkdownImportDeps = {
       id: String(note.id),
       title: note.title
     }));
+  },
+  findNoteById: async (id) => {
+    if (!isValidNoteIdString(id)) {
+      return null;
+    }
+    const numericId = Number(id);
+    const note = await models.note.findUnique({
+      select: {
+        id: true,
+        title: true
+      },
+      where: { id: numericId }
+    });
+    return note ? {
+      id: String(note.id),
+      title: note.title
+    } : null;
   }
 };
 function stripUnsupportedMarkdownBlocks(blocks) {
@@ -46,6 +65,16 @@ function visitBlocks(blocks, visit) {
 function createTagPlaceholder(index) {
   return `${TAG_PLACEHOLDER_PREFIX}${index}${TAG_PLACEHOLDER_SUFFIX}`;
 }
+function createReferencePlaceholder(index) {
+  return `${REFERENCE_PLACEHOLDER_PREFIX}${index}${REFERENCE_PLACEHOLDER_SUFFIX}`;
+}
+function isValidNoteIdString(id) {
+  if (!/^[1-9]\d*$/.test(id)) {
+    return false;
+  }
+  const numericId = Number(id);
+  return Number.isSafeInteger(numericId) && numericId <= MAX_SQLITE_INT_ID;
+}
 function isTableContent(content) {
   return !Array.isArray(content) && content?.type === "tableContent";
 }
@@ -114,23 +143,16 @@ function mapBlocks(blocks, mapContent) {
     children: block.children?.length ? mapBlocks(block.children, mapContent) : []
   }));
 }
-async function mapBlocksAsync(blocks, mapContent) {
-  return Promise.all(
-    blocks.map(async (block) => ({
-      ...block,
-      content: await mapContent(block.content),
-      children: block.children?.length ? await mapBlocksAsync(block.children, mapContent) : []
-    }))
-  );
-}
 function preprocessCustomInlineContent(blocks, placeholderToTag, nextPlaceholderIndex) {
   return mapBlocks(
     blocks,
     (content) => mapBlockContent(content, (inline) => {
       if (inline.type === "reference") {
+        const id = String(inline.props?.id || "");
+        const title = String(inline.props?.title || inline.props?.id || "");
         return {
           type: "text",
-          text: `[[${inline.props?.title || inline.props?.id || ""}]]`,
+          text: isValidNoteIdString(id) ? `[[${title}]](note:${id})` : `[[${title}]]`,
           styles: {}
         };
       }
@@ -168,6 +190,57 @@ function preprocessMarkdownExplicitTags(markdown) {
     placeholderToTag
   };
 }
+function preprocessMarkdownExplicitReferences(markdown) {
+  const placeholderToReference = /* @__PURE__ */ new Map();
+  let activeFence = null;
+  const preprocessedLines = markdown.split(/(?<=\n)/).map((line) => {
+    const { body: lineBody, lineEnding } = splitMarkdownLineEnding(line);
+    const fenceMatch = lineBody.match(MARKDOWN_FENCED_CODE_PATTERN);
+    if (activeFence) {
+      if (isClosingFenceLine(lineBody, activeFence)) {
+        activeFence = null;
+      }
+      return line;
+    }
+    if (fenceMatch?.[1]) {
+      activeFence = {
+        marker: fenceMatch[1][0],
+        length: fenceMatch[1].length
+      };
+      return line;
+    }
+    if (/^(?: {4,}|\t)/.test(lineBody)) {
+      return line;
+    }
+    return `${replaceMarkdownLineExplicitReferences(lineBody, placeholderToReference)}${lineEnding}`;
+  });
+  return {
+    markdown: preprocessedLines.join(""),
+    placeholderToReference
+  };
+}
+function replaceMarkdownLineExplicitReferences(line, placeholderToReference) {
+  let result = "";
+  let cursor = 0;
+  while (cursor < line.length) {
+    const codeSpan = findNextInlineCodeSpan(line, cursor);
+    if (!codeSpan) {
+      result += replaceExplicitReferenceTokens(line.slice(cursor), placeholderToReference);
+      break;
+    }
+    result += replaceExplicitReferenceTokens(line.slice(cursor, codeSpan.start), placeholderToReference);
+    result += line.slice(codeSpan.start, codeSpan.end);
+    cursor = codeSpan.end;
+  }
+  return result;
+}
+function replaceExplicitReferenceTokens(text, placeholderToReference) {
+  return text.replace(/\[\[([^\]\n]+)\]\]\(note:([^)\s]+)\)/g, (token, title, id) => {
+    const placeholder = createReferencePlaceholder(placeholderToReference.size);
+    placeholderToReference.set(placeholder, { id, title, token });
+    return placeholder;
+  });
+}
 const MARKDOWN_ANGLE_BRACKET_TOKEN_PATTERN = /<([^<>\n]+)>/g;
 const MARKDOWN_NUMERIC_TILDE_RANGE_PATTERN = /(\d)~(?=\d)/g;
 const MARKDOWN_FENCED_CODE_PATTERN = /^ {0,3}(`{3,}|~{3,})/;
@@ -175,6 +248,9 @@ const ANGLE_BRACKET_PLACEHOLDER_PREFIX = "\uE000OBANGLE";
 const ANGLE_BRACKET_PLACEHOLDER_SUFFIX = "\uE001";
 const NUMERIC_TILDE_RANGE_PLACEHOLDER_PREFIX = "\uE000OBTILDE";
 const NUMERIC_TILDE_RANGE_PLACEHOLDER_SUFFIX = "\uE001";
+const HARD_BREAK_PLACEHOLDER_PREFIX = "\uE000OBHARDBREAK";
+const HARD_BREAK_PLACEHOLDER_SUFFIX = "\uE001";
+const MAX_SQLITE_INT_ID = 2147483647;
 function isMarkdownAutolinkAngleBracketText(innerText) {
   if (innerText !== innerText.trim()) {
     return false;
@@ -253,6 +329,49 @@ function protectMarkdownNumericTildeRanges(markdown) {
     placeholderToToken
   };
 }
+function protectMarkdownLineEndHardBreakMarkers(markdown) {
+  const protectedLines = [];
+  const placeholderToToken = /* @__PURE__ */ new Map();
+  let activeFence = null;
+  const lines = markdown.split(/(?<=\n)/);
+  for (const [index, line] of lines.entries()) {
+    const { body: lineBody, lineEnding } = splitMarkdownLineEnding(line);
+    const fenceMatch = lineBody.match(MARKDOWN_FENCED_CODE_PATTERN);
+    if (activeFence) {
+      protectedLines.push(line);
+      if (isClosingFenceLine(lineBody, activeFence)) {
+        activeFence = null;
+      }
+      continue;
+    }
+    if (fenceMatch?.[1]) {
+      const marker = fenceMatch[1][0];
+      activeFence = {
+        marker,
+        length: fenceMatch[1].length
+      };
+      protectedLines.push(line);
+      continue;
+    }
+    if (/^(?: {4,}|\t)/.test(lineBody)) {
+      protectedLines.push(line);
+      continue;
+    }
+    const nextLineBody = splitMarkdownLineEnding(lines[index + 1] ?? "").body;
+    protectedLines.push(
+      `${protectMarkdownLineEndHardBreakMarker(
+        lineBody,
+        lineEnding,
+        isMarkdownHardBreakContinuationLine(nextLineBody),
+        placeholderToToken
+      )}${lineEnding}`
+    );
+  }
+  return {
+    markdown: protectedLines.join(""),
+    placeholderToToken
+  };
+}
 function protectMarkdownTextAngleBrackets(markdown) {
   const protectedLines = [];
   const placeholderToToken = /* @__PURE__ */ new Map();
@@ -404,12 +523,61 @@ function replaceNumericTildeRangeMarkers(text, placeholderToToken) {
     return `${leadingDigit}${placeholder}`;
   });
 }
+function protectMarkdownLineEndHardBreakMarker(line, lineEnding, hasContinuationLine, placeholderToToken) {
+  if (!lineEnding || !line.endsWith("\\")) {
+    return line;
+  }
+  const placeholder = createHardBreakPlaceholder(placeholderToToken.size);
+  const shouldPreserveAsHardBreak = hasContinuationLine && !hasUnclosedInlineCodeSpanAtLineEnd(line);
+  placeholderToToken.set(placeholder, shouldPreserveAsHardBreak ? "" : "\\");
+  return `${line.slice(0, -1)}${placeholder}`;
+}
+function isMarkdownHardBreakContinuationLine(line) {
+  if (!line.trim()) {
+    return false;
+  }
+  const trimmedLine = line.trimStart();
+  if (trimmedLine.match(MARKDOWN_FENCED_CODE_PATTERN)) {
+    return false;
+  }
+  if (/^(?:#{1,6})(?:\s|$)/.test(trimmedLine)) {
+    return false;
+  }
+  if (/^>/.test(trimmedLine)) {
+    return false;
+  }
+  if (/^(?:[-+*])(?:\s|$)/.test(trimmedLine) || /^\d{1,9}[.)](?:\s|$)/.test(trimmedLine)) {
+    return false;
+  }
+  if (/^(?:-{3,}|\*{3,}|_{3,})\s*$/.test(trimmedLine)) {
+    return false;
+  }
+  return true;
+}
+function hasUnclosedInlineCodeSpanAtLineEnd(line) {
+  let cursor = 0;
+  let openDelimiter = null;
+  while (cursor < line.length) {
+    const codeStart = line.indexOf("`", cursor);
+    if (codeStart === -1) {
+      break;
+    }
+    const delimiterLength = countRepeatedCharacter(line, codeStart, "`");
+    const delimiter = "`".repeat(delimiterLength);
+    openDelimiter = openDelimiter === delimiter ? null : delimiter;
+    cursor = codeStart + delimiterLength;
+  }
+  return openDelimiter !== null;
+}
 function createAngleBracketPlaceholder(index) {
   return `${ANGLE_BRACKET_PLACEHOLDER_PREFIX}${index}${ANGLE_BRACKET_PLACEHOLDER_SUFFIX}`;
 }
 function createNumericTildeRangePlaceholder(index) {
   return `${NUMERIC_TILDE_RANGE_PLACEHOLDER_PREFIX}${index}${NUMERIC_TILDE_RANGE_PLACEHOLDER_SUFFIX}`;
 }
+function createHardBreakPlaceholder(index) {
+  return `${HARD_BREAK_PLACEHOLDER_PREFIX}${index}${HARD_BREAK_PLACEHOLDER_SUFFIX}`;
+}
 function countRepeatedCharacter(value, start, character) {
   let cursor = start;
   while (value[cursor] === character) {
@@ -428,6 +596,17 @@ function findTagPlaceholderAtCursor(text, cursor, placeholderToTag) {
   }
   return null;
 }
+function findReferencePlaceholderAtCursor(text, cursor, placeholderToReference) {
+  for (const [placeholder, reference] of placeholderToReference.entries()) {
+    if (text.startsWith(placeholder, cursor)) {
+      return {
+        placeholder,
+        reference
+      };
+    }
+  }
+  return null;
+}
 function restoreRemainingTagPlaceholders(blocks, placeholderToTag) {
   return mapBlocks(
     blocks,
@@ -494,9 +673,10 @@ function appendInline(target, inline) {
   }
   target.push(inline);
 }
-async function restoreCustomInlineContent(blocks, deps, placeholderToTag) {
+async function restoreCustomInlineContent(blocks, deps, placeholderToTag, placeholderToReference = /* @__PURE__ */ new Map()) {
   const tagCache = /* @__PURE__ */ new Map();
   const noteCache = /* @__PURE__ */ new Map();
+  const noteByIdCache = /* @__PURE__ */ new Map();
   const getTag = (token) => {
     const normalizedToken = token.startsWith("#") ? `@${token.slice(1)}` : token;
     let existing = tagCache.get(normalizedToken);
@@ -517,6 +697,14 @@ async function restoreCustomInlineContent(blocks, deps, placeholderToTag) {
     }
     return existing;
   };
+  const getNoteById = (id) => {
+    let existing = noteByIdCache.get(id);
+    if (!existing) {
+      existing = deps.findNoteById ? deps.findNoteById(id) : Promise.resolve(null);
+      noteByIdCache.set(id, existing);
+    }
+    return existing;
+  };
   const restoreTextInline = async (inline) => {
     if (inline.type !== "text" || typeof inline.text !== "string" || !inline.text || inline.styles?.code === true) {
       return [inline];
@@ -525,6 +713,32 @@ async function restoreCustomInlineContent(blocks, deps, placeholderToTag) {
     const styles = inline.styles ?? {};
     let cursor = 0;
     while (cursor < inline.text.length) {
+      const referencePlaceholderMatch = findReferencePlaceholderAtCursor(
+        inline.text,
+        cursor,
+        placeholderToReference
+      );
+      if (referencePlaceholderMatch) {
+        if (!isValidNoteIdString(referencePlaceholderMatch.reference.id)) {
+          appendInline(restored, createTextInline(referencePlaceholderMatch.reference.token, styles));
+          cursor += referencePlaceholderMatch.placeholder.length;
+          continue;
+        }
+        const note = await getNoteById(referencePlaceholderMatch.reference.id);
+        if (note) {
+          appendInline(restored, {
+            type: "reference",
+            props: {
+              id: note.id,
+              title: note.title
+            }
+          });
+        } else {
+          appendInline(restored, createTextInline(referencePlaceholderMatch.reference.token, styles));
+        }
+        cursor += referencePlaceholderMatch.placeholder.length;
+        continue;
+      }
       if (inline.text.startsWith("[[", cursor)) {
         const closeIndex = inline.text.indexOf("]]", cursor + 2);
         if (closeIndex !== -1) {
@@ -564,12 +778,35 @@ async function restoreCustomInlineContent(blocks, deps, placeholderToTag) {
           nextCursor = Math.min(nextCursor, nextPlaceholderCursor);
         }
       }
+      for (const placeholder of placeholderToReference.keys()) {
+        const nextPlaceholderCursor = inline.text.indexOf(placeholder, cursor + 1);
+        if (nextPlaceholderCursor !== -1) {
+          nextCursor = Math.min(nextCursor, nextPlaceholderCursor);
+        }
+      }
       appendInline(restored, createTextInline(inline.text.slice(cursor, nextCursor), styles));
       cursor = nextCursor;
     }
     return restored;
   };
-  return mapBlocksAsync(blocks, (content) => mapBlockContentAsync(content, restoreTextInline));
+  const restoreBlocks = async (items) => {
+    return Promise.all(
+      items.map(async (block) => {
+        if (block.type === "codeBlock") {
+          return {
+            ...block,
+            children: block.children?.length ? await restoreBlocks(block.children) : []
+          };
+        }
+        return {
+          ...block,
+          content: await mapBlockContentAsync(block.content, restoreTextInline),
+          children: block.children?.length ? await restoreBlocks(block.children) : []
+        };
+      })
+    );
+  };
+  return restoreBlocks(blocks);
 }
 function collectTagIds(blocks) {
   const tagIds = /* @__PURE__ */ new Set();
@@ -613,36 +850,49 @@ async function blocksToMarkdown(contentJson) {
 async function markdownToBlocksJson(markdown, deps = defaultMarkdownImportDeps) {
   const editor = getEditor();
   const preprocessedMarkdown = preprocessMarkdownExplicitTags(markdown);
-  const tildeProtectedMarkdown = protectMarkdownNumericTildeRanges(preprocessedMarkdown.markdown);
+  const preprocessedReferenceMarkdown = preprocessMarkdownExplicitReferences(preprocessedMarkdown.markdown);
+  const tildeProtectedMarkdown = protectMarkdownNumericTildeRanges(preprocessedReferenceMarkdown.markdown);
+  const hardBreakProtectedMarkdown = protectMarkdownLineEndHardBreakMarkers(tildeProtectedMarkdown.markdown);
+  const basePlaceholderToToken = new Map([
+    ...tildeProtectedMarkdown.placeholderToToken,
+    ...hardBreakProtectedMarkdown.placeholderToToken
+  ]);
   const contentJson = await parseMarkdownToContentJson(
     editor,
-    tildeProtectedMarkdown.markdown,
+    hardBreakProtectedMarkdown.markdown,
     deps,
     preprocessedMarkdown.placeholderToTag,
-    tildeProtectedMarkdown.placeholderToToken
+    preprocessedReferenceMarkdown.placeholderToReference,
+    basePlaceholderToToken
   );
-  if (extractLiteralAngleBracketTextTokens(preprocessedMarkdown.markdown).length === 0) {
+  if (extractLiteralAngleBracketTextTokens(preprocessedReferenceMarkdown.markdown).length === 0) {
     return contentJson;
   }
-  if (!hasLiteralAngleBracketTextTokenLoss(preprocessedMarkdown.markdown, await blocksToMarkdown(contentJson))) {
+  if (!hasLiteralAngleBracketTextTokenLoss(
+    preprocessedReferenceMarkdown.markdown,
+    await blocksToMarkdown(contentJson)
+  )) {
     return contentJson;
   }
-  const protectedMarkdown = protectMarkdownTextAngleBrackets(tildeProtectedMarkdown.markdown);
-  const placeholderToToken = new Map([
-    ...tildeProtectedMarkdown.placeholderToToken,
-    ...protectedMarkdown.placeholderToToken
-  ]);
+  const protectedMarkdown = protectMarkdownTextAngleBrackets(hardBreakProtectedMarkdown.markdown);
+  const placeholderToToken = new Map([...basePlaceholderToToken, ...protectedMarkdown.placeholderToToken]);
   return parseMarkdownToContentJson(
     editor,
     protectedMarkdown.markdown,
     deps,
     preprocessedMarkdown.placeholderToTag,
+    preprocessedReferenceMarkdown.placeholderToReference,
     placeholderToToken
   );
 }
-async function parseMarkdownToContentJson(editor, markdown, deps, placeholderToTag, placeholderToProtectedTextToken = /* @__PURE__ */ new Map()) {
+async function parseMarkdownToContentJson(editor, markdown, deps, placeholderToTag, placeholderToReference = /* @__PURE__ */ new Map(), placeholderToProtectedTextToken = /* @__PURE__ */ new Map()) {
   const blocks = await editor.tryParseMarkdownToBlocks(markdown);
-  const restoredBlocks = await restoreCustomInlineContent(blocks, deps, placeholderToTag);
+  const restoredBlocks = await restoreCustomInlineContent(
+    blocks,
+    deps,
+    placeholderToTag,
+    placeholderToReference
+  );
   const restoredTagBlocks = restoreRemainingTagPlaceholders(restoredBlocks, placeholderToTag);
   const restoredProtectedTextBlocks = restoreProtectedTextPlaceholders(
     restoredTagBlocks,