feat(editor): add provider for base adapter (#11169)

blocksuite/affine/shared/src/adapters/attachment.ts

@@ -131,8 +131,8 @@ export const AttachmentAdapterFactoryIdentifier =
 
 export const AttachmentAdapterFactoryExtension: ExtensionType = {
   setup: di => {
-    di.addImpl(AttachmentAdapterFactoryIdentifier, () => ({
-      get: (job: Transformer) => new AttachmentAdapter(job),
+    di.addImpl(AttachmentAdapterFactoryIdentifier, provider => ({
+      get: (job: Transformer) => new AttachmentAdapter(job, provider),
     }));
   },
 };

blocksuite/affine/shared/src/adapters/clipboard/clipboard.ts

@@ -0,0 +1,107 @@
+import { BlockSuiteError, ErrorCode } from '@blocksuite/global/exceptions';
+import type {
+  BlockSnapshot,
+  DocSnapshot,
+  FromBlockSnapshotPayload,
+  FromBlockSnapshotResult,
+  FromDocSnapshotPayload,
+  FromDocSnapshotResult,
+  FromSliceSnapshotPayload,
+  FromSliceSnapshotResult,
+  SliceSnapshot,
+  ToBlockSnapshotPayload,
+  ToDocSnapshotPayload,
+  ToSliceSnapshotPayload,
+} from '@blocksuite/store';
+import { BaseAdapter } from '@blocksuite/store';
+
+import { NotificationProvider } from '../../services/notification-service.js';
+import { decodeClipboardBlobs, encodeClipboardBlobs } from './utils.js';
+
+export type FileSnapshot = {
+  name: string;
+  type: string;
+  content: string;
+};
+
+export class ClipboardAdapter extends BaseAdapter<string> {
+  static MIME = 'BLOCKSUITE/SNAPSHOT';
+
+  private readonly _onError = (message: string) => {
+    const notification = this.provider.getOptional(NotificationProvider);
+    if (!notification) return;
+
+    notification.toast(message);
+  };
+
+  override fromBlockSnapshot(
+    _payload: FromBlockSnapshotPayload
+  ): Promise<FromBlockSnapshotResult<string>> {
+    throw new BlockSuiteError(
+      ErrorCode.TransformerNotImplementedError,
+      'ClipboardAdapter.fromBlockSnapshot is not implemented'
+    );
+  }
+
+  override fromDocSnapshot(
+    _payload: FromDocSnapshotPayload
+  ): Promise<FromDocSnapshotResult<string>> {
+    throw new BlockSuiteError(
+      ErrorCode.TransformerNotImplementedError,
+      'ClipboardAdapter.fromDocSnapshot is not implemented'
+    );
+  }
+
+  override async fromSliceSnapshot(
+    payload: FromSliceSnapshotPayload
+  ): Promise<FromSliceSnapshotResult<string>> {
+    const snapshot = payload.snapshot;
+    const assets = payload.assets;
+    if (!assets) {
+      throw new BlockSuiteError(
+        ErrorCode.ValueNotExists,
+        'ClipboardAdapter.fromSliceSnapshot: assets is not found'
+      );
+    }
+    const map = assets.getAssets();
+    const blobs: Record<string, FileSnapshot> = await encodeClipboardBlobs(
+      map,
+      this._onError
+    );
+    return {
+      file: JSON.stringify({
+        snapshot,
+        blobs,
+      }),
+      assetsIds: [],
+    };
+  }
+
+  override toBlockSnapshot(
+    _payload: ToBlockSnapshotPayload<string>
+  ): Promise<BlockSnapshot> {
+    throw new BlockSuiteError(
+      ErrorCode.TransformerNotImplementedError,
+      'ClipboardAdapter.toBlockSnapshot is not implemented'
+    );
+  }
+
+  override toDocSnapshot(
+    _payload: ToDocSnapshotPayload<string>
+  ): Promise<DocSnapshot> {
+    throw new BlockSuiteError(
+      ErrorCode.TransformerNotImplementedError,
+      'ClipboardAdapter.toDocSnapshot is not implemented'
+    );
+  }
+
+  override toSliceSnapshot(
+    payload: ToSliceSnapshotPayload<string>
+  ): Promise<SliceSnapshot> {
+    const json = JSON.parse(payload.file);
+    const { blobs, snapshot } = json;
+    const map = payload.assets?.getAssets();
+    decodeClipboardBlobs(blobs, map);
+    return Promise.resolve(snapshot);
+  }
+}

blocksuite/affine/shared/src/adapters/clipboard/index.ts

@@ -0,0 +1,2 @@
+export * from './clipboard';
+export * from './utils';

blocksuite/affine/shared/src/adapters/clipboard/utils.ts

@@ -0,0 +1,117 @@
+import type { FileSnapshot } from './clipboard.js';
+
+const chars =
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+// Use a lookup table to find the index.
+const lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
+for (let i = 0; i < chars.length; i++) {
+  lookup[chars.charCodeAt(i)] = i;
+}
+
+export const encode = (arraybuffer: ArrayBuffer): string => {
+  const bytes = new Uint8Array(arraybuffer);
+  const len = bytes.length;
+  let i,
+    base64 = '';
+
+  for (i = 0; i < len; i += 3) {
+    base64 += chars[bytes[i] >> 2];
+    base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
+    base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
+    base64 += chars[bytes[i + 2] & 63];
+  }
+
+  if (len % 3 === 2) {
+    base64 = base64.substring(0, base64.length - 1) + '=';
+  } else if (len % 3 === 1) {
+    base64 = base64.substring(0, base64.length - 2) + '==';
+  }
+
+  return base64;
+};
+
+export const decode = (base64: string): ArrayBuffer => {
+  const len = base64.length;
+  let bufferLength = base64.length * 0.75,
+    i,
+    p = 0,
+    encoded1,
+    encoded2,
+    encoded3,
+    encoded4;
+
+  if (base64[base64.length - 1] === '=') {
+    bufferLength--;
+    if (base64[base64.length - 2] === '=') {
+      bufferLength--;
+    }
+  }
+
+  const arraybuffer = new ArrayBuffer(bufferLength),
+    bytes = new Uint8Array(arraybuffer);
+
+  for (i = 0; i < len; i += 4) {
+    encoded1 = lookup[base64.charCodeAt(i)];
+    encoded2 = lookup[base64.charCodeAt(i + 1)];
+    encoded3 = lookup[base64.charCodeAt(i + 2)];
+    encoded4 = lookup[base64.charCodeAt(i + 3)];
+
+    bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
+    bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+    bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+  }
+
+  return arraybuffer;
+};
+
+export async function encodeClipboardBlobs(
+  map: Map<string, Blob>,
+  onError?: (message: string) => void
+) {
+  const blobs: Record<string, FileSnapshot> = {};
+  let sumSize = 0;
+  await Promise.all(
+    Array.from(map.entries()).map(async ([id, blob]) => {
+      if (blob.size > 4 * 1024 * 1024) {
+        onError?.((blob as File).name ?? 'File' + ' is too large to be copied');
+        return;
+      }
+      sumSize += blob.size;
+      if (sumSize > 6 * 1024 * 1024) {
+        onError?.(
+          (blob as File).name ??
+            'File' + ' cannot be copied due to the clipboard size limit'
+        );
+        return;
+      }
+      const content = encode(await blob.arrayBuffer());
+      const file: FileSnapshot = {
+        name: (blob as File).name,
+        type: blob.type,
+        content,
+      };
+      blobs[id] = file;
+    })
+  );
+  return blobs;
+}
+
+export function decodeClipboardBlobs(
+  blobs: Record<string, FileSnapshot>,
+  map: Map<string, Blob> | undefined
+) {
+  if (!map) {
+    console.error(
+      `Trying to decode clipboard blobs, but the map is not found.`
+    );
+    return;
+  }
+  Object.entries<FileSnapshot>(blobs).forEach(([sourceId, file]) => {
+    const blob = new Blob([decode(file.content)]);
+    const f = new File([blob], file.name, {
+      type: file.type,
+    });
+    map.set(sourceId, f);
+  });
+}

blocksuite/affine/shared/src/adapters/html/html.ts

@@ -174,11 +174,8 @@ export class HtmlAdapter extends BaseAdapter<Html> {
 
   readonly blockMatchers: BlockHtmlAdapterMatcher[];
 
-  constructor(
-    job: Transformer,
-    readonly provider: ServiceProvider
-  ) {
-    super(job);
+  constructor(job: Transformer, provider: ServiceProvider) {
+    super(job, provider);
     const blockMatchers = Array.from(
       provider.getAll(BlockHtmlAdapterMatcherIdentifier).values()
     );

blocksuite/affine/shared/src/adapters/image.ts

@@ -122,8 +122,8 @@ export const ImageAdapterFactoryIdentifier = AdapterFactoryIdentifier('Image');
 
 export const ImageAdapterFactoryExtension: ExtensionType = {
   setup: di => {
-    di.addImpl(ImageAdapterFactoryIdentifier, () => ({
-      get: (job: Transformer) => new ImageAdapter(job),
+    di.addImpl(ImageAdapterFactoryIdentifier, provider => ({
+      get: (job: Transformer) => new ImageAdapter(job, provider),
     }));
   },
 };

blocksuite/affine/shared/src/adapters/index.ts

@@ -1,4 +1,5 @@
 export * from './attachment';
+export * from './clipboard';
 export {
   BlockHtmlAdapterExtension,
   type BlockHtmlAdapterMatcher,

blocksuite/affine/shared/src/adapters/markdown/markdown.ts

@@ -170,11 +170,8 @@ export class MarkdownAdapter extends BaseAdapter<Markdown> {
 
   readonly blockMatchers: BlockMarkdownAdapterMatcher[];
 
-  constructor(
-    job: Transformer,
-    readonly provider: ServiceProvider
-  ) {
-    super(job);
+  constructor(job: Transformer, provider: ServiceProvider) {
+    super(job, provider);
     const blockMatchers = Array.from(
       provider.getAll(BlockMarkdownAdapterMatcherIdentifier).values()
     );

blocksuite/affine/shared/src/adapters/mix-text.ts

@@ -38,7 +38,7 @@ export class MixTextAdapter extends BaseAdapter<MixText> {
   private readonly _markdownAdapter: MarkdownAdapter;
 
   constructor(job: Transformer, provider: ServiceProvider) {
-    super(job);
+    super(job, provider);
     this._markdownAdapter = new MarkdownAdapter(job, provider);
   }
 

blocksuite/affine/shared/src/adapters/notion-html/notion-html.ts

@@ -116,7 +116,7 @@ export class NotionHtmlAdapter extends BaseAdapter<NotionHtml> {
   readonly blockMatchers: BlockNotionHtmlAdapterMatcher[];
 
   constructor(job: Transformer, provider: ServiceProvider) {
-    super(job);
+    super(job, provider);
     const blockMatchers = Array.from(
       provider.getAll(BlockNotionHtmlAdapterMatcherIdentifier).values()
     );

blocksuite/affine/shared/src/adapters/notion-text.ts

@@ -163,8 +163,8 @@ export const NotionTextAdapterFactoryIdentifier =
 
 export const NotionTextAdapterFactoryExtension: ExtensionType = {
   setup: di => {
-    di.addImpl(NotionTextAdapterFactoryIdentifier, () => ({
-      get: (job: Transformer) => new NotionTextAdapter(job),
+    di.addImpl(NotionTextAdapterFactoryIdentifier, provider => ({
+      get: (job: Transformer) => new NotionTextAdapter(job, provider),
     }));
   },
 };

blocksuite/affine/shared/src/adapters/plain-text/plain-text.ts

@@ -49,11 +49,8 @@ export class PlainTextAdapter extends BaseAdapter<PlainText> {
 
   readonly blockMatchers: BlockPlainTextAdapterMatcher[];
 
-  constructor(
-    job: Transformer,
-    readonly provider: ServiceProvider
-  ) {
-    super(job);
+  constructor(job: Transformer, provider: ServiceProvider) {
+    super(job, provider);
     const blockMatchers = Array.from(
       provider.getAll(BlockPlainTextAdapterMatcherIdentifier).values()
     );