@atlaspack/core 2.14.0 → 2.14.1-canary.10

package/lib/atlaspack-v3/fs.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FileSystemV3 = void 0;
+var _jsCallable = require("./jsCallable");
+class FileSystemV3 {
+  #fs;
+  constructor(fs) {
+    this.#fs = fs;
+  }
+  canonicalize = (0, _jsCallable.jsCallable)(path => this.#fs.realpathSync(path));
+  createDirectory = (0, _jsCallable.jsCallable)(path => this.#fs.mkdirp(path));
+  cwd = (0, _jsCallable.jsCallable)(() => this.#fs.cwd());
+  isFile = path => {
+    try {
+      return this.#fs.statSync(path).isFile();
+    } catch {
+      return false;
+    }
+  };
+  isDir = path => {
+    try {
+      return this.#fs.statSync(path).isDirectory();
+    } catch {
+      return false;
+    }
+  };
+  readFile = (0, _jsCallable.jsCallable)((path, encoding) => {
+    if (!encoding) {
+      // $FlowFixMe
+      return [...this.#fs.readFileSync(path)];
+    } else {
+      return this.#fs.readFileSync(path, encoding);
+    }
+  });
+}
+exports.FileSystemV3 = FileSystemV3;

package/lib/atlaspack-v3/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AtlaspackV3", {
+  enumerable: true,
+  get: function () {
+    return _AtlaspackV.AtlaspackV3;
+  }
+});
+Object.defineProperty(exports, "FileSystemV3", {
+  enumerable: true,
+  get: function () {
+    return _fs.FileSystemV3;
+  }
+});
+Object.defineProperty(exports, "NapiWorkerPool", {
+  enumerable: true,
+  get: function () {
+    return _NapiWorkerPool.NapiWorkerPool;
+  }
+});
+var _fs = require("./fs");
+var _AtlaspackV = require("./AtlaspackV3");
+var _NapiWorkerPool = require("./NapiWorkerPool");

package/lib/atlaspack-v3/jsCallable.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsCallable = jsCallable;
+function jsCallable(fn) {
+  return async (...args) => {
+    try {
+      // $FlowFixMe "await" is needed to log the error from
+      // Promises and is safe to use on non-promises
+      return await fn(...args);
+      // $FlowFixMe
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error(error);
+      throw error;
+    }
+  };
+}

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

@@ -0,0 +1,197 @@
+"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,
+      loc,
+      local,
+      isEsmExport,
+      selfReferenced
+    } of inner || []) {
+      this.set(exported, local, loc, {
+        isEsm: isEsmExport,
+        selfReferenced
+      });
+    }
+  }
+  intoNapi() {
+    const results = [];
+    for (const [exportSymbol, {
+      local,
+      loc,
+      meta
+    }] 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,
+        isEsmExport: Boolean(meta === null || meta === void 0 ? void 0 : meta.isEsm),
+        isWeak: false,
+        selfReferenced: Boolean(meta === null || meta === void 0 ? void 0 : meta.selfReferenced)
+      });
+    }
+    return results;
+  }
+  ensure() {
+    throw new Error('MutableAssetSymbols.ensure()');
+  }
+  set(exportSymbol, local, loc, meta) {
+    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 ?? inner.sourcePath;
+    this.range = inner.range;
+    this.pipeline = inner.pipeline;
+  }
+}
+exports.Dependency = Dependency;

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

@@ -0,0 +1,57 @@
+"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;
+    this.unstableSingleFileOutput = false;
+  }
+  isBrowser() {
+    return this.context === 'browser' || this.isWorker() || this.isWorklet() || this.context === 'electron-renderer';
+  }
+  isNode() {
+    return this.context === 'node' || this.isElectron();
+  }
+  isElectron() {
+    return this.context === 'electron-main' || this.context === 'electron-renderer';
+  }
+  isWorker() {
+    return this.context === 'web-worker' || this.context === 'service-worker';
+  }
+  isWorklet() {
+    return this.context === 'worklet';
+  }
+  isIsolated() {
+    return this.isWorker() || this.isWorklet();
+  }
+
+  // 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];
+    }
+  });
+});