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/widgets/drag-handle/src/middleware/blocks-filter.ts

@@ -0,0 +1,114 @@
+import type { SurfaceBlockModel } from '@blocksuite/affine-block-surface';
+import type { ConnectorElementModel } from '@blocksuite/affine-model';
+import type { IVec, SerializedXYWH } from '@blocksuite/global/gfx';
+import { assertType } from '@blocksuite/global/utils';
+import type { BlockStdScope } from '@blocksuite/std';
+import {
+  GfxController,
+  type GfxModel,
+  isGfxGroupCompatibleModel,
+} from '@blocksuite/std/gfx';
+import type { TransformerMiddleware } from '@blocksuite/store';
+
+/**
+ * Used to filter out gfx elements that are not selected
+ * @param ids
+ * @param std
+ * @returns
+ */
+export const gfxBlocksFilter = (
+  ids: string[],
+  std: BlockStdScope
+): TransformerMiddleware => {
+  const selectedIds = new Set<string>();
+  const store = std.store;
+  const surface = store.getBlocksByFlavour('affine:surface')[0]
+    .model as SurfaceBlockModel;
+  const idsToCheck = ids.slice();
+  const gfx = std.get(GfxController);
+
+  for (const id of idsToCheck) {
+    const blockOrElem = store.getBlock(id)?.model ?? surface.getElementById(id);
+
+    if (!blockOrElem) continue;
+
+    if (isGfxGroupCompatibleModel(blockOrElem)) {
+      idsToCheck.push(...blockOrElem.childIds);
+    }
+
+    selectedIds.add(id);
+  }
+
+  return ({ slots, transformerConfigs }) => {
+    slots.beforeExport.subscribe(payload => {
+      if (payload.type !== 'block') {
+        return;
+      }
+
+      if (payload.model.flavour === 'affine:surface') {
+        transformerConfigs.set('selectedElements', selectedIds);
+        payload.model.children = payload.model.children.filter(model =>
+          selectedIds.has(model.id)
+        );
+        return;
+      }
+    });
+
+    slots.afterExport.subscribe(payload => {
+      if (payload.type !== 'block') {
+        return;
+      }
+
+      if (payload.model.flavour === 'affine:surface') {
+        const { snapshot } = payload;
+        const elementsMap = snapshot.props.elements as Record<
+          string,
+          { type: string }
+        >;
+
+        Object.entries(elementsMap).forEach(([elementId, val]) => {
+          if (val.type === 'connector') {
+            assertType<{
+              type: 'connector';
+              source: { position: IVec; id?: string };
+              target: { position: IVec; id?: string };
+              xywh: SerializedXYWH;
+            }>(val);
+
+            const connectorElem = gfx.getElementById(
+              elementId
+            ) as ConnectorElementModel;
+
+            if (!connectorElem) {
+              delete elementsMap[elementId];
+              return;
+            }
+
+            // should be deleted during the import process
+            val.xywh = connectorElem.xywh;
+
+            ['source', 'target'].forEach(key => {
+              const endpoint = val[key as 'source' | 'target'];
+              if (endpoint.id && !selectedIds.has(endpoint.id)) {
+                const endElem = gfx.getElementById(endpoint.id);
+
+                if (!endElem) {
+                  delete elementsMap[elementId];
+                  return;
+                }
+
+                const endElemBound = (endElem as GfxModel).elementBound;
+
+                val[key as 'source' | 'target'] = {
+                  position: endElemBound.getRelativePoint(
+                    endpoint.position ?? [0.5, 0.5]
+                  ),
+                };
+              }
+            });
+          }
+        });
+      }
+    });
+  };
+};

blocksuite/affine/widgets/drag-handle/src/middleware/new-id-cross-doc.ts

@@ -0,0 +1,44 @@
+import { DatabaseBlockModel } from '@blocksuite/affine-model';
+import { matchModels } from '@blocksuite/affine-shared/utils';
+import type { BlockStdScope } from '@blocksuite/std';
+import type { TransformerMiddleware } from '@blocksuite/store';
+
+export const newIdCrossDoc =
+  (std: BlockStdScope): TransformerMiddleware =>
+  ({ slots }) => {
+    let samePage = false;
+    const oldToNewIdMap = new Map<string, string>();
+
+    slots.beforeImport.subscribe(payload => {
+      if (payload.type === 'slice') {
+        samePage = payload.snapshot.pageId === std.store.id;
+      }
+      if (payload.type === 'block' && !samePage) {
+        const newId = std.workspace.idGenerator();
+
+        oldToNewIdMap.set(payload.snapshot.id, newId);
+        payload.snapshot.id = newId;
+      }
+    });
+
+    slots.afterImport.subscribe(payload => {
+      if (
+        !samePage &&
+        payload.type === 'block' &&
+        matchModels(payload.model, [DatabaseBlockModel])
+      ) {
+        const originalCells = payload.model.props.cells;
+        const newCells = {
+          ...originalCells,
+        };
+
+        Object.keys(originalCells).forEach(cellId => {
+          if (oldToNewIdMap.has(cellId)) {
+            newCells[oldToNewIdMap.get(cellId)!] = originalCells[cellId];
+          }
+        });
+
+        payload.model.props.cells$.value = newCells;
+      }
+    });
+  };

blocksuite/affine/widgets/drag-handle/src/middleware/reorder-list.ts

@@ -0,0 +1,25 @@
+import { correctNumberedListsOrderToPrev } from '@blocksuite/affine-block-list';
+import { ListBlockModel } from '@blocksuite/affine-model';
+import { matchModels } from '@blocksuite/affine-shared/utils';
+import type { BlockStdScope } from '@blocksuite/std';
+import type { TransformerMiddleware } from '@blocksuite/store';
+
+export const reorderList =
+  (std: BlockStdScope): TransformerMiddleware =>
+  ({ slots }) => {
+    slots.afterImport.subscribe(payload => {
+      if (payload.type === 'block') {
+        const model = payload.model;
+        if (
+          matchModels(model, [ListBlockModel]) &&
+          model.props.type === 'numbered'
+        ) {
+          const next = std.store.getNext(model);
+          correctNumberedListsOrderToPrev(std.store, model);
+          if (next) {
+            correctNumberedListsOrderToPrev(std.store, next);
+          }
+        }
+      }
+    });
+  };