@codingame/monaco-vscode-image-resize-service-override 20.0.0

package/index.d.ts

@@ -0,0 +1,2 @@
+import { type IEditorOverrideServices } from "@codingame/monaco-vscode-api/vscode/vs/editor/standalone/browser/standaloneServices";
+export default function getServiceOverride(): IEditorOverrideServices;

package/index.js

@@ -0,0 +1,13 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/editor/standalone/browser/standaloneServices';
+import { ImageResizeService } from './vscode/src/vs/platform/imageResize/browser/imageResizeService.js';
+import { IImageResizeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/imageResize/common/imageResizeService.service';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+
+function getServiceOverride() {
+    return {
+        [IImageResizeService.toString()]: new SyncDescriptor(ImageResizeService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@codingame/monaco-vscode-image-resize-service-override",
+  "version": "20.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - image-resize service-override",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-api": "20.0.0"
+  },
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./vscode/*.css": {
+      "default": "./vscode/src/*.css"
+    },
+    "./vscode/*": {
+      "types": "./vscode/src/*.d.ts",
+      "default": "./vscode/src/*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vscode/*": [
+        "./vscode/src/*.d.ts"
+      ]
+    }
+  }
+}

package/vscode/src/vs/platform/imageResize/browser/imageResizeService.d.ts

@@ -0,0 +1,14 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IImageResizeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/imageResize/common/imageResizeService.service";
+export declare class ImageResizeService implements IImageResizeService {
+    readonly _serviceBrand: undefined;
+    resizeImage(data: Uint8Array | string, mimeType?: string): Promise<Uint8Array>;
+    convertStringToUInt8Array(data: string): Uint8Array;
+    convertUint8ArrayToString(data: Uint8Array): string;
+    isValidBase64(str: string): boolean;
+    createFileForMedia(fileService: IFileService, imagesFolder: URI, dataTransfer: Uint8Array, mimeType: string): Promise<URI | undefined>;
+    cleanupOldImages(fileService: IFileService, logService: ILogService, imagesFolder: URI): Promise<void>;
+    getTimestampFromFilename(filename: string): number | undefined;
+}

package/vscode/src/vs/platform/imageResize/browser/imageResizeService.js

@@ -0,0 +1,135 @@
+
+import { createElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { decodeBase64, VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+class ImageResizeService {
+    async resizeImage(data, mimeType) {
+        const isGif = mimeType === 'image/gif';
+        if (typeof data === 'string') {
+            data = this.convertStringToUInt8Array(data);
+        }
+        return ( new Promise((resolve, reject) => {
+            const blob = ( new Blob([data], { type: mimeType }));
+            const img = ( new Image());
+            const url = URL.createObjectURL(blob);
+            img.src = url;
+            img.onload = () => {
+                URL.revokeObjectURL(url);
+                let { width, height } = img;
+                if ((width <= 768 || height <= 768) && !isGif) {
+                    resolve(data);
+                    return;
+                }
+                if (width > 2048 || height > 2048) {
+                    const scaleFactor = 2048 / Math.max(width, height);
+                    width = Math.round(width * scaleFactor);
+                    height = Math.round(height * scaleFactor);
+                }
+                const scaleFactor = 768 / Math.min(width, height);
+                width = Math.round(width * scaleFactor);
+                height = Math.round(height * scaleFactor);
+                const canvas = createElement('canvas');
+                canvas.width = width;
+                canvas.height = height;
+                const ctx = canvas.getContext('2d');
+                if (ctx) {
+                    ctx.drawImage(img, 0, 0, width, height);
+                    const jpegTypes = ['image/jpeg', 'image/jpg'];
+                    const outputMimeType = mimeType && jpegTypes.includes(mimeType) ? 'image/jpeg' : 'image/png';
+                    canvas.toBlob(blob => {
+                        if (blob) {
+                            const reader = ( new FileReader());
+                            reader.onload = () => {
+                                resolve(( new Uint8Array(reader.result)));
+                            };
+                            reader.onerror = (error) => reject(error);
+                            reader.readAsArrayBuffer(blob);
+                        }
+                        else {
+                            reject(( new Error('Failed to create blob from canvas')));
+                        }
+                    }, outputMimeType);
+                }
+                else {
+                    reject(( new Error('Failed to get canvas context')));
+                }
+            };
+            img.onerror = (error) => {
+                URL.revokeObjectURL(url);
+                reject(error);
+            };
+        }));
+    }
+    convertStringToUInt8Array(data) {
+        const base64Data = data.includes(',') ? data.split(',')[1] : data;
+        if (this.isValidBase64(base64Data)) {
+            return decodeBase64(base64Data).buffer;
+        }
+        return ( new TextEncoder()).encode(data);
+    }
+    convertUint8ArrayToString(data) {
+        try {
+            const decoder = ( new TextDecoder());
+            const decodedString = decoder.decode(data);
+            return decodedString;
+        }
+        catch {
+            return '';
+        }
+    }
+    isValidBase64(str) {
+        try {
+            decodeBase64(str);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async createFileForMedia(fileService, imagesFolder, dataTransfer, mimeType) {
+        const exists = await fileService.exists(imagesFolder);
+        if (!exists) {
+            await fileService.createFolder(imagesFolder);
+        }
+        const ext = mimeType.split('/')[1] || 'png';
+        const filename = `image-${Date.now()}.${ext}`;
+        const fileUri = joinPath(imagesFolder, filename);
+        const buffer = VSBuffer.wrap(dataTransfer);
+        await fileService.writeFile(fileUri, buffer);
+        return fileUri;
+    }
+    async cleanupOldImages(fileService, logService, imagesFolder) {
+        const exists = await fileService.exists(imagesFolder);
+        if (!exists) {
+            return;
+        }
+        const duration = 7 * 24 * 60 * 60 * 1000;
+        const files = await fileService.resolve(imagesFolder);
+        if (!files.children) {
+            return;
+        }
+        await Promise.all(( files.children.map(async (file) => {
+            try {
+                const timestamp = this.getTimestampFromFilename(file.name);
+                if (timestamp && (Date.now() - timestamp > duration)) {
+                    await fileService.del(file.resource);
+                }
+            }
+            catch (err) {
+                logService.error('Failed to clean up old images', err);
+            }
+        })));
+    }
+    getTimestampFromFilename(filename) {
+        const match = filename.match(/image-(\d+)\./);
+        if (match) {
+            return parseInt(match[1], 10);
+        }
+        return undefined;
+    }
+}
+
+export { ImageResizeService };