feat: edgeless dnd (#9988)

### Changed
- Support edgelss dnd
- Simplify the drag-handle state

blocksuite/framework/block-std/src/gfx/model/surface/surface-model.ts

@@ -433,6 +433,10 @@ export class SurfaceBlockModel extends BlockModel<SurfaceBlockProps> {
     this._watchGroupRelationChange();
   }
 
+  getConstructor(type: string) {
+    return this._elementCtorMap[type];
+  }
+
   addElement<T extends object = Record<string, unknown>>(
     props: Partial<T> & { type: string }
   ) {

blocksuite/framework/store/src/__tests__/transformer.unit.spec.ts

@@ -50,7 +50,7 @@ function createTestOptions() {
   return { id: 'test-collection', idGenerator, schema };
 }
 
-const transformer = new BaseBlockTransformer();
+const transformer = new BaseBlockTransformer(new Map());
 const blobCRUD = new MemoryBlobCRUD();
 const assets = new AssetsManager({ blob: blobCRUD });
 

blocksuite/framework/store/src/model/block/zod.ts

@@ -40,7 +40,7 @@ export const BlockSchema = z.object({
   }),
   transformer: z
     .function()
-    .args()
+    .args(z.custom<Map<string, unknown>>())
     .returns(z.custom<BaseBlockTransformer>())
     .optional(),
 });
@@ -69,14 +69,14 @@ export function defineBlockSchema<
   metadata: Metadata;
   props?: (internalPrimitives: InternalPrimitives) => Props;
   toModel?: () => Model;
-  transformer?: () => Transformer;
+  transformer?: (transformerConfig: Map<string, unknown>) => Transformer;
 }): {
   version: number;
   model: {
     props: PropsGetter<Props>;
     flavour: Flavour;
   } & Metadata;
-  transformer?: () => Transformer;
+  transformer?: (transformerConfig: Map<string, unknown>) => Transformer;
 };
 
 export function defineBlockSchema({
@@ -96,7 +96,9 @@ export function defineBlockSchema({
   };
   props?: (internalPrimitives: InternalPrimitives) => Record<string, unknown>;
   toModel?: () => BlockModel;
-  transformer?: () => BaseBlockTransformer;
+  transformer?: (
+    transformerConfig: Map<string, unknown>
+  ) => BaseBlockTransformer;
 }): BlockSchemaType {
   const schema = {
     version: metadata.version,

blocksuite/framework/store/src/transformer/base.ts

@@ -51,6 +51,8 @@ export class BaseBlockTransformer<Props extends object = object> {
     );
   }
 
+  constructor(public readonly transformerConfigs: Map<string, unknown>) {}
+
   fromSnapshot({
     json,
   }: FromSnapshotPayload): Promise<SnapshotNode<Props>> | SnapshotNode<Props> {

blocksuite/framework/store/src/transformer/middleware.ts

@@ -82,7 +82,8 @@ type TransformerMiddlewareOptions = {
   assetsManager: AssetsManager;
   slots: TransformerSlots;
   docCRUD: DocCRUD;
-  adapterConfigs: Map<string, string>;
+  adapterConfigs: Map<string, unknown>;
+  transformerConfigs: Map<string, unknown>;
 };
 
 export type TransformerMiddleware = (

blocksuite/framework/store/src/transformer/transformer.ts

@@ -56,6 +56,8 @@ const BATCH_SIZE = 100;
 export class Transformer {
   private readonly _adapterConfigs = new Map<string, string>();
 
+  private readonly _transformerConfigs = new Map<string, unknown>();
+
   private readonly _assetsManager: AssetsManager;
 
   private readonly _schema: Schema;
@@ -72,6 +74,11 @@ export class Transformer {
   blockToSnapshot = (model: DraftModel): BlockSnapshot | undefined => {
     try {
       const snapshot = this._blockToSnapshot(model);
+
+      if (!snapshot) {
+        return;
+      }
+
       BlockSnapshotSchema.parse(snapshot);
 
       return snapshot;
@@ -354,24 +361,28 @@ export class Transformer {
         docCRUD: this._docCRUD,
         assetsManager: this._assetsManager,
         adapterConfigs: this._adapterConfigs,
+        transformerConfigs: this._transformerConfigs,
       });
     });
   }
 
-  private _blockToSnapshot(model: DraftModel): BlockSnapshot {
+  private _blockToSnapshot(model: DraftModel): BlockSnapshot | null {
     this._slots.beforeExport.emit({
       type: 'block',
       model,
     });
+
     const schema = this._getSchema(model.flavour);
     const transformer = this._getTransformer(schema);
     const snapshotLeaf = transformer.toSnapshot({
       model,
       assets: this._assetsManager,
     });
-    const children = model.children.map(child => {
-      return this._blockToSnapshot(child);
-    });
+    const children = model.children
+      .map(child => {
+        return this._blockToSnapshot(child);
+      })
+      .filter(Boolean) as BlockSnapshot[];
     const snapshot: BlockSnapshot = {
       type: 'block',
       ...snapshotLeaf,
@@ -489,7 +500,10 @@ export class Transformer {
   }
 
   private _getTransformer(schema: BlockSchemaType) {
-    return schema.transformer?.() ?? new BaseBlockTransformer();
+    return (
+      schema.transformer?.(this._transformerConfigs) ??
+      new BaseBlockTransformer(this._transformerConfigs)
+    );
   }
 
   private async _insertBlockTree(