blocksuite/affine/widgets/linked-doc/src/transformers/google-keep.ts (3)

802-803: toHtml is declared async but never uses await.

The function body is entirely synchronous. Dropping async and returning string directly avoids an unnecessary microtask tick on every call.

Suggested fix

-async function toHtml(
+function toHtml(
   note: GoogleKeepNote,
   fallbackTitle: string
-): Promise<string> {
+): string {

Then at the call site (line 928):

-    const html = await toHtml(note, fallbackTitle);
+    const html = toHtml(note, fallbackTitle);

---

880-895: Zip entries are iterated twice — can be consolidated into a single pass.

The first loop (lines 880-884) collects JSON candidates, and the second loop (lines 893-895) builds the full file map. Both iterate the same unzip entries and can be merged.

Suggested consolidation

-  const candidates: Array<{ path: string; content: Blob }> = [];
-
-  for (const entry of unzip) {
-    if (entry.path.toLowerCase().endsWith('.json')) {
-      candidates.push({ path: entry.path, content: entry.content });
-    }
-  }
-
-  const notesToImport: Array<{
-    note: GoogleKeepNote;
-    fallbackTitle: string;
-    notePath: string;
-  }> = [];
-  const allFiles = new Map<string, Blob>();
-
-  for (const entry of unzip) {
-    allFiles.set(normalizePath(entry.path), entry.content);
-  }
+  const candidates: Array<{ path: string; content: Blob }> = [];
+  const allFiles = new Map<string, Blob>();
+
+  for (const entry of unzip) {
+    allFiles.set(normalizePath(entry.path), entry.content);
+    if (entry.path.toLowerCase().endsWith('.json')) {
+      candidates.push({ path: entry.path, content: entry.content });
+    }
+  }
+
+  const notesToImport: Array<{
+    note: GoogleKeepNote;
+    fallbackTitle: string;
+    notePath: string;
+  }> = [];

---

927-968: Notes are processed sequentially — acceptable for import but consider error resilience.

If a single note fails mid-import (e.g., HtmlTransformer.importHTMLToDoc throws), the entire remaining batch is skipped. Consider wrapping the per-note logic in a try/catch to continue importing the remaining notes and report failures.

Suggested resilience improvement

   for (const { note, fallbackTitle, notePath } of notesToImport) {
+    try {
       const html = await toHtml(note, fallbackTitle);
       // ... existing body ...
       docIds.push(docId);
       importedDocs += 1;
       onProgress?.({ totalDocs: notesToImport.length, importedDocs });
     }
+    } catch (error) {
+      console.error(`Failed to import note "${fallbackTitle}":`, error);
+      importedDocs += 1;
+      onProgress?.({ totalDocs: notesToImport.length, importedDocs });
+    }
   }

blocksuite/affine/widgets/linked-doc/src/transformers/google-keep.ts (1)

343-346: Deduplicate path candidates when baseDir is empty.

When the note JSON resides at the archive root, baseDir is '' and both candidates are identical, causing a redundant second Map.get for the same key.

♻️ Proposed fix

-  const candidates = [
-    normalizedFilePath,
-    baseDir ? `${baseDir}/${normalizedFilePath}` : normalizedFilePath,
-  ];
+  const candidates = baseDir
+    ? [normalizedFilePath, `${baseDir}/${normalizedFilePath}`]
+    : [normalizedFilePath];

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@blocksuite/affine/widgets/linked-doc/src/transformers/google-keep.ts` around
lines 343 - 346, The candidates array currently contains duplicate entries when
baseDir is an empty string, causing redundant lookups; update the logic that
builds candidates (the const candidates = [...] block using normalizedFilePath
and baseDir) to only include the second entry when baseDir is non-empty/truthy
(or otherwise deduplicate entries e.g., filter unique values) so that Map.get is
not called twice for the same key.

blocksuite/affine/widgets/linked-doc/src/transformers/google-keep.ts (2)

542-571: resolveKeepAttachments is async with no await expressions.

Every operation in the body is synchronous — resolveAttachmentBlob, toFileName, and the MIME-type derivation are all pure. Removing async makes the caller's dependency on Promise resolution explicit and avoids misleading readers about its asynchrony.

♻️ Proposed refactor

-async function resolveKeepAttachments(
+function resolveKeepAttachments(
   note: GoogleKeepNote,
   notePath: string,
   files: Map<string, Blob>
-): Promise<ResolvedKeepAttachment[]> {
+): ResolvedKeepAttachment[] {

The call site at line 911 (await resolveKeepAttachments(...)) still compiles correctly once the return type changes; the await becomes a no-op on a non-Promise value, so no other change is required.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@blocksuite/affine/widgets/linked-doc/src/transformers/google-keep.ts` around
lines 542 - 571, The function resolveKeepAttachments is marked async but
contains no awaits; remove the async keyword and change its return type from
Promise<ResolvedKeepAttachment[]> to ResolvedKeepAttachment[] so it returns a
plain array; keep the internal logic as-is (calls to resolveAttachmentBlob,
toFileName, and mimeType derivation remain unchanged); you can leave callers
that currently do "await resolveKeepAttachments(...)" unchanged since awaiting a
non-Promise is a no-op.

---

491-532: Consider upstreaming the createImageBitmap path to the shared utility.

A readImageSize function already exists in blocksuite/affine/shared/src/utils/image.ts. The local implementation in google-keep.ts is genuinely superior (adds createImageBitmap primary path for better performance, avoids unnecessary DOMPurify.sanitize on blob URLs, uses proper try/finally for URL revocation, and returns a non-zero fallback size). This duplication means future improvements must be applied in both places.

To consolidate, consider upstreaming the createImageBitmap path and improved error handling into the shared utility, then import from there instead. The non-zero fallback value ({260, 180}) is specific to Keep attachment layouts and would need design consideration for the shared API.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@blocksuite/affine/widgets/linked-doc/src/transformers/google-keep.ts` around
lines 491 - 532, The local readImageSize implementation duplicates and improves
the shared utility; refactor by merging the createImageBitmap-first logic,
try/finally URL.revokeObjectURL usage, and non-zero fallback behavior into the
shared readImageSize utility so callers (including the google-keep transformer)
import the single implementation; update the shared function to accept an
optional fallback size or remove the KEEP_ATTACHMENTS_COLUMN_WIDTH-specific
constant from the shared module and have the google-keep caller apply its {
width: KEEP_ATTACHMENTS_COLUMN_WIDTH, height: 180 } fallback after importing the
unified readImageSize, ensuring references to createImageBitmap, readImageSize,
and KEEP_ATTACHMENTS_COLUMN_WIDTH are preserved and tested.

blocksuite/affine/widgets/linked-doc/src/transformers/google-keep.ts (1)

595-623: Isolate image-attachment failures so one bad file doesn’t drop the whole batch.

Promise.all rejects the entire image prep if any attachment fails. Consider per-attachment error handling (or Promise.allSettled) so successful images still import.

♻️ Suggested refactor (best-effort per attachment)

-      const preparedImages = await Promise.all(
-        imageAttachments.map(async attachment => {
-          const blobWithType = new File(
-            [attachment.blob],
-            attachment.fileName,
-            {
-              type: attachment.mimeType,
-            }
-          );
-          const [sourceId, naturalSize] = await Promise.all([
-            store.blobSync.set(blobWithType),
-            // Use the typed File for size detection; raw zip blobs can miss MIME type.
-            readImageSize(blobWithType, {
-              width: KEEP_ATTACHMENTS_COLUMN_WIDTH,
-              height: 180,
-            }),
-          ]);
-
-          return {
-            sourceId,
-            naturalWidth: Math.max(1, naturalSize.width),
-            naturalHeight: Math.max(1, naturalSize.height),
-          };
-        })
-      );
+      const preparedImages = (
+        await Promise.all(
+          imageAttachments.map(async attachment => {
+            try {
+              const blobWithType = new File(
+                [attachment.blob],
+                attachment.fileName,
+                {
+                  type: attachment.mimeType,
+                }
+              );
+              const [sourceId, naturalSize] = await Promise.all([
+                store.blobSync.set(blobWithType),
+                // Use the typed File for size detection; raw zip blobs can miss MIME type.
+                readImageSize(blobWithType, {
+                  width: KEEP_ATTACHMENTS_COLUMN_WIDTH,
+                  height: 180,
+                }),
+              ]);
+
+              return {
+                sourceId,
+                naturalWidth: Math.max(1, naturalSize.width),
+                naturalHeight: Math.max(1, naturalSize.height),
+              };
+            } catch (error) {
+              console.warn(
+                '[GoogleKeepTransformer] Failed to prepare image attachment:',
+                attachment.fileName,
+                error
+              );
+              return null;
+            }
+          })
+        )
+      ).filter(
+        (image): image is { sourceId: string; naturalWidth: number; naturalHeight: number } =>
+          Boolean(image)
+      );

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@blocksuite/affine/widgets/linked-doc/src/transformers/google-keep.ts` around
lines 595 - 623, The image preparation uses Promise.all over imageAttachments so
a single bad file rejects the whole batch; change to per-attachment error
isolation by mapping attachments to individual promises that catch their own
errors (or use Promise.allSettled on the mapped promises) and then filter out
failures before using preparedImages. Locate the block around
imageAttachments.map in google-keep.ts (functions/identifiers:
ensureSurfaceModel, getAttachmentsAnchorFromNote, store.blobSync.set,
readImageSize, KEEP_ATTACHMENTS_COLUMN_WIDTH, preparedImages) and update the
logic to either wrap the inner async work for each attachment in try/catch and
return null/error marker, or use Promise.allSettled and keep only settled
results with status "fulfilled" before proceeding so one bad attachment does not
drop the whole batch.

blocksuite/affine/widgets/linked-doc/src/transformers/google-keep.ts (1)

525-759: Make attachment import best‑effort per file.
A single failed image (Promise.all) or file attachment currently aborts all remaining attachments for that note. Consider isolating failures so the rest still import.

♻️ Possible direction (images)

-      const preparedImages = await Promise.all(
-        imageAttachments.map(async attachment => {
+      const preparedImages = (
+        await Promise.allSettled(
+          imageAttachments.map(async attachment => {
             const blobWithType = new File(
               [attachment.blob],
               attachment.fileName,
               {
                 type: attachment.mimeType,
               }
             );
             const [sourceId, naturalSize] = await Promise.all([
               store.blobSync.set(blobWithType),
               readImageSize(blobWithType, {
                 width: KEEP_ATTACHMENTS_COLUMN_WIDTH,
                 height: 180,
               }),
             ]);
             return {
               sourceId,
               naturalWidth: Math.max(1, naturalSize.width),
               naturalHeight: Math.max(1, naturalSize.height),
             };
-        })
-      );
+          })
+        )
+      )
+        .filter(
+          (result): result is PromiseFulfilledResult<{
+            sourceId: string;
+            naturalWidth: number;
+            naturalHeight: number;
+          }> => result.status === 'fulfilled'
+        )
+        .map(result => result.value);

Also consider per‑file try/catch in the non‑image loop so one bad file doesn’t drop the rest.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@blocksuite/affine/widgets/linked-doc/src/transformers/google-keep.ts` around
lines 525 - 759, The image and file attachment import currently uses Promise.all
for preparedImages and has no error handling in the file loop, so one failure
aborts all attachments; update appendAttachmentBlocksToDoc to handle failures
per-file: replace the Promise.all(imageAttachments.map(...)) with either
Promise.allSettled or individual try/catch per image (referencing
imageAttachments, preparedImages, readImageSize, store.blobSync.set) and only
keep fulfilled results, and wrap the non-image loop body (creation of File,
await store.blobSync.set, and store.addBlock for 'affine:attachment') in a
try/catch that logs/skips failed files so one bad file doesn't stop the rest.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Disabled knowledge base sources:

• Linear integration is disabled

You can enable these sources in your CodeRabbit configuration.