chore(editor): reorg packages (#10702)

blocksuite/affine/blocks/block-surface/src/adapters/utils/mindmap.ts

@@ -0,0 +1,74 @@
+import type {
+  MindMapElement,
+  MindMapJson,
+  MindMapTreeNode,
+} from '../types/mindmap.js';
+
+function isMindMapElement(element: unknown): element is MindMapElement {
+  return (
+    typeof element === 'object' &&
+    element !== null &&
+    'type' in element &&
+    (element as MindMapElement).type === 'mindmap' &&
+    'children' in element &&
+    typeof (element as MindMapElement).children === 'object' &&
+    'json' in (element as MindMapElement).children
+  );
+}
+
+export function getMindMapChildrenJson(
+  element: Record<string, unknown>
+): MindMapJson | null {
+  if (!isMindMapElement(element)) {
+    return null;
+  }
+
+  return element.children.json;
+}
+
+export function getMindMapNodeMap(
+  element: Record<string, unknown>
+): Map<string, MindMapTreeNode> {
+  const nodeMap = new Map<string, MindMapTreeNode>();
+  const childrenJson = getMindMapChildrenJson(element);
+  if (!childrenJson) {
+    return nodeMap;
+  }
+
+  for (const [id, info] of Object.entries(childrenJson)) {
+    nodeMap.set(id, {
+      id,
+      index: info.index,
+      children: [],
+    });
+  }
+
+  return nodeMap;
+}
+
+export function buildMindMapTree(element: Record<string, unknown>) {
+  let root: MindMapTreeNode | null = null;
+
+  // First traverse to get node map
+  const nodeMap = getMindMapNodeMap(element);
+  const childrenJson = getMindMapChildrenJson(element);
+  if (!childrenJson) {
+    return root;
+  }
+
+  // Second traverse to build tree
+  for (const [id, info] of Object.entries(childrenJson)) {
+    const node = nodeMap.get(id)!;
+
+    if (info.parent) {
+      const parentNode = nodeMap.get(info.parent);
+      if (parentNode) {
+        parentNode.children.push(node);
+      }
+    } else {
+      root = node;
+    }
+  }
+
+  return root;
+}

blocksuite/affine/blocks/block-surface/src/adapters/utils/text.ts

@@ -0,0 +1,162 @@
+import type { DeltaInsert } from '@blocksuite/inline/types';
+
+import type { MindMapTreeNode } from '../types/mindmap.js';
+import { buildMindMapTree } from './mindmap.js';
+
+export function getShapeType(elementModel: Record<string, unknown>): string {
+  let shapeType = '';
+  if (elementModel.type !== 'shape') {
+    return shapeType;
+  }
+
+  if (
+    'shapeType' in elementModel &&
+    typeof elementModel.shapeType === 'string'
+  ) {
+    shapeType = elementModel.shapeType;
+  }
+  return shapeType;
+}
+
+export function getShapeText(elementModel: Record<string, unknown>): string {
+  let text = '';
+  if (elementModel.type !== 'shape') {
+    return text;
+  }
+
+  if (
+    'text' in elementModel &&
+    typeof elementModel.text === 'object' &&
+    elementModel.text
+  ) {
+    let delta: DeltaInsert[] = [];
+    if ('delta' in elementModel.text) {
+      delta = elementModel.text.delta as DeltaInsert[];
+    }
+    text = delta.map(d => d.insert).join('');
+  }
+  return text;
+}
+
+export function getConnectorText(
+  elementModel: Record<string, unknown>
+): string {
+  let text = '';
+  if (elementModel.type !== 'connector') {
+    return text;
+  }
+
+  if (
+    'text' in elementModel &&
+    typeof elementModel.text === 'object' &&
+    elementModel.text
+  ) {
+    let delta: DeltaInsert[] = [];
+    if ('delta' in elementModel.text) {
+      delta = elementModel.text.delta as DeltaInsert[];
+    }
+    text = delta.map(d => d.insert).join('');
+  }
+  return text;
+}
+
+export function getGroupTitle(elementModel: Record<string, unknown>): string {
+  let title = '';
+  if (elementModel.type !== 'group') {
+    return title;
+  }
+
+  if (
+    'title' in elementModel &&
+    typeof elementModel.title === 'object' &&
+    elementModel.title
+  ) {
+    let delta: DeltaInsert[] = [];
+    if ('delta' in elementModel.title) {
+      delta = elementModel.title.delta as DeltaInsert[];
+    }
+    title = delta.map(d => d.insert).join('');
+  }
+  return title;
+}
+
+export function getTextElementText(
+  elementModel: Record<string, unknown>
+): string {
+  let text = '';
+  if (elementModel.type !== 'text') {
+    return text;
+  }
+  if (
+    'text' in elementModel &&
+    typeof elementModel.text === 'object' &&
+    elementModel.text
+  ) {
+    let delta: DeltaInsert[] = [];
+    if ('delta' in elementModel.text) {
+      delta = elementModel.text.delta as DeltaInsert[];
+    }
+    text = delta.map(d => d.insert).join('');
+  }
+  return text;
+}
+
+/**
+ * traverse the mindMapTree and construct the content string
+ * like:
+ * - Root
+ *   - Child 1
+ *     - Child 1.1
+ *     - Child 1.2
+ *   - Child 2
+ *     - Child 2.1
+ *     - Child 2.2
+ *   - Child 3
+ *     - Child 3.1
+ *     - Child 3.2
+ * @param elementModel - the mindmap element model
+ * @param elements - the elements map
+ * @returns the mindmap tree text
+ */
+export function getMindMapTreeText(
+  elementModel: Record<string, unknown>,
+  elements: Record<string, Record<string, unknown>>,
+  options: {
+    prefix: string;
+    repeat: number;
+  } = {
+    prefix: ' ',
+    repeat: 2,
+  }
+): string {
+  let mindMapContent = '';
+  if (elementModel.type !== 'mindmap') {
+    return mindMapContent;
+  }
+
+  const mindMapTree = buildMindMapTree(elementModel);
+  if (!mindMapTree) {
+    return mindMapContent;
+  }
+
+  let layer = 0;
+  const traverseMindMapTree = (
+    node: MindMapTreeNode,
+    prefix: string,
+    repeat: number
+  ) => {
+    const shapeElement = elements[node.id as string];
+    const shapeText = getShapeText(shapeElement);
+    if (shapeElement) {
+      mindMapContent += `${prefix.repeat(layer * repeat)}- ${shapeText}\n`;
+    }
+    node.children.forEach(child => {
+      layer++;
+      traverseMindMapTree(child, prefix, repeat);
+      layer--;
+    });
+  };
+  traverseMindMapTree(mindMapTree, options.prefix, options.repeat);
+
+  return mindMapContent;
+}