wip

# Conflicts:
#	codecs/cpp.Dockerfile
#	codecs/imagequant/example.html
#	codecs/webp/dec/webp_dec.d.ts
#	codecs/webp/dec/webp_dec.js
#	codecs/webp/dec/webp_dec.wasm
#	codecs/webp/enc/webp_enc.d.ts
#	codecs/webp/enc/webp_enc.js
#	codecs/webp/enc/webp_enc.wasm
#	package-lock.json
#	package.json
#	src/codecs/tiny.webp
#	src_old/codecs/encoders.ts
#	src_old/codecs/processor-worker/tiny.avif
#	src_old/codecs/processor-worker/tiny.webp
#	src_old/codecs/tiny.webp
#	src_old/components/compress/index.tsx
#	src_old/lib/util.ts
#	src_old/sw/util.ts

lib/simple-ts.js

@@ -0,0 +1,130 @@
+/**
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { spawn } from 'child_process';
+import { relative, join } from 'path';
+import { promises as fsp } from 'fs';
+import { promisify } from 'util';
+
+import * as ts from 'typescript';
+import glob from 'glob';
+
+const globP = promisify(glob);
+
+const extRe = /\.tsx?$/;
+
+function loadConfig(mainPath) {
+  const fileName = ts.findConfigFile(mainPath, ts.sys.fileExists);
+  if (!fileName) throw Error('tsconfig not found');
+  const text = ts.sys.readFile(fileName);
+  const loadedConfig = ts.parseConfigFileTextToJson(fileName, text).config;
+  const parsedTsConfig = ts.parseJsonConfigFileContent(
+    loadedConfig,
+    ts.sys,
+    process.cwd(),
+    undefined,
+    fileName,
+  );
+  return parsedTsConfig;
+}
+
+export default function simpleTS(mainPath, { noBuild, watch } = {}) {
+  const config = loadConfig(mainPath);
+  const args = ['-b', mainPath];
+
+  let tsBuildDone;
+
+  async function watchBuiltFiles(rollupContext) {
+    const matches = await globP(config.options.outDir + '/**/*.js');
+    for (const match of matches) rollupContext.addWatchFile(match);
+  }
+
+  async function tsBuild(rollupContext) {
+    if (tsBuildDone) {
+      // Watch lists are cleared on each build, so we need to rewatch all the JS files.
+      await watchBuiltFiles(rollupContext);
+      return tsBuildDone;
+    }
+    if (noBuild) {
+      return (tsBuildDone = Promise.resolve());
+    }
+    tsBuildDone = Promise.resolve().then(async () => {
+      await new Promise((resolve) => {
+        const proc = spawn('tsc', args, {
+          stdio: 'inherit',
+        });
+
+        proc.on('exit', (code) => {
+          if (code !== 0) {
+            throw Error('TypeScript build failed');
+          }
+          resolve();
+        });
+      });
+
+      await watchBuiltFiles(rollupContext);
+
+      if (watch) {
+        tsBuildDone.then(() => {
+          spawn('tsc', [...args, '--watch', '--preserveWatchOutput'], {
+            stdio: 'inherit',
+          });
+        });
+      }
+    });
+
+    return tsBuildDone;
+  }
+
+  return {
+    name: 'simple-ts',
+    resolveId(id, importer) {
+      // If there isn't an importer, it's an entry point, so we don't need to resolve it relative
+      // to something.
+      if (!importer) return null;
+
+      const tsResolve = ts.resolveModuleName(
+        id,
+        importer,
+        config.options,
+        ts.sys,
+      );
+
+      if (
+        // It didn't find anything
+        !tsResolve.resolvedModule ||
+        // Or if it's linking to a definition file, it's something in node_modules,
+        // or something local like css.d.ts
+        tsResolve.resolvedModule.extension === '.d.ts'
+      ) {
+        return null;
+      }
+      return tsResolve.resolvedModule.resolvedFileName;
+    },
+    async load(id) {
+      if (!extRe.test(id)) return null;
+
+      // TypeScript building is deferred until the first TS file load.
+      // This allows prerequisites to happen first,
+      // such as css.d.ts generation in css-plugin.
+      await tsBuild(this);
+
+      // Look for the JS equivalent in the tmp folder
+      const newId = join(
+        config.options.outDir,
+        relative(process.cwd(), id),
+      ).replace(extRe, '.js');
+
+      return fsp.readFile(newId, { encoding: 'utf8' });
+    },
+  };
+}