html2canvas-pro 2.0.4 → 2.1.0

package/{dist/lib/core/__tests__/cache-storage.js → src/core/__tests__/cache-storage.ts}

@@ -1,22 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const assert_1 = require("assert");
-const features_1 = require("../features");
-const cache_storage_1 = require("../cache-storage");
-const context_1 = require("../context");
-const bounds_1 = require("../../css/layout/bounds");
-const config_1 = require("../../config");
+import { deepStrictEqual, fail } from 'assert';
+import { FEATURES } from '../features';
+import { CacheStorage } from '../cache-storage';
+import { Context } from '../context';
+import { Bounds } from '../../css/layout/bounds';
+import { Html2CanvasConfig } from '../../config';
+
 const proxy = 'http://example.com/proxy';
-const createMockContext = (origin, opts = {}) => {
+
+const createMockContext = (origin: string, opts = {}) => {
     const mockWindow = {
         location: {
             href: origin
         },
         document: {
-            createElement(_name) {
+            createElement(_name: string) {
                 let _href = '';
                 return {
-                    set href(value) {
+                    set href(value: string) {
                         _href = value;
                     },
                     get href() {
@@ -35,34 +35,56 @@ const createMockContext = (origin, opts = {}) => {
             }
         }
     };
+
     // For backward compatibility, also initialize static CacheStorage
-    cache_storage_1.CacheStorage.setContext(mockWindow);
-    const config = new config_1.Html2CanvasConfig({ window: mockWindow });
-    return new context_1.Context({
-        logging: false,
-        imageTimeout: 0,
-        useCORS: false,
-        allowTaint: false,
-        proxy,
-        ...opts
-    }, new bounds_1.Bounds(0, 0, 0, 0), config);
+    CacheStorage.setContext(mockWindow as Window);
+
+    const config = new Html2CanvasConfig({ window: mockWindow as Window });
+
+    return new Context(
+        {
+            logging: false,
+            imageTimeout: 0,
+            useCORS: false,
+            allowTaint: false,
+            proxy,
+            ...opts
+        },
+        new Bounds(0, 0, 0, 0),
+        config
+    );
 };
-const images = [];
-const xhr = [];
-const sleep = async (timeout) => await new Promise((resolve) => setTimeout(resolve, timeout));
+
+const images: ImageMock[] = [];
+const xhr: XMLHttpRequestMock[] = [];
+const sleep = async (timeout: number) => await new Promise((resolve) => setTimeout(resolve, timeout));
+
 class ImageMock {
+    src?: string;
+    crossOrigin?: string;
+    onload?: () => void;
     constructor() {
         images.push(this);
     }
 }
+
 class XMLHttpRequestMock {
+    sent: boolean;
+    status: number;
+    timeout: number;
+    method?: string;
+    url?: string;
+    response?: string;
+    onload?: () => void;
+    ontimeout?: () => void;
     constructor() {
         this.sent = false;
         this.status = 500;
         this.timeout = 5000;
         xhr.push(this);
     }
-    async load(status, response) {
+
+    async load(status: number, response: string) {
         this.response = response;
         this.status = status;
         if (this.onload) {
@@ -70,7 +92,8 @@ class XMLHttpRequestMock {
         }
         await sleep(0);
     }
-    open(method, url) {
+
+    open(method: string, url: string) {
         this.method = method;
         this.url = url;
     }
@@ -78,25 +101,29 @@ class XMLHttpRequestMock {
         this.sent = true;
     }
 }
+
 Object.defineProperty(global, 'Image', { value: ImageMock, writable: true });
 Object.defineProperty(global, 'XMLHttpRequest', {
     value: XMLHttpRequestMock,
     writable: true
 });
-const setFeatures = (opts = {}) => {
-    const defaults = {
+
+const setFeatures = (opts: { [key: string]: boolean } = {}) => {
+    const defaults: { [key: string]: boolean } = {
         SUPPORT_SVG_DRAWING: true,
         SUPPORT_CORS_IMAGES: true,
         SUPPORT_CORS_XHR: true,
         SUPPORT_RESPONSE_TYPE: false
     };
+
     Object.keys(defaults).forEach((key) => {
-        Object.defineProperty(features_1.FEATURES, key, {
+        Object.defineProperty(FEATURES, key, {
             value: typeof opts[key] === 'boolean' ? opts[key] : defaults[key],
             writable: true
         });
     });
 };
+
 describe('cache-storage', () => {
     beforeEach(() => setFeatures());
     afterEach(() => {
@@ -107,119 +134,145 @@ describe('cache-storage', () => {
         const { cache } = createMockContext('http://example.com', { proxy: null });
         await cache.addImage('http://example.com/test.jpg');
         await cache.addImage('http://example.com/test2.jpg');
-        (0, assert_1.deepStrictEqual)(images.length, 2);
-        (0, assert_1.deepStrictEqual)(images[0].src, 'http://example.com/test.jpg');
-        (0, assert_1.deepStrictEqual)(images[1].src, 'http://example.com/test2.jpg');
+
+        deepStrictEqual(images.length, 2);
+        deepStrictEqual(images[0].src, 'http://example.com/test.jpg');
+        deepStrictEqual(images[1].src, 'http://example.com/test2.jpg');
     });
+
     it('addImage should not add duplicate entries', async () => {
         const { cache } = createMockContext('http://example.com');
         await cache.addImage('http://example.com/test.jpg');
         await cache.addImage('http://example.com/test.jpg');
-        (0, assert_1.deepStrictEqual)(images.length, 1);
-        (0, assert_1.deepStrictEqual)(images[0].src, 'http://example.com/test.jpg');
+
+        deepStrictEqual(images.length, 1);
+        deepStrictEqual(images[0].src, 'http://example.com/test.jpg');
     });
+
     describe('svg', () => {
         it('should add svg images correctly', async () => {
             const { cache } = createMockContext('http://example.com');
             await cache.addImage('http://example.com/test.svg');
             await cache.addImage('http://example.com/test2.svg');
-            (0, assert_1.deepStrictEqual)(images.length, 2);
-            (0, assert_1.deepStrictEqual)(images[0].src, 'http://example.com/test.svg');
-            (0, assert_1.deepStrictEqual)(images[1].src, 'http://example.com/test2.svg');
+
+            deepStrictEqual(images.length, 2);
+            deepStrictEqual(images[0].src, 'http://example.com/test.svg');
+            deepStrictEqual(images[1].src, 'http://example.com/test2.svg');
         });
+
         it('should omit svg images if not supported', async () => {
             setFeatures({ SUPPORT_SVG_DRAWING: false });
             const { cache } = createMockContext('http://example.com');
             await cache.addImage('http://example.com/test.svg');
             await cache.addImage('http://example.com/test2.svg');
-            (0, assert_1.deepStrictEqual)(images.length, 0);
+
+            deepStrictEqual(images.length, 0);
         });
     });
+
     describe('cross-origin', () => {
         it('addImage should not add images it cannot load/render', async () => {
             const { cache } = createMockContext('http://example.com', {
                 proxy: undefined
             });
             await cache.addImage('http://html2canvas.hertzen.com/test.jpg');
-            (0, assert_1.deepStrictEqual)(images.length, 0);
+            deepStrictEqual(images.length, 0);
         });
+
         it('addImage should add images if tainting enabled', async () => {
             const { cache } = createMockContext('http://example.com', {
                 allowTaint: true,
                 proxy: undefined
             });
             await cache.addImage('http://html2canvas.hertzen.com/test.jpg');
-            (0, assert_1.deepStrictEqual)(images.length, 1);
-            (0, assert_1.deepStrictEqual)(images[0].src, 'http://html2canvas.hertzen.com/test.jpg');
-            (0, assert_1.deepStrictEqual)(images[0].crossOrigin, undefined);
+            deepStrictEqual(images.length, 1);
+            deepStrictEqual(images[0].src, 'http://html2canvas.hertzen.com/test.jpg');
+            deepStrictEqual(images[0].crossOrigin, undefined);
         });
+
         it('addImage should add images if cors enabled', async () => {
             const { cache } = createMockContext('http://example.com', { useCORS: true });
             await cache.addImage('http://html2canvas.hertzen.com/test.jpg');
-            (0, assert_1.deepStrictEqual)(images.length, 1);
-            (0, assert_1.deepStrictEqual)(images[0].src, 'http://html2canvas.hertzen.com/test.jpg');
-            (0, assert_1.deepStrictEqual)(images[0].crossOrigin, 'anonymous');
+            deepStrictEqual(images.length, 1);
+            deepStrictEqual(images[0].src, 'http://html2canvas.hertzen.com/test.jpg');
+            deepStrictEqual(images[0].crossOrigin, 'anonymous');
         });
+
         it('addImage should not add images if cors enabled but not supported', async () => {
             setFeatures({ SUPPORT_CORS_IMAGES: false });
+
             const { cache } = createMockContext('http://example.com', {
                 useCORS: true,
                 proxy: undefined
             });
             await cache.addImage('http://html2canvas.hertzen.com/test.jpg');
-            (0, assert_1.deepStrictEqual)(images.length, 0);
+            deepStrictEqual(images.length, 0);
         });
+
         it('addImage should not add images to proxy if cors enabled', async () => {
             const { cache } = createMockContext('http://example.com', { useCORS: true });
             await cache.addImage('http://html2canvas.hertzen.com/test.jpg');
-            (0, assert_1.deepStrictEqual)(images.length, 1);
-            (0, assert_1.deepStrictEqual)(images[0].src, 'http://html2canvas.hertzen.com/test.jpg');
-            (0, assert_1.deepStrictEqual)(images[0].crossOrigin, 'anonymous');
+            deepStrictEqual(images.length, 1);
+            deepStrictEqual(images[0].src, 'http://html2canvas.hertzen.com/test.jpg');
+            deepStrictEqual(images[0].crossOrigin, 'anonymous');
         });
+
         it('addImage should use proxy ', async () => {
             const { cache } = createMockContext('http://example.com');
             await cache.addImage('http://html2canvas.hertzen.com/test.jpg');
-            (0, assert_1.deepStrictEqual)(xhr.length, 1);
-            (0, assert_1.deepStrictEqual)(xhr[0].url, `${proxy}?url=${encodeURIComponent('http://html2canvas.hertzen.com/test.jpg')}&responseType=text`);
+            deepStrictEqual(xhr.length, 1);
+            deepStrictEqual(
+                xhr[0].url,
+                `${proxy}?url=${encodeURIComponent('http://html2canvas.hertzen.com/test.jpg')}&responseType=text`
+            );
             await xhr[0].load(200, '<data response>');
-            (0, assert_1.deepStrictEqual)(images.length, 1);
-            (0, assert_1.deepStrictEqual)(images[0].src, '<data response>');
+
+            deepStrictEqual(images.length, 1);
+            deepStrictEqual(images[0].src, '<data response>');
         });
+
         it('proxy should respect imageTimeout', async () => {
             const { cache } = createMockContext('http://example.com', {
                 imageTimeout: 10
             });
             await cache.addImage('http://html2canvas.hertzen.com/test.jpg');
-            (0, assert_1.deepStrictEqual)(xhr.length, 1);
-            (0, assert_1.deepStrictEqual)(xhr[0].url, `${proxy}?url=${encodeURIComponent('http://html2canvas.hertzen.com/test.jpg')}&responseType=text`);
-            (0, assert_1.deepStrictEqual)(xhr[0].timeout, 10);
+
+            deepStrictEqual(xhr.length, 1);
+            deepStrictEqual(
+                xhr[0].url,
+                `${proxy}?url=${encodeURIComponent('http://html2canvas.hertzen.com/test.jpg')}&responseType=text`
+            );
+            deepStrictEqual(xhr[0].timeout, 10);
             if (xhr[0].ontimeout) {
                 xhr[0].ontimeout();
             }
             try {
                 await cache.match('http://html2canvas.hertzen.com/test.jpg');
-                (0, assert_1.fail)('Expected result to timeout');
-            }
-            catch (e) { }
+                fail('Expected result to timeout');
+            } catch (e) {}
         });
     });
+
     it('match should return cache entry', async () => {
         const { cache } = createMockContext('http://example.com');
         await cache.addImage('http://example.com/test.jpg');
+
         if (images[0].onload) {
             images[0].onload();
         }
+
         const response = await cache.match('http://example.com/test.jpg');
-        (0, assert_1.deepStrictEqual)(response.src, 'http://example.com/test.jpg');
+
+        deepStrictEqual((response as HTMLImageElement).src, 'http://example.com/test.jpg');
     });
+
     it('image should respect imageTimeout', async () => {
         const { cache } = createMockContext('http://example.com', { imageTimeout: 10 });
         cache.addImage('http://example.com/test.jpg');
+
         try {
             await cache.match('http://example.com/test.jpg');
-            (0, assert_1.fail)('Expected result to timeout');
-        }
-        catch (e) { }
+            fail('Expected result to timeout');
+        } catch (e) {}
     });
 });
-//# sourceMappingURL=cache-storage.js.map

package/{dist/lib/core/__tests__/logger.js → src/core/__tests__/logger.ts}

@@ -1,27 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = require("../logger");
+import { Logger } from '../logger';
+
 describe('logger', () => {
-    let infoSpy;
+    let infoSpy: any;
+
     beforeEach(() => {
-        infoSpy = jest.spyOn(console, 'info').mockImplementation(() => {
+        infoSpy = vi.spyOn(console, 'info').mockImplementation(() => {
             // do nothing
         });
     });
+
     afterEach(() => {
         infoSpy.mockRestore();
     });
+
     it('should call console.info when logger enabled', () => {
         const id = Math.random().toString();
-        const logger = new logger_1.Logger({ id, enabled: true });
+        const logger = new Logger({ id, enabled: true });
         logger.info('testing');
         expect(infoSpy).toHaveBeenLastCalledWith(id, expect.stringMatching(/\d+ms/), 'testing');
     });
+
     it("shouldn't call console.info when logger disabled", () => {
         const id = Math.random().toString();
-        const logger = new logger_1.Logger({ id, enabled: false });
+        const logger = new Logger({ id, enabled: false });
         logger.info('testing');
         expect(infoSpy).not.toHaveBeenCalled();
     });
 });
-//# sourceMappingURL=logger.js.map