@atlaspack/core 2.16.2-canary.27 → 2.16.2-canary.270

package/dist/utils.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildAbortError = void 0;
+exports.getBundleGroupId = getBundleGroupId;
+exports.assertSignalNotAborted = assertSignalNotAborted;
+exports.getPublicId = getPublicId;
+exports.optionsProxy = optionsProxy;
+exports.hashFromOption = hashFromOption;
+exports.invalidateOnFileCreateToInternal = invalidateOnFileCreateToInternal;
+exports.createInvalidations = createInvalidations;
+exports.fromInternalSourceLocation = fromInternalSourceLocation;
+exports.toInternalSourceLocation = toInternalSourceLocation;
+exports.toInternalSymbols = toInternalSymbols;
+const assert_1 = __importDefault(require("assert"));
+const base_x_1 = __importDefault(require("base-x"));
+const utils_1 = require("@atlaspack/utils");
+const projectPath_1 = require("./projectPath");
+// /flow-to-ts helpers
+const base62 = (0, base_x_1.default)('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
+function getBundleGroupId(bundleGroup) {
+    return 'bundle_group:' + bundleGroup.target.name + bundleGroup.entryAssetId;
+}
+function assertSignalNotAborted(signal) {
+    if (signal && signal.aborted) {
+        throw new BuildAbortError();
+    }
+}
+class BuildAbortError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'BuildAbortError';
+    }
+}
+exports.BuildAbortError = BuildAbortError;
+function getPublicId(id, alreadyExists) {
+    let encoded = base62.encode(Buffer.from(id, 'hex'));
+    for (let end = 5; end <= encoded.length; end++) {
+        let candidate = encoded.slice(0, end);
+        if (!alreadyExists(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error('Original id was not unique');
+}
+// These options don't affect compilation and should cause invalidations
+const ignoreOptions = new Set([
+    'env', // handled by separate invalidateOnEnvChange
+    'inputFS',
+    'outputFS',
+    'workerFarm',
+    'packageManager',
+    'detailedReport',
+    'shouldDisableCache',
+    'cacheDir',
+    'shouldAutoInstall',
+    'logLevel',
+    'shouldProfile',
+    'shouldTrace',
+    'shouldPatchConsole',
+    'projectRoot',
+    'additionalReporters',
+]);
+function optionsProxy(options, invalidateOnOptionChange, addDevDependency) {
+    let packageManager = addDevDependency
+        ? proxyPackageManager(options.projectRoot, options.packageManager, addDevDependency)
+        : options.packageManager;
+    return new Proxy(options, {
+        get(target, prop) {
+            if (prop === 'packageManager') {
+                return packageManager;
+            }
+            if (!ignoreOptions.has(prop)) {
+                invalidateOnOptionChange(prop);
+            }
+            // @ts-expect-error TS7053
+            return target[prop];
+        },
+    });
+}
+function proxyPackageManager(projectRoot, packageManager, addDevDependency) {
+    let require = (id, from, opts) => {
+        addDevDependency({
+            specifier: id,
+            resolveFrom: (0, projectPath_1.toProjectPath)(projectRoot, from),
+            range: opts?.range,
+        });
+        return packageManager.require(id, from, opts);
+    };
+    return new Proxy(packageManager, {
+        get(target, prop) {
+            if (prop === 'require') {
+                return require;
+            }
+            // @ts-expect-error TS7053
+            return target[prop];
+        },
+    });
+}
+function hashFromOption(value) {
+    if (typeof value === 'object' && value != null) {
+        // @ts-expect-error TS2345
+        return (0, utils_1.hashObject)(value);
+    }
+    return String(value);
+}
+function invalidateOnFileCreateToInternal(projectRoot, invalidation) {
+    // @ts-expect-error TS2339
+    if (invalidation.glob != null) {
+        // @ts-expect-error TS2339
+        return { glob: (0, projectPath_1.toProjectPath)(projectRoot, invalidation.glob) };
+        // @ts-expect-error TS2339
+    }
+    else if (invalidation.filePath != null) {
+        return {
+            // @ts-expect-error TS2339
+            filePath: (0, projectPath_1.toProjectPath)(projectRoot, invalidation.filePath),
+        };
+    }
+    else {
+        (0, assert_1.default)(
+        // @ts-expect-error TS2339
+        invalidation.aboveFilePath != null && invalidation.fileName != null);
+        return {
+            // @ts-expect-error TS2339
+            fileName: invalidation.fileName,
+            // @ts-expect-error TS2339
+            aboveFilePath: (0, projectPath_1.toProjectPath)(projectRoot, invalidation.aboveFilePath),
+        };
+    }
+}
+function createInvalidations() {
+    return {
+        invalidateOnBuild: false,
+        invalidateOnStartup: false,
+        invalidateOnOptionChange: new Set(),
+        invalidateOnEnvChange: new Set(),
+        invalidateOnFileChange: new Set(),
+        invalidateOnFileCreate: [],
+    };
+}
+function fromInternalSourceLocation(projectRoot, loc) {
+    if (!loc)
+        return loc;
+    return {
+        filePath: (0, projectPath_1.fromProjectPath)(projectRoot, loc.filePath),
+        start: loc.start,
+        end: loc.end,
+    };
+}
+function toInternalSourceLocation(projectRoot, loc) {
+    if (!loc)
+        return loc;
+    return {
+        filePath: (0, projectPath_1.toProjectPath)(projectRoot, loc.filePath),
+        start: loc.start,
+        end: loc.end,
+    };
+}
+function toInternalSymbols(projectRoot, symbols) {
+    if (!symbols)
+        return symbols;
+    return new Map([...symbols].map(([k, { loc, ...v }]) => [
+        k,
+        {
+            ...v,
+            loc: toInternalSourceLocation(projectRoot, loc),
+        },
+    ]));
+}

package/dist/worker.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearWorkerBuildCaches = clearWorkerBuildCaches;
+exports.runTransform = runTransform;
+exports.runValidate = runValidate;
+exports.runPackage = runPackage;
+exports.childInit = childInit;
+exports.invalidateRequireCache = invalidateRequireCache;
+exports.ping = ping;
+const utils_1 = require("@atlaspack/utils");
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const BundleGraph_1 = __importDefault(require("./BundleGraph"));
+const Transformation_1 = __importDefault(require("./Transformation"));
+const ReporterRunner_1 = require("./ReporterRunner");
+const PackagerRunner_1 = __importDefault(require("./PackagerRunner"));
+const Validation_1 = __importDefault(require("./Validation"));
+const AtlaspackConfig_1 = require("./AtlaspackConfig");
+const registerCoreWithSerializer_1 = require("./registerCoreWithSerializer");
+const build_cache_1 = require("@atlaspack/build-cache");
+const source_map_1 = require("@parcel/source-map");
+// @ts-expect-error TS2305
+const rust_1 = require("@atlaspack/rust");
+const workers_1 = __importDefault(require("@atlaspack/workers"));
+const feature_flags_1 = require("@atlaspack/feature-flags");
+require("@atlaspack/cache"); // register with serializer
+require("@atlaspack/package-manager");
+require("@atlaspack/fs");
+// /flow-to-ts helpers
+(0, registerCoreWithSerializer_1.registerCoreWithSerializer)();
+// TODO: this should eventually be replaced by an in memory cache layer
+let atlaspackConfigCache = new Map();
+function loadOptions(ref, workerApi) {
+    return (0, nullthrows_1.default)(workerApi.getSharedReference(ref));
+}
+async function loadConfig(cachePath, options) {
+    let config = atlaspackConfigCache.get(cachePath);
+    if (config && config.options === options) {
+        return config;
+    }
+    let processedConfig = (0, nullthrows_1.default)(await options.cache.get(cachePath));
+    config = new AtlaspackConfig_1.AtlaspackConfig(processedConfig, options);
+    atlaspackConfigCache.set(cachePath, config);
+    (0, feature_flags_1.setFeatureFlags)(options.featureFlags);
+    return config;
+}
+function clearWorkerBuildCaches() {
+    utils_1.loadConfig.clear();
+    (0, build_cache_1.clearBuildCaches)();
+}
+async function runTransform(workerApi, opts) {
+    let { optionsRef, configCachePath, ...rest } = opts;
+    let options = loadOptions(optionsRef, workerApi);
+    let config = await loadConfig(configCachePath, options);
+    return new Transformation_1.default({
+        workerApi,
+        options,
+        // @ts-expect-error TS2783
+        config,
+        ...rest,
+    }).run();
+}
+async function runValidate(workerApi, opts) {
+    let { optionsRef, configCachePath, ...rest } = opts;
+    let options = loadOptions(optionsRef, workerApi);
+    let config = await loadConfig(configCachePath, options);
+    return new Validation_1.default({
+        workerApi,
+        // @ts-expect-error TS2783
+        report: ReporterRunner_1.reportWorker.bind(null, workerApi),
+        options,
+        // @ts-expect-error TS2783
+        config,
+        ...rest,
+    }).run();
+}
+async function runPackage(workerApi, { bundle, bundleGraphReference, configCachePath, optionsRef, previousDevDeps, invalidDevDeps, previousInvalidations, }) {
+    let bundleGraph = workerApi.getSharedReference(bundleGraphReference);
+    (0, assert_1.default)(bundleGraph instanceof BundleGraph_1.default);
+    let options = loadOptions(optionsRef, workerApi);
+    let atlaspackConfig = await loadConfig(configCachePath, options);
+    let runner = new PackagerRunner_1.default({
+        config: atlaspackConfig,
+        options,
+        // @ts-expect-error TS2322
+        report: workers_1.default.isWorker() ? ReporterRunner_1.reportWorker.bind(null, workerApi) : ReporterRunner_1.report,
+        previousDevDeps,
+        previousInvalidations,
+    });
+    return runner.run(bundleGraph, bundle, invalidDevDeps);
+}
+async function childInit() {
+    await source_map_1.init;
+    await (0, rust_1.init)?.();
+}
+const PKG_RE = /node_modules[/\\]((?:@[^/\\]+[/\\][^/\\]+)|[^/\\]+)(?!.*[/\\]node_modules[/\\])/;
+function invalidateRequireCache(workerApi, file) {
+    if (process.env.ATLASPACK_BUILD_ENV === 'test') {
+        // Delete this module and all children in the same node_modules folder
+        let module = require.cache[file];
+        if (module) {
+            delete require.cache[file];
+            let pkg = file.match(PKG_RE)?.[1];
+            for (let child of module.children) {
+                if (pkg === child.id.match(PKG_RE)?.[1]) {
+                    invalidateRequireCache(workerApi, child.id);
+                }
+            }
+        }
+        atlaspackConfigCache.clear();
+        return;
+    }
+    throw new Error('invalidateRequireCache is only for tests');
+}
+/**
+ * This is used to wait until workers are responding to messages.
+ */
+function ping() {
+    return true;
+}

package/lib/AssetGraph.js

@@ -46,6 +46,14 @@ function _graph() {
 }
 var _Dependency = require("./Dependency");
 var _projectPath = require("./projectPath");
+var _EnvironmentManager = require("./EnvironmentManager");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function nodeFromDep(dep) {
   return {
@@ -63,7 +71,11 @@ function nodeFromDep(dep) {
 }
 function nodeFromAssetGroup(assetGroup) {
   return {
-    id: (0, _rust().hashString)((0, _projectPath.fromProjectPathRelative)(assetGroup.filePath) + assetGroup.env.id + String(assetGroup.isSource) + String(assetGroup.sideEffects) + (assetGroup.code ?? '') + ':' + (assetGroup.pipeline ?? '') + ':' + (assetGroup.query ?? '')),
+    id: (0, _rust().hashString)(
+    // @ts-expect-error TS2345
+    (0, _projectPath.fromProjectPathRelative)(assetGroup.filePath) +
+    // @ts-expect-error TS2345
+    (0, _EnvironmentManager.toEnvironmentId)(assetGroup.env) + String(assetGroup.isSource) + String(assetGroup.sideEffects) + (assetGroup.code ?? '') + ':' + (assetGroup.pipeline ?? '') + ':' + (assetGroup.query ?? '')),
     type: 'asset_group',
     value: assetGroup,
     usedSymbolsDownDirty: true
@@ -93,16 +105,35 @@ function nodeFromEntryFile(entry) {
     value: entry
   };
 }
+
+// @ts-expect-error TS2417
 class AssetGraph extends _graph().ContentGraph {
+  /**
+   * Incremented when the asset graph is modified such that it requires a bundling pass.
+   */
+  #bundlingVersion = 0;
+  /**
+   * Force incremental bundling to be disabled.
+   */
+  #disableIncrementalBundling = false;
+
+  /**
+   * @deprecated
+   */
   safeToIncrementallyBundle = true;
   constructor(opts) {
     if (opts) {
       let {
         hash,
+        bundlingVersion,
+        disableIncrementalBundling,
         ...rest
       } = opts;
+      // @ts-expect-error TS2345
       super(rest);
       this.hash = hash;
+      this.#bundlingVersion = bundlingVersion ?? 0;
+      this.#disableIncrementalBundling = disableIncrementalBundling ?? false;
     } else {
       super();
       this.setRootNodeId(this.addNode({
@@ -114,32 +145,83 @@ class AssetGraph extends _graph().ContentGraph {
     this.undeferredDependencies = new Set();
     this.envCache = new Map();
   }
-
-  // $FlowFixMe[prop-missing]
   static deserialize(opts) {
     return new AssetGraph(opts);
   }
-
-  // $FlowFixMe[prop-missing]
   serialize() {
     return {
       ...super.serialize(),
+      bundlingVersion: this.#bundlingVersion,
+      disableIncrementalBundling: this.#disableIncrementalBundling,
       hash: this.hash
     };
   }
 
+  /**
+   * Force incremental bundling to be disabled.
+   */
+  setDisableIncrementalBundling(disable) {
+    this.#disableIncrementalBundling = disable;
+  }
+  testing_getDisableIncrementalBundling() {
+    return this.#disableIncrementalBundling;
+  }
+
+  /**
+   * Make sure this asset graph is marked as needing a full bundling pass.
+   */
+  setNeedsBundling() {
+    if (!(0, _featureFlags().getFeatureFlag)('incrementalBundlingVersioning')) {
+      // In legacy mode, we rely solely on safeToIncrementallyBundle to
+      // invalidate incremental bundling, so we skip bumping the version.
+      return;
+    }
+    this.#bundlingVersion += 1;
+  }
+
+  /**
+   * Get the current bundling version.
+   *
+   * Each bundle pass should keep this version around. Whenever an asset graph has a new version,
+   * bundling should be re-run.
+   */
+  getBundlingVersion() {
+    if (!(0, _featureFlags().getFeatureFlag)('incrementalBundlingVersioning')) {
+      return 0;
+    }
+    return this.#bundlingVersion;
+  }
+
+  /**
+   * If the `bundlingVersion` has not changed since the last bundling pass,
+   * we can incrementally bundle, which will not require a full bundling pass
+   * but just update assets into the bundle graph output.
+   */
+  canIncrementallyBundle(lastVersion) {
+    if (!(0, _featureFlags().getFeatureFlag)('incrementalBundlingVersioning')) {
+      return this.safeToIncrementallyBundle && !this.#disableIncrementalBundling;
+    }
+    return this.safeToIncrementallyBundle && this.#bundlingVersion === lastVersion && !this.#disableIncrementalBundling;
+  }
+
   // Deduplicates Environments by making them referentially equal
   normalizeEnvironment(input) {
+    if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+      return;
+    }
+
+    // @ts-expect-error TS2345
     let {
       id,
       context
-    } = input.env;
+    } = (0, _EnvironmentManager.fromEnvironmentId)(input.env);
     let idAndContext = `${id}-${context}`;
     let env = this.envCache.get(idAndContext);
     if (env) {
-      input.env = env;
+      input.env = (0, _EnvironmentManager.toEnvironmentRef)(env);
     } else {
-      this.envCache.set(idAndContext, input.env);
+      // @ts-expect-error TS2345
+      this.envCache.set(idAndContext, (0, _EnvironmentManager.fromEnvironmentId)(input.env));
     }
   }
   setRootConnections({
@@ -166,8 +248,6 @@ class AssetGraph extends _graph().ContentGraph {
     let existing = this.getNodeByContentKey(node.id);
     if (existing != null) {
       (0, _assert().default)(existing.type === node.type);
-      // $FlowFixMe[incompatible-type] Checked above
-      // $FlowFixMe[prop-missing]
       existing.value = node.value;
       let existingId = this.getNodeIdByContentKey(node.id);
       this.updateNode(existingId, existing);
@@ -199,13 +279,14 @@ class AssetGraph extends _graph().ContentGraph {
         env: target.env,
         isEntry: true,
         needsStableName: true,
-        symbols: target.env.isLibrary ? new Map([['*', {
+        // @ts-expect-error TS2322
+        symbols: (0, _EnvironmentManager.fromEnvironmentId)(target.env).isLibrary ? new Map([['*', {
           local: '*',
           isWeak: true,
           loc: null
         }]]) : undefined
       }));
-      if (node.value.env.isLibrary) {
+      if ((0, _EnvironmentManager.fromEnvironmentId)(node.value.env).isLibrary) {
         // in library mode, all of the entry's symbols are "used"
         node.usedSymbolsDown.add('*');
         node.usedSymbolsUp.set('*', undefined);
@@ -285,7 +366,10 @@ class AssetGraph extends _graph().ContentGraph {
       if (traversedNode.type === 'asset') {
         let hasDeferred = this.getNodeIdsConnectedFrom(traversedNodeId).some(childNodeId => {
           let childNode = (0, _nullthrows().default)(this.getNode(childNodeId));
-          return childNode.hasDeferred == null ? false : childNode.hasDeferred;
+          // @ts-expect-error TS2339
+          return childNode.hasDeferred == null ? false :
+          // @ts-expect-error TS2339
+          childNode.hasDeferred;
         });
         if (!hasDeferred) {
           delete traversedNode.hasDeferred;
@@ -294,13 +378,16 @@ class AssetGraph extends _graph().ContentGraph {
           hasDeferred
         };
       } else if (traversedNode.type === 'asset_group' && nodeId !== traversedNodeId) {
+        // @ts-expect-error TS2339
         if (!(ctx !== null && ctx !== void 0 && ctx.hasDeferred)) {
           this.safeToIncrementallyBundle = false;
+          this.setNeedsBundling();
           delete traversedNode.hasDeferred;
         }
         actions.skipChildren();
       } else if (traversedNode.type === 'dependency') {
         this.safeToIncrementallyBundle = false;
+        this.setNeedsBundling();
         traversedNode.hasDeferred = false;
       } else if (nodeId !== traversedNodeId) {
         actions.skipChildren();
@@ -348,7 +435,7 @@ class AssetGraph extends _graph().ContentGraph {
       if (this.undeferredDependencies.has(d)) {
         return false;
       }
-      let depIsDeferrable = d.symbols && !(d.env.isLibrary && d.isEntry) && !d.symbols.has('*') && ![...d.symbols.keys()].some(symbol => {
+      let depIsDeferrable = d.symbols && !((0, _EnvironmentManager.fromEnvironmentId)(d.env).isLibrary && d.isEntry) && !d.symbols.has('*') && ![...d.symbols.keys()].some(symbol => {
         var _resolvedAsset$symbol;
         let assetSymbol = (_resolvedAsset$symbol = resolvedAsset.symbols) === null || _resolvedAsset$symbol === void 0 || (_resolvedAsset$symbol = _resolvedAsset$symbol.get(symbol)) === null || _resolvedAsset$symbol === void 0 ? void 0 : _resolvedAsset$symbol.local;
         return assetSymbol != null && symbols.has(assetSymbol);
@@ -363,6 +450,7 @@ class AssetGraph extends _graph().ContentGraph {
   resolveAssetGroup(assetGroup, assets, correspondingRequest) {
     this.normalizeEnvironment(assetGroup);
     let assetGroupNode = nodeFromAssetGroup(assetGroup);
+    // @ts-expect-error TS2322
     assetGroupNode = this.getNodeByContentKey(assetGroupNode.id);
     if (!assetGroupNode) {
       return;
@@ -432,6 +520,15 @@ class AssetGraph extends _graph().ContentGraph {
           ...depNode.value.meta,
           ...existing.value.resolverMeta
         };
+        if ((0, _featureFlags().getFeatureFlag)('hmrImprovements')) {
+          depNode.value.resolverMeta = existing.value.resolverMeta;
+        }
+      }
+      if ((0, _featureFlags().getFeatureFlag)('hmrImprovements')) {
+        if ((existing === null || existing === void 0 ? void 0 : existing.type) === 'dependency' && existing.value.resolverPriority != null) {
+          depNode.value.priority = existing.value.resolverPriority;
+          depNode.value.resolverPriority = existing.value.resolverPriority;
+        }
       }
       let dependentAsset = dependentAssets.find(a => a.uniqueKey === dep.specifier);
       if (dependentAsset) {