@atlaspack/core 2.12.1-canary.3454 → 2.12.1-canary.3456

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;

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

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginOptions = void 0;
+class PluginOptions {
+  #options;
+  get env() {
+    if (!('env' in this.#options)) {
+      return process.env;
+      // throw new Error('PluginOptions.env');
+    }
+
+    return this.#options.env;
+  }
+  get projectRoot() {
+    if (!('projectRoot' in this.#options)) {
+      throw new Error('PluginOptions.projectRoot');
+    }
+    return this.#options.projectRoot;
+  }
+  get packageManager() {
+    if (!('packageManager' in this.#options)) {
+      throw new Error('PluginOptions.packageManager');
+    }
+    return this.#options.packageManager;
+  }
+  get mode() {
+    if (!('mode' in this.#options)) {
+      throw new Error('PluginOptions.mode');
+    }
+    return this.#options.mode;
+  }
+  get parcelVersion() {
+    if (!('parcelVersion' in this.#options)) {
+      return 'UNKNOWN VERSION';
+      // throw new Error('PluginOptions.parcelVersion');
+    }
+
+    return this.#options.parcelVersion;
+  }
+  get hmrOptions() {
+    if (!('hmrOptions' in this.#options)) {
+      throw new Error('PluginOptions.hmrOptions');
+    }
+    return this.#options.hmrOptions;
+  }
+  get serveOptions() {
+    if (!('serveOptions' in this.#options)) {
+      throw new Error('PluginOptions.serveOptions');
+    }
+    return this.#options.serveOptions;
+  }
+  get shouldBuildLazily() {
+    if (!('shouldBuildLazily' in this.#options)) {
+      throw new Error('PluginOptions.shouldBuildLazily');
+    }
+    return this.#options.shouldBuildLazily;
+  }
+  get shouldAutoInstall() {
+    if (!('shouldAutoInstall' in this.#options)) {
+      throw new Error('PluginOptions.shouldAutoInstall');
+    }
+    return this.#options.shouldAutoInstall;
+  }
+  get logLevel() {
+    if (!('logLevel' in this.#options)) {
+      throw new Error('PluginOptions.logLevel');
+    }
+    return this.#options.logLevel;
+  }
+  get cacheDir() {
+    if (!('cacheDir' in this.#options)) {
+      throw new Error('PluginOptions.cacheDir');
+    }
+    return this.#options.cacheDir;
+  }
+  get inputFS() {
+    if (!('inputFS' in this.#options)) {
+      throw new Error('PluginOptions.inputFS');
+    }
+    return this.#options.inputFS;
+  }
+  get outputFS() {
+    if (!('outputFS' in this.#options)) {
+      throw new Error('PluginOptions.outputFS');
+    }
+    return this.#options.outputFS;
+  }
+  get instanceId() {
+    if (!('instanceId' in this.#options)) {
+      throw new Error('PluginOptions.instanceId');
+    }
+    return this.#options.instanceId;
+  }
+  get detailedReport() {
+    if (!('detailedReport' in this.#options)) {
+      throw new Error('PluginOptions.detailedReport');
+    }
+    return this.#options.detailedReport;
+  }
+  get featureFlags() {
+    if (!('featureFlags' in this.#options)) {
+      throw new Error('PluginOptions.featureFlags');
+    }
+    return this.#options.featureFlags;
+  }
+  constructor(options) {
+    this.#options = options;
+  }
+}
+exports.PluginOptions = PluginOptions;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginTracer = void 0;
+class PluginTracer {
+  createMeasurement() {
+    throw new Error('PluginTracer.createMeasurement');
+  }
+}
+exports.PluginTracer = PluginTracer;