feedback 2

packages/playwright-core/src/client/elementHandle.ts

@@ -269,34 +269,25 @@ export async function convertInputFiles(files: string | FilePayload | string[] |
     if (context._connection.isRemote()) {
       let streams: channels.WritableStreamChannel[] | undefined;
       let localPaths: string[] | undefined;
-      for (const item of items as string[]) {
+      await Promise.all((items as string[]).map(async item => {
-        if ((await fs.promises.stat(item)).isDirectory()) {
+        const isDirectory = (await fs.promises.stat(item)).isDirectory();
-          const files = (await fs.promises.readdir(item, { withFileTypes: true, recursive: true })).filter(f => f.isFile()).map(f => path.join(item, f.name));
+        const files = isDirectory ? (await fs.promises.readdir(item, { withFileTypes: true, recursive: true })).filter(f => f.isFile()).map(f => path.join(item, f.name)) : [item];
-          const { writableStreams, dir } = await context._wrapApiCall(async () => context._channel.createTempDirectory({
+        const { writableStreams, remoteDir } = await context._wrapApiCall(async () => context._channel.createTempFiles({
-            root: item,
+          rootDirName: isDirectory ? item : undefined,
-            items: await Promise.all(files.map(async f => {
+          items: await Promise.all(files.map(f => fileToTempFileParams(f))),
-              const lastModifiedMs = (await fs.promises.stat(f)).mtimeMs;
+        }), true);
-              return {
+        for (let i = 0; i < files.length; i++) {
-                name: path.relative(item, f),
+          const writable = WritableStream.from(writableStreams[i]);
-                lastModifiedMs
+          await pipelineAsync(fs.createReadStream(files[i]), writable.stream());
-              };
-            })),
-          }), true);
-          for (let i = 0; i < files.length; i++) {
-            const writable = WritableStream.from(writableStreams[i]);
-            await pipelineAsync(fs.createReadStream(files[i]), writable.stream());
-          }
-          localPaths ??= [];
-          localPaths.push(dir);
-        } else {
-          const lastModifiedMs = (await fs.promises.stat(item)).mtimeMs;
-          const { writableStream } = await context._wrapApiCall(() => context._channel.createTempFile({ name: path.basename(item), lastModifiedMs }), true);
-          const writable = WritableStream.from(writableStream);
-          await pipelineAsync(fs.createReadStream(item), writable.stream());
-          streams ??= [];
-          streams.push(writableStream);
         }
-      }
+        if (isDirectory) {
+          localPaths ??= [];
+          localPaths.push(remoteDir);
+        } else {
+          streams ??= [];
+          streams.push(...writableStreams);
+        }
+      }));
       return { streams, localPaths };
     }
     return { localPaths: items.map(f => path.resolve(f as string)) as string[] };
@@ -308,6 +299,11 @@ export async function convertInputFiles(files: string | FilePayload | string[] |
   return { payloads };
 }
 
+async function fileToTempFileParams(file: string): Promise<channels.BrowserContextCreateTempFilesParams['items'][0]> {
+  const lastModifiedMs = (await fs.promises.stat(file)).mtimeMs;
+  return { name: path.basename(file), lastModifiedMs };
+}
+
 export function determineScreenshotType(options: { path?: string, type?: 'png' | 'jpeg' }): 'png' | 'jpeg' | undefined {
   if (options.path) {
     const mimeType = mime.getType(options.path);

packages/playwright-core/src/protocol/validator.ts

@@ -951,22 +951,15 @@ scheme.BrowserContextHarExportParams = tObject({
 scheme.BrowserContextHarExportResult = tObject({
   artifact: tChannel(['Artifact']),
 });
-scheme.BrowserContextCreateTempFileParams = tObject({
+scheme.BrowserContextCreateTempFilesParams = tObject({
-  name: tString,
+  rootDirName: tOptional(tString),
-  lastModifiedMs: tOptional(tNumber),
-});
-scheme.BrowserContextCreateTempFileResult = tObject({
-  writableStream: tChannel(['WritableStream']),
-});
-scheme.BrowserContextCreateTempDirectoryParams = tObject({
-  root: tString,
   items: tArray(tObject({
     name: tString,
     lastModifiedMs: tOptional(tNumber),
   })),
 });
-scheme.BrowserContextCreateTempDirectoryResult = tObject({
+scheme.BrowserContextCreateTempFilesResult = tObject({
-  dir: tString,
+  remoteDir: tString,
   writableStreams: tArray(tChannel(['WritableStream'])),
 });
 scheme.BrowserContextUpdateSubscriptionParams = tObject({

packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts

@@ -178,22 +178,13 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
     return false;
   }
 
-  async createTempFile(params: channels.BrowserContextCreateTempFileParams): Promise<channels.BrowserContextCreateTempFileResult> {
+  async createTempFiles(params: channels.BrowserContextCreateTempFilesParams): Promise<channels.BrowserContextCreateTempFilesResult> {
     const dir = this._context._browser.options.artifactsDir;
     const tmpDir = path.join(dir, 'upload-' + createGuid());
-    await fs.promises.mkdir(tmpDir);
+    const tempDirWithRootName = path.join(tmpDir, params.rootDirName ? path.basename(params.rootDirName) : '');
-    this._context._tempDirs.push(tmpDir);
-    const file = fs.createWriteStream(path.join(tmpDir, params.name));
-    return { writableStream: new WritableStreamDispatcher(this, file, params.lastModifiedMs) };
-  }
-
-  async createTempDirectory(params: channels.BrowserContextCreateTempDirectoryParams): Promise<channels.BrowserContextCreateTempDirectoryResult> {
-    const dir = this._context._browser.options.artifactsDir;
-    const tmpDir = path.join(dir, 'upload-' + createGuid());
-    const tempDirWithRootName = path.join(tmpDir, path.basename(params.root));
     await fs.promises.mkdir(tempDirWithRootName, { recursive: true });
     return {
-      dir: tempDirWithRootName,
+      remoteDir: tempDirWithRootName,
       writableStreams: await Promise.all(params.items.map(async item => {
         await fs.promises.mkdir(path.dirname(path.join(tempDirWithRootName, item.name)), { recursive: true });
         const file = fs.createWriteStream(path.join(tempDirWithRootName, item.name));

packages/protocol/src/channels.ts

@@ -1458,8 +1458,7 @@ export interface BrowserContextChannel extends BrowserContextEventTarget, EventT
   newCDPSession(params: BrowserContextNewCDPSessionParams, metadata?: CallMetadata): Promise<BrowserContextNewCDPSessionResult>;
   harStart(params: BrowserContextHarStartParams, metadata?: CallMetadata): Promise<BrowserContextHarStartResult>;
   harExport(params: BrowserContextHarExportParams, metadata?: CallMetadata): Promise<BrowserContextHarExportResult>;
-  createTempFile(params: BrowserContextCreateTempFileParams, metadata?: CallMetadata): Promise<BrowserContextCreateTempFileResult>;
+  createTempFiles(params: BrowserContextCreateTempFilesParams, metadata?: CallMetadata): Promise<BrowserContextCreateTempFilesResult>;
-  createTempDirectory(params: BrowserContextCreateTempDirectoryParams, metadata?: CallMetadata): Promise<BrowserContextCreateTempDirectoryResult>;
   updateSubscription(params: BrowserContextUpdateSubscriptionParams, metadata?: CallMetadata): Promise<BrowserContextUpdateSubscriptionResult>;
   clockInstallFakeTimers(params: BrowserContextClockInstallFakeTimersParams, metadata?: CallMetadata): Promise<BrowserContextClockInstallFakeTimersResult>;
   clockRunAllTimers(params?: BrowserContextClockRunAllTimersParams, metadata?: CallMetadata): Promise<BrowserContextClockRunAllTimersResult>;
@@ -1738,28 +1737,18 @@ export type BrowserContextHarExportOptions = {
 export type BrowserContextHarExportResult = {
   artifact: ArtifactChannel,
 };
-export type BrowserContextCreateTempFileParams = {
+export type BrowserContextCreateTempFilesParams = {
-  name: string,
+  rootDirName?: string,
-  lastModifiedMs?: number,
-};
-export type BrowserContextCreateTempFileOptions = {
-  lastModifiedMs?: number,
-};
-export type BrowserContextCreateTempFileResult = {
-  writableStream: WritableStreamChannel,
-};
-export type BrowserContextCreateTempDirectoryParams = {
-  root: string,
   items: {
     name: string,
     lastModifiedMs?: number,
   }[],
 };
-export type BrowserContextCreateTempDirectoryOptions = {
+export type BrowserContextCreateTempFilesOptions = {
-
+  rootDirName?: string,
 };
-export type BrowserContextCreateTempDirectoryResult = {
+export type BrowserContextCreateTempFilesResult = {
-  dir: string,
+  remoteDir: string,
   writableStreams: WritableStreamChannel[],
 };
 export type BrowserContextUpdateSubscriptionParams = {

packages/protocol/src/protocol.yml

@@ -1184,16 +1184,9 @@ BrowserContext:
       returns:
         artifact: Artifact
 
-    createTempFile:
+    createTempFiles:
       parameters:
-        name: string
+        rootDirName: string?
-        lastModifiedMs: number?
-      returns:
-        writableStream: WritableStream
-
-    createTempDirectory:
-      parameters:
-        root: string
         items:
           type: array
           items:
@@ -1202,7 +1195,7 @@ BrowserContext:
               name: string
               lastModifiedMs: number?
       returns:
-        dir: string
+        remoteDir: string
         writableStreams:
           type: array
           items: WritableStream