@atlaspack/core 2.12.1-canary.3453 → 2.12.1-canary.3455

package/lib/SymbolPropagation.js

@@ -438,15 +438,7 @@ function propagateSymbolsDown(assetGraph, changedAssets, assetGroupsWithRemovedP
       wasNodeDirty = node.usedSymbolsDownDirty;
       node.usedSymbolsDownDirty = false;
     } else if (node.type === 'asset' && node.usedSymbolsDownDirty) {
-      visit(node, assetGraph.getIncomingDependencies(node.value).map(d => {
-        let dep = assetGraph.getNodeByContentKey(d.id);
-        (0, _assert().default)(dep && dep.type === 'dependency');
-        return dep;
-      }), outgoing.map(dep => {
-        let depNode = (0, _nullthrows().default)(assetGraph.getNode(dep));
-        (0, _assert().default)(depNode.type === 'dependency');
-        return depNode;
-      }));
+      visit(node, incomingDependencyNodesFromAsset(assetGraph, node.value), dependencyNodesFromIds(assetGraph, outgoing));
       node.usedSymbolsDownDirty = false;
     }
     for (let child of outgoing) {
@@ -494,23 +486,15 @@ function propagateSymbolsUp(assetGraph, changedAssets, changedDepsUsedSymbolsUpD
     let rootNodeId = (0, _nullthrows().default)(assetGraph.rootNodeId, 'A root node is required to traverse');
     const nodeVisitor = nodeId => {
       let node = (0, _nullthrows().default)(assetGraph.getNode(nodeId));
-      let outgoing = assetGraph.getNodeIdsConnectedFrom(nodeId);
-      for (let childId of outgoing) {
-        let child = (0, _nullthrows().default)(assetGraph.getNode(childId));
-        if (node.type === 'asset') {
-          (0, _assert().default)(child.type === 'dependency');
+      if (node.type === 'asset') {
+        let outgoing = outgoingDependencyNodesFromAsset(assetGraph, nodeId);
+        for (let child of outgoing) {
           if (child.usedSymbolsUpDirtyUp) {
             node.usedSymbolsUpDirty = true;
             child.usedSymbolsUpDirtyUp = false;
           }
         }
-      }
-      if (node.type === 'asset') {
-        let incoming = assetGraph.getIncomingDependencies(node.value).map(d => {
-          let n = assetGraph.getNodeByContentKey(d.id);
-          (0, _assert().default)(n && n.type === 'dependency');
-          return n;
-        });
+        let incoming = incomingDependencyNodesFromAsset(assetGraph, node.value);
         for (let dep of incoming) {
           if (dep.usedSymbolsUpDirtyDown) {
             dep.usedSymbolsUpDirtyDown = false;
@@ -518,11 +502,7 @@ function propagateSymbolsUp(assetGraph, changedAssets, changedDepsUsedSymbolsUpD
           }
         }
         if (node.usedSymbolsUpDirty) {
-          let e = visit(node, incoming, outgoing.map(depNodeId => {
-            let depNode = (0, _nullthrows().default)(assetGraph.getNode(depNodeId));
-            (0, _assert().default)(depNode.type === 'dependency');
-            return depNode;
-          }));
+          let e = visit(node, incoming, outgoing);
           if (e.length > 0) {
             node.usedSymbolsUpDirty = true;
             errors.set(nodeId, e);
@@ -548,22 +528,14 @@ function propagateSymbolsUp(assetGraph, changedAssets, changedDepsUsedSymbolsUpD
     let queuedNodeId = setPop(queue);
     let node = (0, _nullthrows().default)(assetGraph.getNode(queuedNodeId));
     if (node.type === 'asset') {
-      let incoming = assetGraph.getIncomingDependencies(node.value).map(dep => {
-        let depNode = assetGraph.getNodeByContentKey(dep.id);
-        (0, _assert().default)(depNode && depNode.type === 'dependency');
-        return depNode;
-      });
+      let incoming = incomingDependencyNodesFromAsset(assetGraph, node.value);
       for (let dep of incoming) {
         if (dep.usedSymbolsUpDirtyDown) {
           dep.usedSymbolsUpDirtyDown = false;
           node.usedSymbolsUpDirty = true;
         }
       }
-      let outgoing = assetGraph.getNodeIdsConnectedFrom(queuedNodeId).map(depNodeId => {
-        let depNode = (0, _nullthrows().default)(assetGraph.getNode(depNodeId));
-        (0, _assert().default)(depNode.type === 'dependency');
-        return depNode;
-      });
+      let outgoing = outgoingDependencyNodesFromAsset(assetGraph, queuedNodeId);
       for (let dep of outgoing) {
         if (dep.usedSymbolsUpDirtyUp) {
           node.usedSymbolsUpDirty = true;
@@ -622,4 +594,21 @@ function setPop(set) {
   let v = (0, _nullthrows().default)(set.values().next().value);
   set.delete(v);
   return v;
+}
+function outgoingDependencyNodesFromAsset(assetGraph, assetNode) {
+  return dependencyNodesFromIds(assetGraph, assetGraph.getNodeIdsConnectedFrom(assetNode));
+}
+function dependencyNodesFromIds(assetGraph, dependencyIds) {
+  return dependencyIds.map(depNodeId => {
+    let depNode = (0, _nullthrows().default)(assetGraph.getNode(depNodeId));
+    (0, _assert().default)(depNode.type === 'dependency');
+    return depNode;
+  });
+}
+function incomingDependencyNodesFromAsset(assetGraph, assetNodeValue) {
+  return assetGraph.getIncomingDependencies(assetNodeValue).map(d => {
+    let n = assetGraph.getNodeByContentKey(d.id);
+    (0, _assert().default)(n && n.type === 'dependency');
+    return n;
+  });
 }

package/lib/atlaspack-v3/worker/compat/asset-symbols.js

@@ -18,7 +18,7 @@ class MutableDependencySymbols {
       local,
       loc,
       isWeak
-    } of inner) {
+    } of inner || []) {
       this.set(exported, local, loc, isWeak);
     }
   }
@@ -59,34 +59,134 @@ class MutableDependencySymbols {
     return this.#symbols.values();
   }
 }
-
-// TODO
 exports.MutableDependencySymbols = MutableDependencySymbols;
-class AssetSymbols extends Array {
-  // eslint-disable-next-line no-unused-vars
-  get() {}
-
-  // eslint-disable-next-line no-unused-vars
-  hasExportSymbol() {
-    throw new Error('AssetSymbols.hasExportSymbol');
+class AssetSymbols {
+  #symbols;
+  #locals;
+  get isCleared() {
+    return this.#symbols.size === 0;
   }
-
-  // eslint-disable-next-line no-unused-vars
-  hasLocalSymbol() {
-    throw new Error('AssetSymbols.hasExportSymbol');
+  constructor(inner) {
+    this.#symbols = new Map();
+    this.#locals = new Set();
+    for (const {
+      exported,
+      local,
+      loc
+    } of inner || []) {
+      this.#set(exported, local, loc);
+    }
+  }
+  #set(exportSymbol, local, loc) {
+    this.#locals.add(local);
+    this.#symbols.set(exportSymbol, {
+      local,
+      loc,
+      meta: {}
+    });
+  }
+  get(exportSymbol) {
+    return this.#symbols.get(exportSymbol);
+  }
+  hasExportSymbol(exportSymbol) {
+    return this.#symbols.has(exportSymbol);
+  }
+  hasLocalSymbol(local) {
+    return this.#locals.has(local);
   }
   exportSymbols() {
+    return this.#symbols.keys();
+  }
+  intoNapi() {
     return [];
   }
-}
 
-// TODO
+  /*::  @@iterator(): Iterator<[Symbol, AssetSymbol]> { return ({}: any); } */
+  // $FlowFixMe Flow can't do computed properties
+  [Symbol.iterator]() {
+    return this.#symbols.values();
+  }
+}
 exports.AssetSymbols = AssetSymbols;
-class MutableAssetSymbols extends AssetSymbols {
-  ensure() {}
-  set() {}
+class MutableAssetSymbols {
+  #symbols;
+  #locals;
+  get isCleared() {
+    return this.#symbols.size === 0;
+  }
+  constructor(inner) {
+    this.#symbols = new Map();
+    this.#locals = new Set();
+    for (const {
+      exported,
+      local,
+      loc
+    } of inner || []) {
+      this.set(exported, local, loc);
+    }
+  }
+  intoNapi() {
+    const results = [];
+    for (const [exportSymbol, {
+      local,
+      loc
+    }] of this.#symbols.entries()) {
+      results.push({
+        exported: exportSymbol,
+        local,
+        loc: loc ? {
+          filePath: loc.filePath,
+          start: {
+            line: loc.start.line,
+            column: loc.start.column
+          },
+          end: {
+            line: loc.end.line,
+            column: loc.end.column
+          }
+        } : undefined,
+        // TODO
+        isWeak: false,
+        isEsmExport: false,
+        selfReferenced: false
+      });
+    }
+    return results;
+  }
+  ensure() {
+    throw new Error('MutableAssetSymbols.ensure()');
+  }
+  set(exportSymbol, local, loc) {
+    this.#locals.add(local);
+    this.#symbols.set(exportSymbol, {
+      local,
+      loc,
+      meta: {}
+    });
+  }
+  get(exportSymbol) {
+    return this.#symbols.get(exportSymbol);
+  }
+  hasExportSymbol(exportSymbol) {
+    return this.#symbols.has(exportSymbol);
+  }
+  hasLocalSymbol(local) {
+    return this.#locals.has(local);
+  }
+  exportSymbols() {
+    return this.#symbols.keys();
+  }
+  delete(exportSymbol) {
+    let existing = this.#symbols.get(exportSymbol);
+    if (!existing) return;
+    this.#locals.delete(existing.local);
+    this.#symbols.delete(exportSymbol);
+  }
 
-  // eslint-disable-next-line no-unused-vars
-  delete() {}
+  /*::  @@iterator(): Iterator<[Symbol, AssetSymbol]> { return ({}: any); } */
+  // $FlowFixMe Flow can't do computed properties
+  [Symbol.iterator]() {
+    return this.#symbols.values();
+  }
 }
 exports.MutableAssetSymbols = MutableAssetSymbols;

package/lib/atlaspack-v3/worker/compat/bitflags.js

@@ -22,6 +22,12 @@ class BitFlags {
     }
     return found;
   }
+  intoNullable(key) {
+    if (key === undefined || key === null) {
+      return undefined;
+    }
+    return this.into(key);
+  }
   intoArray(keys) {
     return keys.map(key => this.into(key));
   }
@@ -33,6 +39,12 @@ class BitFlags {
     }
     return found;
   }
+  fromNullable(key) {
+    if (key === undefined || key === null) {
+      return undefined;
+    }
+    return this.from(key);
+  }
   fromArray(keys) {
     return keys.map(key => this.from(key));
   }

package/lib/atlaspack-v3/worker/compat/index.js

@@ -3,28 +3,6 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _assetCompat = require("./asset-compat");
-Object.keys(_assetCompat).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _assetCompat[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _assetCompat[key];
-    }
-  });
-});
-var _assetSymbols = require("./asset-symbols");
-Object.keys(_assetSymbols).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _assetSymbols[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _assetSymbols[key];
-    }
-  });
-});
 var _bitflags = require("./bitflags");
 Object.keys(_bitflags).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -68,4 +46,59 @@ Object.keys(_target).forEach(function (key) {
       return _target[key];
     }
   });
+});
+var _pluginConfig = require("./plugin-config");
+Object.keys(_pluginConfig).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pluginConfig[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pluginConfig[key];
+    }
+  });
+});
+var _pluginTracer = require("./plugin-tracer");
+Object.keys(_pluginTracer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pluginTracer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pluginTracer[key];
+    }
+  });
+});
+var _pluginLogger = require("./plugin-logger");
+Object.keys(_pluginLogger).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pluginLogger[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pluginLogger[key];
+    }
+  });
+});
+var _pluginOptions = require("./plugin-options");
+Object.keys(_pluginOptions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pluginOptions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pluginOptions[key];
+    }
+  });
+});
+var _mutableAsset = require("./mutable-asset");
+Object.keys(_mutableAsset).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _mutableAsset[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _mutableAsset[key];
+    }
+  });
 });

package/lib/atlaspack-v3/worker/compat/mutable-asset.js

@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MutableAsset = void 0;
+function _stream() {
+  const data = require("stream");
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+var _bitflags = require("./bitflags");
+var _assetSymbols = require("./asset-symbols");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+class MutableAsset {
+  #inner;
+  #ast;
+  #contents;
+  get astGenerator() {
+    throw new Error('get MutableAsset.astGenerator');
+  }
+  set astGenerator(value) {
+    throw new Error('set MutableAsset.astGenerator');
+  }
+  constructor(asset, fs, env) {
+    this.#inner = asset;
+    this.stats = asset.stats;
+    this.id = asset.id;
+    this.filePath = asset.filePath;
+    this.type;
+    this.symbols = new _assetSymbols.MutableAssetSymbols(asset.symbols);
+    this.stats = asset.stats;
+    this.id = asset.id;
+    this.filePath = asset.filePath;
+    this.type = asset.type;
+    this.query = new URLSearchParams(asset.query);
+    this.isSource = asset.isSource;
+    this.meta = asset.meta;
+    this.bundleBehavior = _bitflags.bundleBehaviorMap.fromNullable(asset.bundleBehavior);
+    this.isBundleSplittable = asset.isBundleSplittable;
+    this.sideEffects = asset.sideEffects;
+    this.uniqueKey = asset.uniqueKey;
+    this.pipeline = asset.pipeline;
+    this.#contents = Buffer.from(asset.code);
+    this.fs = fs;
+    this.env = env;
+  }
+
+  // eslint-disable-next-line require-await
+  async getAST() {
+    return this.#ast;
+  }
+  setAST(ast) {
+    this.#ast = ast;
+  }
+  isASTDirty() {
+    throw new Error('MutableAsset.isASTDirty()');
+  }
+
+  // eslint-disable-next-line require-await
+  async getCode() {
+    return this.#contents.toString();
+  }
+  setCode(code) {
+    this.#contents = Buffer.from(code);
+  }
+
+  // eslint-disable-next-line require-await
+  async getBuffer() {
+    return this.#contents;
+  }
+  setBuffer(buf) {
+    this.#contents = buf;
+  }
+  getStream() {
+    return _stream().Readable.from(this.#contents);
+  }
+  setStream(stream) {
+    const data = [];
+    stream.on('data', chunk => {
+      data.push(chunk);
+    });
+    stream.on('end', () => {
+      this.#contents = Buffer.concat(data);
+    });
+    stream.on('error', () => {
+      throw new Error('MutableAsset.setStream()');
+    });
+  }
+  getMap() {
+    throw new Error('MutableAsset.getMap');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  setMap() {
+    throw new Error('MutableAsset.setMap()');
+  }
+  getMapBuffer() {
+    throw new Error('MutableAsset.getMapBuffer');
+  }
+  getDependencies() {
+    throw new Error('MutableAsset.getDependencies');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  addDependency() {
+    throw new Error('MutableAsset.addDependency()');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  addURLDependency() {
+    throw new Error('MutableAsset.addURLDependency()');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  setEnvironment() {
+    throw new Error('MutableAsset.setEnvironment()');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  invalidateOnFileChange() {
+    throw new Error('MutableAsset.invalidateOnFileChange()');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  invalidateOnFileCreate() {
+    throw new Error('MutableAsset.invalidateOnFileCreate()');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  invalidateOnEnvChange() {
+    throw new Error('MutableAsset.invalidateOnEnvChange()');
+  }
+  invalidateOnStartup() {
+    throw new Error('MutableAsset.invalidateOnStartup()');
+  }
+  invalidateOnBuild() {
+    throw new Error('MutableAsset.invalidateOnBuild()');
+  }
+}
+exports.MutableAsset = MutableAsset;

package/lib/atlaspack-v3/worker/compat/plugin-config.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginConfig = void 0;
+class PluginConfig {
+  constructor({
+    env,
+    isSource,
+    searchPath
+  }) {
+    this.env = env;
+    this.isSource = isSource;
+    this.searchPath = searchPath;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  invalidateOnFileChange() {
+    throw new Error('PluginOptions.invalidateOnFileChange');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  invalidateOnFileCreate() {
+    throw new Error('PluginOptions.invalidateOnFileCreate');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  invalidateOnEnvChange() {
+    throw new Error('PluginOptions.invalidateOnEnvChange');
+  }
+  invalidateOnStartup() {
+    throw new Error('PluginOptions.invalidateOnStartup');
+  }
+  invalidateOnBuild() {
+    throw new Error('PluginOptions.invalidateOnBuild');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  addDevDependency() {
+    throw new Error('PluginOptions.addDevDependency');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  setCacheKey() {
+    throw new Error('PluginOptions.setCacheKey');
+  }
+  getConfig() {
+    throw new Error('PluginOptions.getConfig');
+  }
+  getConfigFrom() {
+    throw new Error('PluginOptions.getConfigFrom');
+  }
+  getPackage() {
+    throw new Error('PluginOptions.getPackage');
+  }
+}
+exports.PluginConfig = PluginConfig;

package/lib/atlaspack-v3/worker/compat/plugin-logger.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginLogger = void 0;
+class PluginLogger {
+  verbose(diagnostic) {
+    // eslint-disable-next-line no-console
+    console.log(diagnostic);
+  }
+  info(diagnostic) {
+    // eslint-disable-next-line no-console
+    console.info(diagnostic);
+  }
+  log(diagnostic) {
+    // eslint-disable-next-line no-console
+    console.log(diagnostic);
+  }
+  warn(diagnostic) {
+    // eslint-disable-next-line no-console
+    console.warn(diagnostic);
+  }
+  error(input) {
+    // eslint-disable-next-line no-console
+    console.error(input);
+  }
+}
+exports.PluginLogger = PluginLogger;