@blocklet/images 1.16.33-beta-20241107-065332-b20666d2 → 1.16.33-beta-20241111-162739-f5906773

package/lib/logo-validate.d.ts

@@ -1,9 +1,10 @@
+import { ImageType } from 'image-type';
 type ISizeKB = number;
 interface ILogoValidateOptions {
     maxSize?: ISizeKB;
-    width?: number;
-    logoType?: string;
+    minWidth?: number;
+    logoType?: ImageType[];
     extractedFilepath: string;
 }
-export declare const validateLogo: (logoName: string, options: ILogoValidateOptions) => Promise<any[]>;
+export declare const validateLogo: (logoName: string, options: ILogoValidateOptions) => any[];
 export {};

package/lib/logo-validate.js

@@ -6,14 +6,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateLogo = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const get_image_size_1 = require("./get-image-size");
-const validateLogo = async (logoName, options) => {
-    const { extractedFilepath, maxSize = 1024, width = 256, logoType = '.png,.jpg,.jpeg,.webp' } = options;
+const image_size_1 = __importDefault(require("image-size"));
+const image_type_1 = __importDefault(require("image-type"));
+const is_svg_1 = __importDefault(require("is-svg"));
+const ASPECT_RATIO = 1 / 1;
+const ASPECT_RATIO_THRESHOLD = 0.01;
+const validateLogo = (logoName, options) => {
+    const { extractedFilepath, maxSize = 1024, minWidth = 256 } = options;
+    const logoType = options.logoType || ['png', 'jpg', 'webp', 'svg'];
     const logoPath = path_1.default.join(extractedFilepath, logoName);
     const preLogoMessage = `The logo(${logoName})`;
     const errorMessages = [];
     if (!logoName) {
-        errorMessages.push(`The logo field is required in blocklet.yml.`);
+        errorMessages.push('The logo field is required in blocklet.yml.');
         return errorMessages;
     }
     if (!fs_1.default.existsSync(logoPath)) {
@@ -24,14 +29,24 @@ const validateLogo = async (logoName, options) => {
     if (maxSize && logoStats.size > maxSize * 1024) {
         errorMessages.push(`${preLogoMessage} size exceeds ${maxSize} KB, but got ${(logoStats.size / 1024).toFixed(2)} KB.`);
     }
-    await (0, get_image_size_1.getImageSize)(logoPath).then((imageMeta) => {
-        if (!logoType.split(',').includes(path_1.default.extname(logoPath).toLowerCase())) {
+    const isSvgFile = (0, is_svg_1.default)(fs_1.default.readFileSync(logoPath));
+    if (!isSvgFile) {
+        const imgType = (0, image_type_1.default)(fs_1.default.readFileSync(logoPath));
+        if (!imgType || !logoType.includes(imgType.ext)) {
             errorMessages.push(`${preLogoMessage} format is not supported, expected: [${logoType}].`);
         }
-        if (imageMeta.width !== imageMeta.height || imageMeta.width !== width) {
-            errorMessages.push(`${preLogoMessage} just supports ${width}x${width}, but got ${imageMeta.width}x${imageMeta.height}.`);
+        if (`.${imgType?.ext}` !== path_1.default.extname(logoPath)) {
+            errorMessages.push(`${preLogoMessage} extension is not match the real file extension [.${imgType?.ext}].`);
         }
-    });
+        const logoMeta = (0, image_size_1.default)(logoPath);
+        const aspectRatio = logoMeta.width / logoMeta.height;
+        if (logoMeta.width < minWidth || logoMeta.height < minWidth) {
+            errorMessages.push(`${preLogoMessage} minimum size must be ${minWidth}x${minWidth}, but got ${logoMeta.width}x${logoMeta.height}.`);
+        }
+        if (Math.abs(aspectRatio - ASPECT_RATIO) > ASPECT_RATIO_THRESHOLD) {
+            errorMessages.push(`${preLogoMessage} aspect ratio must be approximately 1:1, but got 1:${parseFloat((logoMeta.height / logoMeta.width).toFixed(2))} (${logoMeta.width}x${logoMeta.height}).`);
+        }
+    }
     return errorMessages;
 };
 exports.validateLogo = validateLogo;

package/lib/screenshot-validate.d.ts

@@ -7,5 +7,5 @@ interface IScreenshotValidateOptions {
     minWidth?: number;
     minHeight?: number;
 }
-export declare const validateScreenshots: (screenshots: string[], options: IScreenshotValidateOptions) => Promise<any[]>;
+export declare const validateScreenshots: (screenshots: string[], options: IScreenshotValidateOptions) => any[];
 export {};

package/lib/screenshot-validate.js

@@ -6,11 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateScreenshots = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const get_image_size_1 = require("./get-image-size");
+const image_size_1 = __importDefault(require("image-size"));
+const image_type_1 = __importDefault(require("image-type"));
+const is_svg_1 = __importDefault(require("is-svg"));
 const ordinal_suffix_1 = require("./ordinal-suffix");
-const ASPECT_RATIO_16_10 = 16 / 10;
-const ASPECT_RATIO_THRESHOLD = 0.01;
-const validateScreenshots = async (screenshots, options) => {
+const ASPECT_RATIO = 16 / 9;
+const ASPECT_RATIO_THRESHOLD = 0.05;
+const validateScreenshots = (screenshots, options) => {
     const { extractedFilepath, minCount, maxCount, maxSize, minWidth, minHeight } = options;
     const errorMessages = [];
     const screenshotList = [];
@@ -23,40 +25,46 @@ const validateScreenshots = async (screenshots, options) => {
         }
     });
     if (minCount && screenshotList.length < minCount) {
-        errorMessages.push(`At least ${minCount} screenshots are required, but just got ${screenshotList.length}.`);
+        errorMessages.unshift(`At least ${minCount} screenshots are required, but just got ${screenshotList.length}.`);
     }
-    if (maxCount && screenshotList.length > maxCount) {
-        errorMessages.push(`At most ${maxCount} screenshots are supported, but just got ${screenshotList.length}.`);
+    else if (maxCount && screenshotList.length > maxCount) {
+        errorMessages.unshift(`At most ${maxCount} screenshots are supported, but just got ${screenshotList.length}.`);
     }
     const asyncErrors = {};
-    await Promise.all(screenshotList.map((screenshot, index) => {
+    screenshotList.forEach((screenshot, index) => {
         const screenshotsPath = path_1.default.join(extractedFilepath, 'screenshots', screenshot);
         const preMessage = `The ${(0, ordinal_suffix_1.ordinalSuffix)(index + 1)}[${screenshot}] screenshot`;
         asyncErrors[screenshot] = [];
         if (!fs_1.default.existsSync(screenshotsPath)) {
             asyncErrors[screenshot].push(`${preMessage} file not found.`);
-            return Promise.resolve('');
+            return;
         }
         const screenshotsStats = fs_1.default.statSync(screenshotsPath);
         if (maxSize && screenshotsStats.size > maxSize * 1024 * 1024) {
             asyncErrors[screenshot].push(`${preMessage} size exceeds ${maxSize} MB, but got ${(screenshotsStats.size / 1024 / 1024).toFixed(2)} MB.`);
         }
-        const screenshotsImageType = ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp', '.svg'];
-        if (!screenshotsImageType.includes(path_1.default.extname(screenshotsPath).toLowerCase())) {
-            asyncErrors[screenshot].push(`${preMessage} format is not supported, expected: [${screenshotsImageType.join(', ')}].`);
-        }
-        return (0, get_image_size_1.getImageSize)(screenshotsPath).then((imageMeta) => {
+        const isSvgFile = (0, is_svg_1.default)(fs_1.default.readFileSync(screenshotsPath));
+        if (!isSvgFile) {
+            const imgType = (0, image_type_1.default)(fs_1.default.readFileSync(screenshotsPath));
+            if (!imgType) {
+                asyncErrors[screenshot].push(`${preMessage} is not a valid image file.`);
+                return;
+            }
+            if (`.${imgType.ext}` !== path_1.default.extname(screenshotsPath)) {
+                asyncErrors[screenshot].push(`${preMessage} extension is not match the real file extension [.${imgType.ext}].`);
+            }
+            const imageMeta = (0, image_size_1.default)(screenshotsPath);
             const aspectRatio = imageMeta.width / imageMeta.height;
-            const width = minWidth || (minHeight && minHeight * ASPECT_RATIO_16_10);
-            const height = minHeight || (width && width / ASPECT_RATIO_16_10);
+            const width = minWidth || (minHeight && Math.round(minHeight * ASPECT_RATIO));
+            const height = minHeight || (width && Math.round(width / ASPECT_RATIO));
             if (imageMeta.width < width || imageMeta.height < height) {
                 asyncErrors[screenshot].push(`${preMessage} minimum size must be ${width}x${height}, but got ${imageMeta.width}x${imageMeta.height}.`);
             }
-            if (Math.abs(aspectRatio - ASPECT_RATIO_16_10) > ASPECT_RATIO_THRESHOLD) {
-                asyncErrors[screenshot].push(`${preMessage} aspect ratio must be approximately 16:10, but got 16:${parseFloat((imageMeta.height / (imageMeta.width / 16)).toFixed(2))} (${imageMeta.width}x${imageMeta.height}).`);
+            if (Math.abs(aspectRatio - ASPECT_RATIO) > ASPECT_RATIO_THRESHOLD) {
+                asyncErrors[screenshot].push(`${preMessage} aspect ratio must be approximately 16:9, but got 16:${parseFloat((imageMeta.height / (imageMeta.width / 16)).toFixed(2))} (${imageMeta.width}x${imageMeta.height}).`);
             }
-        });
-    }));
+        }
+    });
     screenshotList.forEach((screenshot) => {
         if (asyncErrors[screenshot].length) {
             errorMessages.push(...asyncErrors[screenshot]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blocklet/images",
-  "version": "1.16.33-beta-20241107-065332-b20666d2",
+  "version": "1.16.33-beta-20241111-162739-f5906773",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "MIT",
@@ -26,13 +26,20 @@
     "url": "git+https://github.com/ArcBlock/blocklet-server.git"
   },
   "scripts": {
+    "verify": "npm run lint:fix && npm run coverage && npm run build",
+    "lint": "eslint src tests",
+    "lint:fix": "npm run lint -- --fix",
+    "coverage": "npm run test -- --coverage",
+    "clean": "rm -fr lib",
     "build:blocklet-images": "tsc",
     "build": "tsc",
     "test": "jest",
     "watch": "nodemon -w src -e ts -x 'npm run build'"
   },
   "dependencies": {
-    "image-size": "^1.0.2"
+    "image-size": "^1.0.2",
+    "image-type": "^4.1.0",
+    "is-svg": "^4.3.2"
   },
   "devDependencies": {
     "@arcblock/eslint-config-ts": "^0.3.3",
@@ -44,5 +51,5 @@
     "ts-node": "^10.9.1",
     "typescript": "^5.6.3"
   },
-  "gitHead": "cfc4d5837f83a0bfd507567915695894dda2c0ec"
+  "gitHead": "de1be92a37cd504e82b3d963b5b4d5302ecbb887"
 }

package/lib/get-image-size.d.ts

@@ -1,6 +0,0 @@
-export declare const getImageSize: (path: string) => Promise<{
-    width: number | undefined;
-    height: number | undefined;
-    orientation?: number;
-    type?: string;
-}>;

package/lib/get-image-size.js

@@ -1,25 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getImageSize = void 0;
-const image_size_1 = __importDefault(require("image-size"));
-const getImageSize = async (path) => {
-    return new Promise((reslove, reject) => {
-        try {
-            (0, image_size_1.default)(path, (e, res) => {
-                if (e) {
-                    reject(e);
-                }
-                else {
-                    reslove(res);
-                }
-            });
-        }
-        catch (error) {
-            reject(error);
-        }
-    });
-};
-exports.getImageSize = getImageSize;