nolo-cli 0.1.40 → 0.1.41

package/core/prefix.ts

@@ -0,0 +1,23 @@
+const extractKeyPart = (key: string, index: number): string => {
+  const parts = key.split("-");
+  if (index < 2) {
+    return parts[index];
+  }
+  return parts.slice(index).join("-");
+};
+
+export const extractUserId = (key: string): string => {
+  const parts = key.split("-");
+
+  if (parts.length === 2) {
+    return parts[0];
+  }
+
+  if (parts[0] === "user" && parts[1] === "pref" && parts.length >= 3) {
+    return parts[2];
+  }
+
+  return extractKeyPart(key, 1);
+};
+
+export const extractCustomId = (key: string): string => extractKeyPart(key, 2);

package/create/editor/transforms/fromMarkdown/index.ts

@@ -0,0 +1,260 @@
+// create/editor/transforms/fromMarkdown.ts
+
+import { processInlineNodes } from "./inline";
+import { transformTable } from "./table";
+
+interface SlateNode {
+  type: string;
+  children: Array<any>;
+  text?: string;
+  bold?: boolean;
+  italic?: boolean;
+  ordered?: boolean;
+  url?: string;
+  language?: string | null;
+  alt?: string;
+  title?: string;
+  header?: boolean;
+  checked?: boolean;
+  html?: string;
+  start?: number;
+  value?: number;
+  columns?: any[];
+  // 从 Markdown meta 里解析出来的 preview 标记
+  // 使用字符串是为了兼容 element.preview === "true" 的判断
+  preview?: string;
+}
+
+/**
+ * 创建一个空段落节点
+ */
+function createEmptyParagraph(): SlateNode {
+  return {
+    type: "paragraph",
+    children: [{ text: "" }],
+  };
+}
+
+/**
+ * 安全获取 children 数组
+ */
+function getChildren(node: any): any[] {
+  if (!node || typeof node !== "object") return [];
+  if (!Array.isArray(node.children)) return [];
+  return node.children;
+}
+
+/**
+ * 从 mdast 的 code 节点中解析 preview meta
+ * 支持：
+ * ```tsx preview
+ * ```tsx preview=true
+ */
+function getPreviewFlagFromMeta(node: any): "true" | undefined {
+  const meta = typeof node?.meta === "string" ? node.meta.trim() : "";
+  if (!meta) return undefined;
+
+  const tokens = meta.split(/\s+/);
+
+  const hasPreview = tokens.some((tok) => {
+    if (tok === "preview") return true;
+    if (tok.startsWith("preview=")) {
+      const [, value] = tok.split("=");
+      return value === "true";
+    }
+    return false;
+  });
+
+  return hasPreview ? "true" : undefined;
+}
+
+/**
+ * 将一个 list 节点转换为 Slate list 节点
+ */
+function convertList(node: any): SlateNode {
+  const start = typeof node.start === "number" ? node.start : 1;
+  const items = getChildren(node);
+
+  return {
+    type: "list",
+    ordered: !!node.ordered,
+    start,
+    children: items.map((item: any, index: number) =>
+      convertListItem(item, start + index)
+    ),
+  };
+}
+
+/**
+ * 将 listItem 节点转换为 Slate list-item 节点
+ */
+function convertListItem(item: any, value: number): SlateNode {
+  const children = convertListItemChildren(item);
+
+  const listItemNode: SlateNode = {
+    type: "list-item",
+    value,
+    children: children.length ? children : [createEmptyParagraph()],
+  };
+
+  if (item && (item.checked === true || item.checked === false)) {
+    listItemNode.checked = item.checked;
+  }
+
+  return listItemNode;
+}
+
+/**
+ * 将 listItem 里的子节点统一转换
+ * 支持：
+ * - 段落
+ * - 嵌套列表
+ * - 引用
+ * - 代码块
+ * - 表格
+ * - 分割线
+ * - HTML
+ * - 标题等
+ */
+function convertListItemChildren(item: any): SlateNode[] {
+  const children = getChildren(item);
+  if (!children.length) return [createEmptyParagraph()];
+
+  return convertBlockChildren(children);
+}
+
+/**
+ * 转换一组「块级」节点（用于 root / blockquote / listItem 等容器）
+ */
+function convertBlockChildren(nodes: any[]): SlateNode[] {
+  const result: SlateNode[] = [];
+
+  for (const node of nodes || []) {
+    const converted = convertBlockNode(node);
+    if (!converted) continue;
+
+    if (Array.isArray(converted)) {
+      result.push(...converted);
+    } else {
+      result.push(converted);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 将单个 mdast「块级」节点转换为 Slate 节点
+ * 这里处理所有可以作为块的类型：paragraph / heading / list / blockquote / code / table / html / thematicBreak ...
+ */
+function convertBlockNode(node: any): SlateNode | SlateNode[] | null {
+  if (!node || typeof node !== "object") return null;
+
+  switch (node.type) {
+    // 段落
+    case "paragraph":
+      return {
+        type: "paragraph",
+        children: node.children?.length
+          ? processInlineNodes(node.children)
+          : [{ text: "" }],
+      };
+
+    // 标题
+    case "heading": {
+      const depth = (node as any).depth || 1;
+      const headings = ["one", "two", "three", "four", "five", "six"];
+      const suffix = headings[depth - 1] || "one";
+      return {
+        type: `heading-${suffix}`,
+        children: node.children?.length
+          ? processInlineNodes(node.children)
+          : [{ text: "" }],
+      };
+    }
+
+    // 代码块（支持 preview meta）
+    case "code":
+      return {
+        type: "code-block",
+        language: node.lang || "text",
+        preview: getPreviewFlagFromMeta(node),
+        children: (node.value || "").split("\n").map((line: string) => ({
+          type: "code-line",
+          children: [{ text: line }],
+        })),
+      };
+
+    // 列表
+    case "list":
+      return convertList(node);
+
+    // 引用块（blockquote）
+    case "blockquote": {
+      const children = convertBlockChildren(getChildren(node));
+      return {
+        type: "quote",
+        children: children.length ? children : [createEmptyParagraph()],
+      };
+    }
+
+    // 表格
+    case "table": {
+      const tableNode = transformTable(node);
+      return tableNode || null;
+    }
+
+    // 分割线
+    case "thematicBreak":
+      return { type: "thematic-break", children: [{ text: "" }] };
+
+    // 原始 HTML（块级）
+    case "html": {
+      // 原来的实现只处理 position.start.column === 1 的块级 html
+      // 这里保持同样逻辑，避免行为改变太大
+      const isBlockHtml = !node.position || node.position.start?.column === 1;
+
+      if (!isBlockHtml) return null;
+
+      return {
+        type: "html-block",
+        html: node.value || "",
+        children: [{ text: "" }],
+      };
+    }
+
+    // root：取 children 继续处理
+    case "root":
+      return convertBlockChildren(getChildren(node));
+
+    default:
+      return null;
+  }
+}
+
+/**
+ * 顶层入口：MDAST -> Slate 数组
+ */
+export function mdastToSlate(mdastTree: any): SlateNode[] {
+  if (!mdastTree) {
+    return [createEmptyParagraph()];
+  }
+
+  let rootChildren: any[] = [];
+
+  if (mdastTree.type === "root") {
+    rootChildren = getChildren(mdastTree);
+  } else if (Array.isArray(mdastTree.children)) {
+    // 非 root 但有 children 的场景也兼容一下
+    rootChildren = mdastTree.children;
+  } else {
+    // 单节点也走统一转换
+    const single = convertBlockNode(mdastTree);
+    if (!single) return [createEmptyParagraph()];
+    return Array.isArray(single) ? single : [single];
+  }
+
+  const slateNodes = convertBlockChildren(rootChildren);
+
+  return slateNodes.length ? slateNodes : [createEmptyParagraph()];
+}

package/create/editor/transforms/fromMarkdown/inline.ts

@@ -0,0 +1,285 @@
+// 路径：create/editor/transforms/inline.ts
+
+// 辅助类型定义
+export interface SlateTextNode {
+  text: string;
+  bold?: boolean;
+  italic?: boolean;
+  strikethrough?: boolean;
+}
+
+export interface SlateElementNode {
+  type: string;
+  url?: string;
+  alt?: string;
+  title?: string;
+  html?: string; // html-inline 或 html-block
+  language?: string; // 代码块语言
+  children: SlateChild[];
+}
+
+// Mention 节点类型
+export interface SlateMentionNode {
+  type: "mention";
+  resourceType: "tool" | "page" | "agent" | "space";
+  resourceId: string;
+  label: string;
+  children: SlateChild[];
+}
+
+export type SlateChild = SlateTextNode | SlateElementNode | SlateMentionNode;
+export type SlateInlineChild = SlateChild;
+
+// 提取 HTML 标签名，例如 "<span>" -> "span"
+function getTagName(html: string): string | null {
+  if (!html) return null;
+  const match = html.trimStart().match(/^<\/?([a-zA-Z0-9]+)/);
+  return match ? match[1].toLowerCase() : null;
+}
+
+// 递归获取 mdast 节点的纯文本内容
+function getRawTextFromNodes(nodes: any[]): string {
+  if (!Array.isArray(nodes)) return "";
+  return nodes
+    .map((node) => {
+      if (!node) return "";
+      if (node.type === "text") return node.value || "";
+      if (Array.isArray(node.children))
+        return getRawTextFromNodes(node.children);
+      if (node.value && typeof node.value === "string") return node.value;
+      return "";
+    })
+    .join("");
+}
+
+// 合并相邻且样式完全一致的文本节点
+function mergeTextNodes(nodes: SlateInlineChild[]): SlateInlineChild[] {
+  const merged: SlateInlineChild[] = [];
+  for (const node of nodes) {
+    if (
+      merged.length > 0 &&
+      "text" in node &&
+      "text" in merged[merged.length - 1]
+    ) {
+      const prev = merged[merged.length - 1] as SlateTextNode;
+      const cur = node as SlateTextNode;
+
+      if (
+        prev.bold === cur.bold &&
+        prev.italic === cur.italic &&
+        prev.strikethrough === cur.strikethrough
+      ) {
+        prev.text += cur.text;
+        continue;
+      }
+    }
+    merged.push(node);
+  }
+  return merged;
+}
+
+/**
+ * 将 mdast 内联节点转换为 Slate 内联节点列表，
+ * 支持加粗、斜体、删除线、链接、图片、内联代码以及内联 HTML。
+ */
+export function processInlineNodes(mdastChildren: any[]): SlateInlineChild[] {
+  if (!Array.isArray(mdastChildren)) return [{ text: "" }];
+
+  const result: SlateInlineChild[] = [];
+
+  // 当前打开的 HTML 标签状态
+  let activeHtmlTag: {
+    startTag: string;
+    tagName: string;
+    contentNodes: any[];
+  } | null = null;
+
+  try {
+    for (const child of mdastChildren) {
+      if (!child || typeof child !== "object") {
+        // 在 HTML 标签内时收集纯文本
+        if (activeHtmlTag && typeof child === "string") {
+          activeHtmlTag.contentNodes.push({ type: "text", value: child });
+        }
+        continue;
+      }
+
+      // 处理 HTML 节点
+      if (child.type === "html" && typeof child.value === "string") {
+        const htmlValue = child.value;
+        const trimmedEnd = htmlValue.trimEnd();
+        const tagName = getTagName(htmlValue);
+
+        // 自闭合标签，例如 <br/>、<img ... />
+        if (trimmedEnd.endsWith("/>") && tagName) {
+          if (activeHtmlTag) {
+            activeHtmlTag.contentNodes.push(child);
+          } else {
+            result.push({
+              type: "html-inline",
+              html: htmlValue,
+              children: [{ text: "" }],
+            });
+          }
+          continue;
+        }
+
+        // 结束标签
+        if (htmlValue.trimStart().startsWith("</") && tagName) {
+          if (activeHtmlTag && activeHtmlTag.tagName === tagName) {
+            const nodes = processInlineNodes(activeHtmlTag.contentNodes);
+            const rawText = getRawTextFromNodes(activeHtmlTag.contentNodes);
+            const children = nodes.length ? nodes : [{ text: "" }];
+
+            result.push({
+              type: "html-inline",
+              html: activeHtmlTag.startTag + rawText + htmlValue,
+              children,
+            });
+            activeHtmlTag = null;
+          } else if (activeHtmlTag) {
+            // 标签不匹配时，继续当作内容收集
+            activeHtmlTag.contentNodes.push(child);
+          } else {
+            // 没有打开标签，但遇到结束标签，当作纯文本
+            result.push({ text: htmlValue });
+          }
+          continue;
+        }
+
+        // 开始标签
+        if (!htmlValue.trimStart().startsWith("</") && tagName) {
+          if (activeHtmlTag) {
+            activeHtmlTag.contentNodes.push(child);
+          } else {
+            activeHtmlTag = {
+              startTag: htmlValue,
+              tagName,
+              contentNodes: [],
+            };
+          }
+          continue;
+        }
+
+        // 非标准 / 无法识别的 HTML
+        if (activeHtmlTag) {
+          activeHtmlTag.contentNodes.push(child);
+        } else {
+          result.push({ text: htmlValue });
+        }
+        continue;
+      }
+
+      // 在 HTML 标签内时，收集内容节点
+      if (activeHtmlTag) {
+        activeHtmlTag.contentNodes.push(child);
+        continue;
+      }
+
+      // 普通节点处理
+      switch (child.type) {
+        case "strong": {
+          const nodes = processInlineNodes(child.children || []);
+          nodes.forEach((n) => "text" in n && (n.bold = true));
+          result.push(...nodes);
+          break;
+        }
+        case "emphasis": {
+          const nodes = processInlineNodes(child.children || []);
+          nodes.forEach((n) => "text" in n && (n.italic = true));
+          result.push(...nodes);
+          break;
+        }
+        case "delete": {
+          const nodes = processInlineNodes(child.children || []);
+          nodes.forEach((n) => "text" in n && (n.strikethrough = true));
+          result.push(...nodes);
+          break;
+        }
+        case "link":
+          result.push({
+            type: "link",
+            url: child.url || "",
+            children: processInlineNodes(child.children || []),
+          });
+          break;
+
+        case "inlineCode":
+          result.push({
+            type: "code-inline",
+            children: [{ text: child.value || "" }],
+          });
+          break;
+
+        case "image": {
+          const img: SlateElementNode = {
+            type: "image",
+            url: child.url || "",
+            alt: child.alt || "",
+            children: [{ text: "" }],
+          };
+          if (child.title) img.title = child.title;
+          result.push(img);
+          break;
+        }
+
+        case "text": {
+          const text = child.value || "";
+          // 识别 @[type:id|label] 格式的 mention 语法
+          const mentionRegex = /@\[(\w+):([^\]|]+)\|([^\]]+)\]/g;
+
+          if (!mentionRegex.test(text)) {
+            result.push({ text });
+            break;
+          }
+
+          // 有 mention，需要拆分文本
+          let lastIndex = 0;
+          let match;
+          mentionRegex.lastIndex = 0;
+
+          while ((match = mentionRegex.exec(text)) !== null) {
+            // 前面的普通文本
+            if (match.index > lastIndex) {
+              result.push({ text: text.slice(lastIndex, match.index) });
+            }
+            // mention 节点
+            result.push({
+              type: "mention",
+              resourceType: match[1] as "tool" | "page" | "agent" | "space",
+              resourceId: match[2],
+              label: match[3],
+              children: [{ text: "" }],
+            });
+            lastIndex = mentionRegex.lastIndex;
+          }
+          // 剩余文本
+          if (lastIndex < text.length) {
+            result.push({ text: text.slice(lastIndex) });
+          }
+          break;
+        }
+
+        default:
+          if (child.value && typeof child.value === "string") {
+            result.push({ text: child.value });
+          }
+      }
+    }
+
+    // 处理未闭合的 HTML 标签：按开始标签 + 内部内容退化
+    if (activeHtmlTag) {
+      result.push({
+        type: "html-inline",
+        html: activeHtmlTag.startTag,
+        children: [{ text: "" }],
+      });
+      result.push(...processInlineNodes(activeHtmlTag.contentNodes));
+    }
+  } catch {
+    return [{ text: "" }];
+  }
+
+  const finalResult = result.length ? result : [{ text: "" }];
+  return mergeTextNodes(finalResult);
+}

package/create/editor/transforms/fromMarkdown/table.ts

@@ -0,0 +1,130 @@
+// 路径：create/editor/transforms/table.ts
+
+import { Element as SlateElement } from "slate";
+import { processInlineNodes } from "./inline";
+
+// MDAST 类型（简化）
+type MdastNode = { [key: string]: any };
+
+type MdastTableCell = {
+  type: "tableCell";
+  children: MdastNode[];
+};
+
+type MdastTableRow = {
+  type: "tableRow";
+  children: MdastTableCell[];
+};
+
+type MdastTable = {
+  type: "table";
+  align: (string | null)[];
+  children: MdastTableRow[];
+};
+
+// Slate 表格相关类型
+export type SlateTableCell = SlateElement & { header?: boolean };
+type SlateTableRow = SlateElement & { children: SlateTableCell[] };
+type SlateTableColumn = { align: string; width: null | number };
+
+export type SlateTable = SlateElement & {
+  columns: SlateTableColumn[];
+  children: SlateTableRow[];
+};
+
+/**
+ * 创建一个 Slate table-cell 节点。
+ * @param mdastCell - 输入的 MDAST tableCell 节点。
+ * @param isHeader - 当前单元格是否为表头。
+ */
+function createSlateCell(
+  mdastCell: MdastTableCell,
+  isHeader: boolean
+): SlateTableCell {
+  // 1. 使用行内转换，生成 cell 内的行内子节点
+  let inlineChildren = processInlineNodes(mdastCell.children || []);
+
+  // 2. 确保至少有一个 text 节点
+  if (inlineChildren.length === 0) {
+    inlineChildren = [{ text: "" }];
+  }
+
+  // 3. 包裹在一个 paragraph 中（符合 Slate 表格 schema）
+  const slateCellChildren = [
+    {
+      type: "paragraph",
+      children: inlineChildren,
+    },
+  ];
+
+  const slateCell: SlateTableCell = {
+    type: "table-cell",
+    children: slateCellChildren,
+  };
+
+  if (isHeader) {
+    slateCell.header = true;
+  }
+
+  return slateCell;
+}
+
+/**
+ * 将 MDAST 表格节点转换为 Slate 表格节点。
+ */
+export function transformTable(node: MdastTable): SlateTable | null {
+  if (node.type !== "table" || !node.children || node.children.length === 0) {
+    return null;
+  }
+
+  // 计算表格的最大列数
+  const maxColumns = node.children.reduce(
+    (max, row) => Math.max(max, row.children?.length || 0),
+    0
+  );
+
+  if (maxColumns === 0) return null;
+
+  // 将列数不足的行用空单元格补齐，保证每行列数一致
+  const normalizedRows: MdastTableRow[] = node.children.map((row) => {
+    const cells = row.children || [];
+    const diff = maxColumns - cells.length;
+
+    if (diff > 0) {
+      // 使用 Array.from 避免 fill 带来的同一引用问题
+      const emptyCells: MdastTableCell[] = Array.from({ length: diff }, () => ({
+        type: "tableCell",
+        children: [],
+      }));
+      return { ...row, children: [...cells, ...emptyCells] };
+    }
+
+    return row;
+  });
+
+  // 处理列的对齐信息
+  const align = node.align || [];
+  const columns: SlateTableColumn[] = Array.from(
+    { length: maxColumns },
+    (_, i) => ({
+      align: align[i] || "left",
+      width: null,
+    })
+  );
+
+  // 行 & 单元格转换
+  const slateRows: SlateTableRow[] = normalizedRows.map((row, rowIndex) => {
+    const isHeaderRow = rowIndex === 0;
+
+    return {
+      type: "table-row",
+      children: row.children.map((cell) => createSlateCell(cell, isHeaderRow)),
+    };
+  });
+
+  return {
+    type: "table",
+    columns,
+    children: slateRows,
+  };
+}