@atlaspack/core 2.14.0 → 2.14.1-canary.11

package/lib/CommittedAsset.js

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _stream() {
+  const data = require("stream");
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+var _assetUtils = require("./assetUtils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class CommittedAsset {
+  constructor(value, options) {
+    this.value = value;
+    this.key = this.value.contentKey;
+    this.options = options;
+  }
+  getContent() {
+    if (this.content == null) {
+      if (this.key != null) {
+        if (this.value.isLargeBlob) {
+          return this.options.cache.getStream(this.key);
+        } else {
+          return this.options.cache.getBlob(this.key);
+        }
+      } else if (this.value.astKey != null) {
+        return (0, _utils().streamFromPromise)((0, _assetUtils.generateFromAST)(this).then(({
+          content
+        }) => {
+          if (!(content instanceof _stream().Readable)) {
+            this.content = Promise.resolve(content);
+          }
+          return content;
+        }));
+      } else {
+        throw new Error('Asset has no content');
+      }
+    }
+    return this.content;
+  }
+  async getCode() {
+    let content;
+    if (this.content == null && this.key != null) {
+      this.content = this.options.cache.getBlob(this.key);
+      content = await this.content;
+    } else {
+      content = await this.getContent();
+    }
+    if (typeof content === 'string' || content instanceof Buffer) {
+      return content.toString();
+    } else if (content != null) {
+      this.content = (0, _utils().bufferStream)(content);
+      return (await this.content).toString();
+    }
+    return '';
+  }
+  async getBuffer() {
+    let content = await this.getContent();
+    if (content == null) {
+      return Buffer.alloc(0);
+    } else if (typeof content === 'string' || content instanceof Buffer) {
+      return Buffer.from(content);
+    }
+    this.content = (0, _utils().bufferStream)(content);
+    return this.content;
+  }
+  getStream() {
+    let content = this.getContent();
+    return content instanceof Promise ? (0, _utils().streamFromPromise)(content) : (0, _utils().blobToStream)(content);
+  }
+  getMapBuffer() {
+    let mapKey = this.value.mapKey;
+    if (mapKey != null && this.mapBuffer == null) {
+      this.mapBuffer = (async () => {
+        try {
+          // Handle v3 assets that were processed by the native asset graph code (i.e. not runtime
+          // or helper assets)
+          if (this.options.featureFlags.atlaspackV3 && this.value.meta.isV3 === true) {
+            let buffer = await this.options.cache.getBuffer(mapKey);
+            if (!buffer) {
+              return buffer;
+            }
+
+            // We make the conversion from json to buffer here, since both js packagers lazily
+            // instantiate a sourcemap from the map buffer. This ensures we do not have to modify
+            // the packagers in any significant way. Additionally, storing the SourceMap objects
+            // upfront in these packagers appears to make larger builds more prone to failing.
+            let sourceMap = new (_sourceMap().default)(this.options.projectRoot);
+            sourceMap.addVLQMap(JSON.parse(buffer.toString()));
+            return sourceMap.toBuffer();
+          }
+          return await this.options.cache.getBlob(mapKey);
+        } catch (err) {
+          if (err.code === 'ENOENT' && this.value.astKey != null) {
+            var _await$generateFromAS;
+            return (_await$generateFromAS = (await (0, _assetUtils.generateFromAST)(this)).map) === null || _await$generateFromAS === void 0 ? void 0 : _await$generateFromAS.toBuffer();
+          } else {
+            throw err;
+          }
+        }
+      })();
+    }
+    return this.mapBuffer ?? Promise.resolve();
+  }
+  getMap() {
+    if (this.map == null) {
+      this.map = (async () => {
+        let mapBuffer = await this.getMapBuffer();
+        if (mapBuffer) {
+          // Get sourcemap from flatbuffer
+          return new (_sourceMap().default)(this.options.projectRoot, mapBuffer);
+        }
+      })();
+    }
+    return this.map;
+  }
+  getAST() {
+    if (this.value.astKey == null) {
+      return Promise.resolve(null);
+    }
+    if (this.ast == null) {
+      this.ast = this.options.cache.getBlob(this.value.astKey).then(serializedAst => (0, _buildCache().deserializeRaw)(serializedAst));
+    }
+    return this.ast;
+  }
+  getDependencies() {
+    return Array.from(this.value.dependencies.values());
+  }
+}
+exports.default = CommittedAsset;

package/lib/Dependency.js

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDependency = createDependency;
+exports.createDependencyId = createDependencyId;
+exports.mergeDependencies = mergeDependencies;
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+var _types = require("./types");
+var _utils = require("./utils");
+var _projectPath = require("./projectPath");
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+var _IdentifierRegistry = require("./IdentifierRegistry");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function createDependencyId({
+  sourceAssetId,
+  specifier,
+  env,
+  target,
+  pipeline,
+  specifierType,
+  bundleBehavior,
+  priority,
+  packageConditions
+}) {
+  (0, _assert().default)(typeof specifierType === 'string');
+  (0, _assert().default)(typeof priority === 'string' || priority == null);
+  const params = {
+    sourceAssetId,
+    specifier,
+    environmentId: env.id,
+    target,
+    pipeline,
+    specifierType: _types.SpecifierType[specifierType],
+    bundleBehavior,
+    priority: priority ? _types.Priority[priority] : _types.Priority.sync,
+    packageConditions
+  };
+  const id = (0, _rust().createDependencyId)(params);
+  _IdentifierRegistry.identifierRegistry.addIdentifier('dependency', id, params);
+  return id;
+}
+function createDependency(projectRoot, opts) {
+  let id = opts.id || createDependencyId({
+    bundleBehavior: opts.bundleBehavior,
+    env: opts.env,
+    packageConditions: opts.packageConditions,
+    pipeline: opts.pipeline,
+    priority: opts.priority,
+    sourceAssetId: opts.sourceAssetId,
+    specifier: opts.specifier,
+    specifierType: opts.specifierType,
+    target: opts.target
+  });
+  let dep = {
+    id,
+    specifier: opts.specifier,
+    specifierType: _types.SpecifierType[opts.specifierType],
+    priority: _types.Priority[opts.priority ?? 'sync'],
+    needsStableName: opts.needsStableName ?? false,
+    bundleBehavior: opts.bundleBehavior ? _types.BundleBehavior[opts.bundleBehavior] : null,
+    isEntry: opts.isEntry ?? false,
+    isOptional: opts.isOptional ?? false,
+    loc: (0, _utils.toInternalSourceLocation)(projectRoot, opts.loc),
+    env: opts.env,
+    meta: opts.meta || {},
+    target: opts.target,
+    sourceAssetId: opts.sourceAssetId,
+    sourcePath: (0, _projectPath.toProjectPath)(projectRoot, opts.sourcePath),
+    resolveFrom: (0, _projectPath.toProjectPath)(projectRoot, opts.resolveFrom),
+    range: opts.range,
+    symbols: opts.symbols && new Map([...opts.symbols].map(([k, v]) => [k, {
+      local: v.local,
+      meta: v.meta,
+      isWeak: v.isWeak,
+      loc: (0, _utils.toInternalSourceLocation)(projectRoot, v.loc)
+    }])),
+    pipeline: opts.pipeline
+  };
+  if (opts.packageConditions) {
+    convertConditions(opts.packageConditions, dep);
+  }
+  return dep;
+}
+function mergeDependencies(a, b) {
+  let {
+    meta,
+    symbols,
+    needsStableName,
+    isEntry,
+    isOptional,
+    ...other
+  } = b;
+  Object.assign(a, other);
+  Object.assign(a.meta, meta);
+  if (a.symbols && symbols) {
+    for (let [k, v] of symbols) {
+      a.symbols.set(k, v);
+    }
+  }
+  if (needsStableName) a.needsStableName = true;
+  if (isEntry) a.isEntry = true;
+  if (!isOptional) a.isOptional = false;
+}
+function convertConditions(conditions, dep) {
+  // Store common package conditions as bit flags to reduce size.
+  // Custom conditions are stored as strings.
+  let packageConditions = 0;
+  let customConditions = [];
+  for (let condition of conditions) {
+    if (_types.ExportsCondition[condition]) {
+      packageConditions |= _types.ExportsCondition[condition];
+    } else {
+      customConditions.push(condition);
+    }
+  }
+  if (packageConditions) {
+    dep.packageConditions = packageConditions;
+  }
+  if (customConditions.length) {
+    dep.customPackageConditions = customConditions;
+  }
+}

package/lib/Environment.js

@@ -0,0 +1,144 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEnvironment = createEnvironment;
+exports.mergeEnvironments = mergeEnvironments;
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+var _utils = require("./utils");
+var _Environment = _interopRequireWildcard(require("./public/Environment"));
+var _IdentifierRegistry = require("./IdentifierRegistry");
+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; }
+const DEFAULT_ENGINES = {
+  browsers: ['> 0.25%'],
+  node: '>= 8.0.0'
+};
+function createEnvironment({
+  context,
+  engines,
+  includeNodeModules,
+  outputFormat,
+  sourceType = 'module',
+  shouldOptimize = false,
+  isLibrary = false,
+  shouldScopeHoist = false,
+  sourceMap,
+  unstableSingleFileOutput = false,
+  loc
+} = {
+  /*::...null*/
+}) {
+  if (context == null) {
+    var _engines, _engines2;
+    if ((_engines = engines) !== null && _engines !== void 0 && _engines.node) {
+      context = 'node';
+    } else if ((_engines2 = engines) !== null && _engines2 !== void 0 && _engines2.browsers) {
+      context = 'browser';
+    } else {
+      context = 'browser';
+    }
+  }
+  if (engines == null) {
+    switch (context) {
+      case 'node':
+      case 'electron-main':
+        engines = {
+          node: DEFAULT_ENGINES.node
+        };
+        break;
+      case 'browser':
+      case 'web-worker':
+      case 'service-worker':
+      case 'electron-renderer':
+        engines = {
+          browsers: DEFAULT_ENGINES.browsers
+        };
+        break;
+      default:
+        engines = {};
+    }
+  }
+  if (includeNodeModules == null) {
+    switch (context) {
+      case 'node':
+      case 'electron-main':
+      case 'electron-renderer':
+        includeNodeModules = false;
+        break;
+      case 'browser':
+      case 'web-worker':
+      case 'service-worker':
+      default:
+        includeNodeModules = true;
+        break;
+    }
+  }
+  if (outputFormat == null) {
+    switch (context) {
+      case 'node':
+      case 'electron-main':
+      case 'electron-renderer':
+        outputFormat = 'commonjs';
+        break;
+      default:
+        outputFormat = 'global';
+        break;
+    }
+  }
+  let res = {
+    id: '',
+    context,
+    engines,
+    includeNodeModules,
+    outputFormat,
+    sourceType,
+    isLibrary,
+    shouldOptimize,
+    shouldScopeHoist,
+    sourceMap,
+    unstableSingleFileOutput,
+    loc
+  };
+  res.id = getEnvironmentHash(res);
+  return Object.freeze(res);
+}
+function mergeEnvironments(projectRoot, a, b) {
+  // If merging the same object, avoid copying.
+  if (a === b || !b) {
+    return a;
+  }
+  if (b instanceof _Environment.default) {
+    return (0, _Environment.environmentToInternalEnvironment)(b);
+  }
+
+  // $FlowFixMe - ignore the `id` that is already on a
+  return createEnvironment({
+    ...a,
+    ...b,
+    loc: b.loc ? (0, _utils.toInternalSourceLocation)(projectRoot, b.loc) : a.loc
+  });
+}
+function getEnvironmentHash(env) {
+  const data = {
+    context: env.context,
+    engines: env.engines,
+    includeNodeModules: env.includeNodeModules,
+    outputFormat: env.outputFormat,
+    sourceType: env.sourceType,
+    isLibrary: env.isLibrary,
+    shouldOptimize: env.shouldOptimize,
+    shouldScopeHoist: env.shouldScopeHoist,
+    sourceMap: env.sourceMap
+  };
+  const id = (0, _rust().createEnvironmentId)(data);
+  _IdentifierRegistry.identifierRegistry.addIdentifier('environment', id, data);
+  return id;
+}

package/lib/IdentifierRegistry.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.identifierRegistry = exports.IdentifierRegistry = void 0;
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class IdentifierRegistry {
+  #enabled;
+  #createdDirectory = false;
+  constructor(enabled) {
+    this.#enabled = enabled;
+  }
+  addIdentifier(type, identifier, data) {
+    if (this.#enabled) {
+      if (!this.#createdDirectory) {
+        _fs().default.mkdirSync('./.atlaspack', {
+          recursive: true
+        });
+        this.#createdDirectory = true;
+      }
+      _fs().default.appendFile('./.atlaspack/atlaspack-identifiers.txt',
+      // $FlowFixMe
+      `${type} ${identifier} ${JSON.stringify(data)}\n`, () => {});
+    }
+  }
+}
+exports.IdentifierRegistry = IdentifierRegistry;
+const identifierRegistry = exports.identifierRegistry = new IdentifierRegistry(process.env.ATLASPACK_IDENTIFIER_DEBUG === 'true');

package/lib/InternalConfig.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createConfig = createConfig;
+var _projectPath = require("./projectPath");
+var _Environment = require("./Environment");
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+var _IdentifierRegistry = require("./IdentifierRegistry");
+function createConfig({
+  plugin,
+  isSource,
+  searchPath,
+  env,
+  result,
+  invalidateOnFileChange,
+  invalidateOnConfigKeyChange,
+  invalidateOnFileCreate,
+  invalidateOnEnvChange,
+  invalidateOnOptionChange,
+  devDeps,
+  invalidateOnStartup,
+  invalidateOnBuild
+}) {
+  let environment = env ?? (0, _Environment.createEnvironment)();
+  const configId = (0, _rust().hashString)(plugin + (0, _projectPath.fromProjectPathRelative)(searchPath) + environment.id + String(isSource));
+  _IdentifierRegistry.identifierRegistry.addIdentifier('config_request', configId, {
+    plugin,
+    searchPath,
+    environmentId: environment.id,
+    isSource
+  });
+  return {
+    id: configId,
+    isSource: isSource ?? false,
+    searchPath,
+    env: environment,
+    result: result ?? null,
+    cacheKey: null,
+    invalidateOnFileChange: invalidateOnFileChange ?? new Set(),
+    invalidateOnConfigKeyChange: invalidateOnConfigKeyChange ?? [],
+    invalidateOnFileCreate: invalidateOnFileCreate ?? [],
+    invalidateOnEnvChange: invalidateOnEnvChange ?? new Set(),
+    invalidateOnOptionChange: invalidateOnOptionChange ?? new Set(),
+    devDeps: devDeps ?? [],
+    invalidateOnStartup: invalidateOnStartup ?? false,
+    invalidateOnBuild: invalidateOnBuild ?? false
+  };
+}