mardora 1.2.0

package/src/editor/selection-toolbar/commands.ts

@@ -0,0 +1,279 @@
+import type {
+  InlineFormatInput,
+  LinkChangeInput,
+  ParsedSelectionLink,
+  SelectionToolbarListKind,
+  SelectionToolbarBlockType,
+  TextChange,
+  TextCommandResult,
+} from "./types";
+
+const markdownLinkPattern = /^\[([^\]]*)\]\(([^)]*)\)$/;
+const urlPattern = /^(https?:\/\/|www\.)[^\s]+$/i;
+const listMarkerPattern = /^(\s*)([-*+]|\d+\.)\s(\[[ xX]\]\s)?/;
+const headingMarkerPattern = /^(\s*)(#{1,6})(?:[ \t]+|$)/;
+
+function selectedText(input: Pick<InlineFormatInput, "doc" | "from" | "to">): string {
+  return input.doc.slice(input.from, input.to);
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function buildHtmlWrapper(input: InlineFormatInput): { open: string; close: string } {
+  if (input.htmlTag) {
+    return { open: `<${input.htmlTag}>`, close: `</${input.htmlTag}>` };
+  }
+  if (input.spanStyle) {
+    return { open: `<span style="${input.spanStyle.property}: ${input.spanStyle.value}">`, close: "</span>" };
+  }
+  const marker = input.marker ?? "";
+  return { open: marker, close: marker };
+}
+
+export function buildInlineFormatChange(input: InlineFormatInput): TextCommandResult {
+  const text = selectedText(input);
+  const { open, close } = buildHtmlWrapper(input);
+
+  if (input.clear) {
+    const tagPattern = input.spanStyle
+      ? new RegExp(
+          `^<span style="${escapeRegExp(input.spanStyle.property)}: ${
+            input.spanStyle.value ? escapeRegExp(input.spanStyle.value) : "#[0-9a-fA-F]{6}"
+          }">([\\s\\S]*)<\\/span>$`
+        )
+      : input.htmlTag
+        ? new RegExp(`^<${input.htmlTag}>([\\s\\S]*)<\\/${input.htmlTag}>$`)
+        : null;
+    const match = tagPattern ? text.match(tagPattern) : null;
+    const insert = match?.[1] ?? text;
+    return {
+      changes: { from: input.from, to: input.to, insert },
+      selection: { anchor: input.from, head: input.from + insert.length },
+    };
+  }
+
+  const beforeFrom = Math.max(0, input.from - open.length);
+  const afterTo = Math.min(input.doc.length, input.to + close.length);
+  const before = input.doc.slice(beforeFrom, input.from);
+  const after = input.doc.slice(input.to, afterTo);
+
+  if (before === open && after === close) {
+    return {
+      changes: [
+        { from: beforeFrom, to: input.from, insert: "" },
+        { from: input.to, to: afterTo, insert: "" },
+      ],
+      selection: { anchor: beforeFrom, head: beforeFrom + text.length },
+    };
+  }
+
+  const insert = `${open}${text}${close}`;
+  return {
+    changes: { from: input.from, to: input.to, insert },
+    selection: { anchor: input.from + open.length, head: input.from + open.length + text.length },
+  };
+}
+
+export function parseSelectedLink(text: string): ParsedSelectionLink {
+  const linkMatch = text.match(markdownLinkPattern);
+  if (linkMatch) {
+    return { kind: "markdown-link", title: linkMatch[1] ?? "", url: linkMatch[2] ?? "" };
+  }
+  if (urlPattern.test(text)) {
+    return { kind: "url", title: "", url: text };
+  }
+  return { kind: "text", title: text, url: "" };
+}
+
+export function buildLinkChange(input: LinkChangeInput): TextCommandResult {
+  if (input.remove) {
+    return {
+      changes: { from: input.from, to: input.to, insert: input.title },
+      selection: { anchor: input.from, head: input.from + input.title.length },
+    };
+  }
+
+  if (!input.url.trim()) {
+    throw new Error("Link URL is required");
+  }
+
+  const insert = `[${input.title}](${input.url})`;
+  return {
+    changes: { from: input.from, to: input.to, insert },
+    selection: { anchor: input.from, head: input.from + insert.length },
+  };
+}
+
+function lineRanges(doc: string, from: number, to: number): Array<{ from: number; text: string }> {
+  const ranges: Array<{ from: number; text: string }> = [];
+  let position = 0;
+
+  for (const text of doc.split("\n")) {
+    const lineFrom = position;
+    const lineTo = position + text.length;
+    if (lineTo >= from && lineFrom <= to) {
+      ranges.push({ from: lineFrom, text });
+    }
+    position = lineTo + 1;
+  }
+
+  return ranges;
+}
+
+function markerFor(kind: SelectionToolbarListKind, order: number): string {
+  if (kind === "ordered") return `${order}. `;
+  if (kind === "task") return "- [ ] ";
+  return "- ";
+}
+
+export function buildListChange(input: { doc: string; from: number; to: number; kind: SelectionToolbarListKind }): {
+  changes: TextChange[];
+} {
+  const changes: TextChange[] = [];
+  let order = 1;
+
+  for (const line of lineRanges(input.doc, input.from, input.to)) {
+    const match = line.text.match(listMarkerPattern);
+    const actualMarker = markerFor(input.kind, order);
+
+    if (match) {
+      const indent = match[1] ?? "";
+      const isOrdered = /^\d+\.$/.test(match[2] ?? "");
+      const isUnordered = /^[-*+]$/.test(match[2] ?? "");
+      const hasTask = !!match[3];
+      const same =
+        (input.kind === "ordered" && isOrdered && !hasTask) ||
+        (input.kind === "unordered" && isUnordered && !hasTask) ||
+        (input.kind === "task" && hasTask);
+
+      changes.push({
+        from: line.from,
+        to: line.from + match[0].length,
+        insert: same ? indent : indent + actualMarker,
+      });
+    } else {
+      const indentLength = line.text.match(/^(\s*)/)?.[1]?.length ?? 0;
+      changes.push({ from: line.from + indentLength, to: line.from + indentLength, insert: actualMarker });
+    }
+
+    if (input.kind === "ordered") order += 1;
+  }
+
+  return { changes };
+}
+
+function headingLevelForLine(text: string): number {
+  return text.match(headingMarkerPattern)?.[2]?.length ?? 0;
+}
+
+function escapePlainTextBlockStart(text: string): string {
+  if (/^\d+[.)]\s/.test(text)) {
+    return text.replace(/^(\d+)([.)])/, "$1\\$2");
+  }
+  if (/^[-*+]\s/.test(text) || /^#{1,6}(\s|$)/.test(text) || /^>\s?/.test(text)) {
+    return `\\${text}`;
+  }
+  return text;
+}
+
+function unescapePlainTextBlockStart(text: string): string {
+  if (/^\d+\\[.)]\s/.test(text)) {
+    return text.replace(/^(\d+)\\([.)])/, "$1$2");
+  }
+  if (/^\\([-*+#>])/.test(text)) {
+    return text.slice(1);
+  }
+  return text;
+}
+
+export function detectSelectionBlockType(input: { doc: string; from: number; to: number }): SelectionToolbarBlockType {
+  const line = lineRanges(input.doc, input.from, input.to)[0];
+  const level = line ? headingLevelForLine(line.text) : 0;
+  return level > 0 ? (`heading-${level}` as SelectionToolbarBlockType) : "text";
+}
+
+export function buildBlockTypeChange(input: {
+  doc: string;
+  from: number;
+  to: number;
+  level: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+}): TextCommandResult {
+  const changes: TextChange[] = [];
+  const lines = lineRanges(input.doc, input.from, input.to);
+  let accumulatedDelta = 0;
+  let selectionAnchor: number | null = null;
+  let selectionHead: number | null = null;
+
+  for (const line of lines) {
+    const lineTo = line.from + line.text.length;
+    const headingMatch = line.text.match(headingMarkerPattern);
+    const indent = headingMatch?.[1] ?? line.text.match(/^(\s*)/)?.[1] ?? "";
+    const oldPrefixLength = headingMatch ? headingMatch[0].length : indent.length;
+    const content = line.text.slice(oldPrefixLength);
+
+    if (input.level === 0 && headingMatch) {
+      const escapedContent = escapePlainTextBlockStart(content);
+      if (escapedContent !== content) {
+        const insert = `${indent}${escapedContent}`;
+        const delta = insert.length - line.text.length;
+        changes.push({
+          from: line.from,
+          to: lineTo,
+          insert,
+        });
+
+        const newContentFrom = line.from + accumulatedDelta + indent.length;
+        const newContentTo = lineTo + accumulatedDelta + delta;
+        selectionAnchor ??= newContentFrom;
+        selectionHead = newContentTo;
+        accumulatedDelta += delta;
+        continue;
+      }
+    }
+
+    const newPrefix = input.level === 0 ? indent : `${indent}${"#".repeat(input.level)} `;
+    const delta = newPrefix.length - oldPrefixLength;
+    const headingContent = input.level > 0 ? unescapePlainTextBlockStart(content) : content;
+
+    if (input.level > 0 && headingContent !== content) {
+      const insert = `${newPrefix}${headingContent}`;
+      const lineDelta = insert.length - line.text.length;
+      changes.push({
+        from: line.from,
+        to: lineTo,
+        insert,
+      });
+
+      const newContentFrom = line.from + accumulatedDelta + newPrefix.length;
+      const newContentTo = lineTo + accumulatedDelta + lineDelta;
+      selectionAnchor ??= newContentFrom;
+      selectionHead = newContentTo;
+      accumulatedDelta += lineDelta;
+      continue;
+    }
+
+    if (newPrefix !== line.text.slice(0, oldPrefixLength)) {
+      changes.push({
+        from: line.from,
+        to: line.from + oldPrefixLength,
+        insert: newPrefix,
+      });
+    }
+
+    const newContentFrom = line.from + accumulatedDelta + newPrefix.length;
+    const newContentTo = lineTo + accumulatedDelta + delta;
+    selectionAnchor ??= newContentFrom;
+    selectionHead = newContentTo;
+    accumulatedDelta += delta;
+  }
+
+  return {
+    changes,
+    selection: {
+      anchor: selectionAnchor ?? input.from,
+      head: selectionHead ?? input.to,
+    },
+  };
+}