@atlaspack/core 2.12.1-dev.3450 → 2.12.1-dev.3466

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

@@ -0,0 +1,192 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MutableDependencySymbols = exports.MutableAssetSymbols = exports.AssetSymbols = void 0;
+class MutableDependencySymbols {
+  #symbols;
+  #locals;
+  get isCleared() {
+    return this.#symbols.size === 0;
+  }
+  constructor(inner) {
+    this.#symbols = new Map();
+    this.#locals = new Set();
+    for (const {
+      exported,
+      local,
+      loc,
+      isWeak
+    } of inner || []) {
+      this.set(exported, local, loc, isWeak);
+    }
+  }
+  ensure() {
+    throw new Error('MutableDependencySymbols.ensure()');
+  }
+  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();
+  }
+  set(exportSymbol, local, loc, isWeak) {
+    this.#locals.add(local);
+    this.#symbols.set(exportSymbol, {
+      local,
+      loc,
+      meta: {},
+      isWeak: isWeak ?? false
+    });
+  }
+  delete(exportSymbol) {
+    let existing = this.#symbols.get(exportSymbol);
+    if (!existing) return;
+    this.#locals.delete(existing.local);
+    this.#symbols.delete(exportSymbol);
+  }
+
+  /*::  @@iterator(): Iterator<[Symbol, DependencyAssetSymbol]> { return ({}: any); } */
+  // $FlowFixMe Flow can't do computed properties
+  [Symbol.iterator]() {
+    return this.#symbols.values();
+  }
+}
+exports.MutableDependencySymbols = MutableDependencySymbols;
+class AssetSymbols {
+  #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);
+    }
+  }
+  #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 [];
+  }
+
+  /*::  @@iterator(): Iterator<[Symbol, AssetSymbol]> { return ({}: any); } */
+  // $FlowFixMe Flow can't do computed properties
+  [Symbol.iterator]() {
+    return this.#symbols.values();
+  }
+}
+exports.AssetSymbols = AssetSymbols;
+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);
+  }
+
+  /*::  @@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

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.specifierTypeMap = exports.packageConditionsMap = exports.dependencyPriorityMap = exports.bundleBehaviorMap = exports.BitFlags = void 0;
+/// BitFlags is used to map number/string types from napi types
+class BitFlags {
+  #kv;
+  #vk;
+  constructor(source) {
+    this.#kv = source;
+    this.#vk = Object.fromEntries(
+    // $FlowFixMe
+    Object.entries(source).map(a => a.reverse()));
+  }
+  into(key) {
+    const found = this.#kv[key];
+    if (found === undefined) {
+      // $FlowFixMe
+      throw new Error(`Invalid BundleBehavior(${key})`);
+    }
+    return found;
+  }
+  intoNullable(key) {
+    if (key === undefined || key === null) {
+      return undefined;
+    }
+    return this.into(key);
+  }
+  intoArray(keys) {
+    return keys.map(key => this.into(key));
+  }
+  from(key) {
+    const found = this.#vk[key];
+    if (found === undefined) {
+      // $FlowFixMe
+      throw new Error(`Invalid BundleBehavior(${key})`);
+    }
+    return found;
+  }
+  fromNullable(key) {
+    if (key === undefined || key === null) {
+      return undefined;
+    }
+    return this.from(key);
+  }
+  fromArray(keys) {
+    return keys.map(key => this.from(key));
+  }
+}
+exports.BitFlags = BitFlags;
+const bundleBehaviorMap = exports.bundleBehaviorMap = new BitFlags({
+  inline: 0,
+  isolated: 1
+});
+const dependencyPriorityMap = exports.dependencyPriorityMap = new BitFlags({
+  sync: 0,
+  parallel: 1,
+  lazy: 2,
+  conditional: 3
+});
+const packageConditionsMap = exports.packageConditionsMap = new BitFlags({
+  import: 0,
+  require: 1,
+  module: 2,
+  node: 3,
+  browser: 4,
+  worker: 5,
+  worklet: 6,
+  electron: 7,
+  development: 8,
+  production: 9,
+  types: 10,
+  default: 11,
+  style: 12,
+  sass: 13
+});
+const specifierTypeMap = exports.specifierTypeMap = new BitFlags({
+  esm: 0,
+  commonjs: 1,
+  url: 2,
+  custom: 3
+});

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

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Dependency = void 0;
+var _target = require("./target");
+var _assetSymbols = require("./asset-symbols");
+var _bitflags = require("./bitflags");
+class Dependency {
+  get id() {
+    throw new Error('Dependency.id');
+  }
+  constructor(inner, env) {
+    this.env = env;
+    this.meta = inner.meta || {};
+    this.target = undefined;
+    if (inner.target) {
+      this.target = new _target.Target(inner.target, this.env);
+    }
+    if (!inner.bundleBehavior) {
+      this.bundleBehavior = undefined;
+    } else {
+      this.bundleBehavior = _bitflags.bundleBehaviorMap.from(inner.bundleBehavior);
+    }
+    this.bundleBehavior = undefined;
+    this.symbols = new _assetSymbols.MutableDependencySymbols(inner.symbols || []);
+    this.specifier = inner.specifier;
+    this.specifierType = _bitflags.specifierTypeMap.from(inner.specifierType);
+    this.priority = _bitflags.dependencyPriorityMap.from(inner.priority);
+    this.needsStableName = inner.needsStableName;
+    this.isOptional = inner.isOptional;
+    this.isEntry = inner.isEntry;
+    this.loc = inner.loc;
+    this.packageConditions = _bitflags.packageConditionsMap.fromArray(inner.packageConditions || []);
+    this.sourceAssetId = inner.sourceAssetId;
+    this.sourcePath = inner.sourcePath;
+    this.sourceAssetType = inner.sourceAssetType;
+    this.resolveFrom = inner.resolveFrom;
+    this.range = inner.range;
+    this.pipeline = inner.pipeline;
+  }
+}
+exports.Dependency = Dependency;

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;