1.2.3

When using dark browser themes the text-fields' text-color becomes white, so the text in those white background text-fields is unreadable.

Patched text-color so that it now is readable.

.babelrc

@@ -1,13 +0,0 @@
-{
-  "plugins": [
-    "transform-class-properties",
-    "transform-react-constant-elements",
-    "transform-react-remove-prop-types",
-    [
-      "transform-react-jsx",
-      {
-        "pragma": "h"
-      }
-    ]
-  ]
-}

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,36 @@
+---
+name: Bug report
+about: Something is not working as expected
+labels: 
+
+---
+
+**Before you start**
+Please take a look at the [FAQ](https://github.com/GoogleChromeLabs/squoosh/wiki/FAQ) as well as the already opened issues! If nothing fits your problem, go ahead and fill out the following template:
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Version:**
+ - OS w/ version: [e.g. iOS 12]
+ - Browser w/ version [e.g. Chrome 70]
+ - Node version: [e.g. 10.11.0]
+ - npm version: [e.g. 6.4.1]
+
+**Is your issue related to the quality of image compression?**
+Please attach original and output images (you can drag & drop to attach). 
+- Original image 
+- Output image from Squoosh
+
+**Additional context, screenshots, screencasts**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,18 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+labels: 
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Does other service/app have this feature?**
+Add any service you know/use that has this feature (We want to know for research)
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.travis.yml

@@ -1,5 +1,7 @@
 language: node_js
 node_js:
 - node
+- 10
+- 8
 cache: npm
-script: npm run build || npm run build # scss ts definitions need to be generated before an actual build
+script: npm run build

README.md

@@ -1,5 +1,31 @@
-# Squoosh!
+# [Squoosh]!
 
-Squoosh will be an image compression web app that allows you to dive into the
-advanced options provided by various image compressors.
+[Squoosh] is an image compression web app that allows you to dive into the advanced options provided
+by various image compressors.
 
+# Privacy
+
+Google Analytics is used to record the following:
+
+* [Basic visit data](https://support.google.com/analytics/answer/6004245?ref_topic=2919631).
+* Before and after image size once an image is downloaded. These values are rounded to the nearest
+  kilobyte.
+
+Image compression is handled locally; no additional data is sent to the server.
+
+# Building locally
+
+Clone the repo, and:
+
+```sh
+npm install
+npm run build
+```
+
+You can run the development server with:
+
+```sh
+npm start
+```
+
+[Squoosh]: https://squoosh.app

_headers.ejs

@@ -0,0 +1,18 @@
+# Long-term cache by default.
+/*
+  Cache-Control: max-age=31536000
+
+# And here are the exceptions:
+/
+  Cache-Control: no-cache
+
+/serviceworker.js
+  Cache-Control: no-cache
+
+/manifest.json
+  Cache-Control: must-revalidate, max-age=3600
+
+# URLs in /assets do not include a hash and are mutable.
+# But it isn't a big deal if the user gets an old version.
+/assets/*
+  Cache-Control: must-revalidate, max-age=3600

codecs/README.md

@@ -11,6 +11,6 @@ $ npm install
 $ npm run build
 ```
 
-This will build two files: `<codec name>_<enc or dec>.js` and `<codec name>_<enc or dec>.wasm`. It will most likely be necessary to set [`Module["locateFile"]`](https://kripken.github.io/emscripten-site/docs/api_reference/module.html#affecting-execution) to sucessfully load the `.wasm` file. When the `.js` file is loaded, a global `<codec name>_<enc or dec>` is created with the same API as an [Emscripten `Module`](https://kripken.github.io/emscripten-site/docs/api_reference/module.html).
+This will build two files: `<codec name>_<enc or dec>.js` and `<codec name>_<enc or dec>.wasm`. It will most likely be necessary to set [`Module["locateFile"]`](https://kripken.github.io/emscripten-site/docs/api_reference/module.html#affecting-execution) to successfully load the `.wasm` file. When the `.js` file is loaded, a global `<codec name>_<enc or dec>` is created with the same API as an [Emscripten `Module`](https://kripken.github.io/emscripten-site/docs/api_reference/module.html).
 
 Each codec will document its API in its README.

config/add-css-types.js

@@ -0,0 +1,74 @@
+const DtsCreator = require('typed-css-modules');
+const chokidar = require('chokidar');
+const util = require('util');
+const sass = require('node-sass');
+
+const sassRender = util.promisify(sass.render);
+
+async function sassToCss(path) {
+  const result = await sassRender({ file: path });
+  return result.css;
+}
+
+/**
+ * @typedef {Object} Opts
+ * @property {boolean} watch Watch for changes
+ */
+/**
+ * Create typing files for CSS & SCSS.
+ *
+ * @param {string[]} rootPaths Paths to search within
+ * @param {Opts} [opts={}] Options.
+ */
+function addCssTypes(rootPaths, opts = {}) {
+  return new Promise((resolve) => {
+    const { watch = false } = opts;
+
+    const paths = [];
+    const preReadyPromises = [];
+    let ready = false;
+
+    for (const rootPath of rootPaths) {
+      // Look for scss & css in each path.
+      paths.push(rootPath + '/**/*.scss');
+      paths.push(rootPath + '/**/*.css');
+    }
+
+    // For simplicity, the watcher is used even if we're not watching.
+    // If we're not watching, we stop the watcher after the initial files are found.
+    const watcher = chokidar.watch(paths, {
+      // Avoid processing already-processed files.
+      ignored: '*.d.*',
+      // Without this, travis and netlify builds never complete. I'm not sure why, but it might be
+      // related to https://github.com/paulmillr/chokidar/pull/758
+      persistent: watch,
+    });
+
+    function change(path) {
+      const promise = (async function() {
+        const creator = new DtsCreator({ camelCase: true });
+        const result = path.endsWith('.scss') ?
+          await creator.create(path, await sassToCss(path)) :
+          await creator.create(path);
+
+        await result.writeFile();
+      })();
+
+      if (!ready) preReadyPromises.push(promise);
+    }
+
+    watcher.on('change', change);
+    watcher.on('add', change);
+
+    // 'ready' is when events have been fired for file discovery.
+    watcher.on('ready', () => {
+      ready = true;
+      // Wait for the current set of processing to finish.
+      Promise.all(preReadyPromises).then(resolve);
+      // And if we're not watching, close the watcher.
+      if (!watch) watcher.close();
+    });
+  })
+}
+
+module.exports = addCssTypes;

config/asset-template-plugin.js

@@ -0,0 +1,47 @@
+const path = require('path');
+const fs = require('fs');
+const ejs = require('ejs');
+const AssetsPlugin = require('assets-webpack-plugin');
+
+module.exports = class AssetTemplatePlugin extends AssetsPlugin {
+  constructor(options) {
+    options = options || {};
+    if (!options.template) throw Error('AssetTemplatePlugin: template option is required.');
+    super({
+      useCompilerPath: true,
+      filename: options.filename,
+      processOutput: files => this._processOutput(files)
+    });
+    this._template = path.resolve(process.cwd(), options.template);
+    const ignore = options.ignore || /(manifest\.json|\.DS_Store)$/;
+    this._ignore = typeof ignore === 'function' ? ({ test: ignore }) : ignore;
+  }
+
+  _processOutput(files) {
+    const mapping = {
+      all: [],
+      byType: {},
+      entries: {}
+    };
+    for (const entryName in files) {
+      // non-entry-point-derived assets are collected under an empty string key
+      // since that's a bit awkward, we'll call them "assets"
+      const name = entryName === '' ? 'assets' : entryName;
+      const listing = files[entryName];
+      const entry = mapping.entries[name] = {
+        all: [],
+        byType: {}
+      };
+      for (let type in listing) {
+        const list = [].concat(listing[type]).filter(file => !this._ignore.test(file));
+        if (!list.length) continue;
+        mapping.all = mapping.all.concat(list);
+        mapping.byType[type] = (mapping.byType[type] || []).concat(list);
+        entry.all = entry.all.concat(list);
+        entry.byType[type] = (entry.byType[type] || []).concat(list);
+      }
+    }
+    mapping.files = mapping.all;
+    return ejs.render(fs.readFileSync(this._template, 'utf8'), mapping);
+  }
+};

config/auto-sw-plugin.js

@@ -0,0 +1,158 @@
+const util = require('util');
+const minimatch = require('minimatch');
+const SingleEntryPlugin = require('webpack/lib/SingleEntryPlugin');
+const WebWorkerTemplatePlugin = require('webpack/lib/webworker/WebWorkerTemplatePlugin');
+const ParserHelpers = require('webpack/lib/ParserHelpers');
+
+const NAME = 'auto-sw-plugin';
+const JS_TYPES = ['auto', 'esm', 'dynamic'];
+
+/**
+ * Automatically finds and bundles Service Workers by looking for navigator.serviceWorker.register(..).
+ * An Array of webpack assets is injected into the Service Worker bundle as a `BUILD_ASSETS` global.
+ * Hidden and `.map` files are excluded by default, and this can be customized using the include & exclude options.
+ * @example
+ *  // webpack config
+ *  plugins: [
+ *    new AutoSWPlugin({
+ *      exclude: [
+ *        '**\/.*',     // don't expose hidden files (default)
+ *        '**\/*.map',  // don't precache sourcemaps (default)
+ *        'index.html'  // don't cache the page itself
+ *      ]
+ *    })
+ *  ]
+ * @param {Object} [options={}]
+ * @param {string[]} [options.exclude]  Minimatch pattern(s) of which assets to omit from BUILD_ASSETS.
+ * @param {string[]} [options.include]  Minimatch pattern(s) of assets to allow in BUILD_ASSETS.
+ */
+module.exports = class AutoSWPlugin {
+  constructor(options) {
+    this.options = Object.assign({
+      exclude: [
+        '**/*.map',
+        '**/.*'
+      ]
+    }, options || {});
+  }
+
+  apply(compiler) {
+    const serviceWorkers = [];
+
+    compiler.hooks.emit.tapPromise(NAME, compilation => this.emit(compiler, compilation, serviceWorkers));
+
+    compiler.hooks.normalModuleFactory.tap(NAME, (factory) => {
+      for (const type of JS_TYPES) {
+        factory.hooks.parser.for(`javascript/${type}`).tap(NAME, parser => {
+          let counter = 0;
+
+          const processRegisterCall = expr => {
+            const dep = parser.evaluateExpression(expr.arguments[0]);
+
+            if (!dep.isString()) {
+              parser.state.module.warnings.push({
+                message: 'navigator.serviceWorker.register() will only be bundled if passed a String literal.'
+              });
+              return false;
+            }
+
+            const filename = dep.string;
+            const outputFilename = this.options.filename || 'serviceworker.js'
+            const context = parser.state.current.context;
+            serviceWorkers.push({
+              outputFilename,
+              filename,
+              context
+            });
+
+            const id = `__webpack__serviceworker__${++counter}`;
+            ParserHelpers.toConstantDependency(parser, id)(expr.arguments[0]);
+            return ParserHelpers.addParsedVariableToModule(parser, id, '__webpack_public_path__ + ' + JSON.stringify(outputFilename));
+          };
+
+          parser.hooks.call.for('navigator.serviceWorker.register').tap(NAME, processRegisterCall);
+          parser.hooks.call.for('self.navigator.serviceWorker.register').tap(NAME, processRegisterCall);
+          parser.hooks.call.for('window.navigator.serviceWorker.register').tap(NAME, processRegisterCall);
+        });
+      }
+    });
+  }
+
+  createFilter(list) {
+    const filters = [].concat(list);
+    for (let i=0; i<filters.length; i++) {
+      if (typeof filters[i] === 'string') {
+        filters[i] = minimatch.filter(filters[i]);
+      }
+    }
+    return filters;
+  }
+
+  async emit(compiler, compilation, serviceWorkers) {
+    let assetMapping = Object.keys(compilation.assets);
+    if (this.options.include) {
+      const filters = this.createFilter(this.options.include);
+      assetMapping = assetMapping.filter(filename => {
+        for (const filter of filters) {
+          if (filter(filename)) return true;
+        }
+        return false;
+      });
+    }
+    if (this.options.exclude) {
+      const filters = this.createFilter(this.options.exclude);
+      assetMapping = assetMapping.filter(filename => {
+        for (const filter of filters) {
+          if (filter(filename)) return false;
+        }
+        return true;
+      });
+    }
+    await Promise.all(serviceWorkers.map(
+      (serviceWorker, index) => this.compileServiceWorker(compiler, compilation, serviceWorker, index, assetMapping)
+    ));
+  }
+
+  async compileServiceWorker(compiler, compilation, options, index, assetMapping) {
+    const entryFilename = options.filename;
+
+    const chunkFilename = compiler.options.output.chunkFilename.replace(/\.([a-z]+)$/i, '.serviceworker.$1');
+    const workerOptions = {
+      filename: options.outputFilename, // chunkFilename.replace(/\.?\[(?:chunkhash|contenthash|hash)(:\d+(?::\d+)?)?\]/g, ''),
+      chunkFilename: this.options.chunkFilename || chunkFilename,
+      globalObject: 'self'
+    };
+
+    const childCompiler = compilation.createChildCompiler(NAME, { filename: workerOptions.filename });
+    (new WebWorkerTemplatePlugin(workerOptions)).apply(childCompiler);
+
+    /* The duplication DefinePlugin ends up causing is problematic (it doesn't hoist injections), so we'll do it manually. */
+    // (new DefinePlugin({
+    //   BUILD_ASSETS: JSON.stringify(assetMapping)
+    // })).apply(childCompiler);
+    (new SingleEntryPlugin(options.context, entryFilename, workerOptions.filename)).apply(childCompiler);
+
+    const subCache = `subcache ${__dirname} ${entryFilename} ${index}`;
+    let childCompilation;
+    childCompiler.hooks.compilation.tap(NAME, c => {
+      childCompilation = c;
+      if (childCompilation.cache) {
+        if (!childCompilation.cache[subCache]) childCompilation.cache[subCache] = {};
+        childCompilation.cache = childCompilation.cache[subCache];
+      }
+    });
+
+    await (util.promisify(childCompiler.runAsChild.bind(childCompiler)))();
+
+    const versionVar = this.options.version ?
+      `var VERSION = ${JSON.stringify(this.options.version)};` : '';
+    const original = childCompilation.assets[workerOptions.filename].source();
+    const source = `${versionVar}var BUILD_ASSETS=${JSON.stringify(assetMapping)};${original}`;
+    childCompilation.assets[workerOptions.filename] = {
+      source: () => source,
+      size: () => Buffer.byteLength(source, 'utf8')
+    };
+
+    Object.assign(compilation.assets, childCompilation.assets);
+  }
+};

global.d.ts

@@ -1,16 +1,21 @@
 declare const __webpack_public_path__: string;
+declare const PRERENDER: boolean;
 
 declare interface NodeModule {
   hot: any;
 }
 
 declare interface Window {
-  STATE: any
+  STATE: any;
+  ga: typeof ga;
 }
 
 declare namespace JSX {
   interface Element { }
   interface IntrinsicElements { }
+  interface HTMLAttributes {
+    decoding?: string;
+  }
 }
 
 declare module 'classnames' {

package.json

@@ -1,13 +1,13 @@
 {
   "private": true,
   "name": "squoosh",
-  "version": "0.0.0",
+  "version": "1.2.3",
   "license": "apache-2.0",
   "scripts": {
-    "start": "webpack serve --host 0.0.0.0 --hot",
+    "start": "webpack-dev-server --host 0.0.0.0 --hot",
     "build": "webpack -p",
-    "lint": "tslint -c tslint.json -t verbose 'src/**/*.{ts,tsx,js,jsx}'",
-    "lintfix": "tslint -c tslint.json -t verbose --fix 'src/**/*.{ts,tsx,js,jsx}'"
+    "lint": "tslint -c tslint.json  -p tsconfig.json -t verbose 'src/**/*.{ts,tsx,js,jsx}'",
+    "lintfix": "tslint -c tslint.json -p tsconfig.json -t verbose --fix 'src/**/*.{ts,tsx,js,jsx}'"
   },
   "husky": {
     "hooks": {
@@ -15,58 +15,55 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^9.6.35",
+    "@types/node": "^10.12.6",
     "@types/pretty-bytes": "^5.1.0",
     "@types/webassembly-js-api": "0.0.1",
     "@webcomponents/custom-elements": "^1.2.1",
-    "babel-loader": "^7.1.5",
-    "babel-plugin-jsx-pragmatic": "^1.0.2",
-    "babel-plugin-syntax-dynamic-import": "^6.18.0",
-    "babel-plugin-transform-class-properties": "^6.24.1",
-    "babel-plugin-transform-decorators-legacy": "^1.3.5",
-    "babel-plugin-transform-object-rest-spread": "^6.26.0",
-    "babel-plugin-transform-react-constant-elements": "^6.23.0",
-    "babel-plugin-transform-react-jsx": "^6.24.1",
-    "babel-plugin-transform-react-remove-prop-types": "^0.4.19",
-    "babel-preset-env": "^1.7.0",
-    "babel-register": "^6.26.0",
+    "@webpack-cli/serve": "^0.1.2",
+    "assets-webpack-plugin": "^3.9.7",
+    "chokidar": "^2.0.4",
     "classnames": "^2.2.6",
-    "clean-webpack-plugin": "^0.1.19",
+    "clean-webpack-plugin": "^1.0.0",
     "comlink": "^3.0.3",
-    "copy-webpack-plugin": "^4.5.3",
-    "css-loader": "^0.28.11",
+    "copy-webpack-plugin": "^4.6.0",
+    "critters-webpack-plugin": "^2.0.1",
+    "css-loader": "^1.0.1",
+    "ejs": "^2.6.1",
     "exports-loader": "^0.7.0",
-    "file-drop-element": "0.0.7",
-    "file-loader": "^1.1.11",
+    "file-drop-element": "^0.0.9",
+    "file-loader": "^2.0.0",
     "html-webpack-plugin": "^3.2.0",
-    "husky": "^1.1.2",
-    "if-env": "^1.0.4",
+    "husky": "^1.1.4",
+    "idb-keyval": "^3.1.0",
     "linkstate": "^1.1.1",
     "loader-utils": "^1.1.0",
-    "mini-css-extract-plugin": "^0.3.0",
-    "node-sass": "^4.9.4",
-    "optimize-css-assets-webpack-plugin": "^4.0.3",
+    "mini-css-extract-plugin": "^0.4.4",
+    "minimatch": "^3.0.4",
+    "node-sass": "^4.11.0",
+    "optimize-css-assets-webpack-plugin": "^5.0.1",
     "pointer-tracker": "^2.0.3",
     "preact": "^8.3.1",
+    "prerender-loader": "^1.2.0",
     "pretty-bytes": "^5.1.0",
     "progress-bar-webpack-plugin": "^1.11.0",
     "raw-loader": "^0.5.1",
     "sass-loader": "^7.1.0",
-    "script-ext-html-webpack-plugin": "^2.0.1",
-    "source-map-loader": "^0.2.3",
-    "style-loader": "^0.22.1",
-    "ts-loader": "^4.4.2",
+    "script-ext-html-webpack-plugin": "^2.1.3",
+    "source-map-loader": "^0.2.4",
+    "style-loader": "^0.23.1",
+    "terser-webpack-plugin": "^1.1.0",
+    "ts-loader": "^5.3.0",
     "tslint": "^5.11.0",
-    "tslint-config-airbnb": "^5.9.2",
+    "tslint-config-airbnb": "^5.11.0",
     "tslint-config-semistandard": "^7.0.0",
     "tslint-react": "^3.6.0",
-    "typescript": "^2.9.2",
-    "typings-for-css-modules-loader": "^1.7.0",
-    "webpack": "=4.19.1",
-    "webpack-bundle-analyzer": "^2.13.1",
-    "webpack-cli": "^2.1.5",
-    "webpack-dev-server": "^3.1.5",
-    "webpack-plugin-replace": "^1.1.1",
+    "typed-css-modules": "^0.3.7",
+    "typescript": "^3.1.6",
+    "url-loader": "^1.1.2",
+    "webpack": "^4.25.1",
+    "webpack-bundle-analyzer": "^3.0.3",
+    "webpack-cli": "^3.1.2",
+    "webpack-dev-server": "^3.1.10",
     "worker-plugin": "^1.1.1"
   }
 }

src/codecs/decoders.ts

@@ -1,9 +1,8 @@
 import { nativeDecode, sniffMimeType, canDecodeImage } from '../lib/util';
 import Processor from './processor';
+import webpDataUrl from 'url-loader!./tiny.webp';
 
-// tslint:disable-next-line:max-line-length It’s a data URL. Whatcha gonna do?
-const webpFile = 'data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAAAAAAfQ//73v/+BiOh/AAA=';
-const nativeWebPSupported = canDecodeImage(webpFile);
+const nativeWebPSupported = canDecodeImage(webpDataUrl);
 
 export async function decodeImage(blob: Blob, processor: Processor): Promise<ImageData> {
   const mimeType = await sniffMimeType(blob);

src/codecs/imagequant/options.tsx

@@ -1,6 +1,6 @@
 import { h, Component } from 'preact';
 import { bind } from '../../lib/initial-util';
-import { inputFieldValueAsNumber, konami } from '../../lib/util';
+import { inputFieldValueAsNumber, konami, preventDefault } from '../../lib/util';
 import { QuantizeOptions } from './processor-meta';
 import * as style from '../../components/Options/style.scss';
 import Expander from '../../components/expander';
@@ -42,7 +42,7 @@ export default class QuantizerOptions extends Component<Props, State> {
 
   render({ options }: Props, { extendedSettings }: State) {
     return (
-      <form class={style.optionsSection}>
+      <form class={style.optionsSection} onSubmit={preventDefault}>
         <Expander>
           {extendedSettings ?
             <label class={style.optionTextFirst}>

src/codecs/input-processors.ts

@@ -0,0 +1,9 @@
+import { defaultOptions as rotateDefaultOptions } from './rotate/processor-meta';
+
+export interface InputProcessorState {
+  rotate: import('./rotate/processor-meta').RotateOptions;
+}
+
+export const defaultInputProcessorState: InputProcessorState = {
+  rotate: rotateDefaultOptions,
+};

src/codecs/mozjpeg/options.tsx

@@ -1,6 +1,6 @@
 import { h, Component } from 'preact';
 import { bind } from '../../lib/initial-util';
-import { inputFieldChecked, inputFieldValueAsNumber } from '../../lib/util';
+import { inputFieldChecked, inputFieldValueAsNumber, preventDefault } from '../../lib/util';
 import { EncodeOptions, MozJpegColorSpace } from './encoder-meta';
 import * as style from '../../components/Options/style.scss';
 import Checkbox from '../../components/checkbox';
@@ -58,7 +58,7 @@ export default class MozJPEGEncoderOptions extends Component<Props, State> {
     // I'm rendering both lossy and lossless forms, as it becomes much easier when
     // gathering the data.
     return (
-      <form class={style.optionsSection}>
+      <form class={style.optionsSection} onSubmit={preventDefault}>
         <div class={style.optionOneCell}>
           <Range
             name="quality"

src/codecs/optipng/options.tsx

@@ -1,6 +1,6 @@
 import { h, Component } from 'preact';
 import { bind } from '../../lib/initial-util';
-import { inputFieldValueAsNumber } from '../../lib/util';
+import { inputFieldValueAsNumber, preventDefault } from '../../lib/util';
 import { EncodeOptions } from './encoder-meta';
 import Range from '../../components/range';
 import * as style from '../../components/Options/style.scss';
@@ -23,7 +23,7 @@ export default class OptiPNGEncoderOptions extends Component<Props, {}> {
 
   render({ options }: Props) {
     return (
-      <form class={style.optionsSection}>
+      <form class={style.optionsSection} onSubmit={preventDefault}>
         <div class={style.optionOneCell}>
           <Range
             name="level"

src/codecs/processor-worker.ts

@@ -1,41 +0,0 @@
-import { expose } from 'comlink';
-import { EncodeOptions as MozJPEGEncoderOptions } from './mozjpeg/encoder-meta';
-import { QuantizeOptions } from './imagequant/processor-meta';
-import { EncodeOptions as OptiPNGEncoderOptions } from './optipng/encoder-meta';
-import { EncodeOptions as WebPEncoderOptions } from './webp/encoder-meta';
-
-async function mozjpegEncode(
-  data: ImageData, options: MozJPEGEncoderOptions,
-): Promise<ArrayBuffer> {
-  const { encode } = await import('./mozjpeg/encoder');
-  return encode(data, options);
-}
-
-async function quantize(data: ImageData, opts: QuantizeOptions): Promise<ImageData> {
-  const { process } = await import('./imagequant/processor');
-  return process(data, opts);
-}
-
-async function optiPngEncode(
-  data: BufferSource, options: OptiPNGEncoderOptions,
-): Promise<ArrayBuffer> {
-  const { compress } = await import('./optipng/encoder');
-  return compress(data, options);
-}
-
-async function webpEncode(
-  data: ImageData, options: WebPEncoderOptions,
-): Promise<ArrayBuffer> {
-  const { encode } = await import('./webp/encoder');
-  return encode(data, options);
-}
-
-async function webpDecode(data: ArrayBuffer): Promise<ImageData> {
-  const { decode } = await import('./webp/decoder');
-  return decode(data);
-}
-
-const exports = { mozjpegEncode, quantize, optiPngEncode, webpEncode, webpDecode };
-export type ProcessorWorkerApi = typeof exports;
-
-expose(exports, self);

src/codecs/processor-worker/index.ts

@@ -0,0 +1,65 @@
+import { expose } from 'comlink';
+
+async function mozjpegEncode(
+  data: ImageData, options: import('../mozjpeg/encoder-meta').EncodeOptions,
+): Promise<ArrayBuffer> {
+  const { encode } = await import(
+    /* webpackChunkName: "process-mozjpeg-enc" */
+    '../mozjpeg/encoder',
+  );
+  return encode(data, options);
+}
+
+async function quantize(
+  data: ImageData, opts: import('../imagequant/processor-meta').QuantizeOptions,
+): Promise<ImageData> {
+  const { process } = await import(
+    /* webpackChunkName: "process-imagequant" */
+    '../imagequant/processor',
+  );
+  return process(data, opts);
+}
+
+async function rotate(
+  data: ImageData, opts: import('../rotate/processor-meta').RotateOptions,
+): Promise<ImageData> {
+  const { rotate } = await import(
+    /* webpackChunkName: "process-rotate" */
+    '../rotate/processor',
+  );
+
+  return rotate(data, opts);
+}
+
+async function optiPngEncode(
+  data: BufferSource, options: import('../optipng/encoder-meta').EncodeOptions,
+): Promise<ArrayBuffer> {
+  const { compress } = await import(
+    /* webpackChunkName: "process-optipng" */
+    '../optipng/encoder',
+  );
+  return compress(data, options);
+}
+
+async function webpEncode(
+  data: ImageData, options: import('../webp/encoder-meta').EncodeOptions,
+): Promise<ArrayBuffer> {
+  const { encode } = await import(
+    /* webpackChunkName: "process-webp-enc" */
+    '../webp/encoder',
+  );
+  return encode(data, options);
+}
+
+async function webpDecode(data: ArrayBuffer): Promise<ImageData> {
+  const { decode } = await import(
+    /* webpackChunkName: "process-webp-dec" */
+    '../webp/decoder',
+  );
+  return decode(data);
+}
+
+const exports = { mozjpegEncode, quantize, rotate, optiPngEncode, webpEncode, webpDecode };
+export type ProcessorWorkerApi = typeof exports;
+
+expose(exports, self);

src/codecs/processor-worker/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "strict": true,
+    "target": "esnext",
+    "module": "esnext",
+    "lib": [
+      "webworker",
+      "esnext"
+    ],
+    "moduleResolution": "node",
+    "experimentalDecorators": true,
+    "noUnusedLocals": true,
+    "sourceMap": true,
+    "allowJs": false,
+    "baseUrl": "."
+  }
+}

src/codecs/processor.ts

@@ -1,6 +1,5 @@
 import { proxy } from 'comlink';
 import { QuantizeOptions } from './imagequant/processor-meta';
-import { ProcessorWorkerApi } from './processor-worker';
 import { canvasEncode, blobToArrayBuffer } from '../lib/util';
 import { EncodeOptions as MozJPEGEncoderOptions } from './mozjpeg/encoder-meta';
 import { EncodeOptions as OptiPNGEncoderOptions } from './optipng/encoder-meta';
@@ -18,8 +17,10 @@ import * as browserTIFF from './browser-tiff/encoder';
 import * as browserJP2 from './browser-jp2/encoder';
 import * as browserPDF from './browser-pdf/encoder';
 
+type ProcessorWorkerApi = import('./processor-worker').ProcessorWorkerApi;
+
 /** How long the worker should be idle before terminating. */
-const workerTimeout = 1000;
+const workerTimeout = 10000;
 
 interface ProcessingJobOptions {
   needsWorker?: boolean;
@@ -61,7 +62,10 @@ export default class Processor {
           // worker-loader does magic here.
           // @ts-ignore - Typescript doesn't know about the 2nd param to new Worker, and the
           // definition can't be overwritten.
-          this._worker = new Worker('./processor-worker.ts', { type: 'module' }) as Worker;
+          this._worker = new Worker(
+            './processor-worker',
+            { name: 'processor-worker', type: 'module' },
+          ) as Worker;
           // Need to do some TypeScript trickery to make the type match.
           this._workerApi = proxy(this._worker) as any as ProcessorWorkerApi;
         }
@@ -114,12 +118,18 @@ export default class Processor {
   }
 
   // Off main thread jobs:
-
   @Processor._processingJob({ needsWorker: true })
   imageQuant(data: ImageData, opts: QuantizeOptions): Promise<ImageData> {
     return this._workerApi!.quantize(data, opts);
   }
 
+  @Processor._processingJob({ needsWorker: true })
+  rotate(
+    data: ImageData, opts: import('./rotate/processor-meta').RotateOptions,
+  ): Promise<ImageData> {
+    return this._workerApi!.rotate(data, opts);
+  }
+
   @Processor._processingJob({ needsWorker: true })
   mozjpegEncode(
     data: ImageData, opts: MozJPEGEncoderOptions,

src/codecs/resize/options.tsx

@@ -1,7 +1,7 @@
 import { h, Component } from 'preact';
 import linkState from 'linkstate';
 import { bind, linkRef } from '../../lib/initial-util';
-import { inputFieldValueAsNumber, inputFieldValue } from '../../lib/util';
+import { inputFieldValueAsNumber, inputFieldValue, preventDefault } from '../../lib/util';
 import { ResizeOptions } from './processor-meta';
 import * as style from '../../components/Options/style.scss';
 import Checkbox from '../../components/checkbox';
@@ -78,7 +78,7 @@ export default class ResizerOptions extends Component<Props, State> {
 
   render({ options, isVector }: Props, { maintainAspect }: State) {
     return (
-      <form ref={linkRef(this, 'form')} class={style.optionsSection}>
+      <form ref={linkRef(this, 'form')} class={style.optionsSection} onSubmit={preventDefault}>
         <label class={style.optionTextFirst}>
           Method:
           <Select
@@ -135,7 +135,7 @@ export default class ResizerOptions extends Component<Props, State> {
                 onChange={this.onChange}
               >
                 <option value="stretch">Stretch</option>
-                <option value="cover">Cover</option>
+                <option value="contain">Contain</option>
               </Select>
             </label>
           }

src/codecs/resize/processor-meta.ts

@@ -4,7 +4,7 @@ export interface ResizeOptions {
   width: number;
   height: number;
   method: 'vector' | BitmapResizeMethods;
-  fitMethod: 'stretch' | 'cover';
+  fitMethod: 'stretch' | 'contain';
 }
 
 export interface BitmapResizeOptions extends ResizeOptions {

src/codecs/resize/processor.ts

@@ -1,7 +1,7 @@
 import { nativeResize, NativeResizeMethod, drawableToImageData } from '../../lib/util';
 import { BitmapResizeOptions, VectorResizeOptions } from './processor-meta';
 
-function getCoverOffsets(sw: number, sh: number, dw: number, dh: number) {
+function getContainOffsets(sw: number, sh: number, dw: number, dh: number) {
   const currentAspect = sw / sh;
   const endAspect = dw / dh;
 
@@ -22,8 +22,8 @@ export function resize(data: ImageData, opts: BitmapResizeOptions): ImageData {
   let sw = data.width;
   let sh = data.height;
 
-  if (opts.fitMethod === 'cover') {
-    ({ sx, sy, sw, sh } = getCoverOffsets(sw, sh, opts.width, opts.height));
+  if (opts.fitMethod === 'contain') {
+    ({ sx, sy, sw, sh } = getContainOffsets(sw, sh, opts.width, opts.height));
   }
 
   return nativeResize(
@@ -38,8 +38,8 @@ export function vectorResize(data: HTMLImageElement, opts: VectorResizeOptions):
   let sw = data.width;
   let sh = data.height;
 
-  if (opts.fitMethod === 'cover') {
-    ({ sx, sy, sw, sh } = getCoverOffsets(sw, sh, opts.width, opts.height));
+  if (opts.fitMethod === 'contain') {
+    ({ sx, sy, sw, sh } = getContainOffsets(sw, sh, opts.width, opts.height));
   }
 
   return drawableToImageData(data, {

src/codecs/rotate/processor-meta.ts

@@ -0,0 +1,5 @@
+export interface RotateOptions {
+  rotate: 0 | 90 | 180 | 270;
+}
+
+export const defaultOptions: RotateOptions = { rotate: 0 };

src/codecs/rotate/processor.ts

@@ -0,0 +1,76 @@
+import { RotateOptions } from './processor-meta';
+
+const bpp = 4;
+
+export function rotate(data: ImageData, opts: RotateOptions): ImageData {
+  const { rotate } = opts;
+  const flipDimensions = rotate % 180 !== 0;
+  const { width: inputWidth, height: inputHeight } = data;
+  const outputWidth = flipDimensions ? inputHeight : inputWidth;
+  const outputHeight = flipDimensions ? inputWidth : inputHeight;
+  const out = new ImageData(outputWidth, outputHeight);
+  let i = 0;
+
+  // In the straight-copy case, d1 is x, d2 is y.
+  // x starts at 0 and increases.
+  // y starts at 0 and increases.
+  let d1Start = 0;
+  let d1Limit = inputWidth;
+  let d1Advance = 1;
+  let d1Multiplier = 1;
+  let d2Start = 0;
+  let d2Limit = inputHeight;
+  let d2Advance = 1;
+  let d2Multiplier = inputWidth;
+
+  if (rotate === 90) {
+    // d1 is y, d2 is x.
+    // y starts at its max value and decreases.
+    // x starts at 0 and increases.
+    d1Start = inputHeight - 1;
+    d1Limit = inputHeight;
+    d1Advance = -1;
+    d1Multiplier = inputWidth;
+    d2Start = 0;
+    d2Limit = inputWidth;
+    d2Advance = 1;
+    d2Multiplier = 1;
+  } else if (rotate === 180) {
+    // d1 is x, d2 is y.
+    // x starts at its max and decreases.
+    // y starts at its max and decreases.
+    d1Start = inputWidth - 1;
+    d1Limit = inputWidth;
+    d1Advance = -1;
+    d1Multiplier = 1;
+    d2Start = inputHeight - 1;
+    d2Limit = inputHeight;
+    d2Advance = -1;
+    d2Multiplier = inputWidth;
+  } else if (rotate === 270) {
+    // d1 is y, d2 is x.
+    // y starts at 0 and increases.
+    // x starts at its max and decreases.
+    d1Start = 0;
+    d1Limit = inputHeight;
+    d1Advance = 1;
+    d1Multiplier = inputWidth;
+    d2Start = inputWidth - 1;
+    d2Limit = inputWidth;
+    d2Advance = -1;
+    d2Multiplier = 1;
+  }
+
+  for (let d2 = d2Start; d2 >= 0 && d2 < d2Limit; d2 += d2Advance) {
+    for (let d1 = d1Start; d1 >= 0 && d1 < d1Limit; d1 += d1Advance) {
+      // Iterate over channels:
+      const start = ((d1 * d1Multiplier) + (d2 * d2Multiplier)) * bpp;
+      for (let j = 0; j < bpp; j += 1) {
+        out.data[i] = data.data[start + j];
+        i += 1;
+      }
+    }
+  }
+
+  return out;
+}

src/codecs/webp/options.tsx

@@ -1,6 +1,6 @@
 import { h, Component } from 'preact';
 import { bind } from '../../lib/initial-util';
-import { inputFieldCheckedAsNumber, inputFieldValueAsNumber } from '../../lib/util';
+import { inputFieldCheckedAsNumber, inputFieldValueAsNumber, preventDefault } from '../../lib/util';
 import { EncodeOptions, WebPImageHint } from './encoder-meta';
 import * as style from '../../components/Options/style.scss';
 import Checkbox from '../../components/checkbox';
@@ -319,7 +319,7 @@ export default class WebPEncoderOptions extends Component<Props, State> {
     // I'm rendering both lossy and lossless forms, as it becomes much easier when
     // gathering the data.
     return (
-      <form class={style.optionsSection}>
+      <form class={style.optionsSection} onSubmit={preventDefault}>
         <label class={style.optionInputFirst}>
           <Checkbox
             name="lossless"

src/components/App/index.tsx

@@ -9,20 +9,20 @@ import '../../lib/SnackBar';
 import Intro from '../intro';
 import '../custom-els/LoadingSpinner';
 
-// This is imported for TypeScript only. It isn't used.
-import Compress from '../compress';
-
-export interface SourceImage {
-  file: File | Fileish;
-  data: ImageData;
-  vectorImage?: HTMLImageElement;
-}
+const compressPromise = import(
+  /* webpackChunkName: "main-app" */
+  '../compress',
+);
+const offlinerPromise = import(
+  /* webpackChunkName: "offliner" */
+  '../../lib/offliner',
+);
 
 interface Props {}
 
 interface State {
   file?: File | Fileish;
-  Compress?: typeof Compress;
+  Compress?: typeof import('../compress').default;
 }
 
 export default class App extends Component<Props, State> {
@@ -36,12 +36,14 @@ export default class App extends Component<Props, State> {
   constructor() {
     super();
 
-    import('../compress').then((module) => {
+    compressPromise.then((module) => {
       this.setState({ Compress: module.default });
     }).catch(() => {
       this.showSnack('Failed to load app');
     });
 
+    offlinerPromise.then(({ offliner }) => offliner(this.showSnack));
+
     // In development, persist application state across hot reloads:
     if (process.env.NODE_ENV === 'development') {
       this.setState(window.STATE);
@@ -71,6 +73,11 @@ export default class App extends Component<Props, State> {
     return this.snackbar.showSnackbar(message, options);
   }
 
+  @bind
+  private onBack() {
+    this.setState({ file: undefined });
+  }
+
   render({}: Props, { file, Compress }: State) {
     return (
       <div id="app" class={style.app}>
@@ -78,7 +85,7 @@ export default class App extends Component<Props, State> {
           {(!file)
             ? <Intro onFile={this.onIntroPickFile} showSnack={this.showSnack} />
             : (Compress)
-              ? <Compress file={file} showSnack={this.showSnack} />
+              ? <Compress file={file} showSnack={this.showSnack} onBack={this.onBack} />
               : <loading-spinner class={style.appLoader}/>
           }
           <snack-bar ref={linkRef(this, 'snackbar')} />

src/components/Options/index.tsx

@@ -35,7 +35,7 @@ import {
 import { QuantizeOptions } from '../../codecs/imagequant/processor-meta';
 import { ResizeOptions } from '../../codecs/resize/processor-meta';
 import { PreprocessorState } from '../../codecs/preprocessors';
-import { SourceImage } from '../App';
+import { SourceImage } from '../compress';
 import Checkbox from '../checkbox';
 import Expander from '../expander';
 import Select from '../select';
@@ -81,7 +81,7 @@ export default class Options extends Component<Props, State> {
   }
 
   @bind
-  onEncoderTypeChange(event: Event) {
+  private onEncoderTypeChange(event: Event) {
     const el = event.currentTarget as HTMLSelectElement;
 
     // The select element only has values matching encoder types,
@@ -91,7 +91,7 @@ export default class Options extends Component<Props, State> {
   }
 
   @bind
-  onPreprocessorEnabledChange(event: Event) {
+  private onPreprocessorEnabledChange(event: Event) {
     const el = event.currentTarget as HTMLInputElement;
     const preprocessor = el.name.split('.')[0] as keyof PreprocessorState;
 
@@ -101,14 +101,14 @@ export default class Options extends Component<Props, State> {
   }
 
   @bind
-  onQuantizerOptionsChange(opts: QuantizeOptions) {
+  private onQuantizerOptionsChange(opts: QuantizeOptions) {
     this.props.onPreprocessorOptionsChange(
       cleanMerge(this.props.preprocessorState, 'quantizer', opts),
     );
   }
 
   @bind
-  onResizeOptionsChange(opts: ResizeOptions) {
+  private onResizeOptionsChange(opts: ResizeOptions) {
     this.props.onPreprocessorOptionsChange(
       cleanMerge(this.props.preprocessorState, 'resize', opts),
     );
@@ -144,7 +144,7 @@ export default class Options extends Component<Props, State> {
                 {preprocessorState.resize.enabled ?
                   <ResizeOptionsComponent
                     isVector={Boolean(source && source.vectorImage)}
-                    aspect={source ? (source.data.width / source.data.height) : 1}
+                    aspect={source ? source.processed.width / source.processed.height : 1}
                     options={preprocessorState.resize}
                     onChange={this.onResizeOptionsChange}
                   />

src/components/Options/style.scss

@@ -43,6 +43,7 @@ $horizontalPadding: 15px;
 
 .text-field {
   background: #fff;
+  color: #000;
   font: inherit;
   border: none;
   padding: 2px 0 2px 10px;
@@ -54,4 +55,5 @@ $horizontalPadding: 15px;
 .options-scroller {
   overflow-x: hidden;
   overflow-y: auto;
+  -webkit-overflow-scrolling: touch;
 }

src/components/Output/custom-els/PinchZoom/index.ts

@@ -242,7 +242,7 @@ export default class PinchZoom extends HTMLElement {
   /**
    * Update transform values without checking bounds. This is only called in setTransform.
    */
-  _updateTransform(scale: number, x: number, y: number, allowChangeEvent: boolean) {
+  private _updateTransform(scale: number, x: number, y: number, allowChangeEvent: boolean) {
     // Avoid scaling to zero
     if (scale < MIN_SCALE) return;
 

src/components/Output/custom-els/TwoUp/index.ts

@@ -70,12 +70,13 @@ export default class TwoUp extends HTMLElement {
   connectedCallback() {
     this._childrenChange();
 
+    this._handle.innerHTML = `<div class="${styles.scrubber}">${
+      `<svg viewBox="0 0 27 20" fill="currentColor">${
+        '<path d="M17 19.2l9.5-9.6L16.9 0zM9.6 0L0 9.6l9.6 9.6z"/>'
+      }</svg>`
+    }</div>`;
+
     if (!this._everConnected) {
-      this._handle.innerHTML = `<div class="${styles.scrubber}">${
-        `<svg viewBox="0 0 27 20" fill="currentColor">${
-          '<path d="M17 19.2l9.5-9.6L16.9 0zM9.6 0L0 9.6l9.6 9.6z"/>'
-        }</svg>`
-      }</div>`;
       this._resetPosition();
       this._everConnected = true;
     }

src/components/Output/index.tsx

@@ -5,16 +5,29 @@ import './custom-els/TwoUp';
 import * as style from './style.scss';
 import { bind, linkRef } from '../../lib/initial-util';
 import { shallowEqual, drawDataToCanvas } from '../../lib/util';
-import { ToggleIcon, AddIcon, RemoveIcon } from '../../lib/icons';
+import {
+    ToggleBackgroundIcon,
+    AddIcon,
+    RemoveIcon,
+    BackIcon,
+    ToggleBackgroundActiveIcon,
+    RotateIcon,
+} from '../../lib/icons';
 import { twoUpHandle } from './custom-els/TwoUp/styles.css';
+import { InputProcessorState } from '../../codecs/input-processors';
+import { cleanSet } from '../../lib/clean-modify';
+import { SourceImage } from '../compress';
 
 interface Props {
-  originalImage?: ImageData;
+  source?: SourceImage;
+  inputProcessorState?: InputProcessorState;
   mobileView: boolean;
   leftCompressed?: ImageData;
   rightCompressed?: ImageData;
   leftImgContain: boolean;
   rightImgContain: boolean;
+  onBack: () => void;
+  onInputProcessorChange: (newState: InputProcessorState) => void;
 }
 
 interface State {
@@ -47,6 +60,15 @@ export default class Output extends Component<Props, State> {
     const leftDraw = this.leftDrawable();
     const rightDraw = this.rightDrawable();
 
+    // Reset the pinch zoom, which may have an position set from the previous view, after pressing
+    // the back button.
+    this.pinchZoomLeft!.setTransform({
+      allowChangeEvent: true,
+      x: 0,
+      y: 0,
+      scale: 1,
+    });
+
     if (this.canvasLeft && leftDraw) {
       drawDataToCanvas(this.canvasLeft, leftDraw);
     }
@@ -60,6 +82,38 @@ export default class Output extends Component<Props, State> {
     const prevRightDraw = this.rightDrawable(prevProps);
     const leftDraw = this.leftDrawable();
     const rightDraw = this.rightDrawable();
+    const sourceFileChanged =
+      // Has the value become (un)defined?
+      (!!this.props.source !== !!prevProps.source) ||
+      // Or has the file changed?
+      (this.props.source && prevProps.source && this.props.source.file !== prevProps.source.file);
+
+    const oldSourceData = prevProps.source && prevProps.source.processed;
+    const newSourceData = this.props.source && this.props.source.processed;
+    const pinchZoom = this.pinchZoomLeft!;
+
+    if (sourceFileChanged) {
+      // New image? Reset the pinch-zoom.
+      pinchZoom.setTransform({
+        allowChangeEvent: true,
+        x: 0,
+        y: 0,
+        scale: 1,
+      });
+    } else if (oldSourceData && newSourceData && oldSourceData !== newSourceData) {
+      // Since the pinch zoom transform origin is the top-left of the content, we need to flip
+      // things around a bit when the content size changes, so the new content appears as if it were
+      // central to the previous content.
+      const scaleChange = 1 - pinchZoom.scale;
+      const oldXScaleOffset = oldSourceData.width / 2 * scaleChange;
+      const oldYScaleOffset = oldSourceData.height / 2 * scaleChange;
+
+      pinchZoom.setTransform({
+        allowChangeEvent: true,
+        x: pinchZoom.x - oldXScaleOffset + oldYScaleOffset,
+        y: pinchZoom.y - oldYScaleOffset + oldXScaleOffset,
+      });
+    }
 
     if (leftDraw && leftDraw !== prevLeftDraw && this.canvasLeft) {
       drawDataToCanvas(this.canvasLeft, leftDraw);
@@ -67,16 +121,6 @@ export default class Output extends Component<Props, State> {
     if (rightDraw && rightDraw !== prevRightDraw && this.canvasRight) {
       drawDataToCanvas(this.canvasRight, rightDraw);
     }
-
-    if (this.props.originalImage !== prevProps.originalImage && this.pinchZoomLeft) {
-      // New image? Reset the pinch-zoom.
-      this.pinchZoomLeft.setTransform({
-        allowChangeEvent: true,
-        x: 0,
-        y: 0,
-        scale: 1,
-      });
-    }
   }
 
   shouldComponentUpdate(nextProps: Props, nextState: State) {
@@ -84,11 +128,11 @@ export default class Output extends Component<Props, State> {
   }
 
   private leftDrawable(props: Props = this.props): ImageData | undefined {
-    return props.leftCompressed || props.originalImage;
+    return props.leftCompressed || (props.source && props.source.processed);
   }
 
   private rightDrawable(props: Props = this.props): ImageData | undefined {
-    return props.rightCompressed || props.originalImage;
+    return props.rightCompressed || (props.source && props.source.processed);
   }
 
   @bind
@@ -112,6 +156,20 @@ export default class Output extends Component<Props, State> {
     this.pinchZoomLeft.scaleTo(this.state.scale / 1.25, scaleToOpts);
   }
 
+  @bind
+  private onRotateClick() {
+    const { inputProcessorState } = this.props;
+    if (!inputProcessorState) return;
+
+    const newState = cleanSet(
+      inputProcessorState,
+      'rotate.rotate',
+      (inputProcessorState.rotate.rotate + 90) % 360,
+    );
+
+    this.props.onInputProcessorChange(newState);
+  }
+
   @bind
   private onScaleValueFocus() {
     this.setState({ editingScale: true }, () => {
@@ -177,14 +235,27 @@ export default class Output extends Component<Props, State> {
     const clonedEvent = new (event.constructor as typeof Event)(event.type, event);
     this.retargetedEvents.add(clonedEvent);
     this.pinchZoomLeft.dispatchEvent(clonedEvent);
+
+    // Unfocus any active element on touchend. This fixes an issue on (at least) Android Chrome,
+    // where the software keyboard is hidden, but the input remains focused, then after interaction
+    // with this element the keyboard reappears for NO GOOD REASON. Thanks Android.
+    if (
+      event.type === 'touchend' &&
+      document.activeElement &&
+      document.activeElement instanceof HTMLElement
+    ) {
+      document.activeElement.blur();
+    }
   }
 
   render(
-    { mobileView, leftImgContain, rightImgContain, originalImage }: Props,
+    { mobileView, leftImgContain, rightImgContain, source, onBack }: Props,
     { scale, editingScale, altBackground }: State,
   ) {
     const leftDraw = this.leftDrawable();
     const rightDraw = this.rightDrawable();
+    // To keep position stable, the output is put in a square using the longest dimension.
+    const originalImage = source && source.processed;
 
     return (
       <div class={`${style.output} ${altBackground ? style.altBackground : ''}`}>
@@ -206,7 +277,7 @@ export default class Output extends Component<Props, State> {
             ref={linkRef(this, 'pinchZoomLeft')}
           >
             <canvas
-              class={style.outputCanvas}
+              class={style.pinchTarget}
               ref={linkRef(this, 'canvasLeft')}
               width={leftDraw && leftDraw.width}
               height={leftDraw && leftDraw.height}
@@ -219,7 +290,7 @@ export default class Output extends Component<Props, State> {
           </pinch-zoom>
           <pinch-zoom class={style.pinchZoom} ref={linkRef(this, 'pinchZoomRight')}>
             <canvas
-              class={style.outputCanvas}
+              class={style.pinchTarget}
               ref={linkRef(this, 'canvasRight')}
               width={rightDraw && rightDraw.width}
               height={rightDraw && rightDraw.height}
@@ -232,6 +303,12 @@ export default class Output extends Component<Props, State> {
           </pinch-zoom>
         </two-up>
 
+        <div class={style.back}>
+          <button class={style.button} onClick={onBack}>
+            <BackIcon />
+          </button>
+        </div>
+
         <div class={style.controls}>
           <div class={style.zoomControls}>
             <button class={style.button} onClick={this.zoomOut}>
@@ -259,10 +336,21 @@ export default class Output extends Component<Props, State> {
               <AddIcon />
             </button>
           </div>
-          <button class={style.button} onClick={this.toggleBackground}>
-            <ToggleIcon />
-            Toggle Background
-          </button>
+          <div class={style.buttonsNoWrap}>
+            <button class={style.button} onClick={this.onRotateClick} title="Rotate image">
+              <RotateIcon />
+            </button>
+            <button
+              class={`${style.button} ${altBackground ? style.active : ''}`}
+              onClick={this.toggleBackground}
+              title="Change canvas color"
+            >
+              {altBackground
+                ? <ToggleBackgroundActiveIcon />
+                : <ToggleBackgroundIcon />
+              }
+            </button>
+          </div>
         </div>
       </div>
     );

src/components/Output/style.scss

@@ -31,6 +31,15 @@
   align-items: center;
 }
 
+.pinch-target {
+  // This fixes a severe painting bug in Chrome.
+  // We should try to remove this once the issue is fixed.
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=870222#c10
+  will-change: auto;
+  // Prevent the image becoming misshapen due to default flexbox layout.
+  flex-shrink: 0;
+}
+
 .controls {
   position: absolute;
   display: flex;
@@ -38,7 +47,7 @@
   top: 0;
   left: 0;
   right: 0;
-  padding: 9px;
+  padding: 9px 84px;
   overflow: hidden;
   flex-wrap: wrap;
   contain: content;
@@ -50,10 +59,12 @@
   }
 
   @media (min-width: 860px) {
+    padding: 9px;
     top: auto;
     left: 320px;
     right: 320px;
     bottom: 0;
+    flex-wrap: wrap-reverse;
   }
 }
 
@@ -78,14 +89,20 @@
   display: flex;
   align-items: center;
   box-sizing: border-box;
-  height: 48px;
-  padding: 0 16px;
   margin: 4px;
   background-color: #fff;
   border: 1px solid rgba(0,0,0,0.2);
   border-radius: 5px;
   line-height: 1;
   white-space: nowrap;
+  height: 36px;
+  padding: 0 8px;
+  cursor: pointer;
+
+  @media (min-width: 600px) {
+    height: 48px;
+    padding: 0 16px;
+  }
 
   &:focus {
     box-shadow: 0 0 0 2px var(--button-fg);
@@ -95,15 +112,20 @@
 }
 
 .button {
-  text-transform: uppercase;
   color: var(--button-fg);
-  cursor: pointer;
-  text-indent: 6px;
-  font-size: 110%;
 
   &:hover {
     background-color: #eee;
   }
+
+  &.active {
+    background: #34B9EB;
+    color: #fff;
+
+    &:hover {
+      background: #32a3ce;
+    }
+  }
 }
 
 .zoom {
@@ -127,10 +149,18 @@
   border-bottom: 1px dashed #999;
 }
 
-.output-canvas {
-  flex-shrink: 0;
-  // This fixes a severe painting bug in Chrome.
-  // We should try to remove this once the issue is fixed.
-  // https://bugs.chromium.org/p/chromium/issues/detail?id=870222#c10
-  will-change: auto;
+.back {
+  position: absolute;
+  top: 0;
+  left: 0;
+  padding: 9px;
+}
+
+.buttons-no-wrap {
+  display: flex;
+  pointer-events: none;
+
+  & > * {
+    pointer-events: auto;
+  }
 }

src/components/compress/custom-els/MultiPanel/index.ts

@@ -103,7 +103,7 @@ export default class MultiPanel extends HTMLElement {
 
   // KeyDown event handler
   private _onKeyDown(event: KeyboardEvent) {
-    const selectedEl = document.activeElement;
+    const selectedEl = document.activeElement!;
     const heading = getClosestHeading(selectedEl);
 
     // if keydown event is not on heading element, ignore
@@ -252,8 +252,8 @@ export default class MultiPanel extends HTMLElement {
       return this.firstElementChild as HTMLElement;
     }
     // previous Element of active Element is previous Content,
-    // previous Element of previous Content  is previousHeading
-    const previousContent = document.activeElement.previousElementSibling;
+    // previous Element of previous Content is previousHeading
+    const previousContent = document.activeElement!.previousElementSibling;
     if (previousContent) {
       return previousContent.previousElementSibling as HTMLElement;
     }
@@ -263,7 +263,7 @@ export default class MultiPanel extends HTMLElement {
   private _nextHeading() {
     // activeElement would be the currently selected heading
     // 2 elemements after that would be the next heading.
-    const nextContent = document.activeElement.nextElementSibling;
+    const nextContent = document.activeElement!.nextElementSibling;
     if (nextContent) {
       return nextContent.nextElementSibling as HTMLElement;
     }

src/components/compress/index.tsx

@@ -35,21 +35,29 @@ import { VectorResizeOptions, BitmapResizeOptions } from '../../codecs/resize/pr
 import './custom-els/MultiPanel';
 import Results from '../results';
 import { ExpandIcon, CopyAcrossIconProps } from '../../lib/icons';
-import SnackBarElement from 'src/lib/SnackBar';
+import SnackBarElement from '../../lib/SnackBar';
+import { InputProcessorState, defaultInputProcessorState } from '../../codecs/input-processors';
 
 export interface SourceImage {
   file: File | Fileish;
-  data: ImageData;
+  decoded: ImageData;
+  processed: ImageData;
   vectorImage?: HTMLImageElement;
+  inputProcessorState: InputProcessorState;
 }
 
-interface EncodedImage {
+interface SideSettings {
+  preprocessorState: PreprocessorState;
+  encoderState: EncoderState;
+}
+
+interface Side {
   preprocessed?: ImageData;
   file?: Fileish;
   downloadUrl?: string;
   data?: ImageData;
-  preprocessorState: PreprocessorState;
-  encoderState: EncoderState;
+  latestSettings: SideSettings;
+  encodedSettings?: SideSettings;
   loading: boolean;
   /** Counter of the latest bmp currently encoding */
   loadingCounter: number;
@@ -60,11 +68,12 @@ interface EncodedImage {
 interface Props {
   file: File | Fileish;
   showSnack: SnackBarElement['showSnackbar'];
+  onBack: () => void;
 }
 
 interface State {
   source?: SourceImage;
-  images: [EncodedImage, EncodedImage];
+  sides: [Side, Side];
   /** Source image load */
   loading: boolean;
   loadingCounter: number;
@@ -76,12 +85,27 @@ interface UpdateImageOptions {
   skipPreprocessing?: boolean;
 }
 
+async function processInput(
+  data: ImageData,
+  inputProcessData: InputProcessorState,
+  processor: Processor,
+) {
+  let processedData = data;
+
+  if (inputProcessData.rotate.rotate !== 0) {
+    processedData = await processor.rotate(processedData, inputProcessData.rotate);
+  }
+
+  return processedData;
+}
+
 async function preprocessImage(
   source: SourceImage,
   preprocessData: PreprocessorState,
   processor: Processor,
 ): Promise<ImageData> {
-  let result = source.data;
+  let result = source.processed;
+
   if (preprocessData.resize.enabled) {
     if (preprocessData.resize.method === 'vector' && source.vectorImage) {
       result = processor.vectorResize(
@@ -130,6 +154,26 @@ async function compressImage(
   );
 }
 
+function stateForNewSourceData(state: State, newSource: SourceImage): State {
+  let newState = { ...state };
+
+  for (const i of [0, 1]) {
+    // Ditch previous encodings
+    const downloadUrl = state.sides[i].downloadUrl;
+    if (downloadUrl) URL.revokeObjectURL(downloadUrl!);
+
+    newState = cleanMerge(state, `sides.${i}`, {
+      preprocessed: undefined,
+      file: undefined,
+      downloadUrl: undefined,
+      data: undefined,
+      encodedSettings: undefined,
+    });
+  }
+
+  return newState;
+}
+
 async function processSvg(blob: Blob): Promise<HTMLImageElement> {
   // Firefox throws if you try to draw an SVG to canvas that doesn't have width/height.
   // In Chrome it loads, but drawImage behaves weirdly.
@@ -161,6 +205,8 @@ const resultTitles = ['Top', 'Bottom'];
 const buttonPositions =
   ['download-left', 'download-right'] as ('download-left' | 'download-right')[];
 
+const originalDocumentTitle = document.title;
+
 export default class Compress extends Component<Props, State> {
   widthQuery = window.matchMedia('(max-width: 599px)');
 
@@ -168,17 +214,21 @@ export default class Compress extends Component<Props, State> {
     source: undefined,
     loading: false,
     loadingCounter: 0,
-    images: [
+    sides: [
       {
-        preprocessorState: defaultPreprocessorState,
-        encoderState: { type: identity.type, options: identity.defaultOptions },
+        latestSettings: {
+          preprocessorState: defaultPreprocessorState,
+          encoderState: { type: identity.type, options: identity.defaultOptions },
+        },
         loadingCounter: 0,
         loadedCounter: 0,
         loading: false,
       },
       {
-        preprocessorState: defaultPreprocessorState,
-        encoderState: { type: mozJPEG.type, options: mozJPEG.defaultOptions },
+        latestSettings: {
+          preprocessorState: defaultPreprocessorState,
+          encoderState: { type: mozJPEG.type, options: mozJPEG.defaultOptions },
+        },
         loadingCounter: 0,
         loadedCounter: 0,
         loading: false,
@@ -195,6 +245,8 @@ export default class Compress extends Component<Props, State> {
     super(props);
     this.widthQuery.addListener(this.onMobileWidthChange);
     this.updateFile(props.file);
+
+    import('../../lib/offliner').then(({ mainAppLoaded }) => mainAppLoaded());
   }
 
   @bind
@@ -204,7 +256,7 @@ export default class Compress extends Component<Props, State> {
 
   private onEncoderTypeChange(index: 0 | 1, newType: EncoderType): void {
     this.setState({
-      images: cleanSet(this.state.images, `${index}.encoderState`, {
+      sides: cleanSet(this.state.sides, `${index}.latestSettings.encoderState`, {
         type: newType,
         options: encoderMap[newType].defaultOptions,
       }),
@@ -213,37 +265,50 @@ export default class Compress extends Component<Props, State> {
 
   private onPreprocessorOptionsChange(index: 0 | 1, options: PreprocessorState): void {
     this.setState({
-      images: cleanSet(this.state.images, `${index}.preprocessorState`, options),
+      sides: cleanSet(this.state.sides, `${index}.latestSettings.preprocessorState`, options),
     });
   }
 
   private onEncoderOptionsChange(index: 0 | 1, options: EncoderOptions): void {
     this.setState({
-      images: cleanSet(this.state.images, `${index}.encoderState.options`, options),
+      sides: cleanSet(this.state.sides, `${index}.latestSettings.encoderState.options`, options),
     });
   }
 
+  private updateDocumentTitle(filename: string = ''): void {
+    document.title = filename ? `${filename} - ${originalDocumentTitle}` : originalDocumentTitle;
+  }
+
   componentWillReceiveProps(nextProps: Props): void {
     if (nextProps.file !== this.props.file) {
       this.updateFile(nextProps.file);
     }
   }
 
-  componentDidUpdate(prevProps: Props, prevState: State): void {
-    const { source, images } = this.state;
+  componentWillUnmount(): void {
+    this.updateDocumentTitle();
+  }
 
-    for (const [i, image] of images.entries()) {
-      const prevImage = prevState.images[i];
-      const sourceChanged = source !== prevState.source;
-      const encoderChanged = image.encoderState !== prevImage.encoderState;
-      const preprocessorChanged = image.preprocessorState !== prevImage.preprocessorState;
+  componentDidUpdate(prevProps: Props, prevState: State): void {
+    const { source, sides } = this.state;
+
+    const sourceDataChanged =
+      // Has the source object become set/unset?
+      !!source !== !!prevState.source ||
+      // Or has the processed data changed?
+      (source && prevState.source && source.processed !== prevState.source.processed);
+
+    for (const [i, side] of sides.entries()) {
+      const prevSettings = prevState.sides[i].latestSettings;
+      const encoderChanged = side.latestSettings.encoderState !== prevSettings.encoderState;
+      const preprocessorChanged =
+        side.latestSettings.preprocessorState !== prevSettings.preprocessorState;
 
       // The image only needs updated if the encoder/preprocessor settings have changed, or the
       // source has changed.
-      if (sourceChanged || encoderChanged || preprocessorChanged) {
-        if (prevImage.downloadUrl) URL.revokeObjectURL(prevImage.downloadUrl);
+      if (sourceDataChanged || encoderChanged || preprocessorChanged) {
         this.updateImage(i, {
-          skipPreprocessing: !sourceChanged && !preprocessorChanged,
+          skipPreprocessing: !sourceDataChanged && !preprocessorChanged,
         }).catch((err) => {
           console.error(err);
         });
@@ -253,10 +318,10 @@ export default class Compress extends Component<Props, State> {
 
   private async onCopyToOtherClick(index: 0 | 1) {
     const otherIndex = (index + 1) % 2;
-    const oldSettings = this.state.images[otherIndex];
+    const oldSettings = this.state.sides[otherIndex];
 
     this.setState({
-      images: cleanSet(this.state.images, otherIndex, this.state.images[index]),
+      sides: cleanSet(this.state.sides, otherIndex, this.state.sides[index]),
     });
 
     const result = await this.props.showSnack('Settings copied across', {
@@ -267,13 +332,67 @@ export default class Compress extends Component<Props, State> {
     if (result !== 'undo') return;
 
     this.setState({
-      images: cleanSet(this.state.images, otherIndex, oldSettings),
+      sides: cleanSet(this.state.sides, otherIndex, oldSettings),
     });
   }
 
+  @bind
+  private async onInputProcessorChange(options: InputProcessorState): Promise<void> {
+    const source = this.state.source;
+    if (!source) return;
+
+    const oldRotate = source.inputProcessorState.rotate.rotate;
+    const newRotate = options.rotate.rotate;
+    const orientationChanged = oldRotate % 180 !== newRotate % 180;
+    const loadingCounter = this.state.loadingCounter + 1;
+    // Either processor is good enough here.
+    const processor = this.leftProcessor;
+
+    this.setState({
+      loadingCounter, loading: true,
+      source: cleanSet(source, 'inputProcessorState', options),
+    });
+
+    // Abort any current encode jobs, as they're redundant now.
+    this.leftProcessor.abortCurrent();
+    this.rightProcessor.abortCurrent();
+
+    try {
+      const processed = await processInput(source.decoded, options, processor);
+
+      // Another file has been opened/processed before this one processed.
+      if (this.state.loadingCounter !== loadingCounter) return;
+
+      let newState = { ...this.state, loading: false };
+      newState = cleanSet(newState, 'source.processed', processed);
+      newState = stateForNewSourceData(newState, newState.source!);
+
+      if (orientationChanged) {
+        // If orientation has changed, we should flip the resize values.
+        for (const i of [0, 1]) {
+          const resizeSettings = newState.sides[i].latestSettings.preprocessorState.resize;
+          newState = cleanMerge(newState, `sides.${i}.latestSettings.preprocessorState.resize`, {
+            width: resizeSettings.height,
+            height: resizeSettings.width,
+          });
+        }
+      }
+      this.setState(newState);
+    } catch (err) {
+      if (err.name === 'AbortError') return;
+      console.error(err);
+      // Another file has been opened/processed before this one processed.
+      if (this.state.loadingCounter !== loadingCounter) return;
+      this.props.showSnack('Processing error');
+      this.setState({ loading: false });
+    }
+  }
+
   @bind
   private async updateFile(file: File | Fileish) {
     const loadingCounter = this.state.loadingCounter + 1;
+    // Either processor is good enough here.
+    const processor = this.leftProcessor;
 
     this.setState({ loadingCounter, loading: true });
 
@@ -282,7 +401,7 @@ export default class Compress extends Component<Props, State> {
     this.rightProcessor.abortCurrent();
 
     try {
-      let data: ImageData;
+      let decoded: ImageData;
       let vectorImage: HTMLImageElement | undefined;
 
       // Special-case SVG. We need to avoid createImageBitmap because of
@@ -290,46 +409,43 @@ export default class Compress extends Component<Props, State> {
       // Also, we cache the HTMLImageElement so we can perform vector resizing later.
       if (file.type.startsWith('image/svg+xml')) {
         vectorImage = await processSvg(file);
-        data = drawableToImageData(vectorImage);
+        decoded = drawableToImageData(vectorImage);
       } else {
         // Either processor is good enough here.
-        data = await decodeImage(file, this.leftProcessor);
+        decoded = await decodeImage(file, processor);
       }
 
-      // Another file has been opened before this one processed.
+      const processed = await processInput(decoded, defaultInputProcessorState, processor);
+
+      // Another file has been opened/processed before this one processed.
       if (this.state.loadingCounter !== loadingCounter) return;
 
       let newState: State = {
         ...this.state,
-        source: { data, file, vectorImage },
+        source: {
+          decoded, file, vectorImage, processed,
+          inputProcessorState: defaultInputProcessorState,
+        },
         loading: false,
       };
 
+      newState = stateForNewSourceData(newState, newState.source!);
+
       for (const i of [0, 1]) {
-        // Ditch previous encodings
-        const downloadUrl = this.state.images[i].downloadUrl;
-        if (downloadUrl) URL.revokeObjectURL(downloadUrl!);
-
-        newState = cleanMerge(newState, `images.${i}`, {
-          preprocessed: undefined,
-          file: undefined,
-          downloadUrl: undefined,
-          data: undefined,
-        });
-
         // Default resize values come from the image:
-        newState = cleanMerge(newState, `images.${i}.preprocessorState.resize`, {
-          width: data.width,
-          height: data.height,
+        newState = cleanMerge(newState, `sides.${i}.latestSettings.preprocessorState.resize`, {
+          width: processed.width,
+          height: processed.height,
           method: vectorImage ? 'vector' : 'browser-high',
         });
       }
 
+      this.updateDocumentTitle(file.name);
       this.setState(newState);
     } catch (err) {
       if (err.name === 'AbortError') return;
       console.error(err);
-      // Another file has been opened before this one processed.
+      // Another file has been opened/processed before this one processed.
       if (this.state.loadingCounter !== loadingCounter) return;
       this.props.showSnack('Invalid image');
       this.setState({ loading: false });
@@ -337,26 +453,31 @@ export default class Compress extends Component<Props, State> {
   }
 
   private async updateImage(index: number, options: UpdateImageOptions = {}): Promise<void> {
-    const { skipPreprocessing = false } = options;
+    const {
+      skipPreprocessing = false,
+    } = options;
     const { source } = this.state;
     if (!source) return;
 
     // Each time we trigger an async encode, the counter changes.
-    const loadingCounter = this.state.images[index].loadingCounter + 1;
+    const loadingCounter = this.state.sides[index].loadingCounter + 1;
 
-    let images = cleanMerge(this.state.images, index, {
+    let sides = cleanMerge(this.state.sides, index, {
       loadingCounter,
       loading: true,
     });
 
-    this.setState({ images });
+    this.setState({ sides });
 
-    const image = images[index];
+    const side = sides[index];
+    const settings = side.latestSettings;
 
     let file: File | Fileish | undefined;
     let preprocessed: ImageData | undefined;
     let data: ImageData | undefined;
-    const cacheResult = this.encodeCache.match(source, image.preprocessorState, image.encoderState);
+    const cacheResult = this.encodeCache.match(
+      source.processed, settings.preprocessorState, settings.encoderState,
+    );
     const processor = (index === 0) ? this.leftProcessor : this.rightProcessor;
 
     // Abort anything the processor is currently doing.
@@ -369,60 +490,66 @@ export default class Compress extends Component<Props, State> {
     } else {
       try {
         // Special case for identity
-        if (image.encoderState.type === identity.type) {
-          ({ file, data } = source);
+        if (settings.encoderState.type === identity.type) {
+          file = source.file;
+          data = source.processed;
         } else {
-          preprocessed = (skipPreprocessing && image.preprocessed)
-            ? image.preprocessed
-            : await preprocessImage(source, image.preprocessorState, processor);
+          preprocessed = (skipPreprocessing && side.preprocessed)
+            ? side.preprocessed
+            : await preprocessImage(source, settings.preprocessorState, processor);
 
-          file = await compressImage(preprocessed, image.encoderState, source.file.name, processor);
+          file = await compressImage(
+            preprocessed, settings.encoderState, source.file.name, processor,
+          );
           data = await decodeImage(file, processor);
 
           this.encodeCache.add({
-            source,
             data,
             preprocessed,
             file,
-            encoderState: image.encoderState,
-            preprocessorState: image.preprocessorState,
+            sourceData: source.processed,
+            encoderState: settings.encoderState,
+            preprocessorState: settings.preprocessorState,
           });
         }
       } catch (err) {
         if (err.name === 'AbortError') return;
-        this.props.showSnack(`Processing error (type=${image.encoderState.type}): ${err}`);
+        this.props.showSnack(`Processing error (type=${settings.encoderState.type}): ${err}`);
         throw err;
       }
     }
 
-    const latestImage = this.state.images[index];
+    const latestData = this.state.sides[index];
     // If a later encode has landed before this one, return.
-    if (loadingCounter < latestImage.loadedCounter) {
+    if (loadingCounter < latestData.loadedCounter) {
       return;
     }
 
-    images = cleanMerge(this.state.images, index, {
+    if (latestData.downloadUrl) URL.revokeObjectURL(latestData.downloadUrl);
+
+    sides = cleanMerge(this.state.sides, index, {
       file,
       data,
       preprocessed,
       downloadUrl: URL.createObjectURL(file),
-      loading: images[index].loadingCounter !== loadingCounter,
+      loading: sides[index].loadingCounter !== loadingCounter,
       loadedCounter: loadingCounter,
+      encodedSettings: settings,
     });
 
-    this.setState({ images });
+    this.setState({ sides });
   }
 
-  render({ }: Props, { loading, images, source, mobileView }: State) {
-    const [leftImage, rightImage] = images;
-    const [leftImageData, rightImageData] = images.map(i => i.data);
+  render({ onBack }: Props, { loading, sides, source, mobileView }: State) {
+    const [leftSide, rightSide] = sides;
+    const [leftImageData, rightImageData] = sides.map(i => i.data);
 
-    const options = images.map((image, index) => (
+    const options = sides.map((side, index) => (
       <Options
         source={source}
         mobileView={mobileView}
-        preprocessorState={image.preprocessorState}
-        encoderState={image.encoderState}
+        preprocessorState={side.latestSettings.preprocessorState}
+        encoderState={side.latestSettings.encoderState}
         onEncoderTypeChange={this.onEncoderTypeChange.bind(this, index)}
         onEncoderOptionsChange={this.onEncoderOptionsChange.bind(this, index)}
         onPreprocessorOptionsChange={this.onPreprocessorOptionsChange.bind(this, index)}
@@ -432,32 +559,44 @@ export default class Compress extends Component<Props, State> {
     const copyDirections =
       (mobileView ? ['down', 'up'] : ['right', 'left']) as CopyAcrossIconProps['copyDirection'][];
 
-    const results = images.map((image, index) => (
+    const results = sides.map((side, index) => (
       <Results
-        downloadUrl={image.downloadUrl}
-        imageFile={image.file}
+        downloadUrl={side.downloadUrl}
+        imageFile={side.file}
         source={source}
-        loading={loading || image.loading}
+        loading={loading || side.loading}
         copyDirection={copyDirections[index]}
         onCopyToOtherClick={this.onCopyToOtherClick.bind(this, index)}
         buttonPosition={mobileView ? 'stack-right' : buttonPositions[index]}
       >
         {!mobileView ? null : [
           <ExpandIcon class={style.expandIcon} key="expand-icon"/>,
-          `${resultTitles[index]} (${encoderMap[image.encoderState.type].label})`,
+          `${resultTitles[index]} (${encoderMap[side.latestSettings.encoderState.type].label})`,
         ]}
       </Results>
     ));
 
+    // For rendering, we ideally want the settings that were used to create the data, not the latest
+    // settings.
+    const leftDisplaySettings = leftSide.encodedSettings || leftSide.latestSettings;
+    const rightDisplaySettings = rightSide.encodedSettings || rightSide.latestSettings;
+    const leftImgContain = leftDisplaySettings.preprocessorState.resize.enabled &&
+      leftDisplaySettings.preprocessorState.resize.fitMethod === 'contain';
+    const rightImgContain = rightDisplaySettings.preprocessorState.resize.enabled &&
+      rightDisplaySettings.preprocessorState.resize.fitMethod === 'contain';
+
     return (
       <div class={style.compress}>
         <Output
-          originalImage={source && source.data}
+          source={source}
           mobileView={mobileView}
           leftCompressed={leftImageData}
           rightCompressed={rightImageData}
-          leftImgContain={leftImage.preprocessorState.resize.fitMethod === 'cover'}
-          rightImgContain={rightImage.preprocessorState.resize.fitMethod === 'cover'}
+          leftImgContain={leftImgContain}
+          rightImgContain={rightImgContain}
+          onBack={onBack}
+          inputProcessorState={source && source.inputProcessorState}
+          onInputProcessorChange={this.onInputProcessorChange}
         />
         {mobileView
           ? (

src/components/compress/result-cache.ts

@@ -1,7 +1,6 @@
 import { EncoderState } from '../../codecs/encoders';
 import { Fileish } from '../../lib/initial-util';
 import { shallowEqual } from '../../lib/util';
-import { SourceImage } from '.';
 import { PreprocessorState } from '../../codecs/preprocessors';
 
 import * as identity from '../../codecs/identity/encoder-meta';
@@ -15,7 +14,7 @@ interface CacheResult {
 interface CacheEntry extends CacheResult {
   preprocessorState: PreprocessorState;
   encoderState: EncoderState;
-  source: SourceImage;
+  sourceData: ImageData;
 }
 
 const SIZE = 5;
@@ -32,13 +31,13 @@ export default class ResultCache {
   }
 
   match(
-    source: SourceImage,
+    sourceData: ImageData,
     preprocessorState: PreprocessorState,
     encoderState: EncoderState,
   ): CacheResult | undefined {
     const matchingIndex = this._entries.findIndex((entry) => {
       // Check for quick exits:
-      if (entry.source !== source) return false;
+      if (entry.sourceData !== sourceData) return false;
       if (entry.encoderState.type !== encoderState.type) return false;
 
       // Check that each set of options in the preprocessor are the same

src/components/compress/style.scss

@@ -22,7 +22,7 @@
   max-width: 400px;
   margin: 0 auto;
   width: calc(100% - 60px);
-  max-height: calc(100% - 143px);
+  max-height: calc(100% - 104px);
   overflow: hidden;
 
   @media (min-width: 600px) {
@@ -32,7 +32,7 @@
   }
 
   @media (min-width: 860px) {
-    max-height: 100%;
+    max-height: calc(100% - 40px);
   }
 }
 

src/components/intro/index.tsx

@@ -4,13 +4,13 @@ import { bind, linkRef, Fileish } from '../../lib/initial-util';
 import '../custom-els/LoadingSpinner';
 
 import logo from './imgs/logo.svg';
-import largePhoto from './imgs/demos/large-photo.jpg';
-import artwork from './imgs/demos/artwork.jpg';
-import deviceScreen from './imgs/demos/device-screen.png';
-import largePhotoIcon from './imgs/demos/large-photo-icon.jpg';
-import artworkIcon from './imgs/demos/artwork-icon.jpg';
-import deviceScreenIcon from './imgs/demos/device-screen-icon.jpg';
-import logoIcon from './imgs/demos/logo-icon.png';
+import largePhoto from './imgs/demos/demo-large-photo.jpg';
+import artwork from './imgs/demos/demo-artwork.jpg';
+import deviceScreen from './imgs/demos/demo-device-screen.png';
+import largePhotoIcon from './imgs/demos/icon-demo-large-photo.jpg';
+import artworkIcon from './imgs/demos/icon-demo-artwork.jpg';
+import deviceScreenIcon from './imgs/demos/icon-demo-device-screen.jpg';
+import logoIcon from './imgs/demos/icon-demo-logo.png';
 import * as style from './style.scss';
 import SnackBarElement from '../../lib/SnackBar';
 
@@ -90,7 +90,7 @@ export default class Intro extends Component<Props, State> {
         <div>
           <div class={style.logoSizer}>
             <div class={style.logoContainer}>
-              <img src={logo} class={style.logo} alt="Squoosh" />
+              <img src={logo} class={style.logo} alt="Squoosh" decoding="async" />
             </div>
           </div>
           <p class={style.openImageGuide}>
@@ -111,7 +111,7 @@ export default class Intro extends Component<Props, State> {
                   <div class={style.demo}>
                     <div class={style.demoImgContainer}>
                       <div class={style.demoImgAspect}>
-                        <img class={style.demoIcon} src={demo.iconUrl} alt=""/>
+                        <img class={style.demoIcon} src={demo.iconUrl} alt="" decoding="async" />
                         {fetchingDemoIndex === i &&
                           <div class={style.demoLoading}>
                             <loading-spinner class={style.demoLoadingSpinner}/>
@@ -129,6 +129,11 @@ export default class Intro extends Component<Props, State> {
         <ul class={style.relatedLinks}>
           <li><a href="https://github.com/GoogleChromeLabs/squoosh/">View the code</a></li>
           <li><a href="https://github.com/GoogleChromeLabs/squoosh/issues">Report a bug</a></li>
+          <li>
+            <a href="https://github.com/GoogleChromeLabs/squoosh/blob/master/README.md#privacy">
+              Privacy
+            </a>
+          </li>
         </ul>
       </div>
     );

src/components/intro/style.scss

@@ -2,6 +2,7 @@
   font-family: 'intro-text';
   font-style: normal;
   font-weight: 300;
+  font-display: block;
   // This only contains the chars for "Drag & drop or"
   src: url('data:font/woff2;base64,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') format('woff2');
 }
@@ -10,6 +11,7 @@
   font-family: 'intro-text';
   font-style: normal;
   font-weight: 500;
+  font-display: block;
   // Only contains the chars for "select an image"
   src: url('data:font/woff2;base64,d09GMgABAAAAAAXMAA4AAAAACwQAAAV5AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhYbg1IcMAZgAGwRCAqJUId/CxoAATYCJAMwBCAFgnAHIBskCcjEh6dNff8Ou/9Tj9VZGnUhJeqFzWGiVVOkxkTthr9f6kWkRdsBbkIj3YuLaloFZWr7aBg22z7IOoWqBWCW5cZU3GBrh0n+dAcBYAUlzYHAzWTYchqKXEyAT0zOLIS1qqm+B8q2ur4OhEMy0PHHUH8KklaSr8T0mp/EU7kRvXlI1E09HXA1qLN8Djxa0AsSDOg3cJARb9mtQJoSK3gvEn372/gcAigg/gOnbsT/MYv491GTReW4rJC5LA+h5FFclF6QQgoZ5Kx7GbsuGeytUgFClkOomY2Gdake3m9HegkHieAx/a0hBTALsy4jvpxBcnFXUnjC+2ZS5zHnDeEaJVwi+ZWqzOm4Uvgy4k6kGv4kFDVkfjk1gkVRRkk2zlo42PBbRJmG30cClJQjak7BnfQqHza4ITKftQZ/ZMUaEiyy1+mYCh4clKhDA5rQglZ0oG9jw+qiNvT+SfxIXCeuFdeIq8VV4gpxyRaGOl0JiChiCocfc7e93DwZIPvWgPiZJLcJugxyjW7UQyl4TJk6dWqYU7Cn0WQiWnNJCdGeprqjW63fpVS3mKy4YGZ6I3ya4nbIVgM1mwkpNEBzixlNxfPmH7owvdE4973OM9quvk11dwvnzDUy/Zn5S5Ywpn/PeqXBQI2m4lna05CRtsI6+GIENjS9K4jWRHUGYA2ozdZm2Smmf0DI3aqpeNbsJfxe7YdFmcZAn5gXLCFa2/Umqiu017APFhMZ0rfQp4sJX0ZrJ+n9UtAljr5VYWb6oj1MrpvX3qe6u8WRJg0bj7aPkDOa7m+E0Oa9Y8eY/gbRbr+efH7hcO49bMd28fbDVHcUmm3XkozQGKjeBHSJ4TQnI879LIFmF2v/BJuEQlffJPfE9oKayS/PsPE44fvM4MsBESxbuEEV39d5pw6oW4vD6S1WQC3UpSbHNbK0Jikl0bphSs+0CGW8Ew4Kzw7zarmcVz873JHTFhKYay18R8vY0ozPiHPAGyROAqlW5fLj5+HbWBn9TpgekKsOy8N+4dlFfL9i/Nk3+gY1bwzZUAvLVNiFpvqHRenetSoVrgn2obGtPsltEVxEeHJAQFhyBIcHT9rDvTJm06e0TLgase2gd2RffGJNg0o1zrdRyi9s1bYE5bi85cK+o/nUwvBR5+jweEBaSMoCub29fEFISmib9Dn5yl5kVFpoGrPQSmZhafQ7WimttNCH7Cktohb6kFpoEfIsdDF7SgvZTbaY3mKFyLXQh+wpzWE3mUNQQkWnR+lgiW9Afkunej49Nz3sYlI8XFTRdkNhUR5d6h4oOpJc8OjcItMXVqoHW2fSW6ycWuiM8NDYoICouLAZ9BYrwwmhycvKlt4Q8hUlCV5nZ7vOm2ut2rizcFpuWpSrT3K1Z3xinbuHnXBTyGAljV/XzHZaNGu6y7vLDziMpIyUdOBBRXXlxznUQiOoheZsZk9njG8er1mNmz2eOCQ3x9BbLP+Zxt+VrbEz9aWxmimRvyl4/sumyoM/nw+LNzV4/uP0/9T/P5f08cvhl38USAS/xTYs2fL/VNFF0vd+SVsRB/khPwW4SCi5SHhx8fDgVPAiAqIJRQL/EuK5bsRzNnAiezD1i7u2VyHHAKRU+E2YUaA5DUsE2ZfbApAmsJcxjBwmQ2Xk4Y2BqZJ+oxSzsNEogz1O3/xkBMKEBHSiC8PoQStaoEIflPCHL/wQBCUKoUITlMhHP+olt5ojykUPOrEQTWgY+f449KMPKnSiB72jGrLQhEZO24925LtbkG5DndTkD2/4um+NQBEyUIJsRBxX24tcDGmbWtGJjq05jhzTaMgCcR+6EA4f+KAXDay5u6RsL7xJsm3w3mzvFvggB8nI/AYBdVnxNvx/2wA=') format('woff2');
 }
@@ -19,7 +21,6 @@
 }
 
 .intro {
-  composes: abs-fill from '../../lib/util.scss';
   display: grid;
   grid-template-rows: 1fr min-content;
   align-items: center;
@@ -29,6 +30,9 @@
   -webkit-overflow-scrolling: touch;
   overflow: auto;
   padding: 20px 0 0;
+  height: 100%;
+  box-sizing: border-box;
+  overscroll-behavior: contain;
 }
 
 .logo-container {
@@ -38,16 +42,17 @@
 
 .logo-sizer {
   width: 90%;
-  max-width: 480px;
+  max-width: 52vh;
   margin: 0 auto;
 }
 
 .logo {
   composes: abs-fill from '../../lib/util.scss';
+  pointer-events: none;
 }
 
 .open-image-guide {
-  font: 300 11vw intro-text;
+  font: 300 11vw intro-text, sans-serif;
   margin-bottom: 0;
 
   @media (min-width: 460px) {
@@ -140,6 +145,7 @@
 
 .demo-icon {
   composes: abs-fill from '../../lib/util.scss';
+  pointer-events: none;
 }
 
 .demo-description {

src/components/range/index.tsx

@@ -13,6 +13,8 @@ export default class Range extends Component<Props, State> {
   @bind
   private onTextInput(event: Event) {
     const input = event.target as HTMLInputElement;
+    const value = input.value.trim();
+    if (!value) return;
     this.rangeWc!.value = input.value;
     const { onInput } = this.props;
     if (onInput) onInput(event);

src/components/results/index.tsx

@@ -58,6 +58,21 @@ export default class Results extends Component<Props, State> {
     this.props.onCopyToOtherClick();
   }
 
+  @bind
+  onDownload() {
+    // GA can’t do floats. So we round to ints. We're deliberately rounding to nearest kilobyte to
+    // avoid cases where exact image sizes leak something interesting about the user.
+    const before = Math.round(this.props.source!.file.size / 1024);
+    const after = Math.round(this.props.imageFile!.size / 1024);
+    const change = Math.round(after / before * 1000);
+
+    ga('send', 'event', 'compression', 'download', {
+      metric1: before,
+      metric2: after,
+      metric3: change,
+    });
+  }
+
   render(
     { source, imageFile, downloadUrl, children, copyDirection, buttonPosition }: Props,
     { showLoadingState }: State,
@@ -93,6 +108,7 @@ export default class Results extends Component<Props, State> {
               href={downloadUrl}
               download={imageFile.name}
               title="Download"
+              onClick={this.onDownload}
             >
               <DownloadIcon class={style.downloadIcon} />
             </a>

src/index.html

@@ -4,13 +4,13 @@
     <meta charset="utf-8">
     <title>Squoosh</title>
     <meta name="description" content="Compress and compare images with different codecs, right in your browser">
-    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
     <meta name="mobile-web-app-capable" content="yes">
     <meta name="apple-mobile-web-app-capable" content="yes">
-    <meta name="theme-color" content="#673ab8">
+    <link rel="shortcut icon" href="/assets/favicon.ico">
+    <meta name="theme-color" content="#f78f21">
     <link rel="manifest" href="/manifest.json">
   </head>
   <body>
-    <div id="app"></div>
   </body>
 </html>

src/index.ts

@@ -1,9 +1,25 @@
 declare module '@webcomponents/custom-elements';
 
-(async function () {
-  if (!('customElements' in self)) {
-    await import('@webcomponents/custom-elements');
-  }
-
+function init() {
   require('./init-app.tsx');
-})();
+}
+
+if (!('customElements' in self)) {
+  import(
+    /* webpackChunkName: "wc-polyfill" */
+    '@webcomponents/custom-elements',
+  ).then(init);
+} else {
+  init();
+}
+
+if (typeof PRERENDER === 'undefined') {
+  window.ga = window.ga || ((...args) => (ga.q = ga.q || []).push(args));
+  ga('create', 'UA-128752250-1', 'auto');
+  ga('set', 'transport', 'beacon');
+  ga('send', 'pageview');
+    // Load the GA script
+  const s = document.createElement('script');
+  s.src = 'https://www.google-analytics.com/analytics.js';
+  document.head!.appendChild(s);
+}

src/init-app.tsx

@@ -4,13 +4,13 @@ import './style';
 import App from './components/App';
 
 // Find the outermost Element in our server-rendered HTML structure.
-let root = document.querySelector('#app') || undefined;
+let root = document.getElementById('app_root') as Element;
 
 // "attach" the client-side rendering to it, updating the DOM in-place instead of replacing:
 root = render(<App />, document.body, root);
+root.setAttribute('id', 'app_root');
 
-// In production, this entire condition is removed.
-if (process.env.NODE_ENV === 'development') {
+if (process.env.NODE_ENV !== 'production') {
   // Enable support for React DevTools and some helpful console warnings:
   require('preact/debug');
 

src/lib/SnackBar/index.ts

@@ -8,12 +8,9 @@ export interface SnackOptions {
 function createSnack(message: string, options: SnackOptions): [Element, Promise<string>] {
   const {
     timeout = 0,
-    actions = [],
+    actions = ['dismiss'],
   } = options;
 
-  // Provide a default 'dismiss' action
-  if (!timeout && actions.length === 0) actions.push('dismiss');
-
   const el = document.createElement('div');
   el.className = style.snackbar;
   el.setAttribute('aria-live', 'assertive');

src/lib/icons.tsx

@@ -12,9 +12,21 @@ export const DownloadIcon = (props: JSX.HTMLAttributes) => (
   </Icon>
 );
 
-export const ToggleIcon = (props: JSX.HTMLAttributes) => (
+export const ToggleBackgroundIcon = (props: JSX.HTMLAttributes) => (
   <Icon {...props}>
-    <path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm2 4v-2H3c0 1.1.89 2 2 2zM3 9h2V7H3v2zm12 12h2v-2h-2v2zm4-18H9c-1.11 0-2 .9-2 2v10c0 1.1.89 2 2 2h10c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 12H9V5h10v10zm-8 6h2v-2h-2v2zm-4 0h2v-2H7v2z" />
+    <path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm2 4v-2H3c0 1.1.9 2 2 2zM3 9h2V7H3v2zm12 12h2v-2h-2v2zm4-18H9a2 2 0 0 0-2 2v10c0 1.1.9 2 2 2h10a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2zm0 12H9V5h10v10zm-8 6h2v-2h-2v2zm-4 0h2v-2H7v2z"/>
+  </Icon>
+);
+
+export const ToggleBackgroundActiveIcon = (props: JSX.HTMLAttributes) => (
+  <Icon {...props}>
+    <path d="M9 7H7v2h2V7zm0 4H7v2h2v-2zm0-8a2 2 0 0 0-2 2h2V3zm4 12h-2v2h2v-2zm6-12v2h2a2 2 0 0 0-2-2zm-6 0h-2v2h2V3zM9 17v-2H7c0 1.1.9 2 2 2zm10-4h2v-2h-2v2zm0-4h2V7h-2v2zm0 8a2 2 0 0 0 2-2h-2v2zM5 7H3v12c0 1.1.9 2 2 2h12v-2H5V7zm10-2h2V3h-2v2zm0 12h2v-2h-2v2z"/>
+  </Icon>
+);
+
+export const RotateIcon = (props: JSX.HTMLAttributes) => (
+  <Icon {...props}>
+    <path d="M15.6 5.5L11 1v3a8 8 0 0 0 0 16v-2a6 6 0 0 1 0-12v4l4.5-4.5zm4.3 5.5a8 8 0 0 0-1.6-3.9L17 8.5c.5.8.9 1.6 1 2.5h2zM13 17.9v2a8 8 0 0 0 3.9-1.6L15.5 17c-.8.5-1.6.9-2.5 1zm3.9-2.4l1.4 1.4A8 8 0 0 0 20 13h-2c-.1.9-.5 1.7-1 2.5z"/>
   </Icon>
 );
 
@@ -48,6 +60,12 @@ export const ExpandIcon = (props: JSX.HTMLAttributes) => (
   </Icon>
 );
 
+export const BackIcon = (props: JSX.HTMLAttributes) => (
+  <Icon {...props}>
+    <path d="M20 11H7.8l5.6-5.6L12 4l-8 8 8 8 1.4-1.4L7.8 13H20v-2z"/>
+  </Icon>
+);
+
 const copyAcrossRotations = {
   up: 90, right: 180, down: -90, left: 0,
 };

src/lib/offliner.ts

@@ -0,0 +1,98 @@
+import { get, set } from 'idb-keyval';
+
+// Just for TypeScript
+import SnackBarElement from './SnackBar';
+
+/** Tell the service worker to skip waiting */
+async function skipWaiting() {
+  const reg = await navigator.serviceWorker.getRegistration();
+  if (!reg || !reg.waiting) return;
+  reg.waiting.postMessage('skip-waiting');
+}
+
+/** Find the service worker that's 'active' or closest to 'active' */
+async function getMostActiveServiceWorker() {
+  const reg = await navigator.serviceWorker.getRegistration();
+  if (!reg) return null;
+  return reg.active || reg.waiting || reg.installing;
+}
+
+/** Wait for an installing worker */
+async function installingWorker(reg: ServiceWorkerRegistration): Promise<ServiceWorker> {
+  if (reg.installing) return reg.installing;
+  return new Promise<ServiceWorker>((resolve) => {
+    reg.addEventListener(
+      'updatefound',
+      () => resolve(reg.installing!),
+      { once: true },
+    );
+  });
+}
+
+/** Wait a service worker to become waiting */
+async function updateReady(reg: ServiceWorkerRegistration): Promise<void> {
+  if (reg.waiting) return;
+  const installing = await installingWorker(reg);
+  return new Promise<void>((resolve) => {
+    installing.addEventListener('statechange', () => {
+      if (installing.state === 'installed') resolve();
+    });
+  });
+}
+
+/** Set up the service worker and monitor changes */
+export async function offliner(showSnack: SnackBarElement['showSnackbar']) {
+  // This needs to be a typeof because Webpack.
+  if (typeof PRERENDER === 'boolean') return;
+
+  if (process.env.NODE_ENV === 'production') {
+    navigator.serviceWorker.register('../sw');
+  }
+
+  const hasController = !!navigator.serviceWorker.controller;
+
+  // Look for changes in the controller
+  navigator.serviceWorker.addEventListener('controllerchange', async () => {
+    // Is it the first install?
+    if (!hasController) {
+      showSnack('Ready to work offline', { timeout: 5000 });
+      return;
+    }
+
+    // Otherwise reload (the user will have agreed to this).
+    location.reload();
+  });
+
+  // If we don't have a controller, we don't need to check for updates – we've just loaded from the
+  // network.
+  if (!hasController) return;
+
+  const reg = await navigator.serviceWorker.getRegistration();
+  // Service worker not registered yet.
+  if (!reg) return;
+  // Look for updates
+  await updateReady(reg);
+
+  // Ask the user if they want to update.
+  const result = await showSnack('Update available', {
+    actions: ['reload', 'dismiss'],
+  });
+
+  // Tell the waiting worker to activate, this will change the controller and cause a reload (see
+  // 'controllerchange')
+  if (result === 'reload') skipWaiting();
+}
+
+/**
+ * Tell the service worker the main app has loaded. If it's the first time the service worker has
+ * heard about this, cache the heavier assets like codecs.
+ */
+export async function mainAppLoaded() {
+  // If the user has already interacted, no need to tell the service worker anything.
+  const userInteracted = await get<boolean | undefined>('user-interacted');
+  if (userInteracted) return;
+  set('user-interacted', true);
+  const serviceWorker = await getMostActiveServiceWorker();
+  if (!serviceWorker) return; // Service worker not installing yet.
+  serviceWorker.postMessage('cache-all');
+}

src/lib/util.ts

@@ -297,3 +297,10 @@ export async function transitionHeight(el: HTMLElement, opts: TransitionOptions)
     el.addEventListener('transitioncancel', listener);
   });
 }
+
+/**
+ * Simple event listener that prevents the default.
+ */
+export function preventDefault(event: Event) {
+  event.preventDefault();
+}

src/manifest.json

@@ -3,14 +3,14 @@
   "short_name": "Squoosh",
   "start_url": "/",
   "display": "standalone",
-  "orientation": "portrait",
+  "orientation": "any",
   "background_color": "#fff",
-  "theme_color": "#673ab8",
+  "theme_color": "#f78f21",
   "icons": [
     {
-      "src": "/assets/icon.png",
+      "src": "/assets/icon-large.png",
       "type": "image/png",
-      "sizes": "512x512"
+      "sizes": "1024x1024"
     }
   ]
-}
+}

src/missing-types.d.ts

@@ -27,3 +27,15 @@ declare module '*.wasm' {
   const content: string;
   export default content;
 }
+
+declare module 'url-loader!*' {
+  const value: string;
+  export default value;
+}
+
+declare var VERSION: string;
+
+declare var ga: {
+  (...args: any[]): void;
+  q: any[];
+};

src/style/index.scss

@@ -2,7 +2,6 @@
 
 html, body {
   height: 100%;
-  width: 100%;
   padding: 0;
   margin: 0;
   font: 12px/1.3 system-ui, -apple-system, BlinkMacSystemFont, Roboto, Helvetica, sans-serif;

src/sw/index.ts

@@ -0,0 +1,69 @@
+import {
+  cacheOrNetworkAndCache, cleanupCache, cacheOrNetwork, cacheBasics, cacheAdditionalProcessors,
+} from './util';
+import { get } from 'idb-keyval';
+
+// Give TypeScript the correct global.
+declare var self: ServiceWorkerGlobalScope;
+// This is populated by webpack.
+declare var BUILD_ASSETS: string[];
+
+const versionedCache = 'static-' + VERSION;
+const dynamicCache = 'dynamic';
+const expectedCaches = [versionedCache, dynamicCache];
+
+self.addEventListener('install', (event) => {
+  event.waitUntil(async function () {
+    const promises = [];
+    promises.push(cacheBasics(versionedCache, BUILD_ASSETS));
+
+    // If the user has already interacted with the app, update the codecs too.
+    if (await get('user-interacted')) {
+      promises.push(cacheAdditionalProcessors(versionedCache, BUILD_ASSETS));
+    }
+
+    await Promise.all(promises);
+  }());
+});
+
+self.addEventListener('activate', (event) => {
+  self.clients.claim();
+
+  event.waitUntil(async function () {
+    // Remove old caches.
+    const promises = (await caches.keys()).map((cacheName) => {
+      if (!expectedCaches.includes(cacheName)) return caches.delete(cacheName);
+    });
+
+    await Promise.all<any>(promises);
+  }());
+});
+
+self.addEventListener('fetch', (event) => {
+  // We only care about GET.
+  if (event.request.method !== 'GET') return;
+
+  const url = new URL(event.request.url);
+
+  // Don't care about other-origin URLs
+  if (url.origin !== location.origin) return;
+
+  if (url.pathname.startsWith('/demo-') || url.pathname.startsWith('/wc-polyfill')) {
+    cacheOrNetworkAndCache(event, dynamicCache);
+    cleanupCache(event, dynamicCache, BUILD_ASSETS);
+    return;
+  }
+
+  cacheOrNetwork(event);
+});
+
+self.addEventListener('message', (event) => {
+  switch (event.data) {
+    case 'cache-all':
+      event.waitUntil(cacheAdditionalProcessors(versionedCache, BUILD_ASSETS));
+      break;
+    case 'skip-waiting':
+      self.skipWaiting();
+      break;
+  }
+});

src/sw/missing-types.d.ts

@@ -0,0 +1 @@
+import '../missing-types';

src/sw/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "strict": true,
+    "target": "esnext",
+    "module": "esnext",
+    "lib": [
+      "webworker",
+      "esnext"
+    ],
+    "moduleResolution": "node",
+    "experimentalDecorators": true,
+    "noUnusedLocals": true,
+    "sourceMap": true,
+    "allowJs": false,
+    "baseUrl": "."
+  }
+}

src/sw/util.ts

@@ -0,0 +1,106 @@
+import webpDataUrl from 'url-loader!../codecs/tiny.webp';
+
+export function cacheOrNetwork(event: FetchEvent): void {
+  event.respondWith(async function () {
+    const cachedResponse = await caches.match(event.request);
+    return cachedResponse || fetch(event.request);
+  }());
+}
+
+export function cacheOrNetworkAndCache(event: FetchEvent, cacheName: string): void {
+  event.respondWith(async function () {
+    const { request } = event;
+    // Return from cache if possible.
+    const cachedResponse = await caches.match(request);
+    if (cachedResponse) return cachedResponse;
+
+    // Else go to the network.
+    const response = await fetch(request);
+    const responseToCache = response.clone();
+
+    event.waitUntil(async function () {
+      // Cache what we fetched.
+      const cache = await caches.open(cacheName);
+      await cache.put(request, responseToCache);
+    }());
+
+    // Return the network response.
+    return response;
+  }());
+}
+
+export function cleanupCache(event: FetchEvent, cacheName: string, keepAssets: string[]) {
+  event.waitUntil(async function () {
+    const cache = await caches.open(cacheName);
+
+    // Clean old entries from the dynamic cache.
+    const requests = await cache.keys();
+    const promises = requests.map((cachedRequest) => {
+      // Get pathname without leading /
+      const assetPath = new URL(cachedRequest.url).pathname.slice(1);
+      // If it isn't one of our keepAssets, we don't need it anymore.
+      if (!keepAssets.includes(assetPath)) return cache.delete(cachedRequest);
+    });
+
+    await Promise.all<any>(promises);
+  }());
+}
+
+function getAssetsWithPrefix(assets: string[], prefixes: string[]) {
+  return assets.filter(
+    asset => prefixes.some(prefix => asset.startsWith(prefix)),
+  );
+}
+
+export async function cacheBasics(cacheName: string, buildAssets: string[]) {
+  const toCache = ['/', '/assets/favicon.ico'];
+
+  const prefixesToCache = [
+    // Main app JS & CSS:
+    'main-app.',
+    // Service worker handler:
+    'offliner.',
+    // Little icons for the demo images on the homescreen:
+    'icon-demo-',
+    // Site logo:
+    'logo.',
+  ];
+
+  const prefixMatches = getAssetsWithPrefix(buildAssets, prefixesToCache);
+
+  toCache.push(...prefixMatches);
+
+  const cache = await caches.open(cacheName);
+  await cache.addAll(toCache);
+}
+
+export async function cacheAdditionalProcessors(cacheName: string, buildAssets: string[]) {
+  let toCache = [];
+
+  const prefixesToCache = [
+    // Worker which handles image processing:
+    'processor-worker.',
+    // processor-worker imports:
+    'process-',
+  ];
+
+  const prefixMatches = getAssetsWithPrefix(buildAssets, prefixesToCache);
+  const wasm = buildAssets.filter(asset => asset.endsWith('.wasm'));
+
+  toCache.push(...prefixMatches, ...wasm);
+
+  const supportsWebP = await (async () => {
+    if (!self.createImageBitmap) return false;
+    const response = await fetch(webpDataUrl);
+    const blob = await response.blob();
+    return createImageBitmap(blob).then(() => true, () => false);
+  })();
+
+  // No point caching the WebP decoder if it's supported natively:
+  if (supportsWebP) {
+    toCache = toCache.filter(asset => !/webp[\-_]dec/.test(asset));
+  }
+
+  const cache = await caches.open(cacheName);
+  await cache.addAll(toCache);
+}

tsconfig.json

@@ -12,5 +12,9 @@
     "jsxFactory": "h",
     "allowJs": false,
     "baseUrl": "."
-  }
-}
+  },
+  "exclude": [
+    "src/sw/**/*",
+    "src/codecs/processor-worker/**/*"
+  ]
+}

webpack.config.js

@@ -2,23 +2,28 @@ const fs = require('fs');
 const path = require('path');
 const webpack = require('webpack');
 const CleanPlugin = require('clean-webpack-plugin');
-const UglifyJsPlugin = require('uglifyjs-webpack-plugin');
+const TerserPlugin = require('terser-webpack-plugin');
 const ProgressBarPlugin = require('progress-bar-webpack-plugin');
 const MiniCssExtractPlugin = require('mini-css-extract-plugin');
 const OptimizeCssAssetsPlugin = require('optimize-css-assets-webpack-plugin');
 const HtmlPlugin = require('html-webpack-plugin');
 const ScriptExtHtmlPlugin = require('script-ext-html-webpack-plugin');
-const ReplacePlugin = require('webpack-plugin-replace');
 const CopyPlugin = require('copy-webpack-plugin');
 const WatchTimestampsPlugin = require('./config/watch-timestamps-plugin');
 const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
 const WorkerPlugin = require('worker-plugin');
+const AutoSWPlugin = require('./config/auto-sw-plugin');
+const CrittersPlugin = require('critters-webpack-plugin');
+const AssetTemplatePlugin = require('./config/asset-template-plugin');
+const addCssTypes = require('./config/add-css-types');
 
 function readJson (filename) {
   return JSON.parse(fs.readFileSync(filename));
 }
 
-module.exports = function (_, env) {
+const VERSION = readJson('./package.json').version;
+
+module.exports = async function (_, env) {
   const isProd = env.mode === 'production';
   const nodeModules = path.join(__dirname, 'node_modules');
   const componentStyleDirs = [
@@ -28,14 +33,18 @@ module.exports = function (_, env) {
     path.join(__dirname, 'src/lib'),
   ];
 
+  await addCssTypes(componentStyleDirs, { watch: !isProd });
+
   return {
     mode: isProd ? 'production' : 'development',
-    entry: './src/index',
+    entry: {
+      'first-interaction': './src/index'
+    },
     devtool: isProd ? 'source-map' : 'inline-source-map',
     stats: 'minimal',
     output: {
       filename: isProd ? '[name].[chunkhash:5].js' : '[name].js',
-      chunkFilename: '[name].chunk.[chunkhash:5].js',
+      chunkFilename: '[name].[chunkhash:5].js',
       path: path.join(__dirname, 'build'),
       publicPath: '/',
       globalObject: 'self'
@@ -103,9 +112,7 @@ module.exports = function (_, env) {
             // In production, CSS is extracted to files on disk. In development, it's inlined into JS:
             isProd ? MiniCssExtractPlugin.loader : 'style-loader',
             {
-              // This is a fork of css-loader that auto-generates .d.ts files for CSS module imports.
-              // The result is a definition file with the exported String classname mappings.
-              loader: 'typings-for-css-modules-loader',
+              loader: 'css-loader',
               options: {
                 modules: true,
                 localIdentName: isProd ? '[hash:base64:5]' : '[local]__[hash:base64:5]',
@@ -138,12 +145,6 @@ module.exports = function (_, env) {
           exclude: nodeModules,
           loader: 'ts-loader'
         },
-        {
-          test: /\.jsx?$/,
-          loader: 'babel-loader',
-          // Don't respect any Babel RC files found on the filesystem:
-          options: Object.assign(readJson('.babelrc'), { babelrc: false })
-        },
         {
           // All the codec files define a global with the same name as their file name. `exports-loader` attaches those to `module.exports`.
           test: /\/codecs\/.*\.js$/,
@@ -154,16 +155,26 @@ module.exports = function (_, env) {
           // This is needed to make webpack NOT process wasm files.
           // See https://github.com/webpack/webpack/issues/6725
           type: 'javascript/auto',
-          loader: 'file-loader'
+          loader: 'file-loader',
+          options: {
+            name: '[name].[hash:5].[ext]',
+          },
         },
         {
           test: /\.(png|svg|jpg|gif)$/,
-          loader: 'file-loader'
+          loader: 'file-loader',
+          options: {
+            name: '[name].[hash:5].[ext]',
+          },
         }
       ]
     },
     plugins: [
-      new webpack.IgnorePlugin(/(fs|crypto|path)/, /\/codecs\//),
+      new webpack.IgnorePlugin(
+        /(fs|crypto|path)/,
+        new RegExp(`${path.sep}codecs${path.sep}`)
+      ),
+
       // Pretty progressbar showing build progress:
       new ProgressBarPlugin({
         format: '\u001b[90m\u001b[44mBuild\u001b[49m\u001b[39m [:bar] \u001b[32m\u001b[1m:percent\u001b[22m\u001b[39m (:elapseds) \u001b[2m:msg\u001b[22m\r',
@@ -195,7 +206,7 @@ module.exports = function (_, env) {
       // See also: https://twitter.com/wsokra/status/970253245733113856
       isProd && new MiniCssExtractPlugin({
         filename: '[name].[contenthash:5].css',
-        chunkFilename: '[name].chunk.[contenthash:5].css'
+        chunkFilename: '[name].[contenthash:5].css'
       }),
 
       new OptimizeCssAssetsPlugin({
@@ -220,7 +231,7 @@ module.exports = function (_, env) {
       // For now we're not doing SSR.
       new HtmlPlugin({
         filename: path.join(__dirname, 'build/index.html'),
-        template: 'src/index.html',
+        template: isProd ? '!!prerender-loader?string!src/index.html' : 'src/index.html',
         minify: isProd && {
           collapseWhitespace: true,
           removeScriptTypeAttributes: true,
@@ -229,32 +240,29 @@ module.exports = function (_, env) {
           removeComments: true
         },
         manifest: readJson('./src/manifest.json'),
-        inject: true,
+        inject: 'body',
         compile: true
       }),
 
+      new AutoSWPlugin({ version: VERSION }),
+
+      isProd && new AssetTemplatePlugin({
+        template: path.join(__dirname, '_headers.ejs'),
+        filename: '_headers',
+      }),
+
       new ScriptExtHtmlPlugin({
-        defaultAttribute: 'async'
+        inline: ['first']
       }),
 
       // Inline constants during build, so they can be folded by UglifyJS.
       new webpack.DefinePlugin({
+        VERSION: JSON.stringify(VERSION),
         // We set node.process=false later in this config.
         // Here we make sure if (process && process.foo) still works:
         process: '{}'
       }),
 
-      // Babel embeds helpful error messages into transpiled classes that we don't need in production.
-      // Here we replace the constructor and message with a static throw, leaving the message to be DCE'd.
-      // This is useful since it shows the message in SourceMapped code when debugging.
-      isProd && new ReplacePlugin({
-        include: /babel-helper$/,
-        patterns: [{
-          regex: /throw\s+(?:new\s+)?((?:Type|Reference)?Error)\s*\(/g,
-          value: (s, type) => `throw 'babel error'; (`
-        }]
-      }),
-
       // Copying files via Webpack allows them to be served dynamically by `webpack serve`
       new CopyPlugin([
         { from: 'src/manifest.json', to: 'manifest.json' },
@@ -266,17 +274,31 @@ module.exports = function (_, env) {
         analyzerMode: 'static',
         defaultSizes: 'gzip',
         openAnalyzer: false
+      }),
+
+      // Inline Critical CSS (for the intro screen, essentially)
+      isProd && new CrittersPlugin({
+        // use <link rel="stylesheet" media="not x" onload="this.media='all'"> hack to load async css:
+        preload: 'media',
+        // inline all styles from any stylesheet below this size:
+        inlineThreshold: 2000,
+        // don't bother lazy-loading non-critical stylesheets below this size, just inline the non-critical styles too:
+        minimumExternalSize: 4000,
+        // don't emit <noscript> external stylesheet links since the app fundamentally requires JS anyway:
+        noscriptFallback: false,
+        // inline the tiny data URL fonts we have for the intro screen:
+        inlineFonts: true,
+        // (and don't lazy load them):
+        preloadFonts: false
       })
     ].filter(Boolean), // Filter out any falsey plugin array entries.
 
     optimization: {
       minimizer: [
-        new UglifyJsPlugin({
+        new TerserPlugin({
           sourceMap: isProd,
-          extractComments: {
-            file: 'build/licenses.txt'
-          },
-          uglifyOptions: {
+          extractComments: 'build/licenses.txt',
+          terserOptions: {
             compress: {
               inline: 1
             },