LibSquoosh: add smoke test

.husky/pre-commit

@@ -1 +0,0 @@
-npx lint-staged

cli/src/index.js

@@ -4,7 +4,6 @@ import { program } from 'commander/esm.mjs';
 import JSON5 from 'json5';
 import path from 'path';
 import { promises as fsp } from 'fs';
-import { cpus } from 'os';
 import ora from 'ora';
 import kleur from 'kleur';
 
@@ -76,9 +75,7 @@ async function getInputFiles(paths) {
 
   for (const inputPath of paths) {
     const files = (await fsp.lstat(inputPath)).isDirectory()
-      ? (await fsp.readdir(inputPath, { withFileTypes: true }))
-          .filter((dirent) => dirent.isFile())
-          .map((dirent) => path.join(inputPath, dirent.name))
+      ? (await fsp.readdir(inputPath, {withFileTypes: true})).filter(dirent => dirent.isFile()).map(dirent => path.join(inputPath, dirent.name))
       : [inputPath];
     for (const file of files) {
       try {
@@ -104,7 +101,7 @@ async function getInputFiles(paths) {
 async function processFiles(files) {
   files = await getInputFiles(files);
 
-  const imagePool = new ImagePool(cpus().length);
+  const imagePool = new ImagePool();
 
   const results = new Map();
   const progress = progressTracker(results);
@@ -119,8 +116,7 @@ async function processFiles(files) {
   let decoded = 0;
   let decodedFiles = await Promise.all(
     files.map(async (file) => {
-      const buffer = await fsp.readFile(file);
-      const image = imagePool.ingestImage(buffer);
+      const image = imagePool.ingestImage(file);
       await image.decoded;
       results.set(image, {
         file,
@@ -182,7 +178,7 @@ async function processFiles(files) {
       const outputPath = path.join(
         program.opts().outputDir,
         path.basename(originalFile, path.extname(originalFile)) +
-          program.opts().suffix,
+        program.opts().suffix
       );
       for (const output of Object.values(image.encodedWith)) {
         const outputFile = `${outputPath}.${(await output).extension}`;

lib/data-url-plugin.js

@@ -14,40 +14,28 @@ import { promises as fs } from 'fs';
 
 import { lookup as lookupMime } from 'mime-types';
 
-const prefix = /^data-url(-text)?:/;
+const prefix = 'data-url:';
 
 export default function dataURLPlugin() {
   return {
     name: 'data-url-plugin',
     async resolveId(id, importer) {
-      const match = prefix.exec(id);
-      if (!match) return;
+      if (!id.startsWith(prefix)) return;
       return (
-        match[0] + (await this.resolve(id.slice(match[0].length), importer)).id
+        prefix + (await this.resolve(id.slice(prefix.length), importer)).id
       );
     },
     async load(id) {
-      const match = prefix.exec(id);
-      if (!match) return;
-
-      const isText = !!match[1];
-      const realId = id.slice(match[0].length);
+      if (!id.startsWith(prefix)) return;
+      const realId = id.slice(prefix.length);
       this.addWatchFile(realId);
 
       const source = await fs.readFile(realId);
       const type = lookupMime(realId) || 'text/plain';
 
-      if (isText) {
-        const encodedBody = encodeURIComponent(source.toString('utf8'));
-
-        return `export default ${JSON.stringify(
-          `data:${type};charset=utf-8,${encodedBody}`,
-        )};`;
-      }
-
-      return `export default ${JSON.stringify(
-        `data:${type};base64,${source.toString('base64')}`,
-      )};`;
+      return `export default 'data:${type};base64,${source.toString(
+        'base64',
+      )}';`;
     },
   };
 }

lib/entry-data-plugin.js

@@ -77,9 +77,7 @@ export default function entryDataPlugin() {
             }
 
             return JSON.stringify(
-              getDependencies(chunks, chunk).map((filename) =>
-                fileNameToURL(filename),
-              ),
+              getDependencies(chunks, chunk).map((filename) => fileNameToURL(filename)),
             );
           },
         );

lib/omt.ejs

@@ -28,17 +28,10 @@ if (!self.<%- amdFunctionName %>) {
       <% } else { %>
         new Promise(resolve => {
           if ("document" in self) {
-            const link = document.createElement("link");
-            link.rel = "preload";
-            link.as = "script";
-            link.href = uri;
-            link.onload = () => {
-              const script = document.createElement("script");
-              script.src = uri;
-              script.onload = resolve;
-              document.head.appendChild(script);
-            };
-            document.head.appendChild(link);
+            const script = document.createElement("script");
+            script.src = uri;
+            script.onload = resolve;
+            document.head.appendChild(script);
           } else {
             self.nextDefineUri = uri;
             importScripts(uri);

libsquoosh/README.md

@@ -16,25 +16,21 @@ You can start using the libSquoosh by adding these lines to the top of your JS p
 
 ```js
 import { ImagePool } from '@squoosh/lib';
-import { cpus } from 'os';
-const imagePool = new ImagePool(cpus().length);
+const imagePool = new ImagePool();
 ```
 
-This will create an image pool with an underlying processing pipeline that you can use to ingest and encode images. The ImagePool constructor takes one argument that defines how many parallel operations it is allowed to run at any given time.
-
-:warning: Important! Make sure to only create 1 `ImagePool` when performing parallel image processing. If you create multiple pools, the `ImagePool` can run out of memory and crash. By reusing a single `ImagePool`, you can ensure that the backing worker queue and processing pipeline releases memory prior to processing the next image.
+This will create an image pool with an underlying processing pipeline that you can use to ingest and encode images. The ImagePool constructor takes one argument that defines how many parallel operations it is allowed to run at any given time. By default, this number is set to the amount of CPU cores available in the system it is running on.
 
 ## Ingesting images
 
 You can ingest a new image like so:
 
 ```js
-import fs from 'fs/promises';
-const file = await fs.readFile('./path/to/image.png');
-const image = imagePool.ingestImage(file);
+const imagePath = 'path/to/image.png';
+const image = imagePool.ingestImage(imagePath);
 ```
 
-The `ingestImage` function can accept any [`ArrayBuffer`][arraybuffer] whether that is from `readFile()` or `fetch()`.
+The `ingestImage` function can take anything the node [`readFile`][readfile] function can take, including a buffer and `FileHandle`.
 
 The returned `image` object is a representation of the original image, that you can now preprocess, encode, and extract information about.
 
@@ -43,7 +39,7 @@ The returned `image` object is a representation of the original image, that you
 When an image has been ingested, you can start preprocessing it and encoding it to other formats. This example will resize the image and then encode it to a `.jpg` and `.jxl` image:
 
 ```js
-await image.decoded; //Wait until the image is decoded before running preprocessors.
+await image.decoded; //Wait until the image is decoded before running preprocessors. 
 
 const preprocessOptions = {
   //When both width and height are specified, the image resized to specified size.
@@ -51,7 +47,7 @@ const preprocessOptions = {
     enabled: true,
     width: 100,
     height: 50,
-  },
+  }
   /*
   //When either width or height is specified, the image resized to specified size keeping aspect ratio.
   resize: {
@@ -59,7 +55,7 @@ const preprocessOptions = {
     width: 100,
   }
   */
-};
+}
 await image.preprocess(preprocessOptions);
 
 const encodeOptions = {
@@ -67,8 +63,9 @@ const encodeOptions = {
   jxl: {
     quality: 90,
   },
-};
+}
 await image.encode(encodeOptions);
+
 ```
 
 The default values for each option can be found in the [`codecs.ts`][codecs.ts] file under `defaultEncoderOptions`. Every unspecified value will use the default value specified there. _Better documentation is needed here._
@@ -171,4 +168,4 @@ const encodeOptions: {
 [squoosh]: https://squoosh.app
 [codecs.ts]: https://github.com/GoogleChromeLabs/squoosh/blob/dev/libsquoosh/src/codecs.ts
 [butteraugli]: https://github.com/google/butteraugli
-[arraybuffer]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer
+[readfile]: https://nodejs.org/api/fs.html#fs_fspromises_readfile_path_options

libsquoosh/package.json

@@ -8,7 +8,8 @@
     "/build/*"
   ],
   "scripts": {
-    "build": "rollup -c"
+    "build": "rollup -c",
+    "test": "uvu -r ts-node/register test"
   },
   "keywords": [],
   "author": "Google Chrome Developers <chromium-dev@google.com>",
@@ -34,7 +35,9 @@
     "@types/node": "^15.6.1",
     "rollup": "^2.46.0",
     "rollup-plugin-terser": "^7.0.2",
+    "ts-node": "^10.2.1",
     "typescript": "^4.1.3",
+    "uvu": "^0.5.1",
     "which": "^2.0.2"
   }
 }

libsquoosh/src/codecs.ts

@@ -29,23 +29,14 @@ interface ResizeWithAspectParams {
   target_height: number;
 }
 
-export interface ResizeOptions {
+interface ResizeInstantiateOptions {
   width: number;
   height: number;
-  method: 'triangle' | 'catrom' | 'mitchell' | 'lanczos3';
+  method: string;
   premultiply: boolean;
   linearRGB: boolean;
 }
 
-export interface QuantOptions {
-  numColors: number;
-  dither: number;
-}
-
-export interface RotateOptions {
-  numRotations: number;
-}
-
 declare global {
   // Needed for being able to use ImageData as type in codec types
   type ImageData = import('./image_data.js').default;
@@ -61,7 +52,6 @@ import mozEnc from '../../codecs/mozjpeg/enc/mozjpeg_node_enc.js';
 import mozEncWasm from 'asset-url:../../codecs/mozjpeg/enc/mozjpeg_node_enc.wasm';
 import mozDec from '../../codecs/mozjpeg/dec/mozjpeg_node_dec.js';
 import mozDecWasm from 'asset-url:../../codecs/mozjpeg/dec/mozjpeg_node_dec.wasm';
-import type { EncodeOptions as MozJPEGEncodeOptions } from '../../codecs/mozjpeg/enc/mozjpeg_enc';
 
 // WebP
 import type { WebPModule as WebPEncodeModule } from '../../codecs/webp/enc/webp_enc';
@@ -69,7 +59,6 @@ import webpEnc from '../../codecs/webp/enc/webp_node_enc.js';
 import webpEncWasm from 'asset-url:../../codecs/webp/enc/webp_node_enc.wasm';
 import webpDec from '../../codecs/webp/dec/webp_node_dec.js';
 import webpDecWasm from 'asset-url:../../codecs/webp/dec/webp_node_dec.wasm';
-import type { EncodeOptions as WebPEncodeOptions } from '../../codecs/webp/enc/webp_enc.js';
 
 // AVIF
 import type { AVIFModule as AVIFEncodeModule } from '../../codecs/avif/enc/avif_enc';
@@ -80,7 +69,6 @@ import avifEncMtWorker from 'chunk-url:../../codecs/avif/enc/avif_node_enc_mt.wo
 import avifEncMtWasm from 'asset-url:../../codecs/avif/enc/avif_node_enc_mt.wasm';
 import avifDec from '../../codecs/avif/dec/avif_node_dec.js';
 import avifDecWasm from 'asset-url:../../codecs/avif/dec/avif_node_dec.wasm';
-import type { EncodeOptions as AvifEncodeOptions } from '../../codecs/avif/enc/avif_enc.js';
 
 // JXL
 import type { JXLModule as JXLEncodeModule } from '../../codecs/jxl/enc/jxl_enc';
@@ -88,7 +76,6 @@ import jxlEnc from '../../codecs/jxl/enc/jxl_node_enc.js';
 import jxlEncWasm from 'asset-url:../../codecs/jxl/enc/jxl_node_enc.wasm';
 import jxlDec from '../../codecs/jxl/dec/jxl_node_dec.js';
 import jxlDecWasm from 'asset-url:../../codecs/jxl/dec/jxl_node_dec.wasm';
-import type { EncodeOptions as JxlEncodeOptions } from '../../codecs/jxl/enc/jxl_enc.js';
 
 // WP2
 import type { WP2Module as WP2EncodeModule } from '../../codecs/wp2/enc/wp2_enc';
@@ -96,7 +83,6 @@ import wp2Enc from '../../codecs/wp2/enc/wp2_node_enc.js';
 import wp2EncWasm from 'asset-url:../../codecs/wp2/enc/wp2_node_enc.wasm';
 import wp2Dec from '../../codecs/wp2/dec/wp2_node_dec.js';
 import wp2DecWasm from 'asset-url:../../codecs/wp2/dec/wp2_node_dec.wasm';
-import type { EncodeOptions as WP2EncodeOptions } from '../../codecs/wp2/enc/wp2_enc.js';
 
 // PNG
 import * as pngEncDec from '../../codecs/png/pkg/squoosh_png.js';
@@ -109,9 +95,6 @@ const pngEncDecPromise = pngEncDec.default(
 import * as oxipng from '../../codecs/oxipng/pkg/squoosh_oxipng.js';
 import oxipngWasm from 'asset-url:../../codecs/oxipng/pkg/squoosh_oxipng_bg.wasm';
 const oxipngPromise = oxipng.default(fsp.readFile(pathify(oxipngWasm)));
-interface OxiPngEncodeOptions {
-  level: number;
-}
 
 // Resize
 import * as resize from '../../codecs/resize/pkg/squoosh_resize.js';
@@ -188,7 +171,13 @@ export const preprocessors = {
         buffer: Uint8Array,
         input_width: number,
         input_height: number,
-        { width, height, method, premultiply, linearRGB }: ResizeOptions,
+        {
+          width,
+          height,
+          method,
+          premultiply,
+          linearRGB,
+        }: ResizeInstantiateOptions,
       ) => {
         ({ width, height } = resizeWithAspect({
           input_width,
@@ -229,7 +218,7 @@ export const preprocessors = {
         buffer: Uint8Array,
         width: number,
         height: number,
-        { numColors, dither }: QuantOptions,
+        { numColors, dither }: { numColors: number; dither: number },
       ) =>
         new ImageData(
           imageQuant.quantize(buffer, width, height, numColors, dither),
@@ -250,7 +239,7 @@ export const preprocessors = {
         buffer: Uint8Array,
         width: number,
         height: number,
-        { numRotations }: RotateOptions,
+        { numRotations }: { numRotations: number },
       ) => {
         const degrees = (numRotations * 90) % 360;
         const sameDimensions = degrees == 0 || degrees == 180;
@@ -412,13 +401,13 @@ export const codecs = {
         jxlEncWasm,
       ),
     defaultEncoderOptions: {
-      effort: 1,
+      speed: 4,
       quality: 75,
       progressive: false,
       epf: -1,
+      nearLossless: 0,
       lossyPalette: false,
       decodingSpeedTier: 0,
-      photonNoiseIso: 0,
     },
     autoOptimize: {
       option: 'quality',
@@ -491,12 +480,3 @@ export const codecs = {
     },
   },
 } as const;
-
-export {
-  MozJPEGEncodeOptions,
-  WebPEncodeOptions,
-  AvifEncodeOptions,
-  JxlEncodeOptions,
-  WP2EncodeOptions,
-  OxiPngEncodeOptions,
-};

libsquoosh/src/index.ts

@@ -1,18 +1,8 @@
 import { isMainThread } from 'worker_threads';
+import { cpus } from 'os';
+import { promises as fsp } from 'fs';
 
-import {
-  AvifEncodeOptions,
-  codecs as encoders,
-  JxlEncodeOptions,
-  MozJPEGEncodeOptions,
-  OxiPngEncodeOptions,
-  preprocessors,
-  QuantOptions,
-  ResizeOptions,
-  RotateOptions,
-  WebPEncodeOptions,
-  WP2EncodeOptions,
-} from './codecs.js';
+import { codecs as encoders, preprocessors } from './codecs.js';
 import WorkerPool from './worker_pool.js';
 import { autoOptimize } from './auto-optimizer.js';
 import type ImageData from './image_data';
@@ -20,34 +10,30 @@ import type ImageData from './image_data';
 export { ImagePool, encoders, preprocessors };
 type EncoderKey = keyof typeof encoders;
 type PreprocessorKey = keyof typeof preprocessors;
-
-type PreprocessOptions = {
-  resize?: ResizeOptions;
-  quant?: QuantOptions;
-  rotate?: RotateOptions;
-};
-type EncodeResult = {
-  optionsUsed: object;
-  binary: Uint8Array;
-  extension: string;
-  size: number;
-};
-type EncoderOptions = {
-  mozjpeg?: Partial<MozJPEGEncodeOptions>;
-  webp?: Partial<WebPEncodeOptions>;
-  avif?: Partial<AvifEncodeOptions>;
-  jxl?: Partial<JxlEncodeOptions>;
-  wp2?: Partial<WP2EncodeOptions>;
-  oxipng?: Partial<OxiPngEncodeOptions>;
-};
+type FileLike = Buffer | ArrayBuffer | string | ArrayBufferView;
 
 async function decodeFile({
   file,
 }: {
-  file: ArrayBuffer | ArrayLike<number>;
+  file: FileLike;
 }): Promise<{ bitmap: ImageData; size: number }> {
-  const array = new Uint8Array(file);
-  const firstChunk = array.slice(0, 16);
+  let buffer;
+  if (ArrayBuffer.isView(file)) {
+    buffer = Buffer.from(file.buffer);
+    file = 'Binary blob';
+  } else if (file instanceof ArrayBuffer) {
+    buffer = Buffer.from(file);
+    file = 'Binary blob';
+  } else if ((file as unknown) instanceof Buffer) {
+    // TODO: Check why we need type assertions here.
+    buffer = (file as unknown) as Buffer;
+    file = 'Binary blob';
+  } else if (typeof file === 'string') {
+    buffer = await fsp.readFile(file);
+  } else {
+    throw Error('Unexpected input type');
+  }
+  const firstChunk = buffer.slice(0, 16);
   const firstChunkString = Array.from(firstChunk)
     .map((v) => String.fromCodePoint(v))
     .join('');
@@ -55,14 +41,14 @@ async function decodeFile({
     detectors.some((detector) => detector.exec(firstChunkString)),
   )?.[0] as EncoderKey | undefined;
   if (!key) {
-    throw Error(`File has an unsupported format`);
+    throw Error(`${file} has an unsupported format`);
   }
   const encoder = encoders[key];
   const mod = await encoder.dec();
-  const rgba = mod.decode(array);
+  const rgba = mod.decode(new Uint8Array(buffer));
   return {
     bitmap: rgba,
-    size: array.length,
+    size: buffer.length,
   };
 }
 
@@ -97,7 +83,7 @@ async function encodeImage({
   encConfig: any;
   optimizerButteraugliTarget: number;
   maxOptimizerRounds: number;
-}): Promise<EncodeResult> {
+}) {
   let binary: Uint8Array;
   let optionsUsed = encConfig;
   const encoder = await encoders[encName].enc();
@@ -183,15 +169,12 @@ function handleJob(params: JobMessage) {
  * Represents an ingested image.
  */
 class Image {
-  public file: ArrayBuffer | ArrayLike<number>;
+  public file: FileLike;
   public workerPool: WorkerPool<JobMessage, any>;
   public decoded: Promise<{ bitmap: ImageData }>;
-  public encodedWith: { [key in EncoderKey]?: EncodeResult };
+  public encodedWith: { [key: string]: any };
 
-  constructor(
-    workerPool: WorkerPool<JobMessage, any>,
-    file: ArrayBuffer | ArrayLike<number>,
-  ) {
+  constructor(workerPool: WorkerPool<JobMessage, any>, file: FileLike) {
     this.file = file;
     this.workerPool = workerPool;
     this.decoded = workerPool.dispatchJob({ operation: 'decode', file });
@@ -200,10 +183,10 @@ class Image {
 
   /**
    * Define one or several preprocessors to use on the image.
-   * @param {PreprocessOptions} preprocessOptions - An object with preprocessors to use, and their settings.
+   * @param {object} preprocessOptions - An object with preprocessors to use, and their settings.
    * @returns {Promise<undefined>} - A promise that resolves when all preprocessors have completed their work.
    */
-  async preprocess(preprocessOptions: PreprocessOptions = {}) {
+  async preprocess(preprocessOptions = {}) {
     for (const [name, options] of Object.entries(preprocessOptions)) {
       if (!Object.keys(preprocessors).includes(name)) {
         throw Error(`Invalid preprocessor "${name}"`);
@@ -227,16 +210,17 @@ class Image {
   /**
    * Define one or several encoders to use on the image.
    * @param {object} encodeOptions - An object with encoders to use, and their settings.
-   * @returns {Promise<{ [key in keyof T]: EncodeResult }>} - A promise that resolves when the image has been encoded with all the specified encoders.
+   * @returns {Promise<void>} - A promise that resolves when the image has been encoded with all the specified encoders.
    */
-  async encode<T extends EncoderOptions>(
+  async encode(
     encodeOptions: {
       optimizerButteraugliTarget?: number;
       maxOptimizerRounds?: number;
-    } & T,
-  ): Promise<{ [key in keyof T]: EncodeResult }> {
+    } & {
+      [key in EncoderKey]?: any; // any is okay for now
+    } = {},
+  ): Promise<void> {
     const { bitmap } = await this.decoded;
-    const setEncodedWithPromises = [];
     for (const [name, options] of Object.entries(encodeOptions)) {
       if (!Object.keys(encoders).includes(name)) {
         continue;
@@ -247,26 +231,18 @@ class Image {
         typeof options === 'string'
           ? options
           : Object.assign({}, encRef.defaultEncoderOptions, options);
-      setEncodedWithPromises.push(
-        this.workerPool
-          .dispatchJob({
-            operation: 'encode',
-            bitmap,
-            encName,
-            encConfig,
-            optimizerButteraugliTarget: Number(
-              encodeOptions.optimizerButteraugliTarget ?? 1.4,
-            ),
-            maxOptimizerRounds: Number(encodeOptions.maxOptimizerRounds ?? 6),
-          })
-          .then((encodeResult) => {
-            this.encodedWith[encName] = encodeResult;
-          }),
-      );
+      this.encodedWith[encName] = this.workerPool.dispatchJob({
+        operation: 'encode',
+        bitmap,
+        encName,
+        encConfig,
+        optimizerButteraugliTarget: Number(
+          encodeOptions.optimizerButteraugliTarget ?? 1.4,
+        ),
+        maxOptimizerRounds: Number(encodeOptions.maxOptimizerRounds ?? 6),
+      });
     }
-
-    await Promise.all(setEncodedWithPromises);
-    return this.encodedWith as { [key in keyof T]: EncodeResult };
+    await Promise.all(Object.values(this.encodedWith));
   }
 }
 
@@ -278,19 +254,19 @@ class ImagePool {
 
   /**
    * Create a new pool.
-   * @param {number} [threads] - Number of concurrent image processes to run in the pool.
+   * @param {number} [threads] - Number of concurrent image processes to run in the pool. Defaults to the number of CPU cores in the system.
    */
   constructor(threads: number) {
-    this.workerPool = new WorkerPool(threads, __filename);
+    this.workerPool = new WorkerPool(threads || cpus().length, __filename);
   }
 
   /**
    * Ingest an image into the image pool.
-   * @param {ArrayBuffer | ArrayLike<number>} file - The image that should be ingested and decoded.
+   * @param {FileLike} image - The image or path to the image that should be ingested and decoded.
    * @returns {Image} - A custom class reference to the decoded image.
    */
-  ingestImage(file: ArrayBuffer | ArrayLike<number>): Image {
-    return new Image(this.workerPool, file);
+  ingestImage(image: FileLike): Image {
+    return new Image(this.workerPool, image);
   }
 
   /**

libsquoosh/test/index.test.ts

@@ -0,0 +1,43 @@
+import * as path from 'path';
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { ImagePool } from '..';
+
+let imagePool: ImagePool;
+
+test.after.each(async () => {
+  if (imagePool) {
+    try {
+      await imagePool.close();
+    } catch (e) {}
+  }
+  imagePool = undefined;
+});
+
+test('smoke test', async () => {
+  imagePool = new ImagePool(1);
+
+  const imagePath = path.resolve(__dirname, '../../icon-large-maskable.png');
+  const image = imagePool.ingestImage(imagePath);
+
+  const { bitmap } = await image.decoded;
+  assert.equal(bitmap.width, 1024);
+
+  await image.preprocess({
+    resize: {
+      enabled: true,
+      width: 100,
+    },
+  });
+
+  await image.encode({
+    mozjpeg: {},
+  });
+
+  const { size } = await image.encodedWith.mozjpeg;
+  // resulting image is 1554b
+  assert.ok(size > 500);
+  assert.ok(size < 5000);
+});
+
+test.run();

libsquoosh/tsconfig.json

@@ -5,5 +5,12 @@
     "types": ["node"],
     "allowJs": true
   },
-  "include": ["src/**/*", "../codecs/**/*"]
+  "include": ["src/**/*", "../codecs/**/*"],
+  "ts-node": {
+    "transpileOnly": true,
+    "compilerOptions": {
+      "module": "commonjs"
+    },
+    "include": ["tests/**/*"]
+  }
 }

missing-types.d.ts

@@ -44,11 +44,6 @@ declare module 'data-url:*' {
   export default url;
 }
 
-declare module 'data-url-text:*' {
-  const url: string;
-  export default url;
-}
-
 declare module 'service-worker:*' {
   const url: string;
   export default url;

package.json

@@ -8,8 +8,7 @@
     "debug": "node --inspect-brk node_modules/.bin/rollup -c",
     "dev": "DEV_PORT=\"${DEV_PORT:=5000}\" run-p watch serve",
     "watch": "rollup -cw",
-    "serve": "serve --listen=$DEV_PORT --config ../../../serve.json .tmp/build/static",
-    "prepare": "husky install"
+    "serve": "serve --listen=$DEV_PORT --config ../../../serve.json .tmp/build/static"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^17.0.0",
@@ -17,15 +16,15 @@
     "@rollup/plugin-replace": "^2.3.4",
     "@surma/rollup-plugin-off-main-thread": "^2.2.2",
     "@types/dedent": "^0.7.0",
-    "@types/mime-types": "^2.1.1",
-    "@types/node": "^16.11.1",
+    "@types/mime-types": "^2.1.0",
+    "@types/node": "^14.14.7",
     "@web/rollup-plugin-import-meta-assets": "^1.0.6",
     "comlink": "^4.3.0",
     "cssnano": "^4.1.10",
     "dedent": "^0.7.0",
     "del": "^5.1.0",
     "file-drop-element": "^1.0.1",
-    "husky": "^7.0.2",
+    "husky": "^4.3.0",
     "idb-keyval": "^3.2.0",
     "image-size": "^0.9.3",
     "linkstate": "^2.0.0",
@@ -41,20 +40,24 @@
     "postcss-url": "^8.0.0",
     "preact": "^10.5.5",
     "preact-render-to-string": "^5.1.11",
-    "prettier": "^2.4.1",
+    "prettier": "^2.1.2",
     "rollup": "^2.38.0",
     "rollup-plugin-terser": "^7.0.2",
     "serve": "^11.3.2",
-    "typescript": "^4.4.4",
+    "typescript": "^4.1.3",
     "which": "^2.0.2"
   },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
   "lint-staged": {
     "*.{js,css,json,md,ts,tsx}": "prettier --write",
     "*.{c,h,cpp,hpp}": "clang-format -i",
     "*.rs": "rustfmt"
   },
   "dependencies": {
-    "strict-csp": "^1.0.4",
     "wasm-feature-detect": "^1.2.11"
   }
 }

src/client/initial-app/index.tsx

@@ -37,10 +37,8 @@ main();
   ga('set', 'transport', 'beacon');
   ga('set', 'dimension1', displayMode);
   ga('send', 'pageview', '/index.html', { title: 'Squoosh' });
-  // Load the GA script without keeping the browser spinner going.
-  addEventListener('load', () => {
-    const script = document.createElement('script');
-    script.src = 'https://www.google-analytics.com/analytics.js';
-    document.head.appendChild(script);
-  });
+  // Load the GA script
+  const script = document.createElement('script');
+  script.src = 'https://www.google-analytics.com/analytics.js';
+  document.head.appendChild(script);
 }

src/client/lazy-app/Compress/Options/index.tsx

@@ -40,23 +40,24 @@ type PartialButNotUndefined<T> = {
   [P in keyof T]: T[P];
 };
 
-const supportedEncoderMapP: Promise<PartialButNotUndefined<typeof encoderMap>> =
-  (async () => {
-    const supportedEncoderMap: PartialButNotUndefined<typeof encoderMap> = {
-      ...encoderMap,
-    };
+const supportedEncoderMapP: Promise<PartialButNotUndefined<
+  typeof encoderMap
+>> = (async () => {
+  const supportedEncoderMap: PartialButNotUndefined<typeof encoderMap> = {
+    ...encoderMap,
+  };
 
-    // Filter out entries where the feature test fails
-    await Promise.all(
-      Object.entries(encoderMap).map(async ([encoderName, details]) => {
-        if ('featureTest' in details && !(await details.featureTest())) {
-          delete supportedEncoderMap[encoderName as keyof typeof encoderMap];
-        }
-      }),
-    );
+  // Filter out entries where the feature test fails
+  await Promise.all(
+    Object.entries(encoderMap).map(async ([encoderName, details]) => {
+      if ('featureTest' in details && !(await details.featureTest())) {
+        delete supportedEncoderMap[encoderName as keyof typeof encoderMap];
+      }
+    }),
+  );
 
-    return supportedEncoderMap;
-  })();
+  return supportedEncoderMap;
+})();
 
 export default class Options extends Component<Props, State> {
   state: State = {

src/client/lazy-app/Compress/index.tsx

@@ -116,7 +116,7 @@ async function decodeImage(
     // Otherwise fall through and try built-in decoding for a laugh.
     return await builtinDecode(signal, blob, mimeType);
   } catch (err) {
-    if (err instanceof Error && err.name === 'AbortError') throw err;
+    if (err.name === 'AbortError') throw err;
     console.log(err);
     throw Error("Couldn't decode image");
   }
@@ -481,7 +481,7 @@ export default class Compress extends Component<Props, State> {
         open('https://github.com/GoogleChromeLabs/squoosh/tree/dev/cli');
       }
     } catch (e) {
-      this.props.showSnack(String(e));
+      this.props.showSnack(e);
     }
   };
 
@@ -640,7 +640,7 @@ export default class Compress extends Component<Props, State> {
           return { sides };
         });
       } catch (err) {
-        if (err instanceof Error && err.name === 'AbortError') return;
+        if (err.name === 'AbortError') return;
         this.props.showSnack(`Source decoding error: ${err}`);
         throw err;
       }
@@ -698,7 +698,7 @@ export default class Compress extends Component<Props, State> {
           return newState;
         });
       } catch (err) {
-        if (err instanceof Error && err.name === 'AbortError') return;
+        if (err.name === 'AbortError') return;
         this.setState({ loading: false });
         this.props.showSnack(`Preprocessing error: ${err}`);
         throw err;
@@ -822,7 +822,7 @@ export default class Compress extends Component<Props, State> {
 
         this.activeSideJobs[sideIndex] = undefined;
       } catch (err) {
-        if (err instanceof Error && err.name === 'AbortError') return;
+        if (err.name === 'AbortError') return;
         this.setState((currentState) => {
           const sides = cleanMerge(currentState.sides, sideIndex, {
             loading: false,

src/features/encoders/oxiPNG/worker/oxipngEncode.ts

@@ -14,11 +14,9 @@ import { EncodeOptions } from '../shared/meta';
 import { threads } from 'wasm-feature-detect';
 
 async function initMT() {
-  const {
-    default: init,
-    initThreadPool,
-    optimise,
-  } = await import('codecs/oxipng/pkg-parallel/squoosh_oxipng');
+  const { default: init, initThreadPool, optimise } = await import(
+    'codecs/oxipng/pkg-parallel/squoosh_oxipng'
+  );
   await init();
   await initThreadPool(navigator.hardwareConcurrency);
   return optimise;

src/shared/custom-els/loading-spinner/index.ts

@@ -2,9 +2,9 @@ import * as styles from './styles.css';
 import 'add-css:./styles.css';
 
 // So it doesn't cause an error when running in node
-const HTMLEl = (__PRERENDER__
+const HTMLEl = ((__PRERENDER__
   ? Object
-  : HTMLElement) as unknown as typeof HTMLElement;
+  : HTMLElement) as unknown) as typeof HTMLElement;
 
 /**
  * A simple spinner. This custom element has no JS API. Just put it in the document, and it'll

src/shared/custom-els/snack-bar/index.ts

@@ -2,9 +2,9 @@ import * as style from './styles.css';
 import 'add-css:./styles.css';
 
 // So it doesn't cause an error when running in node
-const HTMLEl = (__PRERENDER__
+const HTMLEl = ((__PRERENDER__
   ? Object
-  : HTMLElement) as unknown as typeof HTMLElement;
+  : HTMLElement) as unknown) as typeof HTMLElement;
 
 export interface SnackOptions {
   timeout?: number;

src/shared/missing-types.d.ts

@@ -13,3 +13,24 @@
 /// <reference path="../../missing-types.d.ts" />
 
 declare const __PRERENDER__: boolean;
+
+type ResizeObserverCallback = (
+  entries: ResizeObserverEntry[],
+  observer: ResizeObserver,
+) => void;
+
+interface ResizeObserverEntry {
+  readonly target: Element;
+  readonly contentRect: DOMRectReadOnly;
+}
+
+interface ResizeObserver {
+  observe(target: Element): void;
+  unobserve(target: Element): void;
+  disconnect(): void;
+}
+
+declare var ResizeObserver: {
+  prototype: ResizeObserver;
+  new (callback: ResizeObserverCallback): ResizeObserver;
+};

src/shared/prerendered-app/Intro/index.tsx

@@ -14,7 +14,7 @@ import smallSectionAsset from 'url:./imgs/info-content/small.svg';
 import simpleSectionAsset from 'url:./imgs/info-content/simple.svg';
 import secureSectionAsset from 'url:./imgs/info-content/secure.svg';
 import logoIcon from 'url:./imgs/demos/icon-demo-logo.png';
-import logoWithText from 'data-url-text:./imgs/logo-with-text.svg';
+import logoWithText from 'url:./imgs/logo-with-text.svg';
 import * as style from './style.css';
 import type SnackBarElement from 'shared/custom-els/snack-bar';
 import 'shared/custom-els/snack-bar';

src/shared/prerendered-app/Intro/missing-types.d.ts

@@ -30,6 +30,11 @@ interface WindowEventMap {
   beforeinstallprompt: BeforeInstallPromptEvent;
 }
 
+interface ClipboardItem {
+  types: string[];
+  getType(type: string): Promise<Blob>;
+}
+
 interface Clipboard {
   read(): Promise<ClipboardItem[]>;
 }

src/static-build/pages/index/index.tsx

@@ -57,7 +57,6 @@ const Index: FunctionalComponent<Props> = () => (
       <meta name="mobile-web-app-capable" content="yes" />
       <meta name="apple-mobile-web-app-capable" content="yes" />
       <link rel="shortcut icon" href={favicon} />
-      <link rel="apple-touch-icon" href={ogImage} />
       <meta name="theme-color" content="#ff3385" />
       <link rel="manifest" href="/manifest.json" />
       <link rel="canonical" href={siteOrigin} />

src/static-build/utils.tsx

@@ -16,35 +16,8 @@ import { join as joinPath } from 'path';
 import render from 'preact-render-to-string';
 import { VNode } from 'preact';
 
-import { StrictCsp } from 'strict-csp';
-
 export function renderPage(vnode: VNode) {
-  const htmlString = '<!DOCTYPE html>' + render(vnode);
-  const htmlStringWithCsp = addCspAsMetaTag(htmlString);
-  return htmlStringWithCsp;
-}
-
-/**
- * Add to the html string a strict Content-Security-Policy (CSP), as a meta tag.
- * Details at https://web.dev/strict-csp/
- */
-function addCspAsMetaTag(htmlString: string) {
-  const s = new StrictCsp(htmlString);
-  // Refactor sourced scripts so that we can set a strict CSP
-  s.refactorSourcedScriptsForHashBasedCsp();
-  // Hash inline scripts from this html file, if there are any
-  const scriptHashes = s.hashAllInlineScripts();
-  // Generate a strict CSP as a string
-  // enableUnsafeEval is set to true, to accomodate for uses of eval by emscripten. This makes the CSP a bit less secure
-  const strictCsp = StrictCsp.getStrictCsp(scriptHashes, {
-    enableBrowserFallbacks: true,
-    enableTrustedTypes: false,
-    enableUnsafeEval: true,
-  });
-  // Set this CSP via a meta tag
-  s.addMetaTag(strictCsp);
-  const htmlStringWithCsp = s.serializeDom();
-  return htmlStringWithCsp;
+  return '<!DOCTYPE html>' + render(vnode);
 }
 
 interface OutputMap {

src/sw/to-cache.ts

@@ -82,20 +82,24 @@ initialJs = subtractSets(
 export const initial = ['/', ...initialJs];
 
 export const theRest = (async () => {
-  const [supportsThreads, supportsSimd, supportsWebP, supportsAvif] =
-    await Promise.all([
-      threads(),
-      simd(),
-      ...[webpDataUrl, avifDataUrl].map(async (dataUrl) => {
-        if (!self.createImageBitmap) return false;
-        const response = await fetch(dataUrl);
-        const blob = await response.blob();
-        return createImageBitmap(blob).then(
-          () => true,
-          () => false,
-        );
-      }),
-    ]);
+  const [
+    supportsThreads,
+    supportsSimd,
+    supportsWebP,
+    supportsAvif,
+  ] = await Promise.all([
+    threads(),
+    simd(),
+    ...[webpDataUrl, avifDataUrl].map(async (dataUrl) => {
+      if (!self.createImageBitmap) return false;
+      const response = await fetch(dataUrl);
+      const blob = await response.blob();
+      return createImageBitmap(blob).then(
+        () => true,
+        () => false,
+      );
+    }),
+  ]);
 
   const items: string[] = [];