@atlaspack/core 2.13.2-dev.3689 → 2.14.0

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

@@ -1,164 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.MutableAsset = void 0;
-function _sourceMap() {
-  const data = _interopRequireDefault(require("@parcel/source-map"));
-  _sourceMap = function () {
-    return data;
-  };
-  return data;
-}
-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; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-class MutableAsset {
-  #astDirty;
-  #ast;
-  #contents;
-  #inner;
-  #map;
-  #projectRoot;
-  #sourceMap;
-  get astGenerator() {
-    throw new Error('get MutableAsset.astGenerator');
-  }
-  set astGenerator(value) {
-    throw new Error('set MutableAsset.astGenerator');
-  }
-  constructor(asset, contents, env, fs, map, projectRoot) {
-    this.bundleBehavior = _bitflags.bundleBehaviorMap.fromNullable(asset.bundleBehavior);
-    this.env = env;
-    this.filePath = asset.filePath;
-    this.fs = fs;
-    this.id = asset.id;
-    this.isBundleSplittable = asset.isBundleSplittable;
-    this.isSource = asset.isSource;
-    this.meta = asset.meta;
-    this.pipeline = asset.pipeline;
-    this.query = new URLSearchParams(asset.query);
-    this.sideEffects = asset.sideEffects;
-    this.stats = asset.stats;
-    this.symbols = new _assetSymbols.MutableAssetSymbols(asset.symbols);
-    this.type = asset.type;
-    this.uniqueKey = asset.uniqueKey;
-    this.#astDirty = false;
-    this.#contents = contents;
-    this.#inner = asset;
-    this.#map = map;
-    this.#projectRoot = projectRoot;
-  }
-
-  // eslint-disable-next-line require-await
-  async getAST() {
-    return this.#ast;
-  }
-  setAST(ast) {
-    this.#astDirty = true;
-    this.#ast = ast;
-  }
-  isASTDirty() {
-    return this.#astDirty;
-  }
-
-  // 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() {
-    // Only create the source map if it is requested
-    if (!this.#sourceMap && this.#map && typeof this.#map === 'string') {
-      let sourceMap = new (_sourceMap().default)(this.#projectRoot);
-      // $FlowFixMe Flow is dumb
-      sourceMap.addVLQMap(JSON.parse(this.#map));
-      this.#sourceMap = sourceMap;
-    }
-    return Promise.resolve(this.#sourceMap);
-  }
-
-  // eslint-disable-next-line no-unused-vars
-  setMap(sourceMap) {
-    this.isMapDirty = true;
-    this.#sourceMap = sourceMap;
-  }
-  getMapBuffer() {
-    throw new Error('getMapBuffer() is considered an internal implementation detail, please use getMap() instead');
-  }
-  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() {
-    // TODO: Forward invalidations to Rust
-  }
-
-  // eslint-disable-next-line no-unused-vars
-  invalidateOnFileCreate() {
-    // TODO: Forward invalidations to Rust
-  }
-
-  // eslint-disable-next-line no-unused-vars
-  invalidateOnEnvChange() {
-    // TODO: Forward invalidations to Rust
-  }
-  invalidateOnStartup() {
-    // TODO: Forward invalidations to Rust
-  }
-  invalidateOnBuild() {
-    // TODO: Forward invalidations to Rust
-  }
-}
-exports.MutableAsset = MutableAsset;

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

@@ -1,78 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.PluginConfig = void 0;
-var _Config = _interopRequireDefault(require("../../../public/Config"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-class PluginConfig {
-  #projectRoot;
-  #inner;
-  constructor({
-    env,
-    isSource,
-    searchPath,
-    projectRoot,
-    fs,
-    packageManager
-  }) {
-    this.env = env;
-    this.isSource = isSource;
-    this.searchPath = searchPath;
-    this.#inner = new _Config.default(
-    // $FlowFixMe
-    {
-      invalidateOnConfigKeyChange: [],
-      invalidateOnFileCreate: [],
-      invalidateOnFileChange: new Set(),
-      devDeps: [],
-      // $FlowFixMe
-      searchPath: searchPath.replace(projectRoot + '/', '')
-    },
-    // $FlowFixMe
-    {
-      projectRoot,
-      inputFS: fs,
-      outputFS: fs,
-      packageManager
-    });
-  }
-
-  // eslint-disable-next-line no-unused-vars
-  invalidateOnFileChange() {}
-
-  // eslint-disable-next-line no-unused-vars
-  invalidateOnFileCreate() {}
-
-  // eslint-disable-next-line no-unused-vars
-  invalidateOnEnvChange() {}
-  invalidateOnStartup() {}
-  invalidateOnBuild() {}
-
-  // eslint-disable-next-line no-unused-vars
-  addDevDependency() {}
-
-  // eslint-disable-next-line no-unused-vars
-  setCacheKey() {}
-  getConfig(
-  // eslint-disable-next-line no-unused-vars
-  filePaths,
-  // eslint-disable-next-line no-unused-vars
-  options) {
-    return this.#inner.getConfig(filePaths, options);
-  }
-  getConfigFrom(
-  // eslint-disable-next-line no-unused-vars
-  searchPath,
-  // eslint-disable-next-line no-unused-vars
-  filePaths,
-  // eslint-disable-next-line no-unused-vars
-  options) {
-    return this.#inner.getConfigFrom(searchPath, filePaths, options);
-  }
-  getPackage() {
-    return this.#inner.getPackage();
-  }
-}
-exports.PluginConfig = PluginConfig;

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

@@ -1,29 +0,0 @@
-"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

@@ -1,113 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-"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

@@ -1,17 +0,0 @@
-"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;

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

@@ -1,3 +0,0 @@
-"use strict";
-
-require('./worker');

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

@@ -1,280 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.AtlaspackWorker = void 0;
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
-function napi() {
-  const data = _interopRequireWildcard(require("@atlaspack/rust"));
-  napi = function () {
-    return data;
-  };
-  return data;
-}
-function _fs() {
-  const data = require("@atlaspack/fs");
-  _fs = function () {
-    return data;
-  };
-  return data;
-}
-function _packageManager() {
-  const data = require("@atlaspack/package-manager");
-  _packageManager = function () {
-    return data;
-  };
-  return data;
-}
-function _worker_threads() {
-  const data = require("worker_threads");
-  _worker_threads = function () {
-    return data;
-  };
-  return data;
-}
-function _module() {
-  const data = _interopRequireWildcard(require("module"));
-  _module = function () {
-    return data;
-  };
-  return data;
-}
-var _jsCallable = require("../jsCallable");
-var _compat = require("./compat");
-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; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const CONFIG = Symbol.for('parcel-plugin-config');
-class AtlaspackWorker {
-  #resolvers;
-  #transformers;
-  #fs;
-  constructor() {
-    this.#resolvers = new Map();
-    this.#transformers = new Map();
-    this.#fs = new (_fs().NodeFS)();
-  }
-  loadPlugin = (0, _jsCallable.jsCallable)(async ({
-    kind,
-    specifier,
-    resolveFrom
-  }) => {
-    let customRequire = _module().createRequire(resolveFrom);
-    let resolvedPath = customRequire.resolve(specifier);
-    // $FlowFixMe
-    let resolvedModule = await import(resolvedPath);
-    let instance = undefined;
-    if (resolvedModule.default && resolvedModule.default[CONFIG]) {
-      instance = resolvedModule.default[CONFIG];
-    } else if (resolvedModule.default && resolvedModule.default.default && resolvedModule.default.default[CONFIG]) {
-      instance = resolvedModule.default.default[CONFIG];
-    } else {
-      throw new Error(`Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`);
-    }
-    switch (kind) {
-      case 'resolver':
-        this.#resolvers.set(specifier, {
-          resolver: instance
-        });
-        break;
-      case 'transformer':
-        this.#transformers.set(specifier, {
-          transformer: instance
-        });
-        break;
-    }
-  });
-  runResolverResolve = (0, _jsCallable.jsCallable)(async ({
-    key,
-    dependency: napiDependency,
-    specifier,
-    pipeline,
-    pluginOptions
-  }) => {
-    const state = this.#resolvers.get(key);
-    if (!state) {
-      throw new Error(`Resolver not found: ${key}`);
-    }
-    let packageManager = state.packageManager;
-    if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, pluginOptions.projectRoot);
-      state.packageManager = packageManager;
-    }
-    const env = new _compat.Environment(napiDependency.env);
-    const dependency = new _compat.Dependency(napiDependency, env);
-    const defaultOptions = {
-      logger: new _compat.PluginLogger(),
-      tracer: new _compat.PluginTracer(),
-      options: new _compat.PluginOptions({
-        ...pluginOptions,
-        packageManager,
-        shouldAutoInstall: false,
-        inputFS: this.#fs,
-        outputFS: this.#fs
-      })
-    };
-    if (!('config' in state)) {
-      var _state$resolver$loadC, _state$resolver;
-      state.config = await ((_state$resolver$loadC = (_state$resolver = state.resolver).loadConfig) === null || _state$resolver$loadC === void 0 ? void 0 : _state$resolver$loadC.call(_state$resolver, {
-        config: new _compat.PluginConfig({
-          env,
-          isSource: true,
-          searchPath: specifier,
-          projectRoot: pluginOptions.projectRoot,
-          fs: this.#fs,
-          packageManager
-        }),
-        ...defaultOptions
-      }));
-    }
-    const result = await state.resolver.resolve({
-      specifier,
-      dependency,
-      pipeline,
-      config: state.config,
-      ...defaultOptions
-    });
-    if (!result) {
-      return {
-        invalidations: [],
-        resolution: {
-          type: 'unresolved'
-        }
-      };
-    }
-    return {
-      invalidations: [],
-      resolution: {
-        type: 'resolved',
-        filePath: result.filePath || '',
-        canDefer: result.canDefer || false,
-        sideEffects: result.sideEffects || false,
-        code: result.code || undefined,
-        meta: result.meta || undefined,
-        pipeline: result.pipeline || undefined,
-        priority: _compat.dependencyPriorityMap.intoNullable(result.priority),
-        query: result.query && result.query.toString()
-      }
-    };
-  });
-  runTransformerTransform = (0, _jsCallable.jsCallable)(async ({
-    key,
-    env: napiEnv,
-    options,
-    asset: innerAsset
-  }, contents, map) => {
-    var _transformer$loadConf;
-    const state = this.#transformers.get(key);
-    if (!state) {
-      throw new Error(`Transformer not found: ${key}`);
-    }
-    let packageManager = state.packageManager;
-    if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, options.projectRoot);
-      state.packageManager = packageManager;
-    }
-    const transformer = state.transformer;
-    const resolveFunc = (from, to) => {
-      let customRequire = _module().createRequire(from);
-      let resolvedPath = customRequire.resolve(to);
-      return Promise.resolve(resolvedPath);
-    };
-    const env = new _compat.Environment(napiEnv);
-    const mutableAsset = new _compat.MutableAsset(innerAsset, contents, env, this.#fs, map, options.projectRoot);
-    const defaultOptions = {
-      logger: new _compat.PluginLogger(),
-      tracer: new _compat.PluginTracer(),
-      options: new _compat.PluginOptions({
-        ...options,
-        packageManager,
-        shouldAutoInstall: false,
-        inputFS: this.#fs,
-        outputFS: this.#fs
-      })
-    };
-    const config = await ((_transformer$loadConf = transformer.loadConfig) === null || _transformer$loadConf === void 0 ? void 0 : _transformer$loadConf.call(transformer, {
-      config: new _compat.PluginConfig({
-        env,
-        isSource: true,
-        searchPath: innerAsset.filePath,
-        projectRoot: options.projectRoot,
-        fs: this.#fs,
-        packageManager
-      }),
-      ...defaultOptions
-    }));
-    if (transformer.parse) {
-      const ast = await transformer.parse({
-        asset: mutableAsset,
-        config,
-        resolve: resolveFunc,
-        ...defaultOptions
-      });
-      if (ast) {
-        mutableAsset.setAST(ast);
-      }
-    }
-    const result = await state.transformer.transform({
-      asset: mutableAsset,
-      config,
-      resolve: resolveFunc,
-      ...defaultOptions
-    });
-    if (transformer.generate) {
-      const ast = await mutableAsset.getAST();
-      if (ast) {
-        // $FlowFixMe "Cannot call `transformer.generate` because  undefined [1] is not a function." 🤷‍♀️
-        const output = await transformer.generate({
-          asset: mutableAsset,
-          ast,
-          ...defaultOptions
-        });
-        if (typeof output.content === 'string') {
-          mutableAsset.setCode(output.content);
-        } else if (output.content instanceof Buffer) {
-          mutableAsset.setBuffer(output.content);
-        } else {
-          mutableAsset.setStream(output.content);
-        }
-        if (output.map) {
-          mutableAsset.setMap(output.map);
-        }
-      }
-    }
-    (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
-    (0, _assert().default)(result[0] === mutableAsset, '[V3] Unimplemented: New asset returned from Node transformer');
-    return [{
-      id: mutableAsset.id,
-      bundleBehavior: _compat.bundleBehaviorMap.intoNullable(mutableAsset.bundleBehavior),
-      code: [],
-      filePath: mutableAsset.filePath,
-      isBundleSplittable: mutableAsset.isBundleSplittable,
-      isSource: mutableAsset.isSource,
-      meta: mutableAsset.meta,
-      pipeline: mutableAsset.pipeline,
-      // Query should be undefined if it's empty
-      query: mutableAsset.query.toString() || undefined,
-      sideEffects: mutableAsset.sideEffects,
-      symbols: mutableAsset.symbols.intoNapi(),
-      type: mutableAsset.type,
-      uniqueKey: mutableAsset.uniqueKey
-    }, await mutableAsset.getBuffer(),
-    // Only send back the map if it has changed
-    mutableAsset.isMapDirty ?
-    // $FlowFixMe A dirty map means this will be valid
-    JSON.stringify((await mutableAsset.getMap()).toVLQ()) : ''];
-  });
-}
-
-// Create napi worker and send it back to main thread
-exports.AtlaspackWorker = AtlaspackWorker;
-const worker = new AtlaspackWorker();
-const napiWorker = napi().newNodejsWorker(worker);
-_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage(napiWorker);