refactor(editor): unify directories naming (#11516)

**Directory Structure Changes**

- Renamed multiple block-related directories by removing the "block-" prefix:
  - `block-attachment` → `attachment`
  - `block-bookmark` → `bookmark`
  - `block-callout` → `callout`
  - `block-code` → `code`
  - `block-data-view` → `data-view`
  - `block-database` → `database`
  - `block-divider` → `divider`
  - `block-edgeless-text` → `edgeless-text`
  - `block-embed` → `embed`

blocksuite/affine/blocks/surface/src/adapters/markdown/element-adapter/index.ts

@@ -0,0 +1,33 @@
+import type { MarkdownAST } from '@blocksuite/affine-shared/adapters';
+
+import {
+  ElementModelAdapter,
+  type ElementModelAdapterContext,
+} from '../../type.js';
+import type { ElementToMarkdownAdapterMatcher } from './type.js';
+
+export class MarkdownElementModelAdapter extends ElementModelAdapter<
+  MarkdownAST,
+  MarkdownAST
+> {
+  constructor(
+    readonly elementModelMatchers: ElementToMarkdownAdapterMatcher[]
+  ) {
+    super();
+  }
+
+  fromElementModel(
+    element: Record<string, unknown>,
+    context: ElementModelAdapterContext<MarkdownAST>
+  ) {
+    const markdownAST: MarkdownAST | null = null;
+    for (const matcher of this.elementModelMatchers) {
+      if (matcher.match(element)) {
+        return matcher.toAST(element, context);
+      }
+    }
+    return markdownAST;
+  }
+}
+
+export * from './type.js';

blocksuite/affine/blocks/surface/src/adapters/markdown/element-adapter/type.ts

@@ -0,0 +1,29 @@
+import type { ExtensionType } from '@blocksuite/affine/store';
+import type { MarkdownAST } from '@blocksuite/affine-shared/adapters';
+import {
+  createIdentifier,
+  type ServiceIdentifier,
+} from '@blocksuite/global/di';
+
+import type { ElementModelMatcher } from '../../type.js';
+
+export type ElementToMarkdownAdapterMatcher = ElementModelMatcher<MarkdownAST>;
+
+export const ElementToMarkdownAdapterMatcherIdentifier =
+  createIdentifier<ElementToMarkdownAdapterMatcher>(
+    'elementToMarkdownAdapterMatcher'
+  );
+
+export function ElementToMarkdownAdapterExtension(
+  matcher: ElementToMarkdownAdapterMatcher
+): ExtensionType & {
+  identifier: ServiceIdentifier<ElementToMarkdownAdapterMatcher>;
+} {
+  const identifier = ElementToMarkdownAdapterMatcherIdentifier(matcher.name);
+  return {
+    setup: di => {
+      di.addImpl(identifier, () => matcher);
+    },
+    identifier,
+  };
+}

blocksuite/affine/blocks/surface/src/adapters/markdown/markdown.ts

@@ -0,0 +1,76 @@
+import { getMindMapNodeMap } from '@blocksuite/affine-model';
+import {
+  BlockMarkdownAdapterExtension,
+  type BlockMarkdownAdapterMatcher,
+} from '@blocksuite/affine-shared/adapters';
+
+import { MarkdownElementModelAdapter } from './element-adapter/index.js';
+import { ElementToMarkdownAdapterMatcherIdentifier } from './element-adapter/type.js';
+
+export const surfaceBlockMarkdownAdapterMatcher: BlockMarkdownAdapterMatcher = {
+  flavour: 'affine:surface',
+  toMatch: () => false,
+  fromMatch: o => o.node.flavour === 'affine:surface',
+  toBlockSnapshot: {},
+  fromBlockSnapshot: {
+    enter: (_, context) => {
+      context.walkerContext.skipAllChildren();
+    },
+  },
+};
+
+export const SurfaceBlockMarkdownAdapterExtension =
+  BlockMarkdownAdapterExtension(surfaceBlockMarkdownAdapterMatcher);
+
+export const edgelessSurfaceBlockMarkdownAdapterMatcher: BlockMarkdownAdapterMatcher =
+  {
+    flavour: 'affine:surface',
+    toMatch: () => false,
+    fromMatch: o => o.node.flavour === 'affine:surface',
+    toBlockSnapshot: {},
+    fromBlockSnapshot: {
+      enter: (o, context) => {
+        const { walkerContext, provider } = context;
+        if (!provider) {
+          context.walkerContext.skipAllChildren();
+          return;
+        }
+
+        const elementModelMatchers = Array.from(
+          provider.getAll(ElementToMarkdownAdapterMatcherIdentifier).values()
+        );
+        const markdownElementModelAdapter = new MarkdownElementModelAdapter(
+          elementModelMatchers
+        );
+        if ('elements' in o.node.props) {
+          const elements = o.node.props.elements as Record<
+            string,
+            Record<string, unknown>
+          >;
+          // Get all the node maps of mindMap elements
+          const mindMapArray = Object.entries(elements)
+            .filter(([_, element]) => element.type === 'mindmap')
+            .map(([_, element]) => getMindMapNodeMap(element));
+          walkerContext.setGlobalContext(
+            'surface:mindMap:nodeMapArray',
+            mindMapArray
+          );
+
+          Object.entries(
+            o.node.props.elements as Record<string, Record<string, unknown>>
+          ).forEach(([_, element]) => {
+            const markdownAST = markdownElementModelAdapter.fromElementModel(
+              element,
+              { walkerContext, elements }
+            );
+            if (markdownAST) {
+              walkerContext.openNode(markdownAST, 'children').closeNode();
+            }
+          });
+        }
+      },
+    },
+  };
+
+export const EdgelessSurfaceBlockMarkdownAdapterExtension =
+  BlockMarkdownAdapterExtension(edgelessSurfaceBlockMarkdownAdapterMatcher);