feat(image-extract): improvements for image file resolving (#108)

Details of improvements for resolving image file:
- Try decode the file path if not found
- Try resolve the image file in current workspace folders if not found

Author: laggage

src/commands/extract-images.ts

@@ -48,7 +48,7 @@ export const extractImages = async (
             const failedImages = await window.withProgress(
                 { title: '提取图片', location: ProgressLocation.Notification },
                 async progress => {
-                    extractor.onProgress = (idx, images) => {
+                    extractor.progressHook = (idx, images) => {
                         const total = images.length;
                         const image = images[idx];
                         progress.report({
@@ -98,12 +98,13 @@ export const extractImages = async (
                 }
             );
             if (failedImages && failedImages.length > 0) {
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                window.showErrorMessage(
-                    `${failedImages.length}张图片提取失败\n${failedImages
-                        .map(x => [x.symbol, extractor.errors.find(y => y[0] === x.symbol)?.[1] ?? ''].join(': '))
-                        .join('\n')}`
-                );
+                window
+                    .showErrorMessage(
+                        `${failedImages.length}张图片提取失败\n${failedImages
+                            .map(x => [x.symbol, extractor.errors.find(y => y[0] === x.symbol)?.[1] ?? ''].join(': '))
+                            .join('\n')}`
+                    )
+                    .then(undefined, console.warn);
             }
         }
     }

src/services/images-extractor.service.ts

@@ -1,8 +1,10 @@
 import path from 'path';
 import fs from 'fs';
-import { Uri } from 'vscode';
+import { Uri, workspace } from 'vscode';
 import { imageService } from './image.service';
 import { isErrorResponse } from '../models/error-response';
+import { promisify } from 'util';
+import { Stream } from 'stream';
 
 export interface MarkdownImage {
     link: string;
@@ -43,12 +45,15 @@ export class MarkdownImagesExtractor {
     private _status: 'pending' | 'extracting' | 'extracted' = 'pending';
     private _errors: [symbol: string, message: string][] = [];
     private _images: MarkdownImages | null | undefined = null;
+    private readonly _workspaceDirs: string[] | undefined;
 
     constructor(
-        private markdown: string,
-        private filePath: Uri,
-        public onProgress?: (index: number, images: MarkdownImages) => void
-    ) {}
+        private readonly markdown: string,
+        private readonly targetFileUri: Uri,
+        public progressHook?: (index: number, images: MarkdownImages) => void
+    ) {
+        this._workspaceDirs = workspace.workspaceFolders?.map(({ uri: { fsPath } }) => fsPath);
+    }
 
     get status() {
         return this._status;
@@ -63,12 +68,13 @@ export class MarkdownImagesExtractor {
         let idx = 0;
         const result: ReturnType<MarkdownImagesExtractor['extract']> extends Promise<infer U> ? U : never = [];
         for (const image of sourceImages) {
-            this.onProgress?.call(this, idx++, sourceImages);
+            this.progressHook?.call(this, idx++, sourceImages);
             let newImageLink = result.find(x => x[1] != null && x[0].link === image.link)?.[1]?.link;
-            const imageFile = newImageLink ? newImageLink : await this.resolveImageFile(image);
-            if (imageFile !== false) {
+            const imageStream = newImageLink ? newImageLink : await this.resolveImageFile(image);
+            if (imageStream != null) {
                 try {
-                    newImageLink = typeof imageFile === 'string' ? imageFile : await imageService.upload(imageFile);
+                    newImageLink =
+                        typeof imageStream === 'string' ? imageStream : await imageService.upload(imageStream);
                 } catch (ex) {
                     this._errors.push([
                         image.symbol,
@@ -108,29 +114,49 @@ export class MarkdownImagesExtractor {
         ).filter(x => createImageTypeFilter(this.imageType).call(null, x));
     }
 
-    private async resolveImageFile(image: MarkdownImage) {
+    private async resolveImageFile(image: MarkdownImage): Promise<Stream | undefined | null> {
         const { link, symbol, alt, title } = image;
         if (webImageFilter(image)) {
             const imageStream = await imageService.download(link, alt ?? title);
             if (!(imageStream instanceof Array)) {
                 return imageStream;
             } else {
                 this._errors.push([symbol, `无法下载网络图片, ${imageStream[0]} - ${imageStream[2]}`]);
-                return false;
+                return undefined;
             }
         } else {
-            const triedPathed: string[] = [];
-            const createReadStream = (file: string) => {
-                triedPathed.push(file);
-                return fs.existsSync(file) ? fs.createReadStream(file) : false;
-            };
-            let stream = createReadStream(link);
-
-            stream =
-                stream === false ? createReadStream(path.resolve(path.dirname(this.filePath.fsPath), link)) : stream;
-            if (stream === false) this._errors.push([symbol, `本地图片文件不存在(${triedPathed.join(', ')})`]);
-
-            return stream;
+            const checkReadAccess = (filePath: string) =>
+                promisify(fs.access)(filePath).then(
+                    () => true,
+                    () => false
+                );
+
+            let iPath: string | undefined | null = link,
+                iDir = 0,
+                searchingDirs: string[] | undefined | null,
+                triedPath: string[] | undefined,
+                isEncodedPath = false;
+
+            while (iPath != null) {
+                if (await checkReadAccess(iPath)) {
+                    return fs.createReadStream(iPath);
+                } else {
+                    (triedPath ??= []).push(iPath);
+
+                    if (!isEncodedPath) {
+                        iPath = decodeURIComponent(iPath);
+                        isEncodedPath = true;
+                        continue;
+                    }
+                }
+
+                searchingDirs ??= [path.dirname(this.targetFileUri.fsPath), ...(this._workspaceDirs ?? [])];
+                iPath = iDir >= 0 && searchingDirs.length > iDir ? path.resolve(searchingDirs[iDir], link) : undefined;
+                iDir++;
+                isEncodedPath = false;
+            }
+
+            return undefined;
         }
     }
 }