Expo FileSystem

Copies a directory.

Copies a directory synchronously.

Creates a directory that the current uri points to.

Deletes a directory. Also deletes all files and directories inside the directory.

Retrieves an object containing properties of a directory.

Lists the contents of a directory. Calling this method if the parent directory does not exist will throw an error.

Moves a directory. Updates the uri property that now points to the new location.

Moves a directory synchronously. Updates the uri property that now points to the new location.

Renames a directory.

Watches this directory for changes to its contents or the directory itself.

Events are emitted when files or subdirectories are created, modified, deleted, or renamed within this directory. On iOS, child changes are surfaced as a coarse-grained modified event on the directory itself, so filtering for child-level created, deleted, or renamed events is not reliable. The watcher automatically stops when the directory is deleted or renamed. To stop watching manually, call remove() on the returned subscription.

const cacheDir = new Directory(Paths.cache);
const subscription = cacheDir.watch((event) => {
  console.log(`${event.type}: ${event.target.uri}`);
});

// Later, stop watching:
subscription.remove();

Adds a listener for download progress events.

Note: Prefer the onProgress option unless you need manual subscription control.

Cancels the download operation.

If downloadAsync() or resumeAsync() is pending, its promise is rejected after the native request is cancelled. Calling this method after the task reaches completed, cancelled, or error has no effect.

Starts the download operation.

This method can only be called once, while the task is idle. The promise resolves with the downloaded file when the transfer completes, or with null if the task is paused before completion. It is rejected when the request fails or the task is cancelled.

If options.signal is aborted, the promise is rejected with an AbortError.

Creates a paused download task from saved state.

Use this to continue a download after persisting the value returned by savable(). New options can attach progress callbacks or an abort signal because functions and signals are not stored in DownloadPauseState. If both saved state and new options include headers, the new headers override saved headers with the same names.

Requests pausing the active download operation.

The pending downloadAsync() or resumeAsync() promise resolves with null after native code produces resume data and the task enters the paused state. Use pauseAsync() if you need to wait until the task is ready to resume or save.

Requests pausing the active download operation and waits until the task reaches the paused state.

Releases the native task handle.

Call this when you no longer need the task and want to release native resources manually.

Resumes a paused download operation.

The promise resolves with the downloaded file when the transfer completes, or with null if the task is paused again before completion. It is rejected when the request fails or the task is cancelled.

Returns the paused task state that can be persisted and restored later.

This method can only be called while the task is paused. The returned state contains platform-specific resume data and request metadata, but does not include callbacks or abort signals.

The arrayBuffer() method of the Blob interface returns a Promise that resolves with the contents of the blob as binary data contained in an ArrayBuffer.

MDN Reference

Retrieves content of the file as base64.

Retrieves content of the file as base64.

Retrieves byte content of the entire file.

Retrieves byte content of the entire file.

Determines whether the platform can preview this file.

On iOS, this checks whether Quick Look can preview the file. On Android, this checks whether an installed app can handle the preview intent for the file's MIME type. Invalid files and files the app cannot read reject instead of returning false. If the file does not exist, the promise resolves to false.

Copies a file.

Copies a file synchronously.

Creates a file.

Creates a download task without starting it.

Call downloadAsync() on the returned task to start the download. Use this when you need pause/resume support, task state, cancellation, or manual progress subscriptions.

const destination = new File(Paths.document, 'video.mp4');
const task = File.createDownloadTask('https://example.com/video.mp4', destination, {
  onProgress: ({ bytesWritten, totalBytes }) => {
    console.log(`${bytesWritten} / ${totalBytes}`);
  },
});

const file = await task.downloadAsync();

Creates an upload task for this file without starting it.

Call uploadAsync() on the returned task to start the upload. Use this when you need to inspect task state, cancel the upload, or subscribe to progress manually.

const file = new File(Paths.document, 'photo.jpg');
const task = file.createUploadTask('https://example.com/upload', {
  uploadType: UploadType.MULTIPART,
  onProgress: ({ bytesSent, totalBytes }) => {
    console.log(`${bytesSent} / ${totalBytes}`);
  },
});

const result = await task.uploadAsync();

Deletes a file.

Calculates the digest of the file's contents.

Retrieves an object containing properties of a file

Moves a directory. Updates the uri property that now points to the new location.

Moves a file synchronously. Updates the uri property that now points to the new location.

Returns A FileHandle object that can be used to read and write data to the file.

Opens the system file picker for selecting a single file.

This overload requires options.multipleFiles to be undefined or false.

Opens the system file picker for selecting multiple files.

This overload requires options.multipleFiles to be true.

const result = await File.pickFileAsync({
  multipleFiles: true,
  mimeTypes: ['image/*', 'application/pdf'],
});

if (!result.canceled) {
  for (const file of result.result) {
    console.log(file.uri);
  }
}

A static method that opens a file picker to select a single file of specified type. On iOS, it returns a temporary copy of the file leaving the original file untouched.

Selecting multiple files is not supported yet.

Opens this file with the platform's file preview flow.

On iOS, this presents Quick Look. On Android, this starts an ACTION_VIEW intent. The promise resolves once the preview has been presented or handed off to another app. The promise rejects if the file does not exist or cannot be previewed.

Creates a ReadableStream that reads from this file using a FileHandle internally.

The stream reads in 1024-byte chunks by default. The underlying file handle is closed automatically when the stream is fully consumed or cancelled.

Renames a file.

The slice() method of the Blob interface creates and returns a new Blob object which contains data from a subset of the blob on which it's called.

MDN Reference

Returns a ReadableStream for this file. This is an alias for readableStream() and implements the Blob.stream() interface.

Retrieves text from the file.

Retrieves text from the file.

Uploads this file to a server and starts the request immediately.

The promise resolves with the HTTP response metadata and body for any completed response, including non-2xx status codes. It is rejected only when the file cannot be read, the request fails, or the upload is cancelled.

Watches this file for changes on the filesystem.

The watcher automatically stops when the file is deleted or renamed. To stop watching manually, call remove() on the returned subscription.

const file = new File(Paths.cache, 'data.json');
const subscription = file.watch((event) => {
  console.log(`File ${event.type}`);
});

// Later, stop watching:
subscription.remove();

Creates a WritableStream that writes to this file using a FileHandle internally.

The underlying file handle is closed automatically when the stream is closed or aborted.

Writes content to the file.

Writes content to the file.

Returns the base name of a path.

Returns the directory name of a path.

Returns the extension of a path.

Returns an object that indicates if the specified path represents a directory.

Checks if a path is absolute.

Joins path segments into a single path.

Normalizes a path.

Parses a path into its components.

Resolves a relative path to an absolute path.

Adds a listener for upload progress events.

Note: Prefer the onProgress option unless you need manual subscription control.

Cancels the upload operation.

If uploadAsync() is pending, its promise is rejected after the native request is cancelled. Calling this method after the task reaches completed, cancelled, or error has no effect.

Releases the native task handle.

Call this when you no longer need the task and want to release native resources manually.

Starts the upload operation.

This method can only be called once, while the task is idle. The promise resolves with response metadata and body for completed HTTP responses, including non-2xx status codes. It is rejected when the file cannot be read, the request fails, or the task is cancelled.

If options.signal is aborted, the promise is rejected with an AbortError.

Closes the file handle and releases the underlying file descriptor.

After closing, the offset and size properties return null, and any subsequent call to readBytes, readBytesSync, writeBytes, or writeBytesSync throws an error.

Reads up to length bytes from the file starting at the current offset.

The returned Uint8Array may contain fewer than length bytes if the end of the file is reached. Returns an empty Uint8Array when the offset is already at or past the end of the file. The offset advances by the number of bytes actually read.

The maximum number of bytes that can be read in a single call is limited by the platform's ArrayBuffer size: 2 GB (signed 32-bit max) on Android, and the 64-bit limit on iOS. To read larger files, call this method in a loop.

Reads up to length bytes from the file starting at the current offset, synchronously.

Behaves identically to readBytes but blocks the JS thread until the data is available.

Writes the provided bytes to the file at the current offset, then advances the offset by the number of bytes written.

Writes the provided bytes to the file at the current offset synchronously, then advances the offset by the number of bytes written.