minecodex 2.0.11 → 2.0.13

package/features/markdown-reading/src/adapters/codex/lists.mjs

@@ -0,0 +1,168 @@
+// 使用当前编辑器所属的原生 CodeMirror 实例，避免引入第二套编辑器依赖。
+export async function loadMarkdownListAPI(view) {
+  const links = [...document.querySelectorAll('link[rel="modulepreload"]')];
+  for (const link of links) {
+    if (!/\/dist-[\w-]+\.js$/.test(link.href)) continue;
+    const exports = Object.values(await import(link.href));
+    if (!exports.includes(view.constructor)) continue;
+    const Decoration = exports.find((value) => value?.line && value?.replace && value?.mark);
+    const ViewPlugin = exports.find((value) => value?.fromClass && value?.define);
+    const StateEffect = exports.find((value) => value?.appendConfig && value?.reconfigure);
+    const Compartment = exports.find(
+      (value) => value?.prototype?.reconfigure && value?.prototype?.of && value?.prototype?.get,
+    );
+    const WidgetType = exports.find(
+      (value) => value?.prototype?.eq && value?.prototype?.ignoreEvent && value?.prototype?.updateDOM,
+    );
+    const StateField = exports.find(
+      (value) =>
+        value?.define && value?.prototype?.slot && value?.prototype?.init && value?.prototype?.create,
+    );
+    const Prec = exports.find((value) => value?.highest && value?.lowest && value?.high);
+    if (Decoration && ViewPlugin && StateEffect && Compartment && WidgetType && Prec && StateField)
+      return { Decoration, ViewPlugin, StateEffect, Compartment, WidgetType, Prec, StateField };
+  }
+  throw new Error('native-markdown-list-api-unavailable');
+}
+export function installMarkdownLists(view, api) {
+  const { Decoration, ViewPlugin, StateEffect, Compartment, WidgetType, Prec } = api;
+  class Marker extends WidgetType {
+    constructor(kind, label) {
+      super();
+      this.kind = kind;
+      this.label = label;
+    }
+    eq(other) {
+      return this.kind === other.kind && this.label === other.label;
+    }
+    toDOM() {
+      const span = document.createElement('span');
+      span.className = `mcx-reading-list-marker mcx-reading-${this.kind}`;
+      if (this.kind.startsWith('task')) {
+        span.setAttribute('role', 'img');
+        span.setAttribute('aria-label', this.kind === 'task-checked' ? '已完成' : '未完成');
+        span.append(document.createElement('span'));
+      } else {
+        span.textContent = this.label;
+        span.setAttribute('aria-hidden', 'true');
+      }
+      return span;
+    }
+    ignoreEvent() {
+      return false;
+    }
+  }
+  function build(editor) {
+    const tree = editor.state.tree;
+    if (!tree) return Decoration.none;
+    const rows = new Map();
+    tree.iterate({
+      from: editor.viewport.from,
+      to: editor.viewport.to,
+      enter(node) {
+        if (node.name !== 'ListItem') return;
+        const item = node.node;
+        const mark = item.getChild('ListMark');
+        if (!mark) return;
+        let depth = 0;
+        for (let parent = item.parent; parent; parent = parent.parent)
+          if (parent.name === 'ListItem') depth++;
+        const first = editor.state.doc.lineAt(item.from);
+        const last = editor.state.doc.lineAt(item.to);
+        const task = item.getChild('Task')?.getChild('TaskMarker');
+        let end = task?.to ?? mark.to;
+        while (/[\t ]/.test(editor.state.sliceDoc(end, end + 1))) end++;
+        const prefix = editor.state.sliceDoc(first.from, mark.from);
+        if (!/^[\t >]*$/.test(prefix)) return;
+        const quoteDepth = (prefix.match(/>/g) || []).length;
+        const raw = editor.state.sliceDoc(mark.from, mark.to);
+        const kind = task
+          ? /x/i.test(editor.state.sliceDoc(task.from, task.to))
+            ? 'task-checked'
+            : 'task-empty'
+          : item.parent.name === 'OrderedList'
+            ? 'ordered'
+            : ['disc', 'circle', 'square'][Math.min(depth, 2)];
+        for (let number = first.number; number <= last.number; number++) {
+          const line = editor.state.doc.line(number);
+          if (line.to < editor.viewport.from || line.from > editor.viewport.to) continue;
+          let syntax = tree.resolveInner(line.from + (line.text.match(/^[\t ]*/)?.[0].length ?? 0), 1);
+          let block = false;
+          for (; syntax; syntax = syntax.parent)
+            if (['CodeBlock', 'FencedCode', 'Table', 'MathBlock', 'HTMLBlock'].includes(syntax.name))
+              block = true;
+          if (block) continue;
+          const current = rows.get(line.from);
+          if (!current || current.depth <= depth)
+            rows.set(line.from, {
+              line,
+              depth,
+              quoteDepth,
+              kind,
+              raw,
+              end,
+              first: number === first.number,
+              done: kind === 'task-checked' && line.from < (item.getChild('Task')?.to ?? 0),
+              trim: mark.to - first.from + 1,
+            });
+        }
+      },
+    });
+    const ranges = [];
+    for (const row of rows.values()) {
+      const { line, depth, kind, raw, end, first, done, trim, quoteDepth } = row;
+      // 光标进入标记时显示源码，编辑和选区继续由原生负责。
+      if (
+        first &&
+        view.hasFocus &&
+        view.state.selection.ranges.some((range) => range.from <= end && range.to >= line.from)
+      )
+        continue;
+      const markerWidth = kind === 'ordered' ? Math.max(1.75, raw.length * 0.65 + 0.5) : 1.75;
+      ranges.push(
+        Decoration.line({
+          class: `mcx-reading-list-row${first ? ' mcx-reading-list-first' : ''}${done ? ' mcx-reading-task-done' : ''}`,
+          attributes: {
+            style: `--mcx-list-indent:calc(${depth * 1.75}em + ${quoteDepth * 20}px);--mcx-list-marker-width:${markerWidth}em`,
+          },
+        }).range(line.from),
+      );
+      if (first)
+        ranges.push(
+          Decoration.replace({ widget: new Marker(kind, kind === 'ordered' ? raw : '') }).range(
+            line.from,
+            end,
+          ),
+        );
+      else {
+        const spaces = line.text.match(/^[\t ]+/)?.[0];
+        if (spaces)
+          ranges.push(Decoration.replace({}).range(line.from, line.from + Math.min(spaces.length, trim)));
+      }
+    }
+    return Decoration.set(ranges, true);
+  }
+  const plugin = ViewPlugin.define(
+    (editor) => ({
+      decorations: build(editor),
+      update(update) {
+        if (
+          update.docChanged ||
+          update.viewportChanged ||
+          update.selectionSet ||
+          update.focusChanged ||
+          update.startState.tree !== update.state.tree
+        )
+          this.decorations = build(update.view);
+      },
+    }),
+    { decorations: (value) => value.decorations },
+  );
+  const compartment = new Compartment();
+  view.dispatch({
+    effects: StateEffect.appendConfig.of(compartment.of(Prec ? Prec.highest(plugin) : plugin)),
+  });
+  return () => {
+    if (!view.destroyed) view.dispatch({ effects: compartment.reconfigure([]) });
+  };
+}

package/features/markdown-reading/src/adapters/codex/markdown-native.mjs

@@ -0,0 +1,28 @@
+// 消息流 Markdown 解析与展示组件的原生契约，供表格预览和富文本共用。
+export async function loadNativeMarkdownRenderer(source, url, module) {
+  const exported = source.slice(source.lastIndexOf('export{'));
+  const binding = (name) =>
+    module[exported.match(new RegExp(`\\b${name.replace(/\$/g, '\\$')} as ([\\w$]+)`))?.[1]];
+  const at = source.indexOf('getDefaultComponents:r,...n');
+  const wrapper = source.slice(source.lastIndexOf('function ', at), source.indexOf('function ', at));
+  const markdownName = wrapper.match(/^function ([\w$]+)/)?.[1];
+  const after = source.slice(source.indexOf(wrapper) + wrapper.length);
+  const init = after.match(/^function ([\w$]+)\(\)/)?.[1];
+  const initializer = [
+    ...source.matchAll(/function ([\w$]+)\(\)\{return\(\1=[\w$]+\(\(\(\)=>\{([^}]{0,1600})\}\)\)\)\(\)\}/g),
+  ].find((m) => m[2].includes(`${init}()`) && binding(m[1]));
+  if (!initializer || !binding(markdownName)) throw new Error('native-rich-markdown-contract-unavailable');
+  binding(initializer[1])();
+  let lexer, sharedUrl;
+  const lexerName = source.match(/tokens:([\w$]+)\(e,void 0\)/)?.[1];
+  for (const m of source.matchAll(/import\{([^}]+)\}from["']([^"']+)["']/g))
+    for (const entry of m[1].split(',')) {
+      const parts = entry.trim().split(/\s+as\s+/);
+      if (parts.at(-1) === lexerName) {
+        sharedUrl = new URL(m[2], url).href;
+        lexer = (await import(sharedUrl))[parts[0]];
+      }
+    }
+  if (!sharedUrl || typeof lexer !== 'function') throw new Error('native-markdown-lexer-unavailable');
+  return { Markdown: binding(markdownName), lexer, sharedUrl };
+}

package/features/markdown-reading/src/adapters/codex/preview.mjs

@@ -0,0 +1,38 @@
+import { createMarkdownReadingRuntime } from './reading-runtime.mjs';
+
+// 当前原生 Markdown Preview 是 CodeMirror 视图；Source 与 Pages 不属于此契约。
+export function createMarkdownPreviewAdapter(codex) {
+  let runtime;
+  function preview(editor) {
+    if (!editor.isConnected || !editor.closest('[data-editor-search-surface]')) return null;
+    const content = editor.querySelector('.cm-content[data-language="markdown"]');
+    const scroller = editor.querySelector('.cm-scroller');
+    if (!content || !scroller) return null;
+    const file = codex.props(
+      editor,
+      (props) =>
+        props.fileKind === 'markdown' && typeof props.filePath === 'string' && 'onSaveChange' in props,
+    );
+    const mode =
+      file &&
+      codex.props(
+        editor,
+        (props) =>
+          props.filePath === file.filePath && 'initialMode' in props && 'onSourceDraftChange' in props,
+      );
+    return mode ? { editor, content, scroller } : null;
+  }
+  function previews() {
+    const items = [...document.querySelectorAll('.cm-editor')].map(preview).filter(Boolean);
+    codex.report('markdown-preview', items.length > 0, items.length ? null : 'no-markdown-preview');
+    return items;
+  }
+  return {
+    preview,
+    previews,
+    attach(item) {
+      runtime ??= createMarkdownReadingRuntime(codex);
+      return runtime.attach(item);
+    },
+  };
+}

package/features/markdown-reading/src/adapters/codex/providers.mjs

@@ -0,0 +1,18 @@
+// 同一文件视图下的附加 React 根继承最近的 Provider；原始 Fiber 不离开适配层。
+export function captureMarkdownProviders(element, codex) {
+  const providers = [],
+    seen = new Set();
+  let fiber;
+  for (let anchor = element; anchor && !fiber; anchor = anchor.parentElement)
+    fiber = codex.currentFiber(anchor);
+  for (; fiber; fiber = fiber.return) {
+    if (fiber.tag !== 10 || seen.has(fiber.type)) continue;
+    providers.push({ type: fiber.type, value: fiber.memoizedProps.value });
+    seen.add(fiber.type);
+  }
+  return (React, tree) => {
+    for (const provider of providers)
+      tree = React.createElement(provider.type, { value: provider.value }, tree);
+    return tree;
+  };
+}

package/features/markdown-reading/src/adapters/codex/reading-runtime.mjs

@@ -0,0 +1,152 @@
+import { loadMarkdownListAPI, installMarkdownLists } from './lists.mjs';
+import { loadNativeMarkdownLinks, installMarkdownLinks } from './links.mjs';
+import { installMarkdownTables } from './tables.mjs';
+import { loadNativeMarkdownToc } from './toc-native.mjs';
+import { installMarkdownToc } from './toc.mjs';
+import { loadNativeMarkdownTableActions, installMarkdownTableActions } from './table-actions.mjs';
+import { loadNativeMarkdownRichText, installMarkdownRichText } from './rich-text.mjs';
+
+// 原生能力加载与会话寿命归 Adapter；入口只持有检查结果和释放动作。
+export function createMarkdownReadingRuntime(
+  codex,
+  capabilities = {
+    loadMarkdownListAPI,
+    installMarkdownLists,
+    loadNativeMarkdownLinks,
+    installMarkdownLinks,
+    installMarkdownTables,
+    loadNativeMarkdownToc,
+    installMarkdownToc,
+    loadNativeMarkdownTableActions,
+    installMarkdownTableActions,
+    loadNativeMarkdownRichText,
+    installMarkdownRichText,
+    installMarkdownMetadataScroll,
+  },
+) {
+  const cached = new Map();
+  function load(name, ...args) {
+    if (!cached.has(name)) {
+      const pending = Promise.resolve().then(() => capabilities[name](...args));
+      cached.set(name, pending);
+      pending.catch(() => {
+        if (cached.get(name) === pending) cached.delete(name);
+      });
+    }
+    return cached.get(name);
+  }
+  function attach({ editor, content, scroller }) {
+    const view = content.cmTile?.view;
+    const states = new Map([
+      ['markdown-reading-layout', 'loading'],
+      ['markdown-reading-links', 'loading'],
+      ['markdown-reading-toc', 'loading'],
+      ['markdown-table-actions', 'loading'],
+      ['markdown-reading-rich-text', 'loading'],
+    ]);
+    const cleanups = [capabilities.installMarkdownMetadataScroll(editor, scroller)];
+    let disposed = false;
+    const current = () => !disposed && !view?.destroyed;
+    function report(name, available, reason = null) {
+      if (!current()) return;
+      states.set(name, available ? 'available' : 'unavailable');
+      codex.report(name, available, reason);
+    }
+    async function stage(name, reason, run) {
+      try {
+        await run();
+      } catch {
+        report(name, false, reason);
+      }
+    }
+    async function installLinks(api) {
+      await stage('markdown-reading-links', 'native-link-adapter-unavailable', async () => {
+        const openHref = await load('loadNativeMarkdownLinks');
+        if (!current()) return;
+        cleanups.push(capabilities.installMarkdownLinks(view, api, openHref));
+        report('markdown-reading-links', true);
+      });
+    }
+    async function installRichText(api, actions) {
+      await stage('markdown-reading-rich-text', 'native-rich-text-unavailable', async () => {
+        const rich = await load('loadNativeMarkdownRichText', actions);
+        if (!current()) return;
+        cleanups.push(capabilities.installMarkdownRichText(view, api, rich, codex));
+        report('markdown-reading-rich-text', true);
+      });
+    }
+    async function installActions(api, toc, tables) {
+      await stage('markdown-table-actions', 'native-table-actions-unavailable', async () => {
+        const actions = await load('loadNativeMarkdownTableActions', toc);
+        if (!current()) return;
+        cleanups.push(capabilities.installMarkdownTableActions(view, actions, codex, tables.controller));
+        report('markdown-table-actions', true);
+        await installRichText(api, actions);
+      });
+    }
+    async function installToc(api, tables) {
+      await stage('markdown-reading-toc', 'native-page-toc-unavailable', async () => {
+        const toc = await load('loadNativeMarkdownToc');
+        if (!current()) return;
+        cleanups.push(capabilities.installMarkdownToc(view, api, toc, codex));
+        report('markdown-reading-toc', true);
+        await installActions(api, toc, tables);
+      });
+    }
+    async function start() {
+      if (!view || view.dom !== editor || !view.state.tree) {
+        report('markdown-reading-layout', false, 'native-markdown-view-unavailable');
+        return;
+      }
+      await stage('markdown-reading-layout', 'native-markdown-list-api-unavailable', async () => {
+        const api = await capabilities.loadMarkdownListAPI(view);
+        if (!current()) return;
+        cleanups.push(capabilities.installMarkdownLists(view, api));
+        const tables = capabilities.installMarkdownTables(view, api);
+        cleanups.push(tables);
+        report('markdown-reading-layout', true);
+        await Promise.all([installLinks(api), installToc(api, tables)]);
+      });
+    }
+    const ready = start();
+    return {
+      ready,
+      checks: () => [...states].map(([name, state]) => ({ name, available: state === 'available' })),
+      dispose() {
+        if (disposed) return;
+        disposed = true;
+        // 先释放依赖方，再移除其所依赖的装饰和滚动控制器。
+        for (const cleanup of cleanups.splice(0).reverse()) cleanup();
+      },
+    };
+  }
+  return { attach };
+}
+
+// 保留 React 的兄弟节点结构，让 Metadata 与原生正文共用一个滚动位置。
+export function installMarkdownMetadataScroll(editor, scroller) {
+  const body = editor.parentElement?.parentElement;
+  const frame = body?.parentElement;
+  const metadata =
+    frame && [...frame.children].find((node) => node !== body && node.matches('.max-h-80.overflow-y-auto'));
+  if (!metadata) return () => {};
+  frame.setAttribute('data-mcx-reading-metadata-frame', '');
+  metadata.setAttribute('data-mcx-reading-metadata', '');
+  function sync() {
+    editor.style.setProperty('--mcx-reading-metadata-height', `${metadata.offsetHeight}px`);
+    metadata.style.transform = `translateY(${-scroller.scrollTop}px)`;
+  }
+  const originalTransform = metadata.style.transform;
+  const observer = new ResizeObserver(sync);
+  observer.observe(metadata);
+  scroller.addEventListener('scroll', sync, { passive: true });
+  sync();
+  return () => {
+    observer.disconnect();
+    scroller.removeEventListener('scroll', sync);
+    metadata.style.transform = originalTransform;
+    metadata.removeAttribute('data-mcx-reading-metadata');
+    frame.removeAttribute('data-mcx-reading-metadata-frame');
+    editor.style.removeProperty('--mcx-reading-metadata-height');
+  };
+}