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/note/src/adapters/html.ts

@@ -0,0 +1,44 @@
+import { NoteBlockSchema, NoteDisplayMode } from '@blocksuite/affine-model';
+import {
+  BlockHtmlAdapterExtension,
+  type BlockHtmlAdapterMatcher,
+} from '@blocksuite/affine-shared/adapters';
+
+/**
+ * Create a html adapter matcher for note block.
+ *
+ * @param displayModeToSkip - The note with specific display mode to skip.
+ * For example, the note with display mode `EdgelessOnly` should not be converted to html when current editor mode is `Doc(Page)`.
+ * @returns The html adapter matcher.
+ */
+const createNoteBlockHtmlAdapterMatcher = (
+  displayModeToSkip: NoteDisplayMode
+): BlockHtmlAdapterMatcher => ({
+  flavour: NoteBlockSchema.model.flavour,
+  toMatch: () => false,
+  fromMatch: o => o.node.flavour === NoteBlockSchema.model.flavour,
+  toBlockSnapshot: {},
+  fromBlockSnapshot: {
+    enter: (o, context) => {
+      const node = o.node;
+      if (node.props.displayMode === displayModeToSkip) {
+        context.walkerContext.skipAllChildren();
+      }
+    },
+  },
+});
+
+export const docNoteBlockHtmlAdapterMatcher = createNoteBlockHtmlAdapterMatcher(
+  NoteDisplayMode.EdgelessOnly
+);
+
+export const edgelessNoteBlockHtmlAdapterMatcher =
+  createNoteBlockHtmlAdapterMatcher(NoteDisplayMode.DocOnly);
+
+export const DocNoteBlockHtmlAdapterExtension = BlockHtmlAdapterExtension(
+  docNoteBlockHtmlAdapterMatcher
+);
+
+export const EdgelessNoteBlockHtmlAdapterExtension = BlockHtmlAdapterExtension(
+  edgelessNoteBlockHtmlAdapterMatcher
+);

blocksuite/affine/blocks/note/src/adapters/index.ts

@@ -0,0 +1,30 @@
+import type { ExtensionType } from '@blocksuite/store';
+
+import {
+  DocNoteBlockHtmlAdapterExtension,
+  EdgelessNoteBlockHtmlAdapterExtension,
+} from './html';
+import {
+  DocNoteBlockMarkdownAdapterExtension,
+  EdgelessNoteBlockMarkdownAdapterExtension,
+} from './markdown';
+import {
+  DocNoteBlockPlainTextAdapterExtension,
+  EdgelessNoteBlockPlainTextAdapterExtension,
+} from './plain-text';
+
+export * from './html';
+export * from './markdown';
+export * from './plain-text';
+
+export const DocNoteBlockAdapterExtensions: ExtensionType[] = [
+  DocNoteBlockMarkdownAdapterExtension,
+  DocNoteBlockHtmlAdapterExtension,
+  DocNoteBlockPlainTextAdapterExtension,
+];
+
+export const EdgelessNoteBlockAdapterExtensions: ExtensionType[] = [
+  EdgelessNoteBlockMarkdownAdapterExtension,
+  EdgelessNoteBlockHtmlAdapterExtension,
+  EdgelessNoteBlockPlainTextAdapterExtension,
+];

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

@@ -0,0 +1,123 @@
+import { NoteBlockSchema, NoteDisplayMode } from '@blocksuite/affine-model';
+import {
+  BlockMarkdownAdapterExtension,
+  type BlockMarkdownAdapterMatcher,
+  FOOTNOTE_DEFINITION_PREFIX,
+  type MarkdownAST,
+} from '@blocksuite/affine-shared/adapters';
+import type { FootnoteDefinition, Root } from 'mdast';
+
+const isRootNode = (node: MarkdownAST): node is Root => node.type === 'root';
+const isFootnoteDefinitionNode = (
+  node: MarkdownAST
+): node is FootnoteDefinition => node.type === 'footnoteDefinition';
+
+const createFootnoteDefinition = (
+  identifier: string,
+  content: string
+): MarkdownAST => ({
+  type: 'footnoteDefinition',
+  label: identifier,
+  identifier,
+  children: [
+    {
+      type: 'paragraph',
+      children: [
+        {
+          type: 'text',
+          value: content,
+        },
+      ],
+    },
+  ],
+});
+
+/**
+ * Create a markdown adapter matcher for note block.
+ *
+ * @param displayModeToSkip - The note with specific display mode to skip.
+ * For example, the note with display mode `EdgelessOnly` should not be converted to markdown when current editor mode is `Doc`.
+ * @returns The markdown adapter matcher.
+ */
+const createNoteBlockMarkdownAdapterMatcher = (
+  displayModeToSkip: NoteDisplayMode
+): BlockMarkdownAdapterMatcher => ({
+  flavour: NoteBlockSchema.model.flavour,
+  toMatch: o => isRootNode(o.node),
+  fromMatch: o => o.node.flavour === NoteBlockSchema.model.flavour,
+  toBlockSnapshot: {
+    enter: (o, context) => {
+      if (!isRootNode(o.node)) {
+        return;
+      }
+      const noteAst = o.node;
+      // Find all the footnoteDefinition in the noteAst
+      const { configs } = context;
+      noteAst.children.forEach(child => {
+        if (isFootnoteDefinitionNode(child)) {
+          const identifier = child.identifier;
+          const definitionKey = `${FOOTNOTE_DEFINITION_PREFIX}${identifier}`;
+          // Get the text content of the footnoteDefinition
+          const textContent = child.children
+            .find(child => child.type === 'paragraph')
+            ?.children.find(child => child.type === 'text')?.value;
+          if (textContent) {
+            configs.set(definitionKey, textContent);
+          }
+        }
+      });
+
+      // Remove the footnoteDefinition node from the noteAst
+      noteAst.children = noteAst.children.filter(
+        child => !isFootnoteDefinitionNode(child)
+      );
+    },
+  },
+  fromBlockSnapshot: {
+    enter: (o, context) => {
+      const node = o.node;
+      if (node.props.displayMode === displayModeToSkip) {
+        context.walkerContext.skipAllChildren();
+      }
+    },
+    leave: (_, context) => {
+      const { walkerContext, configs } = context;
+      // Get all the footnote definitions config starts with FOOTNOTE_DEFINITION_PREFIX
+      // And create footnoteDefinition AST node for each of them
+      Array.from(configs.keys())
+        .filter(key => key.startsWith(FOOTNOTE_DEFINITION_PREFIX))
+        .forEach(key => {
+          const hasFootnoteDefinition = !!walkerContext.getGlobalContext(key);
+          // If the footnoteDefinition node is already in md ast, skip it
+          // In markdown file, we only need to create footnoteDefinition once
+          if (hasFootnoteDefinition) {
+            return;
+          }
+          const definition = configs.get(key);
+          const identifier = key.slice(FOOTNOTE_DEFINITION_PREFIX.length);
+          if (definition && identifier) {
+            walkerContext
+              .openNode(
+                createFootnoteDefinition(identifier, definition),
+                'children'
+              )
+              .closeNode();
+            // Set the footnoteDefinition node as global context to avoid duplicate creation
+            walkerContext.setGlobalContext(key, true);
+          }
+        });
+    },
+  },
+});
+
+export const docNoteBlockMarkdownAdapterMatcher =
+  createNoteBlockMarkdownAdapterMatcher(NoteDisplayMode.EdgelessOnly);
+
+export const edgelessNoteBlockMarkdownAdapterMatcher =
+  createNoteBlockMarkdownAdapterMatcher(NoteDisplayMode.DocOnly);
+
+export const DocNoteBlockMarkdownAdapterExtension =
+  BlockMarkdownAdapterExtension(docNoteBlockMarkdownAdapterMatcher);
+
+export const EdgelessNoteBlockMarkdownAdapterExtension =
+  BlockMarkdownAdapterExtension(edgelessNoteBlockMarkdownAdapterMatcher);

blocksuite/affine/blocks/note/src/adapters/plain-text.ts

@@ -0,0 +1,41 @@
+import { NoteBlockSchema, NoteDisplayMode } from '@blocksuite/affine-model';
+import {
+  BlockPlainTextAdapterExtension,
+  type BlockPlainTextAdapterMatcher,
+} from '@blocksuite/affine-shared/adapters';
+
+/**
+ * Create a plain text adapter matcher for note block.
+ *
+ * @param displayModeToSkip - The note with specific display mode to skip.
+ * For example, the note with display mode `EdgelessOnly` should not be converted to plain text when current editor mode is `Doc(Page)`.
+ * @returns The plain text adapter matcher.
+ */
+const createNoteBlockPlainTextAdapterMatcher = (
+  displayModeToSkip: NoteDisplayMode
+): BlockPlainTextAdapterMatcher => ({
+  flavour: NoteBlockSchema.model.flavour,
+  toMatch: () => false,
+  fromMatch: o => o.node.flavour === NoteBlockSchema.model.flavour,
+  toBlockSnapshot: {},
+  fromBlockSnapshot: {
+    enter: (o, context) => {
+      const node = o.node;
+      if (node.props.displayMode === displayModeToSkip) {
+        context.walkerContext.skipAllChildren();
+      }
+    },
+  },
+});
+
+export const docNoteBlockPlainTextAdapterMatcher =
+  createNoteBlockPlainTextAdapterMatcher(NoteDisplayMode.EdgelessOnly);
+
+export const edgelessNoteBlockPlainTextAdapterMatcher =
+  createNoteBlockPlainTextAdapterMatcher(NoteDisplayMode.DocOnly);
+
+export const DocNoteBlockPlainTextAdapterExtension =
+  BlockPlainTextAdapterExtension(docNoteBlockPlainTextAdapterMatcher);
+
+export const EdgelessNoteBlockPlainTextAdapterExtension =
+  BlockPlainTextAdapterExtension(edgelessNoteBlockPlainTextAdapterMatcher);