@atlaspack/core 2.12.1-dev.3443 → 2.12.1-dev.3460

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

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Environment = void 0;
+class Environment {
+  constructor(inner) {
+    // TODO
+    this.id = '';
+    this.includeNodeModules = inner.includeNodeModules;
+    // $FlowFixMe
+    this.context = inner.context;
+    this.engines = inner.engines;
+    // $FlowFixMe
+    this.outputFormat = inner.outputFormat;
+    // $FlowFixMe
+    this.sourceType = inner.sourceType;
+    this.isLibrary = inner.isLibrary;
+    this.shouldOptimize = inner.shouldOptimize;
+    this.shouldScopeHoist = inner.shouldScopeHoist;
+    this.sourceMap = inner.sourceMap;
+    this.loc = inner.loc;
+  }
+
+  // TODO
+  isBrowser() {
+    return true;
+  }
+
+  // TODO
+  isNode() {
+    return false;
+  }
+
+  // TODO
+  isElectron() {
+    return false;
+  }
+
+  // TODO
+  isWorker() {
+    return false;
+  }
+
+  // TODO
+  isWorklet() {
+    return false;
+  }
+
+  // TODO
+  isIsolated() {
+    return false;
+  }
+
+  // TODO
+  // eslint-disable-next-line no-unused-vars
+  matchesEngines() {
+    return true;
+  }
+
+  // TODO
+  // eslint-disable-next-line no-unused-vars
+  supports() {
+    return true;
+  }
+}
+exports.Environment = Environment;

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

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _bitflags = require("./bitflags");
+Object.keys(_bitflags).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bitflags[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _bitflags[key];
+    }
+  });
+});
+var _dependency = require("./dependency");
+Object.keys(_dependency).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _dependency[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _dependency[key];
+    }
+  });
+});
+var _environment = require("./environment");
+Object.keys(_environment).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _environment[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _environment[key];
+    }
+  });
+});
+var _target = require("./target");
+Object.keys(_target).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _target[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      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;

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Target = void 0;
+class Target {
+  constructor(inner, env) {
+    this.distDir = inner.distDir;
+    this.distEntry = inner.distEntry;
+    this.name = inner.name;
+    this.publicUrl = inner.publicUrl;
+    this.loc = inner.loc;
+    this.env = env;
+  }
+}
+exports.Target = Target;