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

package/src/requests/{WriteBundlesRequest.js → WriteBundlesRequest.ts}

@@ -1,14 +1,18 @@
-// @flow strict-local
-
 import type {ContentKey} from '@atlaspack/graph';
 import type {Async} from '@atlaspack/types';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import type {SharedReference} from '@atlaspack/workers';
 import type {StaticRunOpts} from '../RequestTracker';
 import {requestTypes} from '../RequestTracker';
-import type {PackagedBundleInfo} from '../types';
+import {
+  BundleBehavior,
+  type PackagedBundleInfo,
+  type Bundle,
+  type AtlaspackOptions,
+} from '../types';
 import type BundleGraph from '../BundleGraph';
 import type {BundleInfo} from '../PackagerRunner';
+import {report} from '../ReporterRunner';
 
 import {HASH_REF_PREFIX} from '../constants';
 import {joinProjectPath} from '../projectPath';
@@ -16,27 +20,59 @@ import nullthrows from 'nullthrows';
 import {hashString} from '@atlaspack/rust';
 import {createPackageRequest} from './PackageRequest';
 import createWriteBundleRequest from './WriteBundleRequest';
+import {debugTools} from '@atlaspack/utils';
 
-type WriteBundlesRequestInput = {|
-  bundleGraph: BundleGraph,
-  optionsRef: SharedReference,
-|};
+/** Length of the hash suffix in output filenames (e.g. .runtime.13dc01ac.js). */
+const NAME_HASH_DISPLAY_LEN = 8;
 
-export type WriteBundlesRequestResult = Map<string, PackagedBundleInfo>;
+/** Use at most NAME_HASH_DISPLAY_LEN chars for the name hash so filenames stay short. */
+function nameHashForFilename(hash: string): string {
+  return hash.length <= NAME_HASH_DISPLAY_LEN
+    ? hash
+    : hash.slice(-NAME_HASH_DISPLAY_LEN);
+}
 
-type RunInput<TResult> = {|
-  input: WriteBundlesRequestInput,
-  ...StaticRunOpts<TResult>,
-|};
+type WriteBundlesRequestInput = {
+  bundleGraph: BundleGraph;
+  optionsRef: SharedReference;
+};
 
-export type WriteBundlesRequest = {|
-  id: ContentKey,
-  +type: typeof requestTypes.write_bundles_request,
+export type WriteBundlesRequestResult = {
+  bundleInfo: Map<string, PackagedBundleInfo>;
+  scopeHoistingStats?: {
+    totalAssets: number;
+    wrappedAssets: number;
+  };
+};
+
+type RunInput<TResult> = {
+  input: WriteBundlesRequestInput;
+} & StaticRunOpts<TResult>;
+
+export type WriteBundlesRequest = {
+  id: ContentKey;
+  readonly type: typeof requestTypes.write_bundles_request;
   run: (
-    RunInput<WriteBundlesRequestResult>,
-  ) => Async<WriteBundlesRequestResult>,
-  input: WriteBundlesRequestInput,
-|};
+    arg1: RunInput<WriteBundlesRequestResult>,
+  ) => Async<WriteBundlesRequestResult>;
+  input: WriteBundlesRequestInput;
+};
+
+function reportPackagingProgress(
+  completeBundles: number,
+  totalBundles: number,
+) {
+  if (!getFeatureFlag('cliProgressReportingImprovements')) {
+    return;
+  }
+
+  report({
+    type: 'buildProgress',
+    phase: 'packagingAndOptimizing',
+    totalBundles,
+    completeBundles,
+  });
+}
 
 /**
  * Packages, optimizes, and writes all bundles to the dist directory.
@@ -52,17 +88,22 @@ export default function createWriteBundlesRequest(
   };
 }
 
-async function run({input, api, farm, options}) {
+async function run({
+  input,
+  api,
+  farm,
+  options,
+}: RunInput<WriteBundlesRequestResult>) {
   let {bundleGraph, optionsRef} = input;
   let {ref, dispose} = await farm.createSharedReference(bundleGraph);
 
   api.invalidateOnOptionChange('shouldContentHash');
 
   let res = new Map();
-  let bundleInfoMap: {|
-    [string]: BundleInfo,
-  |} = {};
-  let writeEarlyPromises = {};
+  let bundleInfoMap: {
+    [key: string]: BundleInfo;
+  } = {};
+  let writeEarlyPromises: Record<string, Promise<PackagedBundleInfo>> = {};
   let hashRefToNameHash = new Map();
 
   // Include inline bundles so that non-inline bundles referenced from inline bundles are written to
@@ -71,19 +112,24 @@ async function run({input, api, farm, options}) {
     includeInline: getFeatureFlag('inlineBundlesSourceMapFixes'),
   });
   const bundles = allBundles
-    .filter((bundle) => bundle.bundleBehavior !== 'inline')
+    .filter(
+      (bundle) =>
+        bundle.bundleBehavior !== BundleBehavior.inline &&
+        bundle.bundleBehavior !== BundleBehavior.inlineIsolated,
+    )
     .filter((bundle) => {
       // Do not package and write placeholder bundles to disk. We just
       // need to update the name so other bundles can reference it.
       if (bundle.isPlaceholder) {
-        let hash = bundle.id.slice(-8);
-        hashRefToNameHash.set(bundle.hashReference, hash);
+        const nameHash = nameHashForFilename(bundle.id);
+        hashRefToNameHash.set(bundle.hashReference, nameHash);
         let name = nullthrows(
           bundle.name,
           `Expected ${bundle.type} bundle to have a name`,
-        ).replace(bundle.hashReference, hash);
+        ).replace(bundle.hashReference, nameHash);
         res.set(bundle.id, {
           filePath: joinProjectPath(bundle.target.distDir, name),
+          bundleId: bundle.id,
           type: bundle.type, // FIXME: this is wrong if the packager changes the type...
           stats: {
             time: 0,
@@ -96,14 +142,19 @@ async function run({input, api, farm, options}) {
       return true;
     });
 
+  let cachedBundles = new Set(
+    bundles.filter((b) => api.canSkipSubrequest(bundleGraph.getHash(b))),
+  );
+
   // Package on the main thread if there is only one bundle to package.
   // This avoids the cost of serializing the bundle graph for single file change builds.
   let useMainThread =
-    bundles.length === 1 ||
-    bundles.filter((b) => !api.canSkipSubrequest(bundleGraph.getHash(b)))
-      .length === 1;
+    bundles.length === 1 || bundles.length - cachedBundles.size <= 1;
 
   try {
+    let completeBundles = cachedBundles.size;
+    reportPackagingProgress(completeBundles, bundles.length);
+
     await Promise.all(
       bundles.map(async (bundle) => {
         let request = createPackageRequest({
@@ -116,6 +167,11 @@ async function run({input, api, farm, options}) {
 
         let info = await api.runRequest(request);
 
+        if (!cachedBundles.has(bundle)) {
+          completeBundles++;
+          reportPackagingProgress(completeBundles, bundles.length);
+        }
+
         if (!useMainThread) {
           // Force a refresh of the cache to avoid a race condition
           // between threaded reads and writes that can result in an LMDB cache miss:
@@ -132,9 +188,9 @@ async function run({input, api, farm, options}) {
         if (!info.hashReferences.length) {
           hashRefToNameHash.set(
             bundle.hashReference,
-            options.shouldContentHash
-              ? info.hash.slice(-8)
-              : bundle.id.slice(-8),
+            nameHashForFilename(
+              options.shouldContentHash ? info.hash : bundle.id,
+            ),
           );
           let writeBundleRequest = createWriteBundleRequest({
             bundle,
@@ -167,18 +223,42 @@ async function run({input, api, farm, options}) {
       }),
     );
 
-    api.storeResult(res);
-    return res;
+    let result: WriteBundlesRequestResult = {bundleInfo: res};
+
+    if (debugTools['scope-hoisting-stats']) {
+      // Aggregate scope hoisting stats from all bundles
+      let aggregatedScopeHoistingStats = {
+        totalAssets: 0,
+        wrappedAssets: 0,
+      };
+
+      for (let bundle of bundles) {
+        let bundleInfo = bundleInfoMap[bundle.id];
+        if (bundleInfo?.scopeHoistingStats) {
+          aggregatedScopeHoistingStats.totalAssets +=
+            bundleInfo.scopeHoistingStats.totalAssets;
+          aggregatedScopeHoistingStats.wrappedAssets +=
+            bundleInfo.scopeHoistingStats.wrappedAssets;
+        }
+      }
+
+      result.scopeHoistingStats = aggregatedScopeHoistingStats;
+    }
+
+    api.storeResult(result);
+    return result;
   } finally {
     await dispose();
   }
 }
 
 function assignComplexNameHashes(
-  hashRefToNameHash,
-  bundles,
-  bundleInfoMap,
-  options,
+  hashRefToNameHash: Map<string, string>,
+  bundles: Array<Bundle>,
+  bundleInfoMap: {
+    [key: string]: BundleInfo;
+  },
+  options: AtlaspackOptions,
 ) {
   for (let bundle of bundles) {
     if (hashRefToNameHash.get(bundle.hashReference) != null) {
@@ -186,21 +266,25 @@ function assignComplexNameHashes(
     }
     hashRefToNameHash.set(
       bundle.hashReference,
-      options.shouldContentHash
-        ? hashString(
-            [...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
-              .map((bundleId) => bundleInfoMap[bundleId].hash)
-              .join(':'),
-          ).slice(-8)
-        : bundle.id.slice(-8),
+      nameHashForFilename(
+        options.shouldContentHash
+          ? hashString(
+              [...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
+                .map((bundleId) => bundleInfoMap[bundleId].hash)
+                .join(':'),
+            )
+          : bundle.id,
+      ),
     );
   }
 }
 
 function getBundlesIncludedInHash(
-  bundleId,
-  bundleInfoMap,
-  included = new Set(),
+  bundleId: ContentKey | string,
+  bundleInfoMap: {
+    [key: string]: BundleInfo;
+  },
+  included = new Set<string>(),
 ) {
   included.add(bundleId);
   for (let hashRef of bundleInfoMap[bundleId]?.hashReferences ?? []) {

package/src/requests/{asset-graph-diff.js → asset-graph-diff.ts}

@@ -1,15 +1,12 @@
 /* eslint-disable no-console */
-// @flow strict-local
-
-// $FlowFixMe
+// @ts-expect-error missing types
 import deepClone from 'rfdc/default';
-// $FlowFixMe
 import {diff} from 'jest-diff';
 import AssetGraph from '../AssetGraph';
 import type {AssetGraphNode} from '../types';
-import {fromProjectPathRelative, toProjectPath} from '../projectPath';
+import {toProjectPath} from '../projectPath';
 
-function filterNode(node) {
+function filterNode(node: any) {
   let clone = deepClone(node);
 
   // Clean up anything you don't want to see in the diff
@@ -35,24 +32,26 @@ function filterNode(node) {
   return clone;
 }
 
+// @ts-expect-error missing return type
 function compactDeep(
-  obj: mixed,
+  obj: unknown,
   ignoredPatterns: Array<string> = [],
   currentPath: string = '$',
 ) {
   if (obj instanceof Map) {
-    const copy = {};
-    Array.from(obj.entries()).forEach(([k, v]) => {
+    const copy: Record<string, any> = {};
+    Array.from(obj.entries()).forEach(([k, v]: [any, any]) => {
       if (v != null) {
         copy[k] = compactDeep(v, ignoredPatterns, `${currentPath}.${k}`);
       }
     });
     return copy;
   } else if (Array.isArray(obj)) {
+    // @ts-expect-error implicit any
     return obj.map((v) => compactDeep(v, ignoredPatterns, `${currentPath}[]`));
   } else if (typeof obj === 'object') {
-    const copy = {};
-    Object.entries(obj ?? {}).forEach(([key, value]) => {
+    const copy: Record<string, any> = {};
+    Object.entries(obj ?? {}).forEach(([key, value]: [any, any]) => {
       const path = `${currentPath}.${key}`;
       if (ignoredPatterns.some((pattern) => path.includes(pattern))) {
         return;
@@ -72,21 +71,26 @@ function compactDeep(
   }
 }
 
-function assetGraphDiff(jsAssetGraph: AssetGraph, rustAssetGraph: AssetGraph) {
-  const getNodes = (graph) => {
-    let nodes = {};
+function assetGraphDiff(
+  jsAssetGraph: AssetGraph,
+  rustAssetGraph: AssetGraph,
+  projectRoot: string,
+) {
+  const getNodes = (graph: any) => {
+    let nodes: Record<string, any> = {};
 
+    // @ts-expect-error implicit any
     graph.traverse((nodeId) => {
       let node: AssetGraphNode | null = graph.getNode(nodeId) ?? null;
       if (!node) return;
 
       if (node.type === 'dependency') {
-        let sourcePath = node.value.sourcePath ?? toProjectPath('', 'entry');
-        nodes[
-          `dep:${fromProjectPathRelative(sourcePath)}:${node.value.specifier}`
-        ] = filterNode(node);
+        let sourcePath = node.value.sourcePath
+          ? toProjectPath(projectRoot, node.value.sourcePath)
+          : toProjectPath(projectRoot, 'entry');
+        nodes[`dep:${sourcePath}:${node.value.specifier}`] = filterNode(node);
       } else if (node.type === 'asset') {
-        nodes[`asset:${fromProjectPathRelative(node.value.filePath)}`] =
+        nodes[`asset:${toProjectPath(projectRoot, node.value.filePath)}`] =
           filterNode(node);
       }
     });
@@ -98,8 +102,8 @@ function assetGraphDiff(jsAssetGraph: AssetGraph, rustAssetGraph: AssetGraph) {
   const rustNodes = getNodes(rustAssetGraph);
 
   const all = new Set([...Object.keys(jsNodes), ...Object.keys(rustNodes)]);
-  const missing = [];
-  const extra = [];
+  const missing: Array<any | string> = [];
+  const extra: Array<any | string> = [];
 
   for (const key of all.keys()) {
     if (process.env.NATIVE_COMPARE !== 'true') {

package/src/requests/{asset-graph-dot.js → asset-graph-dot.ts}

@@ -1,13 +1,11 @@
-// @flow
 import path from 'path';
 
 import type {AssetGraphNode} from '../types';
 import AssetGraph from '../AssetGraph';
 
 export type AssetGraphToDotOptions = {
-  style?: boolean,
-  sort?: boolean,
-  ...
+  style?: boolean;
+  sort?: boolean;
 };
 
 /** @description Renders AssetGraph into GraphViz Dot format */
@@ -15,8 +13,10 @@ export function assetGraphToDot(
   assetGraph: AssetGraph,
   {sort = false, style = true}: AssetGraphToDotOptions = {},
 ): string {
-  const edges = [];
-  const nodeStyles: {[key: string]: string} = {};
+  const edges: Array<string> = [];
+  const nodeStyles: {
+    [key: string]: string;
+  } = {};
 
   assetGraph.traverse((nodeId) => {
     let node: AssetGraphNode | null = assetGraph.getNode(nodeId) ?? null;
@@ -43,7 +43,6 @@ export function assetGraphToDot(
     }
   });
 
-  // $FlowFixMe
   const nodeStylesList: Array<[string, string]> = Object.entries(nodeStyles);
   if (sort) {
     edges.sort();
@@ -53,7 +52,7 @@ export function assetGraphToDot(
   let digraph = `digraph {\n\tnode [shape=rectangle]\n`;
   if (style) {
     digraph += nodeStylesList
-      .map(([node, style]) => `\t"${node}" [${style}]\n`)
+      .map(([node, style]: [any, any]) => `\t"${node}" [${style}]\n`)
       .join('');
   }
   digraph += edges.map((v) => `\t${v}\n`).join('');
@@ -94,18 +93,15 @@ function fromCwd(input: string): string {
 
 function getNodeName(node: AssetGraphNode): string {
   if (node.type === 'asset_group') {
-    // $FlowFixMe
+    // @ts-expect-error TS2345
     return [`asset_group`, node.id, fromCwd(node.value.filePath)].join('\\n');
   } else if (node.type === 'asset') {
-    // $FlowFixMe
     return [`asset`, node.id, fromCwd(node.value.filePath)].join('\\n');
   } else if (node.type === 'dependency') {
     return [`dependency`, node.id, node.value.specifier].join('\\n');
   } else if (node.type === 'entry_specifier') {
-    // $FlowFixMe
     return [`entry_specifier`, node.value].join('\\n');
   } else if (node.type === 'entry_file') {
-    // $FlowFixMe
     return [`entry_file`, fromCwd(node.value.filePath)].join('\\n');
   }
   return 'ROOT';

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   FilePath,
   InitialAtlaspackOptions,
@@ -93,6 +91,29 @@ export default async function resolveOptions(
     entries = [path.resolve(inputCwd, initialOptions.entries)];
   }
 
+  // When allowExplicitTargetEntries is enabled and no entries are provided,
+  // automatically derive entries from target sources
+  if (
+    getFeatureFlag('allowExplicitTargetEntries') &&
+    initialOptions.targets &&
+    !Array.isArray(initialOptions.targets) &&
+    entries.length === 0
+  ) {
+    const targetSources = new Set<string>();
+
+    for (const [, target] of Object.entries(initialOptions.targets)) {
+      if (target.source) {
+        const sources = Array.isArray(target.source)
+          ? target.source
+          : [target.source];
+        for (const source of sources) {
+          targetSources.add(source);
+        }
+      }
+    }
+    entries = Array.from(targetSources);
+  }
+
   let shouldMakeEntryReferFolder = false;
   if (entries.length === 1 && !isGlob(entries[0])) {
     let [entry] = entries;
@@ -103,20 +124,29 @@ export default async function resolveOptions(
     }
   }
 
-  // getRootDir treats the input as files, so getRootDir(["/home/user/myproject"]) returns "/home/user".
-  // Instead we need to make the the entry refer to some file inside the specified folders if entries refers to the directory.
-  let entryRoot = getRootDir(
-    shouldMakeEntryReferFolder ? [path.join(entries[0], 'index')] : entries,
-  );
-  let projectRootFile =
-    (await resolveConfig(
-      inputFS,
-      path.join(entryRoot, 'index'),
-      [...LOCK_FILE_NAMES, '.git', '.hg'],
-      path.parse(entryRoot).root,
-    )) || path.join(inputCwd, 'index'); // ? Should this just be rootDir
-
-  let projectRoot = path.dirname(projectRootFile);
+  let projectRoot;
+  if (initialOptions.projectRoot) {
+    // Use explicitly provided projectRoot
+    if (!path.isAbsolute(initialOptions.projectRoot)) {
+      throw new Error('Specified project root must be an absolute path');
+    }
+    projectRoot = initialOptions.projectRoot;
+  } else {
+    // getRootDir treats the input as files, so getRootDir(["/home/user/myproject"]) returns "/home/user".
+    // Instead we need to make the the entry refer to some file inside the specified folders if entries refers to the directory.
+    let entryRoot = getRootDir(
+      shouldMakeEntryReferFolder ? [path.join(entries[0], 'index')] : entries,
+    );
+    let projectRootFile =
+      (await resolveConfig(
+        inputFS,
+        path.join(entryRoot, 'index'),
+        [...LOCK_FILE_NAMES, '.git', '.hg'],
+        path.parse(entryRoot).root,
+      )) || path.join(inputCwd, 'index'); // ? Should this just be rootDir
+
+    projectRoot = path.dirname(projectRootFile);
+  }
 
   const gitRoot = await findGitRepositoryRoot(inputFS, projectRoot);
   if (inputFS instanceof NodeVCSAwareFS) {
@@ -151,12 +181,11 @@ export default async function resolveOptions(
       return initialOptions.cache;
     }
 
-    const needsRustLmdbCache = getFeatureFlag('atlaspackV3');
+    const needsRustLmdbCache =
+      getFeatureFlag('atlaspackV3') || getFeatureFlag('nativePackager');
 
-    if (!getFeatureFlag('cachePerformanceImprovements')) {
-      if (!needsRustLmdbCache && !(outputFS instanceof NodeFS)) {
-        return new FSCache(outputFS, cacheDir);
-      }
+    if (!needsRustLmdbCache && !(outputFS instanceof NodeFS)) {
+      return new FSCache(outputFS, cacheDir);
     }
 
     return new LMDBLiteCache(cacheDir);
@@ -239,6 +268,7 @@ export default async function resolveOptions(
       : false,
     shouldDisableCache: initialOptions.shouldDisableCache ?? false,
     shouldProfile: initialOptions.shouldProfile ?? false,
+    nativeProfiler: initialOptions.nativeProfiler,
     shouldTrace: initialOptions.shouldTrace ?? false,
     cacheDir,
     watchDir,
@@ -283,7 +313,7 @@ export default async function resolveOptions(
 function getRelativeConfigSpecifier(
   fs: FileSystem,
   projectRoot: FilePath,
-  specifier: ?DependencySpecifier,
+  specifier?: DependencySpecifier | null,
 ) {
   if (specifier == null) {
     return undefined;
@@ -299,11 +329,11 @@ function getRelativeConfigSpecifier(
 }
 
 function determinePort(
-  initialServerOptions: InitialServerOptions | false | void,
-  portInEnv: string | void,
+  initialServerOptions?: InitialServerOptions | false,
+  portInEnv?: string,
   defaultPort: number = 1234,
 ): number {
-  function parsePort(port: string): number | void {
+  function parsePort(port: string): number | undefined {
     let parsedPort = Number(port);
 
     // return undefined if port number defined in .env is not valid integer
@@ -315,7 +345,7 @@ function determinePort(
 
   if (!initialServerOptions) {
     return typeof portInEnv !== 'undefined'
-      ? parsePort(portInEnv) ?? defaultPort
+      ? (parsePort(portInEnv) ?? defaultPort)
       : defaultPort;
   }
 
@@ -325,6 +355,6 @@ function determinePort(
   }
 
   return typeof portInEnv !== 'undefined'
-    ? parsePort(portInEnv) ?? defaultPort
+    ? (parsePort(portInEnv) ?? defaultPort)
     : defaultPort;
 }

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 /**
  * This is a workaround for https://github.com/rust-lang/rust/issues/91979
  * when running atlaspack with parcel bindings, it is possible that the parcel
@@ -10,9 +8,8 @@
  */
 export function loadRustWorkerThreadDylibHack() {
   try {
-    // $FlowFixMe
     require('@parcel/rust'); // eslint-disable-line
-  } catch (err) {
+  } catch (err: any) {
     /* ignore */
   }
 }

package/src/{serializerCore.browser.js → serializerCore.browser.ts}

@@ -1,9 +1,8 @@
-// @flow
 import {Buffer} from 'buffer';
 import * as msgpackr from 'msgpackr';
 
 let encoder = new msgpackr.Encoder({structuredClone: true});
 
-export let serializeRaw: (any) => Buffer = (v) =>
+export let serializeRaw: (arg1?: any) => Buffer = (v) =>
   Buffer.from(encoder.encode(v));
-export let deserializeRaw: (Buffer) => any = (v) => encoder.decode(v);
+export let deserializeRaw: (arg1: Buffer) => any = (v) => encoder.decode(v);

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

@@ -1,4 +1,3 @@
-// @flow strict-local
 import type {Blob, FilePath} from '@atlaspack/types';
 import type {FileSystem} from '@atlaspack/fs';
 
@@ -10,8 +9,15 @@ const BUFFER_LIMIT = 5000000; // 5mb
 
 export default async function summarizeRequest(
   fs: FileSystem,
-  req: {|filePath: FilePath, code?: string|},
-): Promise<{|content: Blob, size: number, isSource: boolean|}> {
+  req: {
+    filePath: FilePath;
+    code?: string;
+  },
+): Promise<{
+  content: Blob;
+  size: number;
+  isSource: boolean;
+}> {
   let {content, size} = await summarizeDiskRequest(fs, req);
   let isSource = isFilePathSource(fs, req.filePath);
   return {content, size, isSource};
@@ -23,8 +29,14 @@ function isFilePathSource(fs: FileSystem, filePath: FilePath) {
 
 async function summarizeDiskRequest(
   fs: FileSystem,
-  req: {|filePath: FilePath, code?: string|},
-): Promise<{|content: Blob, size: number|}> {
+  req: {
+    filePath: FilePath;
+    code?: string;
+  },
+): Promise<{
+  content: Blob;
+  size: number;
+}> {
   let code = req.code;
   let content: Blob;
   let size: number;