@react-native-gpui/fs 0.0.1-alpha.0 → 0.0.1-alpha.1

package/src/NativeFs.ts

@@ -67,6 +67,61 @@ export type WatchEvent = {
   path: string;
 };
 
+export type DownloadHeader = {
+  name: string;
+  value: string;
+};
+
+export type DownloadOptions = {
+  id: number;
+  method: string;
+  headers: Array<DownloadHeader>;
+};
+
+/**
+ * What a download resolves with. A non-2xx answer is not an error here: it
+ * comes back with its `status` and a small `body`, and no file is written.
+ */
+export type DownloadResult = {
+  status: number;
+  headers: Array<DownloadHeader>;
+  bytes: number;
+  body?: string;
+};
+
+export type DownloadProgress = {
+  id: number;
+  received: number;
+  // -1 when the server did not say how long the body is.
+  total: number;
+};
+
+export type UploadOptions = {
+  id: number;
+  method: string;
+  headers: Array<DownloadHeader>;
+  // Where in the file the body starts.
+  offset: number;
+  // How many bytes to send; -1 sends everything from `offset`.
+  length: number;
+};
+
+/**
+ * What an upload resolves with. Any status is a result; `body` is the first
+ * part of the response.
+ */
+export type UploadResult = {
+  status: number;
+  headers: Array<DownloadHeader>;
+  body: string;
+};
+
+export type UploadProgress = {
+  id: number;
+  sent: number;
+  total: number;
+};
+
 /**
  * The file system module: one instance, on its own thread, so a slow file never
  * blocks JS or the UI.
@@ -154,9 +209,27 @@ export interface Spec extends TurboModule {
   renameSync(from: string, to: string): boolean;
   copyFileSync(from: string, to: string): boolean;
 
+  download(
+    url: string,
+    path: string,
+    options: DownloadOptions,
+  ): Promise<DownloadResult>;
+  // Returns whether a download with that id was running.
+  cancelDownload(id: number): boolean;
+
+  upload(
+    url: string,
+    path: string,
+    options: UploadOptions,
+  ): Promise<UploadResult>;
+  // Returns whether an upload with that id was running.
+  cancelUpload(id: number): boolean;
+
   getPaths(): KnownPaths;
 
   readonly onWatchEvent: CodegenTypes.EventEmitter<WatchEvent>;
+  readonly onDownloadProgress: CodegenTypes.EventEmitter<DownloadProgress>;
+  readonly onUploadProgress: CodegenTypes.EventEmitter<UploadProgress>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('RNFsModule');

package/src/download.ts

@@ -0,0 +1,110 @@
+/**
+ * `download`: an HTTP response streamed into a file.
+ *
+ * The body goes to `<path>.part` as it arrives and is renamed onto `path` once it
+ * is complete, so `path` never holds half a file. The partial file is removed when
+ * the request fails or is aborted.
+ */
+
+import NativeFs from './NativeFs';
+import { nodeError, toPath, withContext, type NodeError } from './shared';
+
+export interface DownloadOptions {
+  /** `GET` unless set. No request body is sent. */
+  method?: string;
+  headers?: Record<string, string>;
+  /** Called while the body arrives; `total` is `-1` when the server did not say. */
+  onProgress?: (received: number, total: number) => void;
+  /** Aborting rejects with an `AbortError` and removes the partial file. */
+  signal?: AbortSignal;
+}
+
+export interface DownloadResult {
+  status: number;
+  /** Response headers, lower-cased; repeated headers are joined with `, `. */
+  headers: Record<string, string>;
+  /** The size of the file that was written. */
+  bytes: number;
+}
+
+/** What a non-2xx response rejects with. */
+export interface DownloadHttpError extends NodeError {
+  status: number;
+  headers: Record<string, string>;
+  /** The first part of the response body. */
+  body: string;
+}
+
+let nextId = 1;
+
+function abortError(): NodeError {
+  const error = nodeError('ABORT_ERR', 'The download was aborted');
+  error.name = 'AbortError';
+  return error;
+}
+
+function toRecord(list: Array<{ name: string; value: string }>) {
+  const record: Record<string, string> = {};
+  for (const { name, value } of list) {
+    record[name] = value;
+  }
+  return record;
+}
+
+export async function download(
+  url: string,
+  path: string,
+  options: DownloadOptions = {},
+): Promise<DownloadResult> {
+  const { signal, onProgress } = options;
+  if (signal?.aborted) {
+    throw abortError();
+  }
+  const target = toPath(path);
+  const id = nextId++;
+  const subscription = onProgress
+    ? NativeFs.onDownloadProgress(event => {
+        if (event.id === id) {
+          onProgress(event.received, event.total);
+        }
+      })
+    : null;
+  const onAbort = () => {
+    NativeFs.cancelDownload(id);
+  };
+  signal?.addEventListener('abort', onAbort);
+
+  try {
+    const result = await NativeFs.download(url, target, {
+      id,
+      method: options.method ?? 'GET',
+      headers: Object.entries(options.headers ?? {}).map(([name, value]) => ({
+        name,
+        value,
+      })),
+    });
+    const headers = toRecord(result.headers);
+    if (result.status < 200 || result.status >= 300) {
+      const error = nodeError(
+        'ERR_HTTP_STATUS',
+        `HTTP ${result.status} downloading ${url}`,
+      ) as DownloadHttpError;
+      error.status = result.status;
+      error.headers = headers;
+      error.body = result.body ?? '';
+      throw error;
+    }
+    return { status: result.status, headers, bytes: result.bytes };
+  } catch (error) {
+    if (signal?.aborted) {
+      throw abortError();
+    }
+    if ((error as NodeError)?.code === 'ABORT_ERR') {
+      throw abortError();
+    }
+    throw withContext(error, 'download', target);
+  } finally {
+    signal?.removeEventListener('abort', onAbort);
+    subscription?.remove();
+  }
+}

package/src/index.ts

@@ -38,6 +38,8 @@ import {
   type Encoding,
   type NodeError,
 } from './shared';
+import { download } from './download';
+import { upload } from './upload';
 import { watch } from './watch';
 
 export type {
@@ -50,13 +52,28 @@ export type {
   WriteOptions,
 } from './promises';
 export type { BinaryData, Encoding, NodeError } from './shared';
+export type { UploadOptions, UploadResult } from './upload';
+export type {
+  DownloadHttpError,
+  DownloadOptions,
+  DownloadResult,
+} from './download';
 export type {
   FSWatcher,
   WatchEventType,
   WatchListener,
   WatchOptions,
 } from './watch';
-export { Dirent, Stats, FileHandle, promises, constants, watch };
+export {
+  Dirent,
+  Stats,
+  FileHandle,
+  promises,
+  constants,
+  watch,
+  download,
+  upload,
+};
 
 /* -------------------------------------------------------------------------- */
 /* Dialogs                                                                    */
@@ -748,6 +765,8 @@ const fs = {
   open,
   reveal,
   openExternal,
+  download,
+  upload,
 
   readFileSync,
   writeFileSync,

package/src/upload.ts

@@ -0,0 +1,97 @@
+/**
+ * `upload`: a file, or a range of one, streamed as an HTTP request body.
+ *
+ * The native side reads the file in small blocks while the connection takes
+ * them, so nothing larger than a block is ever held in memory.
+ */
+
+import NativeFs from './NativeFs';
+import { nodeError, toPath, withContext, type NodeError } from './shared';
+
+export interface UploadOptions {
+  /** `PUT` unless set. */
+  method?: string;
+  headers?: Record<string, string>;
+  /** Where in the file the body starts. Zero unless set. */
+  offset?: number;
+  /** How many bytes to send. Everything from `offset` unless set. */
+  length?: number;
+  /** Called while the body is sent. */
+  onProgress?: (sent: number, total: number) => void;
+  /** Aborting rejects with an `AbortError`. */
+  signal?: AbortSignal;
+}
+
+export interface UploadResult {
+  status: number;
+  /** Response headers, lower-cased; repeated headers are joined with `, `. */
+  headers: Record<string, string>;
+  /** The first part of the response body. */
+  body: string;
+}
+
+let nextId = 1;
+
+function abortError(): NodeError {
+  const error = nodeError('ABORT_ERR', 'The upload was aborted');
+  error.name = 'AbortError';
+  return error;
+}
+
+function toRecord(list: Array<{ name: string; value: string }>) {
+  const record: Record<string, string> = {};
+  for (const { name, value } of list) {
+    record[name] = value;
+  }
+  return record;
+}
+
+export async function upload(
+  url: string,
+  path: string,
+  options: UploadOptions = {},
+): Promise<UploadResult> {
+  const { signal, onProgress } = options;
+  if (signal?.aborted) {
+    throw abortError();
+  }
+  const source = toPath(path);
+  const id = nextId++;
+  const subscription = onProgress
+    ? NativeFs.onUploadProgress(event => {
+        if (event.id === id) {
+          onProgress(event.sent, event.total);
+        }
+      })
+    : null;
+  const onAbort = () => {
+    NativeFs.cancelUpload(id);
+  };
+  signal?.addEventListener('abort', onAbort);
+
+  try {
+    const result = await NativeFs.upload(url, source, {
+      id,
+      method: options.method ?? 'PUT',
+      headers: Object.entries(options.headers ?? {}).map(([name, value]) => ({
+        name,
+        value,
+      })),
+      offset: options.offset ?? 0,
+      length: options.length ?? -1,
+    });
+    return {
+      status: result.status,
+      headers: toRecord(result.headers),
+      body: result.body,
+    };
+  } catch (error) {
+    if (signal?.aborted || (error as NodeError)?.code === 'ABORT_ERR') {
+      throw abortError();
+    }
+    throw withContext(error, 'upload', source);
+  } finally {
+    signal?.removeEventListener('abort', onAbort);
+    subscription?.remove();
+  }
+}