@owomark/core 0.1.0

package/dist/index.js

@@ -0,0 +1,640 @@
+import {
+  BLOCK_TYPE_TO_CLASS,
+  BQ_STEP,
+  NOT_HANDLED,
+  SIDE_ANNOTATION_TAIL_RE,
+  SIDE_CONTINUATION_TAIL_RE,
+  TOKEN_TO_CLASS,
+  applyMarkdownIndent,
+  buildBlockquoteBarsBoxShadow,
+  createBlockElement,
+  createBlockIdGenerator,
+  createCommandRegistry,
+  createOwoMarkCore,
+  deleteToLineEnd,
+  deleteToLineStart,
+  deleteWordBackward,
+  deleteWordForward,
+  detectAndRenderDirty,
+  domRangeToOffset,
+  expandDirtyRange,
+  expandWithContext,
+  fullRender,
+  getBlockAtOffset,
+  getBlockById,
+  getBlockIndexById,
+  getBlockIndexForPosition,
+  getBlockStartOffset,
+  handleCharInput,
+  handleMarkdownEnter,
+  handleSmartBackspace,
+  handleSmartDelete,
+  insertCodeFence,
+  insertImage,
+  insertLink,
+  insertMathBlock,
+  insertSideAnnotation,
+  insertTable,
+  invalidateBlockCache,
+  isVirtualSelectionCollapsed,
+  linearToVirtual,
+  linearToVirtualPosition,
+  normalizeMarkdownPaste,
+  offsetToDomRange,
+  parseMarkdownToDocument,
+  patchDirtyBlocks,
+  readSelection,
+  reconcileBlocks,
+  resetBlockIdCounter,
+  resolveBlockContextType,
+  resolveIndentSize,
+  restoreSelection,
+  serializeDocument,
+  toggleBold,
+  toggleItalic,
+  tokenizeBlock,
+  tokenizeInline,
+  updateBlockElement,
+  virtualPositionToLinear,
+  virtualPositionsEqual,
+  virtualToLinear
+} from "./chunk-RYTHPR7H.js";
+
+// src/preview/block-id.ts
+function deriveBlockId(startLine, endLine) {
+  return `L${startLine}-${endLine}`;
+}
+
+// src/preview/render-key.ts
+function djb2(input) {
+  let hash = 5381;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) + hash ^ input.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(36);
+}
+function deriveRenderKey(raw, kind, themeKey) {
+  const src = `${kind}:${themeKey ?? ""}:${raw}`;
+  return djb2(src);
+}
+
+// src/preview/projection.ts
+var BLOCK_TYPE_TO_KIND = {
+  "paragraph": "paragraph",
+  "heading": "heading",
+  "unordered-list": "unordered-list",
+  "ordered-list": "ordered-list",
+  "blockquote": "blockquote",
+  "code-fence": "code-fence",
+  "directive-container": "custom",
+  "thematic-break": "thematic-break",
+  "math-block": "math-block",
+  "table": "table"
+};
+function blockTypeToPreviewKind(node) {
+  return BLOCK_TYPE_TO_KIND[node.type];
+}
+function isGroupableType(type) {
+  return type === "unordered-list" || type === "ordered-list" || type === "blockquote";
+}
+function countLines(raw) {
+  let count = 1;
+  for (let i = 0; i < raw.length; i++) {
+    if (raw.charCodeAt(i) === 10) count++;
+  }
+  return count;
+}
+function isBlankParagraph(block) {
+  return block.type === "paragraph" && !block.raw.trim();
+}
+function isSideAnnotationHead(block) {
+  return block.type === "paragraph" && SIDE_ANNOTATION_TAIL_RE.test(block.raw);
+}
+function isSideAnnotationContinuation(block) {
+  return block.type === "paragraph" && SIDE_CONTINUATION_TAIL_RE.test(block.raw);
+}
+function collectSideAnnotationChain(blocks, startIndex) {
+  if (!isSideAnnotationHead(blocks[startIndex])) return null;
+  const rawParts = [blocks[startIndex].raw];
+  let endIndex = startIndex;
+  let endLine = 0;
+  let currentLine = 0;
+  let foundContinuation = false;
+  let i = startIndex + 1;
+  while (i < blocks.length) {
+    const block = blocks[i];
+    if (isBlankParagraph(block)) {
+      const next = blocks[i + 1];
+      if (!next || !isSideAnnotationContinuation(next)) break;
+      rawParts.push(block.raw, next.raw);
+      endIndex = i + 1;
+      i += 2;
+      foundContinuation = true;
+      continue;
+    }
+    if (isSideAnnotationContinuation(block)) {
+      rawParts.push(block.raw);
+      endIndex = i;
+      i++;
+      foundContinuation = true;
+      continue;
+    }
+    break;
+  }
+  if (!foundContinuation) return null;
+  for (let j = startIndex; j <= endIndex; j++) {
+    currentLine += countLines(blocks[j].raw);
+  }
+  endLine = currentLine - 1;
+  return {
+    endIndex,
+    raw: rawParts.join("\n"),
+    endLine
+  };
+}
+function projectToPreviewBlocks(doc, themeKey, transforms) {
+  const result = [];
+  const blocks = doc.blocks;
+  let currentLine = 1;
+  let i = 0;
+  while (i < blocks.length) {
+    const block = blocks[i];
+    const blockLines = countLines(block.raw);
+    const startLine = currentLine;
+    const sideChain = collectSideAnnotationChain(blocks, i);
+    if (sideChain) {
+      const endLine2 = startLine + sideChain.endLine;
+      const blockId2 = deriveBlockId(startLine, endLine2);
+      result.push({
+        blockId: blockId2,
+        kind: "paragraph",
+        raw: sideChain.raw,
+        startLine,
+        endLine: endLine2,
+        renderKey: deriveRenderKey(sideChain.raw, "paragraph", themeKey)
+      });
+      currentLine = endLine2 + 1;
+      i = sideChain.endIndex + 1;
+      continue;
+    }
+    if (isGroupableType(block.type)) {
+      const groupType = block.type;
+      const groupRawParts = [block.raw];
+      let endLine2 = startLine + blockLines - 1;
+      let j = i + 1;
+      while (j < blocks.length && blocks[j].type === groupType) {
+        const nextLines = countLines(blocks[j].raw);
+        endLine2 += nextLines;
+        groupRawParts.push(blocks[j].raw);
+        j++;
+      }
+      const raw = groupRawParts.join("\n");
+      const kind2 = blockTypeToPreviewKind(block);
+      const blockId2 = deriveBlockId(startLine, endLine2);
+      result.push({
+        blockId: blockId2,
+        kind: kind2,
+        raw,
+        startLine,
+        endLine: endLine2,
+        renderKey: deriveRenderKey(raw, kind2, themeKey)
+      });
+      currentLine = endLine2 + 1;
+      i = j;
+      continue;
+    }
+    const endLine = startLine + blockLines - 1;
+    const kind = blockTypeToPreviewKind(block);
+    const blockId = deriveBlockId(startLine, endLine);
+    const previewBlock = {
+      blockId,
+      kind,
+      raw: block.raw,
+      startLine,
+      endLine,
+      renderKey: deriveRenderKey(block.raw, kind, themeKey)
+    };
+    if (block.type === "code-fence") {
+      previewBlock.language = block.language || null;
+    }
+    if (block.type === "heading") {
+      previewBlock.headingLevel = block.headingLevel;
+    }
+    result.push(previewBlock);
+    currentLine = endLine + 1;
+    i++;
+  }
+  if (!transforms || transforms.length === 0) return result;
+  return result.map((block) => {
+    let b = block;
+    for (const transform of transforms) {
+      b = transform(b);
+    }
+    return b;
+  });
+}
+function blocksMatch(a, b) {
+  return a.renderKey === b.renderKey && a.blockId === b.blockId;
+}
+function computePreviewDirtyRange(oldBlocks, newBlocks) {
+  const oldLen = oldBlocks.length;
+  const newLen = newBlocks.length;
+  const minLen = Math.min(oldLen, newLen);
+  let start = 0;
+  while (start < minLen && blocksMatch(oldBlocks[start], newBlocks[start])) {
+    start++;
+  }
+  let oldEnd = oldLen - 1;
+  let newEnd = newLen - 1;
+  while (oldEnd >= start && newEnd >= start && blocksMatch(oldBlocks[oldEnd], newBlocks[newEnd])) {
+    oldEnd--;
+    newEnd--;
+  }
+  const end = Math.max(oldEnd, newEnd);
+  if (start > end) return null;
+  return { startBlock: start, endBlock: Math.min(end, newLen - 1) };
+}
+
+// src/state/shared-state.ts
+function createInitialState(markdown, themeKey, transforms) {
+  const document = parseMarkdownToDocument(markdown);
+  const previewBlocks = projectToPreviewBlocks(document, themeKey, transforms);
+  return {
+    document,
+    previewBlocks,
+    dirtyRange: null,
+    dirtyReason: markdown ? "full-rebuild" : null,
+    selection: null,
+    compositionActive: false,
+    visibleBlockIds: [],
+    version: 1,
+    markdown
+  };
+}
+function createSharedStateStore(options) {
+  let themeKey = options?.themeKey;
+  const transforms = options?.transforms;
+  let state = createInitialState(options?.initialMarkdown ?? "", themeKey, transforms);
+  let editor = null;
+  let editorUnsubs = [];
+  const listeners = /* @__PURE__ */ new Set();
+  function notify() {
+    for (const listener of listeners) {
+      listener(state);
+    }
+  }
+  function updateFromMarkdown(markdown, reason) {
+    const oldBlocks = state.previewBlocks;
+    const document = parseMarkdownToDocument(markdown);
+    const previewBlocks = projectToPreviewBlocks(document, themeKey, transforms);
+    const dirtyRange = computePreviewDirtyRange(oldBlocks, previewBlocks);
+    let dirtyReason = null;
+    if (dirtyRange) {
+      if (oldBlocks.length !== previewBlocks.length) {
+        dirtyReason = "structure-edit";
+      } else {
+        dirtyReason = reason;
+      }
+    }
+    state = {
+      document,
+      previewBlocks,
+      dirtyRange,
+      dirtyReason,
+      selection: state.selection,
+      compositionActive: state.compositionActive,
+      visibleBlockIds: state.visibleBlockIds,
+      version: state.version + 1,
+      markdown
+    };
+    notify();
+  }
+  function invalidateAll(reason) {
+    const previewBlocks = projectToPreviewBlocks(state.document, themeKey, transforms);
+    state = {
+      ...state,
+      previewBlocks,
+      dirtyRange: previewBlocks.length > 0 ? { startBlock: 0, endBlock: previewBlocks.length - 1 } : null,
+      dirtyReason: reason,
+      version: state.version + 1
+    };
+    notify();
+  }
+  function connectEditor(instance) {
+    disconnectEditor();
+    editor = instance;
+    const unsubChange = instance.onChange((markdown) => {
+      updateFromMarkdown(markdown, "text-edit");
+    });
+    const unsubSelection = instance.onSelectionChange((selection) => {
+      state = { ...state, selection, version: state.version + 1 };
+      notify();
+    });
+    const unsubComposition = instance.onCompositionStateChange((active) => {
+      state = { ...state, compositionActive: active, version: state.version + 1 };
+      notify();
+    });
+    editorUnsubs = [unsubChange, unsubSelection, unsubComposition];
+    const currentMarkdown = instance.getMarkdown();
+    if (currentMarkdown !== state.markdown) {
+      updateFromMarkdown(currentMarkdown, "full-rebuild");
+    }
+    return disconnectEditor;
+  }
+  function disconnectEditor() {
+    for (const unsub of editorUnsubs) unsub();
+    editorUnsubs = [];
+    editor = null;
+  }
+  return {
+    getState() {
+      return state;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    setMarkdown(markdown) {
+      if (editor) {
+        editor.setMarkdown(markdown);
+      } else {
+        updateFromMarkdown(markdown, "text-edit");
+      }
+    },
+    updateVisibleBlockIds(ids) {
+      const prev = state.visibleBlockIds;
+      if (prev.length === ids.length) {
+        const prevSet = new Set(prev);
+        if (ids.every((id) => prevSet.has(id))) return;
+      }
+      state = { ...state, visibleBlockIds: ids, version: state.version + 1 };
+      notify();
+    },
+    getEditorInstance() {
+      return editor;
+    },
+    connectEditor,
+    setThemeKey(newThemeKey) {
+      if (newThemeKey === themeKey) return;
+      themeKey = newThemeKey;
+      invalidateAll("theme-change");
+    },
+    notifyRendererChange() {
+      invalidateAll("renderer-change");
+    },
+    notifyCustomBlockChange() {
+      invalidateAll("custom-block-change");
+    }
+  };
+}
+
+// src/transforms/image-size.ts
+var OBSIDIAN_RE = /!\[([^\]]*?\|(\d+%?)\s*x\s*(\d+%?))\]\(([^)]+)\)/g;
+var PANDOC_RE = /!\[([^\]]*)\]\(([^)]+)\)\{([^}]+)\}/g;
+var MOU_RE = /!\[([^\]]*)\]\(([^\s)]+)\s+=(\d+%?)x(\d+%?)\)/g;
+var IMG_TAG_RE = /<img\s[^>]*?src=["']([^"']+)["'][^>]*?>/gi;
+var WIDTH_ATTR_RE = /width=["']?(\d+%?)["']?/i;
+var HEIGHT_ATTR_RE = /height=["']?(\d+%?)["']?/i;
+function parseDimValue(val) {
+  if (val.endsWith("%")) return val;
+  const n = parseInt(val, 10);
+  return isNaN(n) ? val : n;
+}
+function extractObsidian(raw) {
+  return [...raw.matchAll(OBSIDIAN_RE)].map((m) => ({
+    src: m[4],
+    width: parseDimValue(m[2]),
+    height: parseDimValue(m[3])
+  }));
+}
+function extractPandoc(raw) {
+  const results = [];
+  for (const m of raw.matchAll(PANDOC_RE)) {
+    const attrs = m[3];
+    const w = attrs.match(/\b(?:width|w)=(\d+%?)/i);
+    const h = attrs.match(/\b(?:height|h)=(\d+%?)/i);
+    if (w || h) {
+      results.push({
+        src: m[2],
+        width: w ? parseDimValue(w[1]) : "auto",
+        height: h ? parseDimValue(h[1]) : "auto"
+      });
+    }
+  }
+  return results;
+}
+function extractMou(raw) {
+  return [...raw.matchAll(MOU_RE)].map((m) => ({
+    src: m[2],
+    width: parseDimValue(m[3]),
+    height: parseDimValue(m[4])
+  }));
+}
+function extractHtmlImg(raw) {
+  const results = [];
+  for (const m of raw.matchAll(IMG_TAG_RE)) {
+    const tag = m[0];
+    const w = tag.match(WIDTH_ATTR_RE);
+    const h = tag.match(HEIGHT_ATTR_RE);
+    if (w || h) {
+      results.push({
+        src: m[1],
+        width: w ? parseDimValue(w[1]) : "auto",
+        height: h ? parseDimValue(h[1]) : "auto"
+      });
+    }
+  }
+  return results;
+}
+function createImageSizeTransform(syntax = "obsidian") {
+  return (block) => {
+    if (block.kind !== "paragraph" && block.kind !== "html-block") return block;
+    const dims = [];
+    dims.push(...extractHtmlImg(block.raw));
+    switch (syntax) {
+      case "obsidian":
+        dims.push(...extractObsidian(block.raw));
+        break;
+      case "pandoc":
+        dims.push(...extractPandoc(block.raw));
+        break;
+      case "mou":
+        dims.push(...extractMou(block.raw));
+        break;
+      case "none":
+        break;
+    }
+    if (dims.length === 0) return block;
+    return {
+      ...block,
+      attributes: {
+        ...block.attributes,
+        images: dims
+      }
+    };
+  };
+}
+
+// src/index.ts
+import { produce, enableMapSet } from "immer";
+
+// src/virtual/editor-virtual-list.ts
+var EDITOR_LINE_HEIGHT = 24;
+var EDITOR_HEADING_SCALE = {
+  1: 2,
+  2: 1.6,
+  3: 1.4,
+  4: 1.2,
+  5: 1.1,
+  6: 1
+};
+var FENCED_BLOCK_PADDING = 16;
+var TABLE_BLOCK_PADDING = 8;
+var HEADING_EXTRA_MARGIN = 8;
+var HR_PADDING = 16;
+function countNewlines(s) {
+  let count = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s.charCodeAt(i) === 10) count++;
+  }
+  return count;
+}
+function estimateEditorBlockHeight(block, charsPerLine = 80) {
+  const lineHeight = EDITOR_LINE_HEIGHT;
+  switch (block.type) {
+    case "heading": {
+      const scale = EDITOR_HEADING_SCALE[block.headingLevel] ?? 1;
+      return Math.ceil(lineHeight * scale) + HEADING_EXTRA_MARGIN;
+    }
+    case "code-fence":
+    case "math-block": {
+      const lineCount = countNewlines(block.raw) + 1;
+      return lineCount * lineHeight + FENCED_BLOCK_PADDING;
+    }
+    case "table": {
+      const lineCount = countNewlines(block.raw) + 1;
+      return lineCount * lineHeight + TABLE_BLOCK_PADDING;
+    }
+    case "thematic-break":
+      return lineHeight + HR_PADDING;
+    default: {
+      if (!block.raw) return lineHeight;
+      const textLines = Math.max(1, Math.ceil(block.raw.length / charsPerLine));
+      return textLines * lineHeight;
+    }
+  }
+}
+function buildVirtualRows(blocks, heightCache, charsPerLine) {
+  return blocks.map((block, index) => ({
+    blockIndex: index,
+    blockId: block.id,
+    height: heightCache.get(block.id) ?? estimateEditorBlockHeight(block, charsPerLine)
+  }));
+}
+function buildPrefixSums(rows) {
+  const sums = new Array(rows.length);
+  let cum = 0;
+  for (let i = 0; i < rows.length; i++) {
+    sums[i] = cum;
+    cum += rows[i].height;
+  }
+  return sums;
+}
+function bisectRight(sums, target, len) {
+  let lo = 0;
+  let hi = len - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >>> 1;
+    if (sums[mid] <= target) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return lo;
+}
+function computeVisibleRange(rows, scrollTop, viewportHeight, overscan = 5) {
+  if (rows.length === 0) {
+    return { startIndex: 0, endIndex: -1, totalHeight: 0, offsetTop: 0, offsetBottom: 0 };
+  }
+  const sums = buildPrefixSums(rows);
+  const totalHeight = sums[rows.length - 1] + rows[rows.length - 1].height;
+  const rawStart = bisectRight(sums, scrollTop, rows.length);
+  const startIndex = Math.max(0, rawStart - overscan);
+  const bottomEdge = scrollTop + viewportHeight;
+  const rawEnd = bisectRight(sums, bottomEdge, rows.length);
+  const endIndex = Math.min(rows.length - 1, rawEnd + overscan);
+  const offsetTop = sums[startIndex];
+  const offsetBottom = totalHeight - sums[endIndex] - rows[endIndex].height;
+  return { startIndex, endIndex, totalHeight, offsetTop, offsetBottom };
+}
+export {
+  BLOCK_TYPE_TO_CLASS,
+  BQ_STEP,
+  NOT_HANDLED,
+  TOKEN_TO_CLASS,
+  applyMarkdownIndent,
+  buildBlockquoteBarsBoxShadow,
+  buildVirtualRows,
+  computePreviewDirtyRange,
+  computeVisibleRange,
+  createBlockElement,
+  createBlockIdGenerator,
+  createCommandRegistry,
+  createImageSizeTransform,
+  createOwoMarkCore,
+  createSharedStateStore,
+  deleteToLineEnd,
+  deleteToLineStart,
+  deleteWordBackward,
+  deleteWordForward,
+  deriveBlockId,
+  deriveRenderKey,
+  detectAndRenderDirty,
+  domRangeToOffset,
+  enableMapSet,
+  estimateEditorBlockHeight,
+  expandDirtyRange,
+  expandWithContext,
+  fullRender,
+  getBlockAtOffset,
+  getBlockById,
+  getBlockIndexById,
+  getBlockIndexForPosition,
+  getBlockStartOffset,
+  handleCharInput,
+  handleMarkdownEnter,
+  handleSmartBackspace,
+  handleSmartDelete,
+  insertCodeFence,
+  insertImage,
+  insertLink,
+  insertMathBlock,
+  insertSideAnnotation,
+  insertTable,
+  invalidateBlockCache,
+  isVirtualSelectionCollapsed,
+  linearToVirtual,
+  linearToVirtualPosition,
+  normalizeMarkdownPaste,
+  offsetToDomRange,
+  parseMarkdownToDocument,
+  patchDirtyBlocks,
+  produce,
+  projectToPreviewBlocks,
+  readSelection,
+  reconcileBlocks,
+  resetBlockIdCounter,
+  resolveBlockContextType,
+  resolveIndentSize,
+  restoreSelection,
+  serializeDocument,
+  toggleBold,
+  toggleItalic,
+  tokenizeBlock,
+  tokenizeInline,
+  updateBlockElement,
+  virtualPositionToLinear,
+  virtualPositionsEqual,
+  virtualToLinear
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@owomark/core",
+  "version": "0.1.0",
+  "description": "Framework-agnostic core engine for the OwoMark editor.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kzhoa/qblog.git",
+    "directory": "owomark/packages/owomark-core"
+  },
+  "bugs": {
+    "url": "https://github.com/kzhoa/qblog/issues"
+  },
+  "keywords": [
+    "markdown",
+    "editor",
+    "owomark"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./internal/dom-adapter": {
+      "types": "./dist/adapter/dom-adapter.d.ts",
+      "import": "./dist/adapter/dom-adapter.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1"
+  },
+  "dependencies": {
+    "immer": "^11.1.4"
+  }
+}