@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/lib/utils.js

@@ -36,7 +36,11 @@ function _utils() {
   return data;
 }
 var _projectPath = require("./projectPath");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
+
 const base62 = (0, _baseX().default)('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
 function getBundleGroupId(bundleGroup) {
   return 'bundle_group:' + bundleGroup.target.name + bundleGroup.entryAssetId;
@@ -75,6 +79,8 @@ function optionsProxy(options, invalidateOnOptionChange, addDevDependency) {
       if (!ignoreOptions.has(prop)) {
         invalidateOnOptionChange(prop);
       }
+
+      // @ts-expect-error TS7053
       return target[prop];
     }
   });
@@ -94,30 +100,39 @@ function proxyPackageManager(projectRoot, packageManager, addDevDependency) {
         return require;
       }
 
-      // $FlowFixMe
+      // @ts-expect-error TS7053
       return target[prop];
     }
   });
 }
 function hashFromOption(value) {
   if (typeof value === 'object' && value != null) {
+    // @ts-expect-error TS2345
     return (0, _utils().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.toProjectPath)(projectRoot, invalidation.glob)
     };
+    // @ts-expect-error TS2339
   } else if (invalidation.filePath != null) {
     return {
+      // @ts-expect-error TS2339
       filePath: (0, _projectPath.toProjectPath)(projectRoot, invalidation.filePath)
     };
   } else {
-    (0, _assert().default)(invalidation.aboveFilePath != null && invalidation.fileName != null);
+    (0, _assert().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.toProjectPath)(projectRoot, invalidation.aboveFilePath)
     };
   }

package/lib/worker.js

@@ -46,7 +46,7 @@ function _buildCache() {
   return data;
 }
 function _sourceMap() {
-  const data = require("@parcel/source-map");
+  const data = require("@atlaspack/source-map");
   _sourceMap = function () {
     return data;
   };
@@ -76,29 +76,25 @@ function _featureFlags() {
 require("@atlaspack/cache");
 require("@atlaspack/package-manager");
 require("@atlaspack/fs");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// @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)();
 
 // Remove the workerApi type from the TransformationOpts and ValidationOpts types:
 // https://github.com/facebook/flow/issues/2835
+
 // 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 +121,7 @@ async function runTransform(workerApi, opts) {
   return new _Transformation.default({
     workerApi,
     options,
+    // @ts-expect-error TS2783
     config,
     ...rest
   }).run();
@@ -139,8 +136,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 +160,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 +172,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.48+3af500201",
+  "version": "2.16.2-canary.481+a1d772935",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -9,39 +9,40 @@
     "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.116+3af500201",
-    "@atlaspack/cache": "3.1.1-canary.48+3af500201",
-    "@atlaspack/diagnostic": "2.14.1-canary.116+3af500201",
-    "@atlaspack/events": "2.14.1-canary.116+3af500201",
-    "@atlaspack/feature-flags": "2.14.1-canary.116+3af500201",
-    "@atlaspack/fs": "2.14.5-canary.48+3af500201",
-    "@atlaspack/graph": "3.4.1-canary.116+3af500201",
-    "@atlaspack/logger": "2.14.5-canary.48+3af500201",
-    "@atlaspack/package-manager": "2.14.5-canary.48+3af500201",
-    "@atlaspack/plugin": "2.14.5-canary.48+3af500201",
-    "@atlaspack/profiler": "2.14.1-canary.116+3af500201",
-    "@atlaspack/rust": "3.2.1-canary.48+3af500201",
-    "@atlaspack/types": "2.14.5-canary.48+3af500201",
-    "@atlaspack/utils": "2.14.5-canary.48+3af500201",
-    "@atlaspack/workers": "2.14.5-canary.48+3af500201",
+    "@atlaspack/build-cache": "2.13.3-canary.549+a1d772935",
+    "@atlaspack/cache": "3.1.1-canary.481+a1d772935",
+    "@atlaspack/diagnostic": "2.14.1-canary.549+a1d772935",
+    "@atlaspack/events": "2.14.1-canary.549+a1d772935",
+    "@atlaspack/feature-flags": "2.14.1-canary.549+a1d772935",
+    "@atlaspack/fs": "2.14.5-canary.481+a1d772935",
+    "@atlaspack/graph": "3.4.1-canary.549+a1d772935",
+    "@atlaspack/logger": "2.14.5-canary.481+a1d772935",
+    "@atlaspack/package-manager": "2.14.5-canary.481+a1d772935",
+    "@atlaspack/plugin": "2.14.5-canary.481+a1d772935",
+    "@atlaspack/profiler": "2.14.1-canary.549+a1d772935",
+    "@atlaspack/rust": "3.2.1-canary.481+a1d772935",
+    "@atlaspack/source-map": "3.3.8-canary.4260+a1d772935",
+    "@atlaspack/types": "2.14.5-canary.481+a1d772935",
+    "@atlaspack/utils": "2.14.5-canary.481+a1d772935",
+    "@atlaspack/workers": "2.14.5-canary.481+a1d772935",
     "@mischnic/json-sourcemap": "^0.1.0",
-    "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",
-    "dotenv": "^7.0.0",
+    "dotenv": "^12.0.4",
     "dotenv-expand": "^5.1.0",
     "json5": "^2.2.0",
     "msgpackr": "^1.9.9",
@@ -49,27 +50,16 @@
     "semver": "^7.5.2"
   },
   "devDependencies": {
-    "@atlaspack/babel-register": "2.14.1",
+    "@atlaspack/babel-register": "2.14.5",
     "@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": "3af5002017ed237c1bcfed5c5cf3f0da5b3a9f92"
-}
+  "gitHead": "a1d772935c9ed74c6d8eafbee6b65eb91ddc38fd"
+}

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,27 @@ 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> & {
+  hash?: string | null | undefined;
+};
+
+type SerializedAssetGraph = SerializedContentGraph<AssetGraphNode> & {
+  hash?: string | null | undefined;
+};
 
 export function nodeFromDep(dep: Dependency): DependencyNode {
   return {
@@ -64,8 +66,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,16 +111,20 @@ 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>;
+
   safeToIncrementallyBundle: boolean = true;
+
   undeferredDependencies: Set<Dependency>;
 
-  constructor(opts: ?AssetGraphOpts) {
+  constructor(opts?: AssetGraphOpts | null) {
     if (opts) {
       let {hash, ...rest} = opts;
+      // @ts-expect-error TS2345
       super(rest);
       this.hash = hash;
     } else {
@@ -134,12 +142,10 @@ 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(),
@@ -147,21 +153,35 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
     };
   }
 
+  /**
+   * Determine if we can incrementally bundle, which will not require a full bundling pass
+   * but just update assets into the bundle graph output.
+   */
+  canIncrementallyBundle(): boolean {
+    return this.safeToIncrementallyBundle;
+  }
+
   // 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 +205,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 +253,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 +281,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 +363,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,6 +378,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
         traversedNode.type === 'asset_group' &&
         nodeId !== traversedNodeId
       ) {
+        // @ts-expect-error TS2339
         if (!ctx?.hasDeferred) {
           this.safeToIncrementallyBundle = false;
           delete traversedNode.hasDeferred;
@@ -378,7 +400,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 +411,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 +426,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 +450,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 +472,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 +496,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 +542,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 +555,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 +599,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 +628,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 +641,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 +653,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();