condenser 0.2 → 0.3

data/lib/condenser/processors/node_modules/@babel/compat-data/native-modules.js

@@ -0,0 +1,4 @@
+// Node < 13.3 doesn't support export maps in package.json.
+// Use this proxy file as a fallback.
+
+module.exports = require("./data/native-modules.json");

data/lib/condenser/processors/node_modules/@babel/compat-data/overlapping-plugins.js

@@ -0,0 +1,4 @@
+// Node < 13.3 doesn't support export maps in package.json.
+// Use this proxy file as a fallback.
+
+module.exports = require("./data/overlapping-plugins.json");

data/lib/condenser/processors/node_modules/@babel/compat-data/package.json

@@ -0,0 +1,72 @@
+{
+  "_from": "@babel/compat-data@^7.9.0",
+  "_id": "@babel/compat-data@7.9.0",
+  "_inBundle": false,
+  "_integrity": "sha512-zeFQrr+284Ekvd9e7KAX954LkapWiOmQtsfHirhxqfdlX6MEC32iRE+pqUGlYIBchdevaCwvzxWGSy/YBNI85g==",
+  "_location": "/@babel/compat-data",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@babel/compat-data@^7.9.0",
+    "name": "@babel/compat-data",
+    "escapedName": "@babel%2fcompat-data",
+    "scope": "@babel",
+    "rawSpec": "^7.9.0",
+    "saveSpec": null,
+    "fetchSpec": "^7.9.0"
+  },
+  "_requiredBy": [
+    "/@babel/helper-compilation-targets",
+    "/@babel/preset-env"
+  ],
+  "_resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.9.0.tgz",
+  "_shasum": "04815556fc90b0c174abd2c0c1bb966faa036a6c",
+  "_spec": "@babel/compat-data@^7.9.0",
+  "_where": "/Users/malomalo/Code/condenser/lib/condenser/processors/node_modules/@babel/preset-env",
+  "author": {
+    "name": "The Babel Team",
+    "url": "https://babeljs.io/team"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "browserslist": "^4.9.1",
+    "invariant": "^2.2.4",
+    "semver": "^5.5.0"
+  },
+  "deprecated": false,
+  "description": "",
+  "devDependencies": {
+    "@babel/helper-compilation-targets": "^7.8.6",
+    "caniuse-db": "1.0.30001035",
+    "electron-to-chromium": "1.3.377",
+    "lodash": "^4.17.15"
+  },
+  "exports": {
+    "./plugins": "./data/plugins.json",
+    "./native-modules": "./data/native-modules.json",
+    "./corejs2-built-ins": "./data/corejs2-built-ins.json",
+    "./corejs3-shipped-proposals": "./data/corejs3-shipped-proposals.json",
+    "./overlapping-plugins": "./data/overlapping-plugins.json",
+    "./plugin-bugfixes": "./data/plugin-bugfixes.json"
+  },
+  "gitHead": "8d5e422be27251cfaadf8dd2536b31b4a5024b02",
+  "keywords": [
+    "babel",
+    "compat-table",
+    "compat-data"
+  ],
+  "license": "MIT",
+  "name": "@babel/compat-data",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel/tree/master/packages/babel-compat-data"
+  },
+  "scripts": {
+    "build-data": "./scripts/download-compat-table.sh; node ./scripts/build-data.js; node ./scripts/build-modules-support.js; node ./scripts/build-bugfixes-targets.js"
+  },
+  "version": "7.9.0"
+}

data/lib/condenser/processors/node_modules/@babel/compat-data/plugin-bugfixes.js

@@ -0,0 +1,4 @@
+// Node < 13.3 doesn't support export maps in package.json.
+// Use this proxy file as a fallback.
+
+module.exports = require("./data/plugin-bugfixes.json");

data/lib/condenser/processors/node_modules/@babel/compat-data/plugins.js

@@ -0,0 +1,4 @@
+// Node < 13.3 doesn't support export maps in package.json.
+// Use this proxy file as a fallback.
+
+module.exports = require("./data/plugins.json");

data/lib/condenser/processors/node_modules/@babel/core/lib/config/caching.js

@@ -3,73 +3,177 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.makeStrongCache = makeStrongCache;
 exports.makeWeakCache = makeWeakCache;
+exports.makeWeakCacheSync = makeWeakCacheSync;
+exports.makeStrongCache = makeStrongCache;
+exports.makeStrongCacheSync = makeStrongCacheSync;
 exports.assertSimpleType = assertSimpleType;
 
-function makeStrongCache(handler) {
-  return makeCachedFunction(new Map(), handler);
+function _gensync() {
+  const data = _interopRequireDefault(require("gensync"));
+
+  _gensync = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _async = require("../gensync-utils/async");
+
+var _util = require("./util");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const synchronize = gen => {
+  return (0, _gensync().default)(gen).sync;
+};
+
+function* genTrue(data) {
+  return true;
 }
 
 function makeWeakCache(handler) {
-  return makeCachedFunction(new WeakMap(), handler);
+  return makeCachedFunction(WeakMap, handler);
 }
 
-function makeCachedFunction(callCache, handler) {
-  return function cachedFunction(arg, data) {
-    let cachedValue = callCache.get(arg);
+function makeWeakCacheSync(handler) {
+  return synchronize(makeWeakCache(handler));
+}
 
-    if (cachedValue) {
-      for (const {
-        value,
-        valid
-      } of cachedValue) {
-        if (valid(data)) return value;
-      }
-    }
+function makeStrongCache(handler) {
+  return makeCachedFunction(Map, handler);
+}
 
-    const cache = new CacheConfigurator(data);
-    const value = handler(arg, cache);
-    if (!cache.configured()) cache.forever();
-    cache.deactivate();
+function makeStrongCacheSync(handler) {
+  return synchronize(makeStrongCache(handler));
+}
 
-    switch (cache.mode()) {
-      case "forever":
-        cachedValue = [{
-          value,
-          valid: () => true
-        }];
-        callCache.set(arg, cachedValue);
-        break;
+function makeCachedFunction(CallCache, handler) {
+  const callCacheSync = new CallCache();
+  const callCacheAsync = new CallCache();
+  const futureCache = new CallCache();
+  return function* cachedFunction(arg, data) {
+    const asyncContext = yield* (0, _async.isAsync)();
+    const callCache = asyncContext ? callCacheAsync : callCacheSync;
+    const cached = yield* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data);
+    if (cached.valid) return cached.value;
+    const cache = new CacheConfigurator(data);
+    const handlerResult = handler(arg, cache);
+    let finishLock;
+    let value;
+
+    if ((0, _util.isIterableIterator)(handlerResult)) {
+      const gen = handlerResult;
+      value = yield* (0, _async.onFirstPause)(gen, () => {
+        finishLock = setupAsyncLocks(cache, futureCache, arg);
+      });
+    } else {
+      value = handlerResult;
+    }
 
-      case "invalidate":
-        cachedValue = [{
-          value,
-          valid: cache.validator()
-        }];
-        callCache.set(arg, cachedValue);
-        break;
-
-      case "valid":
-        if (cachedValue) {
-          cachedValue.push({
-            value,
-            valid: cache.validator()
-          });
-        } else {
-          cachedValue = [{
-            value,
-            valid: cache.validator()
-          }];
-          callCache.set(arg, cachedValue);
-        }
+    updateFunctionCache(callCache, cache, arg, value);
 
+    if (finishLock) {
+      futureCache.delete(arg);
+      finishLock.release(value);
     }
 
     return value;
   };
 }
 
+function* getCachedValue(cache, arg, data) {
+  const cachedValue = cache.get(arg);
+
+  if (cachedValue) {
+    for (const {
+      value,
+      valid
+    } of cachedValue) {
+      if (yield* valid(data)) return {
+        valid: true,
+        value
+      };
+    }
+  }
+
+  return {
+    valid: false,
+    value: null
+  };
+}
+
+function* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data) {
+  const cached = yield* getCachedValue(callCache, arg, data);
+
+  if (cached.valid) {
+    return cached;
+  }
+
+  if (asyncContext) {
+    const cached = yield* getCachedValue(futureCache, arg, data);
+
+    if (cached.valid) {
+      const value = yield* (0, _async.waitFor)(cached.value.promise);
+      return {
+        valid: true,
+        value
+      };
+    }
+  }
+
+  return {
+    valid: false,
+    value: null
+  };
+}
+
+function setupAsyncLocks(config, futureCache, arg) {
+  const finishLock = new Lock();
+  updateFunctionCache(futureCache, config, arg, finishLock);
+  return finishLock;
+}
+
+function updateFunctionCache(cache, config, arg, value) {
+  if (!config.configured()) config.forever();
+  let cachedValue = cache.get(arg);
+  config.deactivate();
+
+  switch (config.mode()) {
+    case "forever":
+      cachedValue = [{
+        value,
+        valid: genTrue
+      }];
+      cache.set(arg, cachedValue);
+      break;
+
+    case "invalidate":
+      cachedValue = [{
+        value,
+        valid: config.validator()
+      }];
+      cache.set(arg, cachedValue);
+      break;
+
+    case "valid":
+      if (cachedValue) {
+        cachedValue.push({
+          value,
+          valid: config.validator()
+        });
+      } else {
+        cachedValue = [{
+          value,
+          valid: config.validator()
+        }];
+        cache.set(arg, cachedValue);
+      }
+
+  }
+}
+
 class CacheConfigurator {
   constructor(data) {
     this._active = true;
@@ -129,33 +233,35 @@ class CacheConfigurator {
 
     this._configured = true;
     const key = handler(this._data);
+    const fn = (0, _async.maybeAsync)(handler, `You appear to be using an async cache handler, but Babel has been called synchronously`);
 
-    this._pairs.push([key, handler]);
+    if ((0, _async.isThenable)(key)) {
+      return key.then(key => {
+        this._pairs.push([key, fn]);
+
+        return key;
+      });
+    }
+
+    this._pairs.push([key, fn]);
 
     return key;
   }
 
   invalidate(handler) {
-    if (!this._active) {
-      throw new Error("Cannot change caching after evaluation has completed.");
-    }
-
-    if (this._never || this._forever) {
-      throw new Error("Caching has already been configured with .never or .forever()");
-    }
-
     this._invalidate = true;
-    this._configured = true;
-    const key = handler(this._data);
-
-    this._pairs.push([key, handler]);
-
-    return key;
+    return this.using(handler);
   }
 
   validator() {
     const pairs = this._pairs;
-    return data => pairs.every(([key, fn]) => key === fn(data));
+    return function* (data) {
+      for (const [key, fn] of pairs) {
+        if (key !== (yield* fn(data))) return false;
+      }
+
+      return true;
+    };
   }
 
   deactivate() {
@@ -190,9 +296,29 @@ function makeSimpleConfigurator(cache) {
 }
 
 function assertSimpleType(value) {
+  if ((0, _async.isThenable)(value)) {
+    throw new Error(`You appear to be using an async cache handler, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously handle your caching logic.`);
+  }
+
   if (value != null && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number") {
     throw new Error("Cache keys must be either string, boolean, number, null, or undefined.");
   }
 
   return value;
+}
+
+class Lock {
+  constructor() {
+    this.released = false;
+    this.promise = new Promise(resolve => {
+      this._resolve = resolve;
+    });
+  }
+
+  release(value) {
+    this.released = true;
+
+    this._resolve(value);
+  }
+
 }

data/lib/condenser/processors/node_modules/@babel/core/lib/config/config-chain.js

@@ -41,8 +41,8 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 const debug = (0, _debug().default)("babel:config:config-chain");
 
-function buildPresetChain(arg, context) {
-  const chain = buildPresetChainWalker(arg, context);
+function* buildPresetChain(arg, context) {
+  const chain = yield* buildPresetChainWalker(arg, context);
   if (!chain) return null;
   return {
     plugins: dedupDescriptors(chain.plugins),
@@ -59,13 +59,13 @@ const buildPresetChainWalker = makeChainWalker({
   overridesEnv: (preset, index, envName) => loadPresetOverridesEnvDescriptors(preset)(index)(envName)
 });
 exports.buildPresetChainWalker = buildPresetChainWalker;
-const loadPresetDescriptors = (0, _caching.makeWeakCache)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors));
-const loadPresetEnvDescriptors = (0, _caching.makeWeakCache)(preset => (0, _caching.makeStrongCache)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName)));
-const loadPresetOverridesDescriptors = (0, _caching.makeWeakCache)(preset => (0, _caching.makeStrongCache)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index)));
-const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCache)(preset => (0, _caching.makeStrongCache)(index => (0, _caching.makeStrongCache)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName))));
+const loadPresetDescriptors = (0, _caching.makeWeakCacheSync)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors));
+const loadPresetEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName)));
+const loadPresetOverridesDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index)));
+const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName))));
 
-function buildRootChain(opts, context) {
-  const programmaticChain = loadProgrammaticChain({
+function* buildRootChain(opts, context) {
+  const programmaticChain = yield* loadProgrammaticChain({
     options: opts,
     dirname: context.cwd
   }, context);
@@ -73,9 +73,9 @@ function buildRootChain(opts, context) {
   let configFile;
 
   if (typeof opts.configFile === "string") {
-    configFile = (0, _files.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller);
+    configFile = yield* (0, _files.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller);
   } else if (opts.configFile !== false) {
-    configFile = (0, _files.findRootConfig)(context.root, context.envName, context.caller);
+    configFile = yield* (0, _files.findRootConfig)(context.root, context.envName, context.caller);
   }
 
   let {
@@ -87,7 +87,7 @@ function buildRootChain(opts, context) {
 
   if (configFile) {
     const validatedFile = validateConfigFile(configFile);
-    const result = loadFileChain(validatedFile, context);
+    const result = yield* loadFileChain(validatedFile, context);
     if (!result) return null;
 
     if (babelrc === undefined) {
@@ -102,7 +102,7 @@ function buildRootChain(opts, context) {
     mergeChain(configFileChain, result);
   }
 
-  const pkgData = typeof context.filename === "string" ? (0, _files.findPackageData)(context.filename) : null;
+  const pkgData = typeof context.filename === "string" ? yield* (0, _files.findPackageData)(context.filename) : null;
   let ignoreFile, babelrcFile;
   const fileChain = emptyChain();
 
@@ -110,14 +110,14 @@ function buildRootChain(opts, context) {
     ({
       ignore: ignoreFile,
       config: babelrcFile
-    } = (0, _files.findRelativeConfig)(pkgData, context.envName, context.caller));
+    } = yield* (0, _files.findRelativeConfig)(pkgData, context.envName, context.caller));
 
     if (ignoreFile && shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)) {
       return null;
     }
 
     if (babelrcFile) {
-      const result = loadFileChain(validateBabelrcFile(babelrcFile), context);
+      const result = yield* loadFileChain(validateBabelrcFile(babelrcFile), context);
       if (!result) return null;
       mergeChain(fileChain, result);
     }
@@ -163,17 +163,17 @@ function babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirector
   });
 }
 
-const validateConfigFile = (0, _caching.makeWeakCache)(file => ({
+const validateConfigFile = (0, _caching.makeWeakCacheSync)(file => ({
   filepath: file.filepath,
   dirname: file.dirname,
   options: (0, _options.validate)("configfile", file.options)
 }));
-const validateBabelrcFile = (0, _caching.makeWeakCache)(file => ({
+const validateBabelrcFile = (0, _caching.makeWeakCacheSync)(file => ({
   filepath: file.filepath,
   dirname: file.dirname,
   options: (0, _options.validate)("babelrcfile", file.options)
 }));
-const validateExtendFile = (0, _caching.makeWeakCache)(file => ({
+const validateExtendFile = (0, _caching.makeWeakCacheSync)(file => ({
   filepath: file.filepath,
   dirname: file.dirname,
   options: (0, _options.validate)("extendsfile", file.options)
@@ -190,10 +190,10 @@ const loadFileChain = makeChainWalker({
   overrides: (file, index) => loadFileOverridesDescriptors(file)(index),
   overridesEnv: (file, index, envName) => loadFileOverridesEnvDescriptors(file)(index)(envName)
 });
-const loadFileDescriptors = (0, _caching.makeWeakCache)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors));
-const loadFileEnvDescriptors = (0, _caching.makeWeakCache)(file => (0, _caching.makeStrongCache)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName)));
-const loadFileOverridesDescriptors = (0, _caching.makeWeakCache)(file => (0, _caching.makeStrongCache)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index)));
-const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCache)(file => (0, _caching.makeStrongCache)(index => (0, _caching.makeStrongCache)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName))));
+const loadFileDescriptors = (0, _caching.makeWeakCacheSync)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors));
+const loadFileEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName)));
+const loadFileOverridesDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index)));
+const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName))));
 
 function buildRootDescriptors({
   dirname,
@@ -235,7 +235,7 @@ function makeChainWalker({
   overrides,
   overridesEnv
 }) {
-  return (input, context, files = new Set()) => {
+  return function* (input, context, files = new Set()) {
     const {
       dirname
     } = input;
@@ -276,7 +276,7 @@ function makeChainWalker({
     const chain = emptyChain();
 
     for (const op of flattenedConfigs) {
-      if (!mergeExtendsChain(chain, op.options, dirname, context, files)) {
+      if (!(yield* mergeExtendsChain(chain, op.options, dirname, context, files))) {
         return null;
       }
 
@@ -287,16 +287,16 @@ function makeChainWalker({
   };
 }
 
-function mergeExtendsChain(chain, opts, dirname, context, files) {
+function* mergeExtendsChain(chain, opts, dirname, context, files) {
   if (opts.extends === undefined) return true;
-  const file = (0, _files.loadConfig)(opts.extends, dirname, context.envName, context.caller);
+  const file = yield* (0, _files.loadConfig)(opts.extends, dirname, context.envName, context.caller);
 
   if (files.has(file)) {
     throw new Error(`Configuration cycle detected loading ${file.filepath}.\n` + `File already loaded following the config chain:\n` + Array.from(files, file => ` - ${file.filepath}`).join("\n"));
   }
 
   files.add(file);
-  const fileChain = loadFileChain(validateExtendFile(file), context, files);
+  const fileChain = yield* loadFileChain(validateExtendFile(file), context, files);
   files.delete(file);
   if (!fileChain) return false;
   mergeChain(chain, fileChain);