@atlaspack/core 2.16.2-canary.37 → 2.16.2-canary.371

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,10 +181,13 @@ export default async function resolveOptions(
       return initialOptions.cache;
     }
 
-    const needsRustLmdbCache = getFeatureFlag('atlaspackV3');
+    const needsRustLmdbCache =
+      getFeatureFlag('atlaspackV3') || getFeatureFlag('nativePackager');
 
-    if (!needsRustLmdbCache && !(outputFS instanceof NodeFS)) {
-      return new FSCache(outputFS, cacheDir);
+    if (!getFeatureFlag('cachePerformanceImprovements')) {
+      if (!needsRustLmdbCache && !(outputFS instanceof NodeFS)) {
+        return new FSCache(outputFS, cacheDir);
+      }
     }
 
     return new LMDBLiteCache(cacheDir);
@@ -237,6 +270,7 @@ export default async function resolveOptions(
       : false,
     shouldDisableCache: initialOptions.shouldDisableCache ?? false,
     shouldProfile: initialOptions.shouldProfile ?? false,
+    nativeProfiler: initialOptions.nativeProfiler,
     shouldTrace: initialOptions.shouldTrace ?? false,
     cacheDir,
     watchDir,
@@ -281,7 +315,7 @@ export default async function resolveOptions(
 function getRelativeConfigSpecifier(
   fs: FileSystem,
   projectRoot: FilePath,
-  specifier: ?DependencySpecifier,
+  specifier?: DependencySpecifier | null,
 ) {
   if (specifier == null) {
     return undefined;
@@ -297,11 +331,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
@@ -313,7 +347,7 @@ function determinePort(
 
   if (!initialServerOptions) {
     return typeof portInEnv !== 'undefined'
-      ? parsePort(portInEnv) ?? defaultPort
+      ? (parsePort(portInEnv) ?? defaultPort)
       : defaultPort;
   }
 
@@ -323,6 +357,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;