@realfavicongenerator/image-adapter-node 0.6.0 → 0.6.3

package/dist/adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/adapter.test.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = require("./adapter");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sharp_1 = __importDefault(require("sharp"));
+describe('NodeImageAdapter', () => {
+    describe('getImageSize', () => {
+        it('should return correct dimensions for a PNG image', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adapter = yield (0, adapter_1.getNodeImageAdapter)();
+            // Read the test image from fixtures
+            const imagePath = path.join(__dirname, '../fixtures/test-image.png');
+            const imageBuffer = fs.readFileSync(imagePath);
+            // Convert to data URL
+            const base64 = imageBuffer.toString('base64');
+            const dataUrl = `data:image/png;base64,${base64}`;
+            // Get image size
+            const size = yield adapter.getImageSize(dataUrl);
+            // Assert dimensions match the test image (100x50)
+            expect(size.width).toBe(100);
+            expect(size.height).toBe(50);
+        }));
+    });
+    describe('convertSvgToPng', () => {
+        it('should convert an SVG to a PNG buffer', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adapter = yield (0, adapter_1.getNodeImageAdapter)();
+            // Create an SVG with a blue rectangle
+            const svg = adapter.createSvg();
+            svg.size(200, 150);
+            svg.rect(200, 150).fill('#0000ff');
+            // Convert to PNG
+            const pngBuffer = yield adapter.convertSvgToPng(svg);
+            // Verify it's a valid PNG buffer
+            expect(Buffer.isBuffer(pngBuffer)).toBe(true);
+            // Verify the PNG has correct dimensions using sharp
+            const metadata = yield (0, sharp_1.default)(pngBuffer).metadata();
+            expect(metadata.format).toBe('png');
+            expect(metadata.width).toBe(200);
+            expect(metadata.height).toBe(150);
+        }));
+    });
+    describe('getImageData', () => {
+        it('should resize an image and return raw pixel data', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adapter = yield (0, adapter_1.getNodeImageAdapter)();
+            // Read the test image from fixtures
+            const imagePath = path.join(__dirname, '../fixtures/test-image.png');
+            const imageBuffer = fs.readFileSync(imagePath);
+            // Convert to data URL
+            const base64 = imageBuffer.toString('base64');
+            const dataUrl = `data:image/png;base64,${base64}`;
+            // Get raw image data resized to 80x80
+            const rawData = yield adapter.getImageData(dataUrl, 80);
+            // Read the reference image and convert to raw data
+            const referencePath = path.join(__dirname, '../fixtures/test-image-small-square.png');
+            const referenceBuffer = fs.readFileSync(referencePath);
+            const referenceRawData = yield (0, sharp_1.default)(referenceBuffer)
+                .raw()
+                .toBuffer();
+            // Compare the raw data
+            expect(Buffer.isBuffer(rawData)).toBe(true);
+            expect(rawData.length).toBe(referenceRawData.length);
+            expect(rawData.toString('hex')).toBe(referenceRawData.toString('hex'));
+        }));
+    });
+});

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@realfavicongenerator/image-adapter-node",
-  "version": "0.6.0",
+  "version": "0.6.3",
   "description": "Image adapter for Node",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
+    "test": "NODE_OPTIONS='--experimental-vm-modules' jest src",
+    "test:watch": "NODE_OPTIONS='--experimental-vm-modules' jest src --watch",
     "build": "tsc",
     "prepublishOnly": "npm run build"
   },
@@ -26,15 +28,18 @@
   },
   "homepage": "https://github.com/RealFaviconGenerator/core#readme",
   "devDependencies": {
+    "@types/jest": "^29.5.12",
     "@types/node": "^20.11.30",
     "@types/svgdom": "^0.1.2",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
     "typescript": "^5.4.3"
   },
   "dependencies": {
-    "@realfavicongenerator/generate-favicon": "^0.6.0",
+    "@realfavicongenerator/generate-favicon": "^0.6.3",
     "@svgdotjs/svg.js": "^3.2.0",
-    "sharp": "^0.32.6",
+    "sharp": "^0.34.5",
     "svgdom": "^0.1.19"
   },
-  "gitHead": "d10b1a6771c8347267f7d55ead77e99d724ebde3"
+  "gitHead": "362f0e79fa6965a2d9f434a4d6a1809874f2a08c"
 }

package/src/adapter.test.ts

@@ -0,0 +1,79 @@
+import { getNodeImageAdapter } from './adapter';
+import * as fs from 'fs';
+import * as path from 'path';
+import sharp from 'sharp';
+
+describe('NodeImageAdapter', () => {
+  describe('getImageSize', () => {
+    it('should return correct dimensions for a PNG image', async () => {
+      const adapter = await getNodeImageAdapter();
+
+      // Read the test image from fixtures
+      const imagePath = path.join(__dirname, '../fixtures/test-image.png');
+      const imageBuffer = fs.readFileSync(imagePath);
+
+      // Convert to data URL
+      const base64 = imageBuffer.toString('base64');
+      const dataUrl = `data:image/png;base64,${base64}`;
+
+      // Get image size
+      const size = await adapter.getImageSize(dataUrl);
+
+      // Assert dimensions match the test image (100x50)
+      expect(size.width).toBe(100);
+      expect(size.height).toBe(50);
+    });
+  });
+
+  describe('convertSvgToPng', () => {
+    it('should convert an SVG to a PNG buffer', async () => {
+      const adapter = await getNodeImageAdapter();
+
+      // Create an SVG with a blue rectangle
+      const svg = adapter.createSvg();
+      svg.size(200, 150);
+      svg.rect(200, 150).fill('#0000ff');
+
+      // Convert to PNG
+      const pngBuffer = await adapter.convertSvgToPng(svg);
+
+      // Verify it's a valid PNG buffer
+      expect(Buffer.isBuffer(pngBuffer)).toBe(true);
+
+      // Verify the PNG has correct dimensions using sharp
+      const metadata = await sharp(pngBuffer).metadata();
+      expect(metadata.format).toBe('png');
+      expect(metadata.width).toBe(200);
+      expect(metadata.height).toBe(150);
+    });
+  });
+
+  describe('getImageData', () => {
+    it('should resize an image and return raw pixel data', async () => {
+      const adapter = await getNodeImageAdapter();
+
+      // Read the test image from fixtures
+      const imagePath = path.join(__dirname, '../fixtures/test-image.png');
+      const imageBuffer = fs.readFileSync(imagePath);
+
+      // Convert to data URL
+      const base64 = imageBuffer.toString('base64');
+      const dataUrl = `data:image/png;base64,${base64}`;
+
+      // Get raw image data resized to 80x80
+      const rawData = await adapter.getImageData(dataUrl, 80);
+
+      // Read the reference image and convert to raw data
+      const referencePath = path.join(__dirname, '../fixtures/test-image-small-square.png');
+      const referenceBuffer = fs.readFileSync(referencePath);
+      const referenceRawData = await sharp(referenceBuffer)
+        .raw()
+        .toBuffer();
+
+      // Compare the raw data
+      expect(Buffer.isBuffer(rawData)).toBe(true);
+      expect(rawData.length).toBe(referenceRawData.length);
+      expect((rawData as Buffer).toString('hex')).toBe(referenceRawData.toString('hex'));
+    });
+  });
+});