@mp-lb/mdkit 0.3.1 → 0.3.3

package/src/markdown/createMdKitTiptapExtensions.ts

@@ -0,0 +1,42 @@
+import type { Extensions } from "@tiptap/core";
+import { Markdown } from "@tiptap/markdown";
+import Placeholder from "@tiptap/extension-placeholder";
+import StarterKit from "@tiptap/starter-kit";
+import { MarkdownPasteExtension } from "./MarkdownPasteExtension";
+import { MarkdownSearchExtension } from "./MarkdownSearchExtension";
+
+type CreateMdKitTiptapExtensionsOptions = {
+  placeholder?: string;
+  undoRedo?: boolean;
+};
+
+export const defaultMdKitMarkdownPlaceholder = "Start writing...";
+
+export const createMdKitTiptapExtensions = ({
+  placeholder = defaultMdKitMarkdownPlaceholder,
+  undoRedo = true,
+}: CreateMdKitTiptapExtensionsOptions = {}): Extensions => [
+  StarterKit.configure({
+    heading: { levels: [1, 2, 3, 4, 5, 6] },
+    link: {
+      HTMLAttributes: {
+        rel: "noopener noreferrer",
+        target: "_blank",
+      },
+      autolink: true,
+      linkOnPaste: true,
+      openOnClick: true,
+    },
+    undoRedo: undoRedo ? undefined : false,
+  }),
+  Placeholder.configure({
+    placeholder,
+  }),
+  Markdown.configure({
+    markedOptions: {
+      gfm: true,
+    },
+  }),
+  MarkdownPasteExtension,
+  MarkdownSearchExtension,
+];

package/src/markdown/editorDebug.ts

@@ -0,0 +1,5 @@
+export type MdKitEditorDebugEvent = {
+  detail: Record<string, unknown>;
+  timestamp: number;
+  type: string;
+};

package/src/markdown/markdownFenceRanges.ts

@@ -0,0 +1,68 @@
+export type MarkdownFenceRange = {
+  end: number;
+  start: number;
+};
+
+const fenceStartPattern = /^ {0,3}(`{3,}|~{3,})/;
+
+export const getMarkdownFenceRanges = (
+  markdown: string,
+): MarkdownFenceRange[] => {
+  const ranges: MarkdownFenceRange[] = [];
+  let activeFence: {
+    char: "`" | "~";
+    length: number;
+    start: number;
+  } | null = null;
+  let lineStart = 0;
+
+  while (lineStart < markdown.length) {
+    const newlineIndex = markdown.indexOf("\n", lineStart);
+    const lineEnd = newlineIndex === -1 ? markdown.length : newlineIndex;
+
+    const nextLineStart =
+      newlineIndex === -1 ? markdown.length : newlineIndex + 1;
+
+    const line = markdown.slice(lineStart, lineEnd);
+    const fenceMatch = line.match(fenceStartPattern);
+
+    if (fenceMatch) {
+      const marker = fenceMatch[1] ?? "";
+      const markerChar = marker[0] as "`" | "~";
+
+      if (!activeFence) {
+        activeFence = {
+          char: markerChar,
+          length: marker.length,
+          start: lineStart,
+        };
+      } else if (
+        markerChar === activeFence.char &&
+        marker.length >= activeFence.length
+      ) {
+        ranges.push({
+          start: activeFence.start,
+          end: nextLineStart,
+        });
+
+        activeFence = null;
+      }
+    }
+
+    lineStart = nextLineStart;
+  }
+
+  if (activeFence) {
+    ranges.push({
+      start: activeFence.start,
+      end: markdown.length,
+    });
+  }
+
+  return ranges;
+};
+
+export const isInsideMarkdownFence = (
+  index: number,
+  ranges: MarkdownFenceRange[],
+) => ranges.some((range) => index >= range.start && index < range.end - 1);

package/src/markdown/normalizeMarkdownSerialization.ts

@@ -0,0 +1,55 @@
+const placeholderLinePattern = /^[ \t]*(?: |\u00a0)[ \t]*$/;
+
+const normalizePlaceholderParagraphs = (markdown: string) => {
+  const lines = markdown.split("\n");
+  const normalizedLines: string[] = [];
+  let index = 0;
+
+  while (index < lines.length) {
+    const line = lines[index] ?? "";
+
+    if (line !== "" && !placeholderLinePattern.test(line)) {
+      normalizedLines.push(line);
+      index += 1;
+      continue;
+    }
+
+    const start = index;
+    let placeholderCount = 0;
+
+    while (
+      index < lines.length &&
+      ((lines[index] ?? "") === "" ||
+        placeholderLinePattern.test(lines[index] ?? ""))
+    ) {
+      if (placeholderLinePattern.test(lines[index] ?? "")) {
+        placeholderCount += 1;
+      }
+
+      index += 1;
+    }
+
+    if (placeholderCount === 0) {
+      normalizedLines.push(...lines.slice(start, index));
+      continue;
+    }
+
+    normalizedLines.push(
+      ...Array.from({ length: placeholderCount + 1 }, () => ""),
+    );
+  }
+
+  const normalizedMarkdown = normalizedLines.join("\n");
+
+  return placeholderLinePattern.test(normalizedMarkdown.trim())
+    ? ""
+    : normalizedMarkdown;
+};
+
+export const normalizeMarkdownSerialization = (markdown: string) =>
+  normalizePlaceholderParagraphs(
+    markdown.replace(
+      /^([ \t]*(?:[-*+]|\d+[.)])[ \t]+)(?:&nbsp;|\u00a0)[ \t]*$/gm,
+      "$1",
+    ),
+  );

package/src/markdown/prepareMarkdownForEditorHydration.ts

@@ -0,0 +1,23 @@
+import {
+  getMarkdownFenceRanges,
+  isInsideMarkdownFence,
+} from "./markdownFenceRanges";
+
+const expandedBlankLineRunPattern = /\n{3,}/g;
+
+export const prepareMarkdownForEditorHydration = (markdown: string) => {
+  const fenceRanges = getMarkdownFenceRanges(markdown);
+
+  return markdown.replace(expandedBlankLineRunPattern, (newlineRun, offset) => {
+    if (isInsideMarkdownFence(offset, fenceRanges)) {
+      return newlineRun;
+    }
+
+    const emptyParagraphs = Array.from(
+      { length: newlineRun.length - 2 },
+      () => " ",
+    ).join("\n\n");
+
+    return `\n\n${emptyParagraphs}\n\n`;
+  });
+};

package/src/markdown/preserveMarkdownWhitespace.ts

@@ -0,0 +1,143 @@
+import {
+  getMarkdownFenceRanges,
+  isInsideMarkdownFence,
+} from "./markdownFenceRanges";
+
+type MarkdownBlockToken = {
+  content: string;
+  separatorAfter: string;
+};
+
+const tokenizeMarkdownBlocks = (markdown: string): MarkdownBlockToken[] => {
+  const ranges = getMarkdownFenceRanges(markdown);
+  const tokens: MarkdownBlockToken[] = [];
+  const separatorPattern = /\n{2,}/g;
+  let contentStart = 0;
+  let match: RegExpExecArray | null;
+
+  while ((match = separatorPattern.exec(markdown))) {
+    const separatorStart = match.index;
+    const separator = match[0] ?? "";
+
+    if (isInsideMarkdownFence(separatorStart, ranges)) {
+      continue;
+    }
+
+    tokens.push({
+      content: markdown.slice(contentStart, separatorStart),
+      separatorAfter: separator,
+    });
+
+    contentStart = separatorStart + separator.length;
+  }
+
+  tokens.push({
+    content: markdown.slice(contentStart),
+    separatorAfter: "",
+  });
+
+  return tokens;
+};
+
+const blockPairKey = (left: MarkdownBlockToken, right: MarkdownBlockToken) =>
+  `${left.content.trim()}\u0000${right.content.trim()}`;
+
+const leadingNewlineRunPattern = /^\n+/;
+const trailingNewlineRunPattern = /\n+$/;
+
+const preserveOuterBlankLines = (
+  previousRawMarkdown: string,
+  nextSerializedMarkdown: string,
+) => {
+  const previousLeading = previousRawMarkdown.match(leadingNewlineRunPattern);
+  const nextLeading = nextSerializedMarkdown.match(leadingNewlineRunPattern);
+  const previousTrailing = previousRawMarkdown.match(trailingNewlineRunPattern);
+  const nextTrailing = nextSerializedMarkdown.match(trailingNewlineRunPattern);
+
+  const isBodyUnchanged =
+    previousRawMarkdown.trim() === nextSerializedMarkdown.trim();
+
+  let nextMarkdown = nextSerializedMarkdown;
+
+  if (
+    isBodyUnchanged &&
+    previousLeading &&
+    previousLeading[0].length > (nextLeading?.[0].length ?? 0)
+  ) {
+    nextMarkdown = `${previousLeading[0]}${nextMarkdown.trimStart()}`;
+  }
+
+  if (
+    isBodyUnchanged &&
+    previousTrailing &&
+    previousTrailing[0].length > (nextTrailing?.[0].length ?? 0)
+  ) {
+    nextMarkdown = `${nextMarkdown.trimEnd()}${previousTrailing[0]}`;
+  }
+
+  return nextMarkdown;
+};
+
+export const preserveMarkdownWhitespace = (
+  previousRawMarkdown: string,
+  nextSerializedMarkdown: string,
+) => {
+  const outerPreservedMarkdown = preserveOuterBlankLines(
+    previousRawMarkdown,
+    nextSerializedMarkdown,
+  );
+
+  if (
+    previousRawMarkdown === outerPreservedMarkdown ||
+    !previousRawMarkdown.includes("\n\n") ||
+    !outerPreservedMarkdown.includes("\n\n")
+  ) {
+    return outerPreservedMarkdown;
+  }
+
+  const previousTokens = tokenizeMarkdownBlocks(previousRawMarkdown);
+  const nextTokens = tokenizeMarkdownBlocks(outerPreservedMarkdown);
+
+  if (previousTokens.length < 2 || nextTokens.length < 2) {
+    return outerPreservedMarkdown;
+  }
+
+  const preservedSeparators = new Map<string, string>();
+
+  for (let index = 0; index < previousTokens.length - 1; index += 1) {
+    const left = previousTokens[index];
+    const right = previousTokens[index + 1];
+
+    if (!left || !right || left.separatorAfter.length <= 2) {
+      continue;
+    }
+
+    preservedSeparators.set(blockPairKey(left, right), left.separatorAfter);
+  }
+
+  if (preservedSeparators.size === 0) {
+    return outerPreservedMarkdown;
+  }
+
+  return nextTokens
+    .map((token, index) => {
+      const nextToken = nextTokens[index + 1];
+
+      if (!nextToken || !token.separatorAfter) {
+        return token.content;
+      }
+
+      const preservedSeparator = preservedSeparators.get(
+        blockPairKey(token, nextToken),
+      );
+
+      const separator =
+        preservedSeparator &&
+        preservedSeparator.length > token.separatorAfter.length
+          ? preservedSeparator
+          : token.separatorAfter;
+
+      return `${token.content}${separator}`;
+    })
+    .join("");
+};

package/src/markdown/yamlFrontMatter.ts

@@ -0,0 +1,135 @@
+import { parseDocument } from "yaml";
+
+export type MdKitYamlFrontMatter = {
+  data: unknown;
+  raw: string;
+  trailingWhitespace: string;
+  yaml: string;
+};
+
+export type MdKitYamlFrontMatterExtraction = {
+  body: string;
+  errors: string[];
+  frontMatter: MdKitYamlFrontMatter | null;
+};
+
+const delimiter = "---";
+
+const getLineEnd = (markdown: string, lineStart: number) => {
+  const newlineIndex = markdown.indexOf("\n", lineStart);
+
+  if (newlineIndex === -1) {
+    return {
+      contentEnd: markdown.length,
+      lineEnd: markdown.length,
+      newline: "",
+    };
+  }
+
+  const contentEnd =
+    newlineIndex > lineStart && markdown[newlineIndex - 1] === "\r"
+      ? newlineIndex - 1
+      : newlineIndex;
+
+  return {
+    contentEnd,
+    lineEnd: newlineIndex + 1,
+    newline: markdown.slice(contentEnd, newlineIndex + 1),
+  };
+};
+
+const getNextBodyStart = (markdown: string, lineStart: number) => {
+  let bodyStart = lineStart;
+
+  while (bodyStart < markdown.length) {
+    const lineEnd = getLineEnd(markdown, bodyStart);
+    const line = markdown.slice(bodyStart, lineEnd.contentEnd);
+
+    if (!/^[ \t]*$/.test(line)) {
+      break;
+    }
+
+    bodyStart = lineEnd.lineEnd;
+  }
+
+  return bodyStart;
+};
+
+export const parseYamlFrontMatter = (yaml: string): unknown => {
+  const document = parseDocument(yaml, { prettyErrors: false });
+
+  if (document.errors.length > 0) {
+    throw new Error(document.errors.map((error) => error.message).join("\n"));
+  }
+
+  return document.toJSON();
+};
+
+export const extractYamlFrontMatter = (
+  markdown: string,
+): MdKitYamlFrontMatterExtraction => {
+  const openingLine = getLineEnd(markdown, 0);
+
+  if (markdown.slice(0, openingLine.contentEnd) !== delimiter) {
+    return { body: markdown, errors: [], frontMatter: null };
+  }
+
+  let lineStart = openingLine.lineEnd;
+
+  while (lineStart < markdown.length) {
+    const lineEnd = getLineEnd(markdown, lineStart);
+    const line = markdown.slice(lineStart, lineEnd.contentEnd);
+
+    if (line !== delimiter) {
+      lineStart = lineEnd.lineEnd;
+      continue;
+    }
+
+    const bodyStart = getNextBodyStart(markdown, lineEnd.lineEnd);
+    const raw = markdown.slice(0, bodyStart);
+    const yaml = markdown.slice(openingLine.lineEnd, lineStart);
+    const trailingWhitespace = markdown.slice(lineEnd.lineEnd, bodyStart);
+
+    try {
+      const data = parseYamlFrontMatter(yaml);
+
+      return {
+        body: markdown.slice(bodyStart),
+        errors: [],
+        frontMatter: {
+          data,
+          raw,
+          trailingWhitespace,
+          yaml,
+        },
+      };
+    } catch (error) {
+      return {
+        body: markdown,
+        errors: [error instanceof Error ? error.message : String(error)],
+        frontMatter: null,
+      };
+    }
+  }
+
+  return { body: markdown, errors: [], frontMatter: null };
+};
+
+export const hasYamlFrontMatter = (markdown: string) =>
+  extractYamlFrontMatter(markdown).frontMatter !== null;
+
+export const removeYamlFrontMatter = (markdown: string) =>
+  extractYamlFrontMatter(markdown).body;
+
+export const prependYamlFrontMatter = (
+  frontMatter: MdKitYamlFrontMatter | string | null,
+  body: string,
+) => {
+  if (!frontMatter) {
+    return body;
+  }
+
+  const raw = typeof frontMatter === "string" ? frontMatter : frontMatter.raw;
+
+  return `${raw}${body}`;
+};

package/src/server.ts

@@ -0,0 +1,6 @@
+export { createMdKitBackend } from "./transport/backend";
+export type {
+  CreateMdKitBackendOptions,
+  MdKitBackendStore,
+  MdKitCreateCheckpointInput,
+} from "./transport/backend";