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

package/lib/AssetGraph.js

@@ -189,8 +189,7 @@ class AssetGraph extends _graph().ContentGraph {
       // The passed project path is ignored in this case, because there is no `loc`
       (0, _Dependency.createDependency)('', {
         specifier: (0, _projectPath.fromProjectPathRelative)(entry.filePath),
-        specifierType: 'esm',
-        // ???
+        specifierType: 'url',
         pipeline: target.pipeline,
         target: target,
         env: target.env,

package/lib/Atlaspack.js

@@ -151,6 +151,11 @@ class Atlaspack {
     if (this.#initialized) {
       return;
     }
+    const featureFlags = {
+      ..._featureFlags().DEFAULT_FEATURE_FLAGS,
+      ...this.#initialOptions.featureFlags
+    };
+    (0, _featureFlags().setFeatureFlags)(featureFlags);
     await _sourceMap().init;
     await (_rust().init === null || _rust().init === void 0 ? void 0 : (0, _rust().init)());
     try {
@@ -162,7 +167,10 @@ class Atlaspack {
       // Fallthrough
       _logger().default.warn(e);
     }
-    let resolvedOptions = await (0, _resolveOptions.default)(this.#initialOptions);
+    let resolvedOptions = await (0, _resolveOptions.default)({
+      ...this.#initialOptions,
+      featureFlags
+    });
     this.#resolvedOptions = resolvedOptions;
     let rustAtlaspack;
     if (resolvedOptions.featureFlags.atlaspackV3) {
@@ -176,15 +184,26 @@ class Atlaspack {
       rustAtlaspack = new _atlaspackV.AtlaspackV3({
         ...options,
         corePath: _path().default.join(__dirname, '..'),
+        threads: process.env.NODE_ENV === 'test' ? 2 : undefined,
         entries: Array.isArray(entries) ? entries : entries == null ? undefined : [entries],
-        fs: inputFS && (0, _atlaspackV.toFileSystemV3)(inputFS)
+        env: resolvedOptions.env,
+        fs: inputFS && (0, _atlaspackV.toFileSystemV3)(inputFS),
+        defaultTargetOptions: {
+          // $FlowFixMe projectPath is just a string
+          distDir: resolvedOptions.defaultTargetOptions.distDir,
+          engines: resolvedOptions.defaultTargetOptions.engines,
+          isLibrary: resolvedOptions.defaultTargetOptions.isLibrary,
+          outputFormat: resolvedOptions.defaultTargetOptions.outputFormat,
+          sourceMaps: resolvedOptions.defaultTargetOptions.sourceMaps,
+          shouldOptimize: resolvedOptions.defaultTargetOptions.shouldOptimize,
+          shouldScopeHoist: resolvedOptions.defaultTargetOptions.shouldScopeHoist
+        }
       });
     }
     let {
       config
     } = await (0, _AtlaspackConfigRequest.loadAtlaspackConfig)(resolvedOptions);
     this.#config = new _AtlaspackConfig.default(config, resolvedOptions);
-    (0, _featureFlags().setFeatureFlags)(resolvedOptions.featureFlags);
     if (this.#initialOptions.workerFarm) {
       if (this.#initialOptions.workerFarm.ending) {
         throw new Error('Supplied WorkerFarm is ending');
@@ -508,6 +527,9 @@ class Atlaspack {
     });
     return this.#farm.takeHeapSnapshot();
   }
+  async unstable_invalidate() {
+    await this._init();
+  }
   async unstable_transform(options) {
     var _options$env;
     if (!this.#initialized) {

package/lib/AtlaspackConfig.schema.js

@@ -5,42 +5,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 exports.validatePackageName = validatePackageName;
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// Reasoning behind this validation:
-// https://github.com/parcel-bundler/parcel/issues/3397#issuecomment-521353931
-function validatePackageName(pkg, pluginType, key) {
-  // $FlowFixMe
-  if (!pkg) {
-    return;
-  }
-  (0, _assert().default)(typeof pkg === 'string', `"${key}" must be a string`);
-
-  // Probably all of these need to be removed
-  if (pkg.startsWith('@atlaspack') || pkg.startsWith('@parcel')) {
-    (0, _assert().default)(pkg.replace(/^@atlaspack\//, '').startsWith(`${pluginType}-`), `Official atlaspack ${pluginType} packages must be named according to "@atlaspack/${pluginType}-{name}"`);
-  } else if (pkg.startsWith('@')) {
-    // Disabling this validation to allow for migration to parcel
-    // let [scope, name] = pkg.split('/');
-    // assert(
-    //   name.startsWith(`parcel-${pluginType}-`) ||
-    //     name === `parcel-${pluginType}` ||
-    //     name.startsWith(`parcel-${pluginType}-`) ||
-    //     name === `parcel-${pluginType}`,
-    //   `Scoped parcel ${pluginType} packages must be named according to "${scope}/parcel-${pluginType}[-{name}]"`,
-    // );
-  } else if (!pkg.startsWith('.')) {
-    (0, _assert().default)(pkg.startsWith(`parcel-${pluginType}-`) || pkg.startsWith(`atlaspack-${pluginType}`),
-    // let the error message be wrong for now
-    `Atlaspack ${pluginType} packages must be named according to "parcel-${pluginType}-{name}"`);
-  }
-}
+// Parcel validates plugin package names due to:
+//
+// * https://github.com/parcel-bundler/parcel/issues/3397#issuecomment-521353931
+//
+// Ultimately:
+//
+// * We do not care about package names
+// * Validation makes interop between parcel/atlaspack confusing.
+//
+function validatePackageName() {}
 const validatePluginName = (pluginType, key) => {
   return val => {
     // allow plugin spread...

package/lib/BundleGraph.js

@@ -44,6 +44,13 @@ var _utils2 = require("./utils");
 var _Environment = require("./public/Environment");
 var _projectPath = require("./projectPath");
 var _constants = require("./constants");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const bundleGraphEdgeTypes = exports.bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -107,16 +114,19 @@ class BundleGraph {
   /** The internal core Graph structure */
 
   _bundlePublicIds /*: Set<string> */ = new Set();
+  _conditions /*: Map<string, Condition> */ = new Map();
   constructor({
     graph,
     publicIdByAssetId,
     assetPublicIds,
-    bundleContentHashes
+    bundleContentHashes,
+    conditions
   }) {
     this._graph = graph;
     this._assetPublicIds = assetPublicIds;
     this._publicIdByAssetId = publicIdByAssetId;
     this._bundleContentHashes = bundleContentHashes;
+    this._conditions = conditions;
   }
 
   /**
@@ -128,6 +138,8 @@ class BundleGraph {
     let assetGroupIds = new Map();
     let dependencies = new Map();
     let assetGraphNodeIdToBundleGraphNodeId = new Map();
+    let conditions = new Map();
+    let placeholderToDependency = new Map();
     let assetGraphRootNode = assetGraph.rootNodeId != null ? assetGraph.getNode(assetGraph.rootNodeId) : null;
     (0, _assert().default)(assetGraphRootNode != null && assetGraphRootNode.type === 'root');
     assetGraph.dfsFast(nodeId => {
@@ -146,6 +158,17 @@ class BundleGraph {
         }
       } else if (node != null && node.type === 'asset_group') {
         assetGroupIds.set(nodeId, assetGraph.getNodeIdsConnectedFrom(nodeId));
+      } else if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node != null && node.type === 'dependency') {
+        var _dep$meta;
+        // The dependency placeholders in the `importCond` calls that will be in the transformed
+        // code need to be mapped to the "real" dependencies, so we need access to a map of placeholders
+        // to dependencies
+        const dep = node.value;
+        // $FlowFixMe[incompatible-type] Meta is untyped
+        const placeholder = (_dep$meta = dep.meta) === null || _dep$meta === void 0 ? void 0 : _dep$meta.placeholder;
+        if (placeholder != null) {
+          placeholderToDependency.set(placeholder, dep);
+        }
       }
     });
     let walkVisited = new Set();
@@ -153,6 +176,34 @@ class BundleGraph {
       if (walkVisited.has(nodeId)) return;
       walkVisited.add(nodeId);
       let node = (0, _nullthrows().default)(assetGraph.getNode(nodeId));
+      if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node.type === 'asset') {
+        const asset = node.value;
+        if (Array.isArray(asset.meta.conditions)) {
+          // $FlowFixMe
+          for (const condition of asset.meta.conditions) {
+            // Resolve the placeholders that were attached to the asset in JSTransformer to dependencies,
+            // as well as create a public id for the condition.
+            const {
+              key,
+              ifTruePlaceholder,
+              ifFalsePlaceholder
+            } = condition;
+            const condHash = (0, _rust().hashString)(`${key}:${ifTruePlaceholder}:${ifFalsePlaceholder}`);
+            const condPublicId = (0, _utils2.getPublicId)(condHash, v => conditions.has(v));
+            if (conditions.has(condHash)) {
+              throw new Error('Unexpected duplicate asset');
+            } else {
+              conditions.set(condHash, {
+                publicId: condPublicId,
+                assets: new Set([asset]),
+                key,
+                ifTrueDependency: (0, _nullthrows().default)(placeholderToDependency.get(ifTruePlaceholder), 'ifTruePlaceholder was undefined'),
+                ifFalseDependency: (0, _nullthrows().default)(placeholderToDependency.get(ifFalsePlaceholder), 'ifFalsePlaceholder was undefined')
+              });
+            }
+          }
+        }
+      }
       if (node.type === 'dependency' && node.value.symbols != null && node.value.env.shouldScopeHoist &&
       // Disable in dev mode because this feature is at odds with safeToIncrementallyBundle
       isProduction) {
@@ -338,7 +389,8 @@ class BundleGraph {
       graph,
       assetPublicIds,
       bundleContentHashes: new Map(),
-      publicIdByAssetId
+      publicIdByAssetId,
+      conditions
     });
   }
   serialize() {
@@ -347,7 +399,8 @@ class BundleGraph {
       graph: this._graph.serialize(),
       assetPublicIds: this._assetPublicIds,
       bundleContentHashes: this._bundleContentHashes,
-      publicIdByAssetId: this._publicIdByAssetId
+      publicIdByAssetId: this._publicIdByAssetId,
+      conditions: this._conditions
     };
   }
   static deserialize(serialized) {
@@ -355,7 +408,8 @@ class BundleGraph {
       graph: _graph().ContentGraph.deserialize(serialized.graph),
       assetPublicIds: serialized.assetPublicIds,
       bundleContentHashes: serialized.bundleContentHashes,
-      publicIdByAssetId: serialized.publicIdByAssetId
+      publicIdByAssetId: serialized.publicIdByAssetId,
+      conditions: serialized.conditions
     });
   }
   createBundle(opts) {
@@ -768,7 +822,7 @@ class BundleGraph {
       return true;
     }
     let assetNodeId = (0, _nullthrows().default)(this._graph.getNodeIdByContentKey(asset.id));
-    if (this._graph.getNodeIdsConnectedTo(assetNodeId, bundleGraphEdgeTypes.references).map(id => this._graph.getNode(id)).some(node => (node === null || node === void 0 ? void 0 : node.type) === 'dependency' && node.value.priority === _types.Priority.lazy && node.value.specifierType !== _types.SpecifierType.url)) {
+    if (this._graph.getNodeIdsConnectedTo(assetNodeId, bundleGraphEdgeTypes.references).map(id => this._graph.getNode(id)).some(node => (node === null || node === void 0 ? void 0 : node.type) === 'dependency' && (node.value.priority === _types.Priority.lazy || node.value.priority === _types.Priority.conditional) && node.value.specifierType !== _types.SpecifierType.url)) {
       // If this asset is referenced by any async dependency, it's referenced.
       return true;
     }

package/lib/Dependency.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createDependency = createDependency;
+exports.createDependencyId = createDependencyId;
 exports.mergeDependencies = mergeDependencies;
 function _rust() {
   const data = require("@atlaspack/rust");
@@ -15,8 +16,52 @@ function _rust() {
 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;
+}
+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,
+    env,
+    target,
+    pipeline,
+    specifierType: _types.SpecifierType[specifierType],
+    bundleBehavior,
+    priority: priority ? _types.Priority[priority] : _types.Priority.sync,
+    packageConditions
+  };
+  return (0, _rust().createDependencyId)(params);
+}
 function createDependency(projectRoot, opts) {
-  let id = opts.id || (0, _rust().hashString)((opts.sourceAssetId ?? '') + opts.specifier + opts.env.id + (opts.target ? JSON.stringify(opts.target) : '') + (opts.pipeline ?? '') + opts.specifierType + (opts.bundleBehavior ?? '') + (opts.priority ?? 'sync') + (opts.packageConditions ? JSON.stringify(opts.packageConditions) : ''));
+  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,

package/lib/Environment.js

@@ -105,7 +105,7 @@ function createEnvironment({
     loc
   };
   res.id = getEnvironmentHash(res);
-  return res;
+  return Object.freeze(res);
 }
 function mergeEnvironments(projectRoot, a, b) {
   // If merging the same object, avoid copying.
@@ -124,5 +124,15 @@ function mergeEnvironments(projectRoot, a, b) {
   });
 }
 function getEnvironmentHash(env) {
-  return (0, _rust().hashString)(JSON.stringify([env.context, env.engines, env.includeNodeModules, env.outputFormat, env.sourceType, env.isLibrary, env.shouldOptimize, env.shouldScopeHoist, env.sourceMap]));
+  return (0, _rust().createEnvironmentId)({
+    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
+  });
 }

package/lib/PackagerRunner.js

@@ -11,13 +11,6 @@ function _assert() {
   };
   return data;
 }
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
 function _logger() {
   const data = require("@atlaspack/logger");
   _logger = function () {
@@ -32,13 +25,6 @@ function _diagnostic() {
   };
   return data;
 }
-function _stream() {
-  const data = require("stream");
-  _stream = function () {
-    return data;
-  };
-  return data;
-}
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
   _nullthrows = function () {
@@ -314,7 +300,7 @@ class PackagerRunner {
     let bundle = _Bundle.NamedBundle.get(internalBundle, internalBundleGraph, this.options);
     let bundleGraph = new _BundleGraph.default(internalBundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), this.options);
     let optimizers = await this.config.getOptimizers(bundle.name, internalBundle.pipeline);
-    if (!optimizers.length) {
+    if (optimizers.length === 0) {
       return {
         type: bundle.type,
         contents,
@@ -447,40 +433,13 @@ class PackagerRunner {
     }
     return devDepHashes;
   }
-  async readFromCache(cacheKey) {
-    let contentKey = PackagerRunner.getContentKey(cacheKey);
-    let mapKey = PackagerRunner.getMapKey(cacheKey);
-    let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists = isLargeBlob || (await this.options.cache.has(contentKey));
-    if (!contentExists) {
-      return null;
-    }
-    let mapExists = await this.options.cache.has(mapKey);
-    return {
-      contents: isLargeBlob ? this.options.cache.getStream(contentKey) : (0, _utils().blobToStream)(await this.options.cache.getBlob(contentKey)),
-      map: mapExists ? (0, _utils().blobToStream)(await this.options.cache.getBlob(mapKey)) : null
-    };
-  }
   async writeToCache(cacheKeys, type, contents, map) {
     let size = 0;
     let hash;
     let hashReferences = [];
-    let isLargeBlob = false;
 
     // TODO: don't replace hash references in binary files??
-    if (contents instanceof _stream().Readable) {
-      isLargeBlob = true;
-      let boundaryStr = '';
-      let h = new (_rust().Hash)();
-      await this.options.cache.setStream(cacheKeys.content, (0, _utils().blobToStream)(contents).pipe(new (_utils().TapStream)(buf => {
-        let str = boundaryStr + buf.toString();
-        hashReferences = hashReferences.concat(str.match(_constants.HASH_REF_REGEX) ?? []);
-        size += buf.length;
-        h.writeBuffer(buf);
-        boundaryStr = str.slice(str.length - BOUNDARY_LENGTH);
-      })));
-      hash = h.finish();
-    } else if (typeof contents === 'string') {
+    if (typeof contents === 'string') {
       let buffer = Buffer.from(contents);
       size = buffer.byteLength;
       hash = (0, _rust().hashBuffer)(buffer);
@@ -500,8 +459,7 @@ class PackagerRunner {
       size,
       hash,
       hashReferences,
-      cacheKeys,
-      isLargeBlob
+      cacheKeys
     };
     await this.options.cache.set(cacheKeys.info, info);
     return info;