@atlaspack/core 2.16.2-canary.21 → 2.16.2-canary.211

package/lib/worker.js

@@ -77,15 +77,13 @@ require("@atlaspack/cache");
 require("@atlaspack/package-manager");
 require("@atlaspack/fs");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// @ts-expect-error TS2305
+
 // register with serializer
-// $FlowFixMe
-if (process.env.ATLASPACK_BUILD_REPL && process.browser) {
-  /* eslint-disable import/no-extraneous-dependencies, monorepo/no-internal-import */
-  require('@atlaspack/repl/src/atlaspack/BrowserPackageManager.js');
-  // $FlowFixMe
-  require('@atlaspack/repl/src/atlaspack/ExtendedMemoryFS.js');
-  /* eslint-enable import/no-extraneous-dependencies, monorepo/no-internal-import */
-}
+
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
 
 (0, _registerCoreWithSerializer.registerCoreWithSerializer)();
 
@@ -94,11 +92,8 @@ if (process.env.ATLASPACK_BUILD_REPL && process.browser) {
 // TODO: this should eventually be replaced by an in memory cache layer
 let atlaspackConfigCache = new Map();
 function loadOptions(ref, workerApi) {
-  return (0, _nullthrows().default)(workerApi.getSharedReference(ref
-  // $FlowFixMe
-  ));
+  return (0, _nullthrows().default)(workerApi.getSharedReference(ref));
 }
-
 async function loadConfig(cachePath, options) {
   let config = atlaspackConfigCache.get(cachePath);
   if (config && config.options === options) {
@@ -125,6 +120,7 @@ async function runTransform(workerApi, opts) {
   return new _Transformation.default({
     workerApi,
     options,
+    // @ts-expect-error TS2783
     config,
     ...rest
   }).run();
@@ -139,8 +135,10 @@ async function runValidate(workerApi, opts) {
   let config = await loadConfig(configCachePath, options);
   return new _Validation.default({
     workerApi,
+    // @ts-expect-error TS2783
     report: _ReporterRunner.reportWorker.bind(null, workerApi),
     options,
+    // @ts-expect-error TS2783
     config,
     ...rest
   }).run();
@@ -161,6 +159,7 @@ async function runPackage(workerApi, {
   let runner = new _PackagerRunner.default({
     config: atlaspackConfig,
     options,
+    // @ts-expect-error TS2322
     report: _workers().default.isWorker() ? _ReporterRunner.reportWorker.bind(null, workerApi) : _ReporterRunner.report,
     previousDevDeps,
     previousInvalidations
@@ -172,7 +171,24 @@ async function childInit() {
   await (_rust().init === null || _rust().init === void 0 ? void 0 : (0, _rust().init)());
 }
 const PKG_RE = /node_modules[/\\]((?:@[^/\\]+[/\\][^/\\]+)|[^/\\]+)(?!.*[/\\]node_modules[/\\])/;
-function invalidateRequireCache() {
+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) {
+      var _file$match;
+      delete require.cache[file];
+      let pkg = (_file$match = file.match(PKG_RE)) === null || _file$match === void 0 ? void 0 : _file$match[1];
+      for (let child of module.children) {
+        var _child$id$match;
+        if (pkg === ((_child$id$match = child.id.match(PKG_RE)) === null || _child$id$match === void 0 ? void 0 : _child$id$match[1])) {
+          invalidateRequireCache(workerApi, child.id);
+        }
+      }
+    }
+    atlaspackConfigCache.clear();
+    return;
+  }
   throw new Error('invalidateRequireCache is only for tests');
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.16.2-canary.21+3a3e8e7be",
+  "version": "2.16.2-canary.211+236e54658",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -9,33 +9,34 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "types": "index.d.ts",
-  "source": "src/index.js",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/types/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "scripts": {
     "test": "mocha",
     "test-ci": "mocha",
-    "check-ts": "tsc --noEmit index.d.ts"
+    "generate-ts": "tsc --emitDeclarationOnly",
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.89+3a3e8e7be",
-    "@atlaspack/cache": "3.1.1-canary.21+3a3e8e7be",
-    "@atlaspack/diagnostic": "2.14.1-canary.89+3a3e8e7be",
-    "@atlaspack/events": "2.14.1-canary.89+3a3e8e7be",
-    "@atlaspack/feature-flags": "2.14.1-canary.89+3a3e8e7be",
-    "@atlaspack/fs": "2.14.5-canary.21+3a3e8e7be",
-    "@atlaspack/graph": "3.4.1-canary.89+3a3e8e7be",
-    "@atlaspack/logger": "2.14.5-canary.21+3a3e8e7be",
-    "@atlaspack/package-manager": "2.14.5-canary.21+3a3e8e7be",
-    "@atlaspack/plugin": "2.14.5-canary.21+3a3e8e7be",
-    "@atlaspack/profiler": "2.14.1-canary.89+3a3e8e7be",
-    "@atlaspack/rust": "3.2.1-canary.21+3a3e8e7be",
-    "@atlaspack/types": "2.14.5-canary.21+3a3e8e7be",
-    "@atlaspack/utils": "2.14.5-canary.21+3a3e8e7be",
-    "@atlaspack/workers": "2.14.5-canary.21+3a3e8e7be",
+    "@atlaspack/build-cache": "2.13.3-canary.279+236e54658",
+    "@atlaspack/cache": "3.1.1-canary.211+236e54658",
+    "@atlaspack/diagnostic": "2.14.1-canary.279+236e54658",
+    "@atlaspack/events": "2.14.1-canary.279+236e54658",
+    "@atlaspack/feature-flags": "2.14.1-canary.279+236e54658",
+    "@atlaspack/fs": "2.14.5-canary.211+236e54658",
+    "@atlaspack/graph": "3.4.1-canary.279+236e54658",
+    "@atlaspack/logger": "2.14.5-canary.211+236e54658",
+    "@atlaspack/package-manager": "2.14.5-canary.211+236e54658",
+    "@atlaspack/plugin": "2.14.5-canary.211+236e54658",
+    "@atlaspack/profiler": "2.14.1-canary.279+236e54658",
+    "@atlaspack/rust": "3.2.1-canary.211+236e54658",
+    "@atlaspack/types": "2.14.5-canary.211+236e54658",
+    "@atlaspack/utils": "2.14.5-canary.211+236e54658",
+    "@atlaspack/workers": "2.14.5-canary.211+236e54658",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -49,27 +50,16 @@
     "semver": "^7.5.2"
   },
   "devDependencies": {
-    "@atlaspack/babel-register": "2.14.1",
+    "@atlaspack/babel-register": "2.14.4",
     "@types/node": ">= 18",
     "graphviz": "^0.0.9",
     "jest-diff": "*",
     "rfdc": "1",
     "tempy": "^0.2.1"
   },
-  "exports": {
-    "./*": "./*",
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./lib/index.js"
-    },
-    "./worker": {
-      "@atlaspack::sources": "./src/worker.js",
-      "default": "./lib/worker.js"
-    }
-  },
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "3a3e8e7be9e2dffd7304436d792f0f595d59665a"
-}
+  "gitHead": "236e5465863dca6044a7191e05260a5b924c342e"
+}

package/src/{AssetGraph.js → AssetGraph.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {GraphVisitor} from '@atlaspack/types';
 import type {
   ContentGraphOpts,
@@ -28,23 +26,31 @@ import {hashObject} from '@atlaspack/utils';
 import nullthrows from 'nullthrows';
 import {ContentGraph} from '@atlaspack/graph';
 import {createDependency} from './Dependency';
-import {type ProjectPath, fromProjectPathRelative} from './projectPath';
-
-type InitOpts = {|
-  entries?: Array<ProjectPath>,
-  targets?: Array<Target>,
-  assetGroups?: Array<AssetGroup>,
-|};
-
-type AssetGraphOpts = {|
-  ...ContentGraphOpts<AssetGraphNode>,
-  hash?: ?string,
-|};
-
-type SerializedAssetGraph = {|
-  ...SerializedContentGraph<AssetGraphNode>,
-  hash?: ?string,
-|};
+import {ProjectPath, fromProjectPathRelative} from './projectPath';
+import {
+  fromEnvironmentId,
+  toEnvironmentId,
+  toEnvironmentRef,
+} from './EnvironmentManager';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+
+type InitOpts = {
+  entries?: Array<ProjectPath>;
+  targets?: Array<Target>;
+  assetGroups?: Array<AssetGroup>;
+};
+
+type AssetGraphOpts = ContentGraphOpts<AssetGraphNode> & {
+  bundlingVersion?: number;
+  disableIncrementalBundling?: boolean;
+  hash?: string | null | undefined;
+};
+
+type SerializedAssetGraph = SerializedContentGraph<AssetGraphNode> & {
+  bundlingVersion: number;
+  disableIncrementalBundling: boolean;
+  hash?: string | null | undefined;
+};
 
 export function nodeFromDep(dep: Dependency): DependencyNode {
   return {
@@ -64,8 +70,10 @@ export function nodeFromDep(dep: Dependency): DependencyNode {
 export function nodeFromAssetGroup(assetGroup: AssetGroup): AssetGroupNode {
   return {
     id: hashString(
+      // @ts-expect-error TS2345
       fromProjectPathRelative(assetGroup.filePath) +
-        assetGroup.env.id +
+        // @ts-expect-error TS2345
+        toEnvironmentId(assetGroup.env) +
         String(assetGroup.isSource) +
         String(assetGroup.sideEffects) +
         (assetGroup.code ?? '') +
@@ -107,18 +115,36 @@ export function nodeFromEntryFile(entry: Entry): EntryFileNode {
   };
 }
 
+// @ts-expect-error TS2417
 export default class AssetGraph extends ContentGraph<AssetGraphNode> {
-  onNodeRemoved: ?(nodeId: NodeId) => mixed;
-  hash: ?string;
+  onNodeRemoved: ((nodeId: NodeId) => unknown) | null | undefined;
+  hash: string | null | undefined;
   envCache: Map<string, Environment>;
+
+  /**
+   * Incremented when the asset graph is modified such that it requires a bundling pass.
+   */
+  #bundlingVersion: number = 0;
+  /**
+   * Force incremental bundling to be disabled.
+   */
+  #disableIncrementalBundling: boolean = false;
+
+  /**
+   * @deprecated
+   */
   safeToIncrementallyBundle: boolean = true;
+
   undeferredDependencies: Set<Dependency>;
 
-  constructor(opts: ?AssetGraphOpts) {
+  constructor(opts?: AssetGraphOpts | null) {
     if (opts) {
-      let {hash, ...rest} = 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(
@@ -134,34 +160,94 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
     this.envCache = new Map();
   }
 
-  // $FlowFixMe[prop-missing]
   static deserialize(opts: AssetGraphOpts): AssetGraph {
     return new AssetGraph(opts);
   }
 
-  // $FlowFixMe[prop-missing]
   serialize(): SerializedAssetGraph {
     return {
       ...super.serialize(),
+      bundlingVersion: this.#bundlingVersion,
+      disableIncrementalBundling: this.#disableIncrementalBundling,
       hash: this.hash,
     };
   }
 
+  /**
+   * Force incremental bundling to be disabled.
+   */
+  setDisableIncrementalBundling(disable: boolean) {
+    this.#disableIncrementalBundling = disable;
+  }
+
+  testing_getDisableIncrementalBundling(): boolean {
+    return this.#disableIncrementalBundling;
+  }
+
+  /**
+   * Make sure this asset graph is marked as needing a full bundling pass.
+   */
+  setNeedsBundling() {
+    if (!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(): number {
+    if (!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: number): boolean {
+    if (!getFeatureFlag('incrementalBundlingVersioning')) {
+      return (
+        this.safeToIncrementallyBundle && !this.#disableIncrementalBundling
+      );
+    }
+    return (
+      this.safeToIncrementallyBundle &&
+      this.#bundlingVersion === lastVersion &&
+      !this.#disableIncrementalBundling
+    );
+  }
+
   // Deduplicates Environments by making them referentially equal
   normalizeEnvironment(input: Asset | Dependency | AssetGroup) {
-    let {id, context} = input.env;
+    if (getFeatureFlag('environmentDeduplication')) {
+      return;
+    }
+
+    // @ts-expect-error TS2345
+    let {id, context} = fromEnvironmentId(input.env);
     let idAndContext = `${id}-${context}`;
 
     let env = this.envCache.get(idAndContext);
     if (env) {
-      input.env = env;
+      input.env = toEnvironmentRef(env);
     } else {
-      this.envCache.set(idAndContext, input.env);
+      // @ts-expect-error TS2345
+      this.envCache.set(idAndContext, fromEnvironmentId(input.env));
     }
   }
 
   setRootConnections({entries, assetGroups}: InitOpts) {
-    let nodes = [];
+    let nodes: Array<AssetGroupNode | EntrySpecifierNode> = [];
     if (entries) {
       for (let entry of entries) {
         let node = nodeFromEntrySpecifier(entry);
@@ -185,8 +271,6 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
     let existing = this.getNodeByContentKey(node.id);
     if (existing != null) {
       invariant(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);
@@ -235,13 +319,14 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
           env: target.env,
           isEntry: true,
           needsStableName: true,
-          symbols: target.env.isLibrary
+          // @ts-expect-error TS2322
+          symbols: fromEnvironmentId(target.env).isLibrary
             ? new Map([['*', {local: '*', isWeak: true, loc: null}]])
             : undefined,
         }),
       );
 
-      if (node.value.env.isLibrary) {
+      if (fromEnvironmentId(node.value.env).isLibrary) {
         // in library mode, all of the entry's symbols are "used"
         node.usedSymbolsDown.add('*');
         node.usedSymbolsUp.set('*', undefined);
@@ -262,7 +347,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
 
   resolveDependency(
     dependency: Dependency,
-    assetGroup: ?AssetGroup,
+    assetGroup: AssetGroup | null | undefined,
     correspondingRequest: string,
   ) {
     let depNodeId = this.getNodeIdByContentKey(dependency.id);
@@ -344,9 +429,11 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
         let hasDeferred = this.getNodeIdsConnectedFrom(traversedNodeId).some(
           (childNodeId) => {
             let childNode = nullthrows(this.getNode(childNodeId));
+            // @ts-expect-error TS2339
             return childNode.hasDeferred == null
               ? false
-              : childNode.hasDeferred;
+              : // @ts-expect-error TS2339
+                childNode.hasDeferred;
           },
         );
         if (!hasDeferred) {
@@ -357,13 +444,16 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
         traversedNode.type === 'asset_group' &&
         nodeId !== traversedNodeId
       ) {
+        // @ts-expect-error TS2339
         if (!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();
@@ -378,7 +468,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
   // a huge number of functions since we can avoid even transforming the files that aren't used.
   shouldDeferDependency(
     dependency: Dependency,
-    sideEffects: ?boolean,
+    sideEffects: boolean | null | undefined,
     canDefer: boolean,
   ): boolean {
     let dependencySymbols = dependency.symbols;
@@ -389,7 +479,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
     }
 
     let isDeferrable =
-      [...dependencySymbols].every(([, {isWeak}]) => isWeak) &&
+      [...dependencySymbols].every(([, {isWeak}]: [any, any]) => isWeak) &&
       sideEffects === false &&
       canDefer &&
       !dependencySymbols.has('*');
@@ -404,7 +494,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
 
     let assets = this.getNodeIdsConnectedTo(depNodeId);
     let symbols = new Map(
-      [...dependencySymbols].map(([key, val]) => [val.local, key]),
+      [...dependencySymbols].map(([key, val]: [any, any]) => [val.local, key]),
     );
     invariant(assets.length === 1);
     let firstAsset = nullthrows(this.getNode(assets[0]));
@@ -428,7 +518,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
 
       let depIsDeferrable =
         d.symbols &&
-        !(d.env.isLibrary && d.isEntry) &&
+        !(fromEnvironmentId(d.env).isLibrary && d.isEntry) &&
         !d.symbols.has('*') &&
         ![...d.symbols.keys()].some((symbol) => {
           let assetSymbol = resolvedAsset.symbols?.get(symbol)?.local;
@@ -450,6 +540,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
   ) {
     this.normalizeEnvironment(assetGroup);
     let assetGroupNode = nodeFromAssetGroup(assetGroup);
+    // @ts-expect-error TS2322
     assetGroupNode = this.getNodeByContentKey(assetGroupNode.id);
     if (!assetGroupNode) {
       return;
@@ -473,16 +564,16 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
       }
     }
 
-    let assetObjects: Array<{|
-      assetNodeId: NodeId,
-      dependentAssets: Array<Asset>,
-    |}> = [];
-    let assetNodeIds = [];
+    let assetObjects: Array<{
+      assetNodeId: NodeId;
+      dependentAssets: Array<Asset>;
+    }> = [];
+    let assetNodeIds: Array<NodeId> = [];
     for (let asset of assets) {
       this.normalizeEnvironment(asset);
       let isDirect = !dependentAssetKeys.has(asset.uniqueKey);
 
-      let dependentAssets = [];
+      let dependentAssets: Array<Asset> = [];
       for (let dep of asset.dependencies.values()) {
         let dependentAsset = assetsByKey.get(dep.specifier);
         if (dependentAsset) {
@@ -519,7 +610,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
 
   resolveAsset(assetNode: AssetNode, dependentAssets: Array<Asset>) {
     let depNodeIds: Array<NodeId> = [];
-    let depNodesWithAssets = [];
+    let depNodesWithAssets: Array<Array<AssetNode | DependencyNode>> = [];
     for (let dep of assetNode.value.dependencies.values()) {
       this.normalizeEnvironment(dep);
       let depNode = nodeFromDep(dep);
@@ -532,6 +623,19 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
           ...depNode.value.meta,
           ...existing.value.resolverMeta,
         };
+
+        if (getFeatureFlag('hmrImprovements')) {
+          depNode.value.resolverMeta = existing.value.resolverMeta;
+        }
+      }
+      if (getFeatureFlag('hmrImprovements')) {
+        if (
+          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,
@@ -563,7 +667,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
   getIncomingDependencies(asset: Asset): Array<Dependency> {
     let nodeId = this.getNodeIdByContentKey(asset.id);
     let assetGroupIds = this.getNodeIdsConnectedTo(nodeId);
-    let dependencies = [];
+    let dependencies: Array<Dependency> = [];
     for (let i = 0; i < assetGroupIds.length; i++) {
       let assetGroupId = assetGroupIds[i];
 
@@ -592,8 +696,8 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
 
   traverseAssets<TContext>(
     visit: GraphVisitor<Asset, TContext>,
-    startNodeId: ?NodeId,
-  ): ?TContext {
+    startNodeId?: NodeId | null,
+  ): TContext | null | undefined {
     return this.filteredTraverse(
       (nodeId) => {
         let node = nullthrows(this.getNode(nodeId));
@@ -605,7 +709,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
   }
 
   getEntryAssetGroupNodes(): Array<AssetGroupNode> {
-    let entryNodes = [];
+    let entryNodes: Array<AssetGroupNode> = [];
     this.traverse((nodeId, _, actions) => {
       let node = nullthrows(this.getNode(nodeId));
       if (node.type === 'asset_group') {
@@ -617,7 +721,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
   }
 
   getEntryAssets(): Array<Asset> {
-    let entries = [];
+    let entries: Array<Asset> = [];
     this.traverseAssets((asset, ctx, traversal) => {
       entries.push(asset);
       traversal.skipChildren();