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

package/lib/resolveOptions.js

@@ -32,6 +32,13 @@ function _cache() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _packageManager() {
   const data = require("@atlaspack/package-manager");
   _packageManager = function () {
@@ -49,13 +56,6 @@ function _utils() {
 var _loadDotEnv = _interopRequireDefault(require("./loadDotEnv"));
 var _projectPath = require("./projectPath");
 var _AtlaspackConfigRequest = require("./requests/AtlaspackConfigRequest");
-function _featureFlags() {
-  const data = require("@atlaspack/feature-flags");
-  _featureFlags = function () {
-    return data;
-  };
-  return data;
-}
 var _constants = require("./constants");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // Default cache directory name
@@ -111,7 +111,12 @@ async function resolveOptions(initialOptions) {
   // where symlinked dependencies outside the project root need to trigger HMR
   // updates. Default to the project root if not provided.
   let watchDir = initialOptions.watchDir != null ? _path().default.resolve(initialOptions.watchDir) : projectRoot;
-  let cache = initialOptions.cache ?? (outputFS instanceof _fs().NodeFS ? new (_cache().LMDBCache)(cacheDir) : new (_cache().FSCache)(outputFS, cacheDir));
+  let cache = initialOptions.cache ?? (outputFS instanceof _fs().NodeFS ? (() => {
+    if ((0, _featureFlags().getFeatureFlag)('useLmdbJsLite')) {
+      return new (_cache().LMDBLiteCache)(cacheDir);
+    }
+    return new (_cache().LMDBCache)(cacheDir);
+  })() : new (_cache().FSCache)(outputFS, cacheDir));
   let mode = initialOptions.mode ?? 'development';
   let shouldOptimize = (initialOptions === null || initialOptions === void 0 || (_initialOptions$defau = initialOptions.defaultTargetOptions) === null || _initialOptions$defau === void 0 ? void 0 : _initialOptions$defau.shouldOptimize) ?? mode === 'production';
   let publicUrl = (initialOptions === null || initialOptions === void 0 || (_initialOptions$defau2 = initialOptions.defaultTargetOptions) === null || _initialOptions$defau2 === void 0 ? void 0 : _initialOptions$defau2.publicUrl) ?? '/';
@@ -192,6 +197,8 @@ async function resolveOptions(initialOptions) {
       outputFormat: initialOptions === null || initialOptions === void 0 || (_initialOptions$defau8 = initialOptions.defaultTargetOptions) === null || _initialOptions$defau8 === void 0 ? void 0 : _initialOptions$defau8.outputFormat,
       isLibrary: initialOptions === null || initialOptions === void 0 || (_initialOptions$defau9 = initialOptions.defaultTargetOptions) === null || _initialOptions$defau9 === void 0 ? void 0 : _initialOptions$defau9.isLibrary
     },
+    // unused, feature-flags are set above this to allow this function to use
+    // feature-flags
     featureFlags: {
       ..._featureFlags().DEFAULT_FEATURE_FLAGS,
       ...(initialOptions === null || initialOptions === void 0 ? void 0 : initialOptions.featureFlags)

package/lib/types.js

@@ -13,7 +13,8 @@ const SpecifierType = exports.SpecifierType = {
 const Priority = exports.Priority = {
   sync: 0,
   parallel: 1,
-  lazy: 2
+  lazy: 2,
+  conditional: 3
 };
 
 // Must match package_json.rs in node-resolver-rs.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-dev.3401+b483af77f",
-  "license": "MIT",
+  "version": "2.12.1-dev.3443+d1170cfc7",
+  "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
   },
@@ -20,20 +20,20 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/cache": "2.12.1-dev.3401+b483af77f",
-    "@atlaspack/diagnostic": "2.12.1-dev.3401+b483af77f",
-    "@atlaspack/events": "2.12.1-dev.3401+b483af77f",
-    "@atlaspack/feature-flags": "2.12.1-dev.3401+b483af77f",
-    "@atlaspack/fs": "2.12.1-dev.3401+b483af77f",
-    "@atlaspack/graph": "3.2.1-dev.3401+b483af77f",
-    "@atlaspack/logger": "2.12.1-dev.3401+b483af77f",
-    "@atlaspack/package-manager": "2.12.1-dev.3401+b483af77f",
-    "@atlaspack/plugin": "2.12.1-dev.3401+b483af77f",
-    "@atlaspack/profiler": "2.12.1-dev.3401+b483af77f",
-    "@atlaspack/rust": "2.12.1-dev.3401+b483af77f",
-    "@atlaspack/types": "2.12.1-dev.3401+b483af77f",
-    "@atlaspack/utils": "2.12.1-dev.3401+b483af77f",
-    "@atlaspack/workers": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/cache": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/diagnostic": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/events": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/feature-flags": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/fs": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/graph": "3.2.1-dev.3443+d1170cfc7",
+    "@atlaspack/logger": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/package-manager": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/plugin": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/profiler": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/rust": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/types": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/utils": "2.12.1-dev.3443+d1170cfc7",
+    "@atlaspack/workers": "2.12.1-dev.3443+d1170cfc7",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -50,10 +50,12 @@
     "@atlaspack/babel-register": "2.12.0",
     "@types/node": ">= 18",
     "graphviz": "^0.0.9",
+    "jest-diff": "*",
+    "rfdc": "1",
     "tempy": "^0.2.1"
   },
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "b483af77f02d1258c8dad156e097b94f83671d8e"
+  "gitHead": "d1170cfc79beb290b2a066f472f68f71f7d7cb23"
 }

package/src/AssetGraph.js

@@ -227,7 +227,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
         // The passed project path is ignored in this case, because there is no `loc`
         createDependency('', {
           specifier: fromProjectPathRelative(entry.filePath),
-          specifierType: 'esm', // ???
+          specifierType: 'url',
           pipeline: target.pipeline,
           target: target,
           env: target.env,

package/src/Atlaspack.js

@@ -57,7 +57,7 @@ import {
   fromProjectPathRelative,
 } from './projectPath';
 import {tracer} from '@atlaspack/profiler';
-import {setFeatureFlags} from '@atlaspack/feature-flags';
+import {setFeatureFlags, DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
 import {AtlaspackV3, toFileSystemV3} from './atlaspack-v3';
 
 registerCoreWithSerializer();
@@ -105,6 +105,12 @@ export default class Atlaspack {
       return;
     }
 
+    const featureFlags = {
+      ...DEFAULT_FEATURE_FLAGS,
+      ...this.#initialOptions.featureFlags,
+    };
+    setFeatureFlags(featureFlags);
+
     await initSourcemaps;
     await initRust?.();
     try {
@@ -117,9 +123,10 @@ export default class Atlaspack {
       logger.warn(e);
     }
 
-    let resolvedOptions: AtlaspackOptions = await resolveOptions(
-      this.#initialOptions,
-    );
+    let resolvedOptions: AtlaspackOptions = await resolveOptions({
+      ...this.#initialOptions,
+      featureFlags,
+    });
     this.#resolvedOptions = resolvedOptions;
 
     let rustAtlaspack: AtlaspackV3;
@@ -130,20 +137,31 @@ export default class Atlaspack {
       rustAtlaspack = new AtlaspackV3({
         ...options,
         corePath: path.join(__dirname, '..'),
+        threads: process.env.NODE_ENV === 'test' ? 2 : undefined,
         entries: Array.isArray(entries)
           ? entries
           : entries == null
           ? undefined
           : [entries],
+        env: resolvedOptions.env,
         fs: inputFS && 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 loadAtlaspackConfig(resolvedOptions);
     this.#config = new AtlaspackConfig(config, resolvedOptions);
 
-    setFeatureFlags(resolvedOptions.featureFlags);
-
     if (this.#initialOptions.workerFarm) {
       if (this.#initialOptions.workerFarm.ending) {
         throw new Error('Supplied WorkerFarm is ending');
@@ -531,6 +549,10 @@ export default class Atlaspack {
     return this.#farm.takeHeapSnapshot();
   }
 
+  async unstable_invalidate(): Promise<void> {
+    await this._init();
+  }
+
   async unstable_transform(
     options: AtlaspackTransformOptions,
   ): Promise<Array<Asset>> {

package/src/AtlaspackConfig.schema.js

@@ -1,47 +1,24 @@
 // @flow strict-local
 import type {PackageName} from '@atlaspack/types';
 import type {SchemaEntity} from '@atlaspack/utils';
-import assert from 'assert';
 
-// Reasoning behind this validation:
-// https://github.com/parcel-bundler/parcel/issues/3397#issuecomment-521353931
+// 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.
+//
 export function validatePackageName(
+  // eslint-disable-next-line no-unused-vars
   pkg: ?PackageName,
+  // eslint-disable-next-line no-unused-vars
   pluginType: string,
+  // eslint-disable-next-line no-unused-vars
   key: string,
-) {
-  // $FlowFixMe
-  if (!pkg) {
-    return;
-  }
-
-  assert(typeof pkg === 'string', `"${key}" must be a string`);
-
-  // Probably all of these need to be removed
-  if (pkg.startsWith('@atlaspack') || pkg.startsWith('@parcel')) {
-    assert(
-      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('.')) {
-    assert(
-      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}"`,
-    );
-  }
-}
+) {}
 
 const validatePluginName = (pluginType: string, key: string) => {
   return (val: string) => {

package/src/BundleGraph.js

@@ -6,6 +6,7 @@ import type {
   Symbol,
   TraversalActions,
   BundleBehavior as IBundleBehavior,
+  ConditionMeta,
 } from '@atlaspack/types';
 import type {
   ContentKey,
@@ -26,6 +27,7 @@ import type {
   Environment,
   InternalSourceLocation,
   Target,
+  Condition,
 } from './types';
 import type AssetGraph from './AssetGraph';
 import type {ProjectPath} from './projectPath';
@@ -46,6 +48,7 @@ import {getBundleGroupId, getPublicId} from './utils';
 import {ISOLATED_ENVS} from './public/Environment';
 import {fromProjectPath, fromProjectPathRelative} from './projectPath';
 import {HASH_REF_PREFIX} from './constants';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 export const bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -91,6 +94,7 @@ type BundleGraphOpts = {|
   bundleContentHashes: Map<string, string>,
   assetPublicIds: Set<string>,
   publicIdByAssetId: Map<string, string>,
+  conditions: Map<string, Condition>,
 |};
 
 type SerializedBundleGraph = {|
@@ -99,6 +103,7 @@ type SerializedBundleGraph = {|
   bundleContentHashes: Map<string, string>,
   assetPublicIds: Set<string>,
   publicIdByAssetId: Map<string, string>,
+  conditions: Map<string, Condition>,
 |};
 
 function makeReadOnlySet<T>(set: Set<T>): $ReadOnlySet<T> {
@@ -139,22 +144,26 @@ export default class BundleGraph {
   /** The internal core Graph structure */
   _graph: ContentGraph<BundleGraphNode, BundleGraphEdgeType>;
   _bundlePublicIds /*: Set<string> */ = new Set<string>();
+  _conditions /*: Map<string, Condition> */ = new Map<string, Condition>();
 
   constructor({
     graph,
     publicIdByAssetId,
     assetPublicIds,
     bundleContentHashes,
+    conditions,
   }: {|
     graph: ContentGraph<BundleGraphNode, BundleGraphEdgeType>,
     publicIdByAssetId: Map<string, string>,
     assetPublicIds: Set<string>,
     bundleContentHashes: Map<string, string>,
+    conditions: Map<string, Condition>,
   |}) {
     this._graph = graph;
     this._assetPublicIds = assetPublicIds;
     this._publicIdByAssetId = publicIdByAssetId;
     this._bundleContentHashes = bundleContentHashes;
+    this._conditions = conditions;
   }
 
   /**
@@ -171,6 +180,9 @@ export default class BundleGraph {
     let assetGroupIds = new Map();
     let dependencies = new Map();
     let assetGraphNodeIdToBundleGraphNodeId = new Map<NodeId, NodeId>();
+    let conditions = new Map<string, Condition>();
+
+    let placeholderToDependency = new Map<string, Dependency>();
 
     let assetGraphRootNode =
       assetGraph.rootNodeId != null
@@ -195,6 +207,20 @@ export default class BundleGraph {
         }
       } else if (node != null && node.type === 'asset_group') {
         assetGroupIds.set(nodeId, assetGraph.getNodeIdsConnectedFrom(nodeId));
+      } else if (
+        getFeatureFlag('conditionalBundlingApi') &&
+        node != null &&
+        node.type === 'dependency'
+      ) {
+        // 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: string | void = dep.meta?.placeholder;
+        if (placeholder != null) {
+          placeholderToDependency.set(placeholder, dep);
+        }
       }
     });
 
@@ -204,6 +230,51 @@ export default class BundleGraph {
       walkVisited.add(nodeId);
 
       let node = nullthrows(assetGraph.getNode(nodeId));
+
+      if (getFeatureFlag('conditionalBundlingApi') && node.type === 'asset') {
+        const asset = node.value;
+        if (Array.isArray(asset.meta.conditions)) {
+          // $FlowFixMe
+          for (const condition of (asset.meta.conditions: ConditionMeta[])) {
+            // 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,
+            }: {
+              key: string,
+              ifTruePlaceholder: string,
+              ifFalsePlaceholder: string,
+              ...
+            } = condition;
+
+            const condHash = hashString(
+              `${key}:${ifTruePlaceholder}:${ifFalsePlaceholder}`,
+            );
+            const condPublicId = 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: nullthrows(
+                  placeholderToDependency.get(ifTruePlaceholder),
+                  'ifTruePlaceholder was undefined',
+                ),
+                ifFalseDependency: nullthrows(
+                  placeholderToDependency.get(ifFalsePlaceholder),
+                  'ifFalsePlaceholder was undefined',
+                ),
+              });
+            }
+          }
+        }
+      }
+
       if (
         node.type === 'dependency' &&
         node.value.symbols != null &&
@@ -440,11 +511,13 @@ export default class BundleGraph {
         );
       }
     }
+
     return new BundleGraph({
       graph,
       assetPublicIds,
       bundleContentHashes: new Map(),
       publicIdByAssetId,
+      conditions,
     });
   }
 
@@ -455,6 +528,7 @@ export default class BundleGraph {
       assetPublicIds: this._assetPublicIds,
       bundleContentHashes: this._bundleContentHashes,
       publicIdByAssetId: this._publicIdByAssetId,
+      conditions: this._conditions,
     };
   }
 
@@ -464,6 +538,7 @@ export default class BundleGraph {
       assetPublicIds: serialized.assetPublicIds,
       bundleContentHashes: serialized.bundleContentHashes,
       publicIdByAssetId: serialized.publicIdByAssetId,
+      conditions: serialized.conditions,
     });
   }
 
@@ -1215,7 +1290,8 @@ export default class BundleGraph {
         .some(
           node =>
             node?.type === 'dependency' &&
-            node.value.priority === Priority.lazy &&
+            (node.value.priority === Priority.lazy ||
+              node.value.priority === Priority.conditional) &&
             node.value.specifierType !== SpecifierType.url,
         )
     ) {

package/src/CommittedAsset.js

@@ -17,7 +17,7 @@ export default class CommittedAsset {
   mapBuffer: ?Promise<?Buffer>;
   map: ?Promise<?SourceMap>;
   ast: ?Promise<AST>;
-  idBase: ?string;
+  code: ?string;
   generatingPromise: ?Promise<void>;
 
   constructor(value: Asset, options: AtlaspackOptions) {

package/src/Dependency.js

@@ -9,7 +9,7 @@ import type {
   SemverRange,
 } from '@atlaspack/types';
 import type {Dependency, Environment, Target} from './types';
-import {hashString} from '@atlaspack/rust';
+import {createDependencyId as createDependencyIdRust} from '@atlaspack/rust';
 import {
   SpecifierType,
   Priority,
@@ -19,6 +19,7 @@ import {
 
 import {toInternalSourceLocation} from './utils';
 import {toProjectPath} from './projectPath';
+import assert from 'assert';
 
 type DependencyOpts = {|
   id?: string,
@@ -45,23 +46,60 @@ type DependencyOpts = {|
   pipeline?: ?string,
 |};
 
+export function createDependencyId({
+  sourceAssetId,
+  specifier,
+  env,
+  target,
+  pipeline,
+  specifierType,
+  bundleBehavior,
+  priority,
+  packageConditions,
+}: {|
+  sourceAssetId: string | void,
+  specifier: DependencySpecifier,
+  env: Environment,
+  target: Target | void,
+  pipeline: ?string,
+  specifierType: $Keys<typeof SpecifierType>,
+  bundleBehavior: ?IBundleBehavior,
+  priority: $Keys<typeof Priority> | void,
+  packageConditions: Array<string> | void,
+|}): string {
+  assert(typeof specifierType === 'string');
+  assert(typeof priority === 'string' || priority == null);
+  const params = {
+    sourceAssetId,
+    specifier,
+    env,
+    target,
+    pipeline,
+    specifierType: SpecifierType[specifierType],
+    bundleBehavior,
+    priority: priority ? Priority[priority] : Priority.sync,
+    packageConditions,
+  };
+  return createDependencyIdRust(params);
+}
+
 export function createDependency(
   projectRoot: FilePath,
   opts: DependencyOpts,
 ): Dependency {
   let id =
     opts.id ||
-    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) : ''),
-    );
+    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: Dependency = {
     id,

package/src/Environment.js

@@ -5,7 +5,7 @@ import type {
   FilePath,
 } from '@atlaspack/types';
 import type {Environment, InternalSourceLocation} from './types';
-import {hashString} from '@atlaspack/rust';
+import {createEnvironmentId} from '@atlaspack/rust';
 import {toInternalSourceLocation} from './utils';
 import PublicEnvironment from './public/Environment';
 import {environmentToInternalEnvironment} from './public/Environment';
@@ -109,7 +109,7 @@ export function createEnvironment({
   };
 
   res.id = getEnvironmentHash(res);
-  return res;
+  return Object.freeze(res);
 }
 
 export function mergeEnvironments(
@@ -135,17 +135,15 @@ export function mergeEnvironments(
 }
 
 function getEnvironmentHash(env: Environment): string {
-  return hashString(
-    JSON.stringify([
-      env.context,
-      env.engines,
-      env.includeNodeModules,
-      env.outputFormat,
-      env.sourceType,
-      env.isLibrary,
-      env.shouldOptimize,
-      env.shouldScopeHoist,
-      env.sourceMap,
-    ]),
-  );
+  return 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,
+  });
 }