@symbiote-native/file-system 0.1.0

package/build/core/file-system.js

@@ -0,0 +1,404 @@
+import { UnavailabilityError, uuid, } from 'expo-modules-core';
+import { Platform } from 'react-native';
+import { expoFileSystem } from './native-module.js';
+import { FileSystemSessionType, FileSystemUploadType, } from './types.js';
+if (!expoFileSystem) {
+    console.warn('No native ExponentFileSystem module found, are you sure the @symbiote-native/file-system module is linked properly?');
+}
+function normalizeEndingSlash(p) {
+    if (p != null) {
+        return p.replace(/\/*$/, '') + '/';
+    }
+    return null;
+}
+/**
+ * `file://` URI pointing to the directory where user documents for this app will be stored.
+ * Files stored here will remain until explicitly deleted by the app. Ends with a trailing `/`.
+ */
+export const documentDirectory = normalizeEndingSlash(expoFileSystem?.documentDirectory ?? null);
+/**
+ * `file://` URI pointing to the directory where temporary files used by this app will be stored.
+ * Files stored here may be automatically deleted by the system when low on storage.
+ */
+export const cacheDirectory = normalizeEndingSlash(expoFileSystem?.cacheDirectory ?? null);
+/**
+ * URI to the directory where assets bundled with the application are stored.
+ */
+export const bundleDirectory = normalizeEndingSlash(expoFileSystem?.bundleDirectory ?? null);
+/**
+ * Get metadata information about a file, directory or external content/asset.
+ */
+export async function getInfoAsync(fileUri, options = {}) {
+    if (!expoFileSystem?.getInfoAsync) {
+        throw new UnavailabilityError('@symbiote-native/file-system', 'getInfoAsync');
+    }
+    return await expoFileSystem.getInfoAsync(fileUri, options);
+}
+/**
+ * Read the entire contents of a file as a string. Binary is returned in raw format — prepend
+ * `data:image/png;base64,` yourself to use it as a data URI.
+ */
+export async function readAsStringAsync(fileUri, options = {}) {
+    if (!expoFileSystem?.readAsStringAsync) {
+        throw new UnavailabilityError('@symbiote-native/file-system', 'readAsStringAsync');
+    }
+    return await expoFileSystem.readAsStringAsync(fileUri, options);
+}
+/**
+ * Takes a `file://` URI and converts it into a `content://` URI so that it can be accessed by
+ * other applications outside of the app.
+ * @platform android
+ */
+export async function getContentUriAsync(fileUri) {
+    if (Platform.OS === 'android') {
+        if (!expoFileSystem?.getContentUriAsync) {
+            throw new UnavailabilityError('@symbiote-native/file-system', 'getContentUriAsync');
+        }
+        return await expoFileSystem.getContentUriAsync(fileUri);
+    }
+    return fileUri;
+}
+/**
+ * Write the entire contents of a file as a string.
+ */
+export async function writeAsStringAsync(fileUri, contents, options = {}) {
+    if (!expoFileSystem?.writeAsStringAsync) {
+        throw new UnavailabilityError('@symbiote-native/file-system', 'writeAsStringAsync');
+    }
+    return await expoFileSystem.writeAsStringAsync(fileUri, contents, options);
+}
+/**
+ * Delete a file or directory. If the URI points to a directory, the directory and all its
+ * contents are recursively deleted.
+ */
+export async function deleteAsync(fileUri, options = {}) {
+    if (!expoFileSystem?.deleteAsync) {
+        throw new UnavailabilityError('@symbiote-native/file-system', 'deleteAsync');
+    }
+    return await expoFileSystem.deleteAsync(fileUri, options);
+}
+/**
+ * Move a file or directory to a new location.
+ */
+export async function moveAsync(options) {
+    if (!expoFileSystem?.moveAsync) {
+        throw new UnavailabilityError('@symbiote-native/file-system', 'moveAsync');
+    }
+    return await expoFileSystem.moveAsync(options);
+}
+/**
+ * Create a copy of a file or directory. Directories are recursively copied with all of their
+ * contents. Also works to copy content shared by other apps into local storage.
+ */
+export async function copyAsync(options) {
+    if (!expoFileSystem?.copyAsync) {
+        throw new UnavailabilityError('@symbiote-native/file-system', 'copyAsync');
+    }
+    return await expoFileSystem.copyAsync(options);
+}
+/**
+ * Create a new empty directory.
+ */
+export async function makeDirectoryAsync(fileUri, options = {}) {
+    if (!expoFileSystem?.makeDirectoryAsync) {
+        throw new UnavailabilityError('@symbiote-native/file-system', 'makeDirectoryAsync');
+    }
+    return await expoFileSystem.makeDirectoryAsync(fileUri, options);
+}
+/**
+ * Enumerate the contents of a directory.
+ */
+export async function readDirectoryAsync(fileUri) {
+    if (!expoFileSystem?.readDirectoryAsync) {
+        throw new UnavailabilityError('@symbiote-native/file-system', 'readDirectoryAsync');
+    }
+    return await expoFileSystem.readDirectoryAsync(fileUri);
+}
+/**
+ * Gets the available internal disk storage size, in bytes.
+ */
+export async function getFreeDiskStorageAsync() {
+    if (!expoFileSystem?.getFreeDiskStorageAsync) {
+        throw new UnavailabilityError('@symbiote-native/file-system', 'getFreeDiskStorageAsync');
+    }
+    return await expoFileSystem.getFreeDiskStorageAsync();
+}
+/**
+ * Gets total internal disk storage size, in bytes.
+ */
+export async function getTotalDiskCapacityAsync() {
+    if (!expoFileSystem?.getTotalDiskCapacityAsync) {
+        throw new UnavailabilityError('@symbiote-native/file-system', 'getTotalDiskCapacityAsync');
+    }
+    return await expoFileSystem.getTotalDiskCapacityAsync();
+}
+/**
+ * Download the contents at a remote URI to a file in the app's file system. The directory for
+ * the local file URI must exist prior to calling this function.
+ */
+export async function downloadAsync(uri, fileUri, options = {}) {
+    if (!expoFileSystem?.downloadAsync) {
+        throw new UnavailabilityError('@symbiote-native/file-system', 'downloadAsync');
+    }
+    return await expoFileSystem.downloadAsync(uri, fileUri, {
+        sessionType: FileSystemSessionType.BACKGROUND,
+        ...options,
+    });
+}
+/**
+ * Upload the contents of the file pointed by `fileUri` to the remote url.
+ */
+export async function uploadAsync(url, fileUri, options = {}) {
+    if (!expoFileSystem?.uploadAsync) {
+        throw new UnavailabilityError('@symbiote-native/file-system', 'uploadAsync');
+    }
+    return await expoFileSystem.uploadAsync(url, fileUri, {
+        sessionType: FileSystemSessionType.BACKGROUND,
+        uploadType: FileSystemUploadType.BINARY_CONTENT,
+        ...options,
+        httpMethod: (options.httpMethod || 'POST').toUpperCase(),
+    });
+}
+/**
+ * Create a `DownloadResumable` object which can start, pause, and resume a download of contents
+ * at a remote URI to a file in the app's file system.
+ */
+export function createDownloadResumable(uri, fileUri, options, callback, resumeData) {
+    return new DownloadResumable(uri, fileUri, options, callback, resumeData);
+}
+export function createUploadTask(url, fileUri, options, callback) {
+    return new UploadTask(url, fileUri, options, callback);
+}
+export class FileSystemCancellableNetworkTask {
+    _uuid = uuid.v4();
+    taskWasCanceled = false;
+    subscription;
+    async cancelAsync() {
+        if (!expoFileSystem?.networkTaskCancelAsync) {
+            throw new UnavailabilityError('@symbiote-native/file-system', 'networkTaskCancelAsync');
+        }
+        this.removeSubscription();
+        this.taskWasCanceled = true;
+        return await expoFileSystem.networkTaskCancelAsync(this.uuid);
+    }
+    isTaskCancelled() {
+        if (this.taskWasCanceled) {
+            console.warn('This task was already canceled.');
+            return true;
+        }
+        return false;
+    }
+    get uuid() {
+        return this._uuid;
+    }
+    addSubscription() {
+        if (this.subscription || !expoFileSystem?.addListener) {
+            return;
+        }
+        this.subscription = expoFileSystem.addListener(this.getEventName(), (event) => {
+            const progressEvent = event;
+            if (progressEvent.uuid === this.uuid) {
+                const callback = this.getCallback();
+                if (callback) {
+                    callback(progressEvent.data);
+                }
+            }
+        });
+    }
+    removeSubscription() {
+        if (!this.subscription) {
+            return;
+        }
+        this.subscription.remove();
+        this.subscription = null;
+    }
+}
+export class UploadTask extends FileSystemCancellableNetworkTask {
+    url;
+    fileUri;
+    callback;
+    options;
+    constructor(url, fileUri, options, callback) {
+        super();
+        this.url = url;
+        this.fileUri = fileUri;
+        this.callback = callback;
+        const httpMethod = (options?.httpMethod?.toUpperCase() ||
+            'POST');
+        this.options = {
+            sessionType: FileSystemSessionType.BACKGROUND,
+            uploadType: FileSystemUploadType.BINARY_CONTENT,
+            ...options,
+            httpMethod,
+        };
+    }
+    getEventName() {
+        return 'expo-file-system.uploadProgress';
+    }
+    getCallback() {
+        return this.callback;
+    }
+    async uploadAsync() {
+        if (!expoFileSystem?.uploadTaskStartAsync) {
+            throw new UnavailabilityError('@symbiote-native/file-system', 'uploadTaskStartAsync');
+        }
+        if (this.isTaskCancelled()) {
+            return;
+        }
+        this.addSubscription();
+        const result = await expoFileSystem.uploadTaskStartAsync(this.url, this.fileUri, this.uuid, this.options);
+        this.removeSubscription();
+        return result;
+    }
+}
+export class DownloadResumable extends FileSystemCancellableNetworkTask {
+    url;
+    _fileUri;
+    options;
+    callback;
+    resumeData;
+    constructor(url, _fileUri, options = {}, callback, resumeData) {
+        super();
+        this.url = url;
+        this._fileUri = _fileUri;
+        this.options = options;
+        this.callback = callback;
+        this.resumeData = resumeData;
+    }
+    get fileUri() {
+        return this._fileUri;
+    }
+    getEventName() {
+        return 'expo-file-system.downloadProgress';
+    }
+    getCallback() {
+        return this.callback;
+    }
+    /**
+     * Download the contents at a remote URI to a file in the app's file system.
+     */
+    async downloadAsync() {
+        if (!expoFileSystem?.downloadResumableStartAsync) {
+            throw new UnavailabilityError('@symbiote-native/file-system', 'downloadResumableStartAsync');
+        }
+        if (this.isTaskCancelled()) {
+            return;
+        }
+        this.addSubscription();
+        return await expoFileSystem.downloadResumableStartAsync(this.url, this._fileUri, this.uuid, this.options, this.resumeData);
+    }
+    /**
+     * Pause the current download operation. `resumeData` is added to the `DownloadResumable`
+     * object after a successful pause operation. Returns an object that can be persisted
+     * (e.g. via a storage module) for future retrieval.
+     */
+    async pauseAsync() {
+        if (!expoFileSystem?.downloadResumablePauseAsync) {
+            throw new UnavailabilityError('@symbiote-native/file-system', 'downloadResumablePauseAsync');
+        }
+        if (this.isTaskCancelled()) {
+            return {
+                fileUri: this._fileUri,
+                options: this.options,
+                url: this.url,
+            };
+        }
+        const pauseResult = await expoFileSystem.downloadResumablePauseAsync(this.uuid);
+        this.removeSubscription();
+        if (pauseResult) {
+            this.resumeData = pauseResult.resumeData;
+            return this.savable();
+        }
+        throw new Error('Unable to generate a savable pause state');
+    }
+    /**
+     * Resume a paused download operation.
+     */
+    async resumeAsync() {
+        if (!expoFileSystem?.downloadResumableStartAsync) {
+            throw new UnavailabilityError('@symbiote-native/file-system', 'downloadResumableStartAsync');
+        }
+        if (this.isTaskCancelled()) {
+            return;
+        }
+        this.addSubscription();
+        return await expoFileSystem.downloadResumableStartAsync(this.url, this.fileUri, this.uuid, this.options, this.resumeData);
+    }
+    /**
+     * The object which can be persisted for future retrieval (e.g. via a storage module), and
+     * fed back into `createDownloadResumable` after an app restart.
+     */
+    savable() {
+        return {
+            url: this.url,
+            fileUri: this.fileUri,
+            options: this.options,
+            resumeData: this.resumeData,
+        };
+    }
+}
+const baseReadAsStringAsync = readAsStringAsync;
+const baseWriteAsStringAsync = writeAsStringAsync;
+const baseDeleteAsync = deleteAsync;
+const baseMoveAsync = moveAsync;
+const baseCopyAsync = copyAsync;
+/**
+ * `StorageAccessFramework` encapsulates the functions usable with SAF URIs, for accessing
+ * user-selected directories outside the app's own storage.
+ * @platform android
+ */
+export const StorageAccessFramework = {
+    /**
+     * Gets a SAF URI pointing to a folder in the Android root directory, given the folder name.
+     * @platform android
+     */
+    getUriForDirectoryInRoot(folderName) {
+        return `content://com.android.externalstorage.documents/tree/primary:${folderName}/document/primary:${folderName}`;
+    },
+    /**
+     * Allows users to select a specific directory, granting the app access to all of the files and
+     * sub-directories within it.
+     * @platform android 11+
+     */
+    async requestDirectoryPermissionsAsync(initialFileUrl = null) {
+        if (!expoFileSystem?.requestDirectoryPermissionsAsync) {
+            throw new UnavailabilityError('@symbiote-native/file-system', 'StorageAccessFramework.requestDirectoryPermissionsAsync');
+        }
+        return await expoFileSystem.requestDirectoryPermissionsAsync(initialFileUrl);
+    },
+    /**
+     * Enumerate the contents of a directory addressed by a SAF URI.
+     * @platform android
+     */
+    async readDirectoryAsync(dirUri) {
+        if (!expoFileSystem?.readSAFDirectoryAsync) {
+            throw new UnavailabilityError('@symbiote-native/file-system', 'StorageAccessFramework.readDirectoryAsync');
+        }
+        return await expoFileSystem.readSAFDirectoryAsync(dirUri);
+    },
+    /**
+     * Creates a new empty directory addressed by a SAF URI.
+     * @platform android
+     */
+    async makeDirectoryAsync(parentUri, dirName) {
+        if (!expoFileSystem?.makeSAFDirectoryAsync) {
+            throw new UnavailabilityError('@symbiote-native/file-system', 'StorageAccessFramework.makeDirectoryAsync');
+        }
+        return await expoFileSystem.makeSAFDirectoryAsync(parentUri, dirName);
+    },
+    /**
+     * Creates a new empty file addressed by a SAF URI.
+     * @platform android
+     */
+    async createFileAsync(parentUri, fileName, mimeType) {
+        if (!expoFileSystem?.createSAFFileAsync) {
+            throw new UnavailabilityError('@symbiote-native/file-system', 'StorageAccessFramework.createFileAsync');
+        }
+        return await expoFileSystem.createSAFFileAsync(parentUri, fileName, mimeType);
+    },
+    writeAsStringAsync: baseWriteAsStringAsync,
+    readAsStringAsync: baseReadAsStringAsync,
+    deleteAsync: baseDeleteAsync,
+    moveAsync: baseMoveAsync,
+    copyAsync: baseCopyAsync,
+};

package/build/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from './file-system';
+export * from './types';

package/build/core/index.js

@@ -0,0 +1,2 @@
+export * from './file-system.js';
+export * from './types.js';

package/build/core/native-module.d.ts

@@ -0,0 +1,32 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { IFileSystemDeletingOptions, IFileSystemDownloadOptions, IFileSystemDownloadResult, IFileSystemFileInfo, IFileSystemInfoOptions, IFileSystemMakeDirectoryOptions, IFileSystemRelocatingOptions, IFileSystemRequestDirectoryPermissionsResult, IFileSystemUploadOptions, IFileSystemUploadResult, IFileSystemWritingOptions } from './types';
+export type INativeFileSystemModule = {
+    documentDirectory: string | null;
+    cacheDirectory: string | null;
+    bundleDirectory: string | null;
+    getInfoAsync?: (fileUri: string, options: IFileSystemInfoOptions) => Promise<IFileSystemFileInfo>;
+    readAsStringAsync?: (fileUri: string, options: Record<string, unknown>) => Promise<string>;
+    getContentUriAsync?: (fileUri: string) => Promise<string>;
+    writeAsStringAsync?: (fileUri: string, contents: string, options: IFileSystemWritingOptions) => Promise<void>;
+    deleteAsync?: (fileUri: string, options: IFileSystemDeletingOptions) => Promise<void>;
+    moveAsync?: (options: IFileSystemRelocatingOptions) => Promise<void>;
+    copyAsync?: (options: IFileSystemRelocatingOptions) => Promise<void>;
+    makeDirectoryAsync?: (fileUri: string, options: IFileSystemMakeDirectoryOptions) => Promise<void>;
+    readDirectoryAsync?: (fileUri: string) => Promise<string[]>;
+    getFreeDiskStorageAsync?: () => Promise<number>;
+    getTotalDiskCapacityAsync?: () => Promise<number>;
+    downloadAsync?: (uri: string, fileUri: string, options: IFileSystemDownloadOptions) => Promise<IFileSystemDownloadResult>;
+    uploadAsync?: (url: string, fileUri: string, options: IFileSystemUploadOptions) => Promise<IFileSystemUploadResult>;
+    networkTaskCancelAsync?: (uuid: string) => Promise<void>;
+    addListener?: (eventName: string, callback: (event: unknown) => void) => EventSubscription;
+    uploadTaskStartAsync?: (url: string, fileUri: string, uuid: string, options: IFileSystemUploadOptions) => Promise<IFileSystemUploadResult | undefined | null>;
+    downloadResumableStartAsync?: (url: string, fileUri: string, uuid: string, options: IFileSystemDownloadOptions, resumeData?: string) => Promise<IFileSystemDownloadResult | undefined>;
+    downloadResumablePauseAsync?: (uuid: string) => Promise<{
+        resumeData?: string;
+    } | undefined>;
+    requestDirectoryPermissionsAsync?: (initialFileUrl: string | null) => Promise<IFileSystemRequestDirectoryPermissionsResult>;
+    readSAFDirectoryAsync?: (dirUri: string) => Promise<string[]>;
+    makeSAFDirectoryAsync?: (parentUri: string, dirName: string) => Promise<string>;
+    createSAFFileAsync?: (parentUri: string, fileName: string, mimeType: string) => Promise<string>;
+};
+export declare const expoFileSystem: INativeFileSystemModule | null;

package/build/core/native-module.js

@@ -0,0 +1,2 @@
+import { requireOptionalNativeModule, } from 'expo-modules-core';
+export const expoFileSystem = requireOptionalNativeModule('ExponentFileSystem');

package/build/core/types.d.ts

@@ -0,0 +1,104 @@
+export declare enum FileSystemSessionType {
+    BACKGROUND = 0,
+    FOREGROUND = 1
+}
+export declare enum FileSystemUploadType {
+    BINARY_CONTENT = 0,
+    MULTIPART = 1
+}
+export type IFileSystemDownloadOptions = {
+    md5?: boolean;
+    cache?: boolean;
+    headers?: Record<string, string>;
+    sessionType?: FileSystemSessionType;
+};
+export type IFileSystemHttpResult = {
+    headers: Record<string, string>;
+    status: number;
+    mimeType: string | null;
+};
+export type IFileSystemDownloadResult = IFileSystemHttpResult & {
+    uri: string;
+    md5?: string;
+};
+export type IFileSystemAcceptedUploadHttpMethod = 'POST' | 'PUT' | 'PATCH';
+export type IFileSystemUploadOptionsBinary = {
+    uploadType?: FileSystemUploadType;
+};
+export type IFileSystemUploadOptionsMultipart = {
+    uploadType: FileSystemUploadType;
+    fieldName?: string;
+    mimeType?: string;
+    parameters?: Record<string, string>;
+};
+export type IFileSystemUploadOptions = (IFileSystemUploadOptionsBinary | IFileSystemUploadOptionsMultipart) & {
+    headers?: Record<string, string>;
+    httpMethod?: IFileSystemAcceptedUploadHttpMethod;
+    sessionType?: FileSystemSessionType;
+};
+export type IFileSystemUploadResult = IFileSystemHttpResult & {
+    body: string;
+};
+export type IFileSystemNetworkTaskProgressCallback<T extends IFileSystemDownloadProgressData | IFileSystemUploadProgressData> = (data: T) => void;
+export type IFileSystemDownloadProgressData = {
+    totalBytesWritten: number;
+    totalBytesExpectedToWrite: number;
+};
+export type IFileSystemUploadProgressData = {
+    totalBytesSent: number;
+    totalBytesExpectedToSend: number;
+};
+export type IFileSystemDownloadPauseState = {
+    url: string;
+    fileUri: string;
+    options: IFileSystemDownloadOptions;
+    resumeData?: string;
+};
+export type IFileSystemFileInfo = {
+    exists: true;
+    uri: string;
+    size: number;
+    isDirectory: boolean;
+    modificationTime: number;
+    md5?: string;
+} | {
+    exists: false;
+    uri: string;
+    isDirectory: false;
+};
+export declare enum FileSystemEncodingType {
+    UTF8 = "utf8",
+    Base64 = "base64"
+}
+export type IFileSystemReadingOptions = {
+    encoding?: FileSystemEncodingType | 'utf8' | 'base64';
+    position?: number;
+    length?: number;
+};
+export type IFileSystemWritingOptions = {
+    encoding?: FileSystemEncodingType | 'utf8' | 'base64';
+    append?: boolean;
+};
+export type IFileSystemDeletingOptions = {
+    idempotent?: boolean;
+};
+export type IFileSystemInfoOptions = {
+    md5?: boolean;
+};
+export type IFileSystemRelocatingOptions = {
+    from: string;
+    to: string;
+};
+export type IFileSystemMakeDirectoryOptions = {
+    intermediates?: boolean;
+};
+export type IFileSystemProgressEvent<T> = {
+    uuid: string;
+    data: T;
+};
+export type IFileSystemRequestDirectoryPermissionsResult = {
+    granted: false;
+} | {
+    granted: true;
+    directoryUri: string;
+};

package/build/core/types.js

@@ -0,0 +1,15 @@
+export var FileSystemSessionType;
+(function (FileSystemSessionType) {
+    FileSystemSessionType[FileSystemSessionType["BACKGROUND"] = 0] = "BACKGROUND";
+    FileSystemSessionType[FileSystemSessionType["FOREGROUND"] = 1] = "FOREGROUND";
+})(FileSystemSessionType || (FileSystemSessionType = {}));
+export var FileSystemUploadType;
+(function (FileSystemUploadType) {
+    FileSystemUploadType[FileSystemUploadType["BINARY_CONTENT"] = 0] = "BINARY_CONTENT";
+    FileSystemUploadType[FileSystemUploadType["MULTIPART"] = 1] = "MULTIPART";
+})(FileSystemUploadType || (FileSystemUploadType = {}));
+export var FileSystemEncodingType;
+(function (FileSystemEncodingType) {
+    FileSystemEncodingType["UTF8"] = "utf8";
+    FileSystemEncodingType["Base64"] = "base64";
+})(FileSystemEncodingType || (FileSystemEncodingType = {}));

package/build/next/directory.d.ts

@@ -0,0 +1,36 @@
+import { File } from './file';
+import { expoFileSystemNext } from './native-module';
+import type { IFileSystemWatchEvent, IFileSystemWatchOptions, IFileSystemWatchSubscription } from './types';
+/**
+ * Represents a directory on the filesystem.
+ *
+ * A `Directory` instance can be created for any path, and does not need to exist on the
+ * filesystem during creation.
+ */
+export declare class Directory extends expoFileSystemNext.FileSystemDirectory {
+    static pickDirectoryAsync: (initialUri?: string) => Promise<Directory>;
+    /**
+     * Creates an instance of a directory. It can be created for any path, and does not need to
+     * exist on the filesystem during creation.
+     */
+    constructor(...uris: (string | File | Directory)[]);
+    /** Directory containing this directory. */
+    get parentDirectory(): Directory;
+    /**
+     * Lists the contents of a directory. Calling this method if the parent directory does not
+     * exist will throw an error.
+     */
+    list(): (Directory | File)[];
+    /** Directory name. */
+    get name(): string;
+    createFile(name: string, mimeType: string | null): File;
+    createDirectory(name: string): Directory;
+    /**
+     * Watches this directory for changes to its contents or the directory itself. 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.
+     */
+    watch(callback: (event: IFileSystemWatchEvent<File | Directory>) => void, options?: IFileSystemWatchOptions): IFileSystemWatchSubscription;
+}

package/build/next/directory.js

@@ -0,0 +1,59 @@
+import { File } from './file.js';
+import { expoFileSystemNext } from './native-module.js';
+import { Paths } from './paths.js';
+import { FileSystemWatcher } from './watcher.js';
+/**
+ * Represents a directory on the filesystem.
+ *
+ * A `Directory` instance can be created for any path, and does not need to exist on the
+ * filesystem during creation.
+ */
+export class Directory extends expoFileSystemNext.FileSystemDirectory {
+    static pickDirectoryAsync;
+    /**
+     * Creates an instance of a directory. It can be created for any path, and does not need to
+     * exist on the filesystem during creation.
+     */
+    constructor(...uris) {
+        super(Paths.join(...uris));
+        this.validatePath();
+    }
+    /** Directory containing this directory. */
+    get parentDirectory() {
+        return new Directory(Paths.join(this.uri, '..'));
+    }
+    /**
+     * Lists the contents of a directory. Calling this method if the parent directory does not
+     * exist will throw an error.
+     */
+    list() {
+        return super
+            .listAsRecords()
+            .map(({ isDirectory, uri }) => isDirectory ? new Directory(uri) : new File(uri));
+    }
+    /** Directory name. */
+    get name() {
+        return Paths.basename(this.uri);
+    }
+    createFile(name, mimeType) {
+        return new File(super.createFile(name, mimeType).uri);
+    }
+    createDirectory(name) {
+        return new Directory(super.createDirectory(name).uri);
+    }
+    /**
+     * Watches this directory for changes to its contents or the directory itself. 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.
+     */
+    watch(callback, options) {
+        return new FileSystemWatcher(this.uri, callback, options, (uri, isDirectory) => (isDirectory ? new Directory(uri) : new File(uri)));
+    }
+}
+Directory.pickDirectoryAsync = async function (initialUri) {
+    const directory = (await expoFileSystemNext.pickDirectoryAsync(initialUri))
+        .uri;
+    return new Directory(directory);
+};