@symbiote-native/file-system 0.1.0

package/build/next/path-utilities.d.ts

@@ -0,0 +1,42 @@
+import type { File } from './file';
+import type { Directory } from './directory';
+export declare class PathUtilities {
+    /**
+     * Joins path segments into a single path.
+     */
+    static join(...paths: (string | File | Directory)[]): string;
+    /**
+     * Resolves a relative path to an absolute path.
+     */
+    static relative(from: string | File | Directory, to: string | File | Directory): string;
+    /**
+     * Checks if a path is absolute.
+     */
+    static isAbsolute(path: string | File | Directory): boolean;
+    /**
+     * Normalizes a path.
+     */
+    static normalize(path: string | File | Directory): string;
+    /**
+     * Returns the directory name of a path.
+     */
+    static dirname(path: string | File | Directory): string;
+    /**
+     * Returns the base name of a path.
+     */
+    static basename(path: string | File | Directory, ext?: string): string;
+    /**
+     * Returns the extension of a path.
+     */
+    static extname(path: string | File | Directory): string;
+    /**
+     * Parses a path into its components.
+     */
+    static parse(path: string | File | Directory): {
+        root: string;
+        dir: string;
+        base: string;
+        ext: string;
+        name: string;
+    };
+}

package/build/next/path-utilities.js

@@ -0,0 +1,110 @@
+import * as nodePath from './node-path.js';
+import { asUrl, isUrl, encodeURLChars } from './url-utilities.js';
+function uriObjectToString(path) {
+    return typeof path === 'string' ? path : path.uri;
+}
+// React Native's own ambient `URL` type (react-native/src/types/globals.d.ts) declares every
+// property but `search` as readonly, so a new pathname is applied by reconstructing the URL
+// rather than assigning `.pathname` in place — matching what a real setter would do internally.
+// Built from `.protocol`/`.host` rather than `.origin`, because `file://` URLs report `.origin`
+// as the literal string `"null"` per spec.
+function withPathname(url, pathname) {
+    return new URL(`${url.protocol}//${url.host}${pathname}${url.search}${url.hash}`);
+}
+export class PathUtilities {
+    /**
+     * Joins path segments into a single path.
+     */
+    static join(...paths) {
+        const [firstSegment = '', ...rest] = paths.map(uriObjectToString);
+        const pathAsUrl = asUrl(firstSegment);
+        if (pathAsUrl) {
+            const joined = nodePath.join(pathAsUrl.pathname, ...rest.map(encodeURLChars));
+            return withPathname(pathAsUrl, joined).toString();
+        }
+        return nodePath.join(firstSegment, ...rest.map(encodeURLChars));
+    }
+    /**
+     * Resolves a relative path to an absolute path.
+     */
+    static relative(from, to) {
+        let fromPath = from;
+        let toPath = to;
+        const fromString = uriObjectToString(from);
+        const toString = uriObjectToString(to);
+        if (isUrl(fromString)) {
+            fromPath = asUrl(fromString).pathname;
+        }
+        if (isUrl(toString)) {
+            toPath = asUrl(toString).pathname;
+        }
+        return nodePath.relative(uriObjectToString(fromPath), uriObjectToString(toPath));
+    }
+    /**
+     * Checks if a path is absolute.
+     */
+    static isAbsolute(path) {
+        const pathString = uriObjectToString(path);
+        if (isUrl(pathString)) {
+            return true;
+        }
+        return nodePath.isAbsolute(pathString);
+    }
+    /**
+     * Normalizes a path.
+     */
+    static normalize(path) {
+        const pathString = uriObjectToString(path);
+        const pathURL = asUrl(encodeURLChars(pathString));
+        if (pathURL) {
+            const normalized = encodeURLChars(nodePath.normalize(decodeURIComponent(pathURL.pathname)));
+            return withPathname(pathURL, normalized).toString();
+        }
+        return nodePath.normalize(pathString);
+    }
+    /**
+     * Returns the directory name of a path.
+     */
+    static dirname(path) {
+        const pathString = uriObjectToString(path);
+        const pathURL = asUrl(pathString);
+        if (pathURL) {
+            const dirnamePath = encodeURLChars(nodePath.dirname(decodeURIComponent(pathURL.pathname)));
+            return withPathname(pathURL, dirnamePath).toString();
+        }
+        return nodePath.dirname(pathString);
+    }
+    /**
+     * Returns the base name of a path.
+     */
+    static basename(path, ext) {
+        const pathString = uriObjectToString(path);
+        const pathURL = asUrl(pathString);
+        if (pathURL) {
+            return nodePath.basename(decodeURIComponent(pathURL.pathname));
+        }
+        return nodePath.basename(pathString, ext);
+    }
+    /**
+     * Returns the extension of a path.
+     */
+    static extname(path) {
+        const pathString = uriObjectToString(path);
+        const pathURL = asUrl(pathString);
+        if (pathURL) {
+            return nodePath.extname(decodeURIComponent(pathURL.pathname));
+        }
+        return nodePath.extname(pathString);
+    }
+    /**
+     * Parses a path into its components.
+     */
+    static parse(path) {
+        const pathString = uriObjectToString(path);
+        const pathURL = asUrl(pathString);
+        if (pathURL) {
+            return nodePath.parse(decodeURIComponent(pathURL.pathname));
+        }
+        return nodePath.parse(pathString);
+    }
+}

package/build/next/paths.d.ts

@@ -0,0 +1,22 @@
+import { Directory } from './directory';
+import { PathUtilities } from './path-utilities';
+import type { IPathInfo } from './types';
+export declare class Paths extends PathUtilities {
+    /**
+     * A place to store files that can be deleted by the system when the device runs low on
+     * storage.
+     */
+    static get cache(): Directory;
+    /** The directory where assets bundled with the application are stored. */
+    static get bundle(): Directory;
+    /** A place to store files that are safe from being deleted by the system. */
+    static get document(): Directory;
+    /** @platform ios */
+    static get appleSharedContainers(): Record<string, Directory>;
+    /** The total space on the device's internal storage, in bytes. */
+    static get totalDiskSpace(): number;
+    /** The available space on the device's internal storage, in bytes. */
+    static get availableDiskSpace(): number;
+    /** Returns an object that indicates if the specified path represents a directory. */
+    static info(...uris: string[]): IPathInfo;
+}

package/build/next/paths.js

@@ -0,0 +1,43 @@
+import { Directory } from './directory.js';
+import { expoFileSystemNext } from './native-module.js';
+import { PathUtilities } from './path-utilities.js';
+export class Paths extends PathUtilities {
+    /**
+     * A place to store files that can be deleted by the system when the device runs low on
+     * storage.
+     */
+    static get cache() {
+        return new Directory(expoFileSystemNext.cacheDirectory);
+    }
+    /** The directory where assets bundled with the application are stored. */
+    static get bundle() {
+        return new Directory(expoFileSystemNext.bundleDirectory);
+    }
+    /** A place to store files that are safe from being deleted by the system. */
+    static get document() {
+        return new Directory(expoFileSystemNext.documentDirectory);
+    }
+    /** @platform ios */
+    static get appleSharedContainers() {
+        const containers = expoFileSystemNext.appleSharedContainers ?? {};
+        const result = {};
+        for (const appGroupId in containers) {
+            if (containers[appGroupId]) {
+                result[appGroupId] = new Directory(containers[appGroupId]);
+            }
+        }
+        return result;
+    }
+    /** The total space on the device's internal storage, in bytes. */
+    static get totalDiskSpace() {
+        return expoFileSystemNext.totalDiskSpace;
+    }
+    /** The available space on the device's internal storage, in bytes. */
+    static get availableDiskSpace() {
+        return expoFileSystemNext.availableDiskSpace;
+    }
+    /** Returns an object that indicates if the specified path represents a directory. */
+    static info(...uris) {
+        return expoFileSystemNext.info(uris.join('/'));
+    }
+}

package/build/next/streams.d.ts

@@ -0,0 +1,25 @@
+import type { IFileSystemHandle } from './types';
+type IReadableByteStreamController = {
+    readonly byobRequest: {
+        view: ArrayBufferView | null;
+        respond(bytesWritten: number): void;
+    } | null;
+    close(): void;
+    enqueue(chunk: Uint8Array): void;
+};
+export declare class FileSystemReadableStreamSource {
+    handle: IFileSystemHandle;
+    size: number;
+    type: "bytes";
+    constructor(handle: IFileSystemHandle);
+    cancel(): void;
+    pull(controller: IReadableByteStreamController): void;
+}
+export declare class FileSystemWritableSink {
+    handle: IFileSystemHandle;
+    constructor(handle: IFileSystemHandle);
+    abort(): void;
+    close(): void;
+    write(chunk: Uint8Array): void;
+}
+export {};

package/build/next/streams.js

@@ -0,0 +1,55 @@
+export class FileSystemReadableStreamSource {
+    handle;
+    size = 1024;
+    type = 'bytes';
+    constructor(handle) {
+        this.handle = handle;
+    }
+    cancel() {
+        this.handle.close();
+    }
+    pull(controller) {
+        const theView = controller.byobRequest?.view;
+        if (!theView) {
+            const bytes = this.handle.readBytes(this.size);
+            if (bytes.length === 0) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(bytes);
+            return;
+        }
+        // TODO: Optimize by adding a native method that can write into a TypedArray at a given offset.
+        const bytes = this.handle.readBytes(theView.byteLength - theView.byteOffset);
+        if (bytes.length === 0) {
+            controller.close();
+            controller.byobRequest.respond(0);
+            return;
+        }
+        if (theView instanceof Uint8Array) {
+            theView.set(bytes, theView.byteOffset);
+        }
+        else {
+            const array = new Uint8Array(theView.buffer);
+            for (let i = 0; i < bytes.length; i++) {
+                array[i + (theView.byteOffset ?? 0)] = bytes[i];
+            }
+        }
+        controller.byobRequest.respond(bytes.length);
+    }
+}
+export class FileSystemWritableSink {
+    handle;
+    constructor(handle) {
+        this.handle = handle;
+    }
+    abort() {
+        this.close();
+    }
+    close() {
+        this.handle.close();
+    }
+    write(chunk) {
+        this.handle.writeBytes(chunk);
+    }
+}

package/build/next/types.d.ts

@@ -0,0 +1,152 @@
+import type { File } from './file';
+import type { Directory } from './directory';
+export type IFileCreateOptions = {
+    intermediates?: boolean;
+    overwrite?: boolean;
+};
+export type IRelocationOptions = {
+    overwrite?: boolean;
+};
+export declare enum FileSystemEncodingType {
+    UTF8 = "utf8",
+    Base64 = "base64"
+}
+export type IFileWriteOptions = {
+    encoding?: FileSystemEncodingType | 'utf8' | 'base64';
+    append?: boolean;
+};
+export declare enum FileMode {
+    ReadWrite = "rw",
+    ReadOnly = "r",
+    WriteOnly = "w",
+    Append = "wa",
+    Truncate = "wt"
+}
+export type IFileSystemHandle = {
+    close(): void;
+    readBytes(length: number): Uint8Array<ArrayBuffer>;
+    writeBytes(bytes: Uint8Array): void;
+    offset: number | null;
+    size: number | null;
+};
+export type IFileInfo = {
+    exists: boolean;
+    uri?: string;
+    size?: number;
+    modificationTime?: number;
+    creationTime?: number;
+    md5?: string;
+};
+export type IFileSystemInfoOptions = {
+    md5?: boolean;
+};
+export type IPickFileGeneralOptions = {
+    initialUri?: string;
+    mimeTypes?: string | string[];
+    multipleFiles?: boolean;
+};
+export type IPickSingleFileOptions = IPickFileGeneralOptions & {
+    multipleFiles?: false;
+};
+export type IPickMultipleFilesOptions = IPickFileGeneralOptions & {
+    multipleFiles: true;
+};
+export type IPickFileOptions = IPickSingleFileOptions | IPickMultipleFilesOptions;
+export type IPickSingleFileSuccessResult = {
+    result: File;
+    canceled: false;
+};
+export type IPickMultipleFilesSuccessResult = {
+    result: File[];
+    canceled: false;
+};
+export type IPickFileCanceledResult = {
+    result: null;
+    canceled: true;
+};
+export type IPickSingleFileResult = IPickSingleFileSuccessResult | IPickFileCanceledResult;
+export type IPickMultipleFilesResult = IPickMultipleFilesSuccessResult | IPickFileCanceledResult;
+export type IDirectoryCreateOptions = {
+    intermediates?: boolean;
+    overwrite?: boolean;
+    idempotent?: boolean;
+};
+export type IDirectoryInfo = {
+    exists: boolean;
+    uri?: string;
+    size?: number;
+    modificationTime?: number;
+    creationTime?: number;
+    files?: string[];
+};
+export type IPathInfo = {
+    exists: boolean;
+    isDirectory: boolean | null;
+};
+export type IFileSystemDownloadProgress = {
+    bytesWritten: number;
+    totalBytes: number;
+};
+export type IFileSystemDownloadOptions = {
+    headers?: Record<string, string>;
+    idempotent?: boolean;
+    onProgress?: (data: IFileSystemDownloadProgress) => void;
+    signal?: AbortSignal;
+};
+export declare enum FileSystemUploadType {
+    BINARY_CONTENT = 0,
+    MULTIPART = 1
+}
+export type IFileSystemUploadProgress = {
+    bytesSent: number;
+    totalBytes: number;
+};
+export type IFileSystemUploadResult = {
+    body: string;
+    status: number;
+    headers: Record<string, string>;
+};
+export type IFileSystemNetworkTaskSessionType = 'background' | 'foreground';
+export type IFileSystemUploadOptions = {
+    httpMethod?: 'POST' | 'PUT' | 'PATCH';
+    uploadType?: FileSystemUploadType;
+    headers?: Record<string, string>;
+    fieldName?: string;
+    mimeType?: string;
+    parameters?: Record<string, string>;
+    onProgress?: (data: IFileSystemUploadProgress) => void;
+    sessionType?: IFileSystemNetworkTaskSessionType;
+    signal?: AbortSignal;
+};
+export type IFileSystemDownloadTaskOptions = {
+    headers?: Record<string, string>;
+    sessionType?: IFileSystemNetworkTaskSessionType;
+    onProgress?: (data: IFileSystemDownloadProgress) => void;
+    signal?: AbortSignal;
+};
+export type IFileSystemDownloadPauseState = {
+    url: string;
+    fileUri: string;
+    isDirectory: boolean;
+    headers?: Record<string, string>;
+    resumeData?: string;
+};
+type IFileSystemTaskState = 'idle' | 'active' | 'paused' | 'completed' | 'cancelled' | 'error';
+export type IFileSystemUploadTaskState = Exclude<IFileSystemTaskState, 'paused'>;
+export type IFileSystemDownloadTaskState = IFileSystemTaskState;
+export declare const DEFAULT_WATCH_DEBOUNCE_MS = 100;
+export type IFileSystemWatchEventType = 'created' | 'modified' | 'deleted' | 'renamed';
+export type IFileSystemWatchEvent<T extends File | Directory> = {
+    type: IFileSystemWatchEventType;
+    target: T;
+    nativeEventFlags?: number;
+    newTarget?: T;
+};
+export type IFileSystemWatchOptions = {
+    debounce?: number;
+    events?: IFileSystemWatchEventType[];
+};
+export type IFileSystemWatchSubscription = {
+    remove(): void;
+};
+export {};

package/build/next/types.js

@@ -0,0 +1,19 @@
+export var FileSystemEncodingType;
+(function (FileSystemEncodingType) {
+    FileSystemEncodingType["UTF8"] = "utf8";
+    FileSystemEncodingType["Base64"] = "base64";
+})(FileSystemEncodingType || (FileSystemEncodingType = {}));
+export var FileMode;
+(function (FileMode) {
+    FileMode["ReadWrite"] = "rw";
+    FileMode["ReadOnly"] = "r";
+    FileMode["WriteOnly"] = "w";
+    FileMode["Append"] = "wa";
+    FileMode["Truncate"] = "wt";
+})(FileMode || (FileMode = {}));
+export var FileSystemUploadType;
+(function (FileSystemUploadType) {
+    FileSystemUploadType[FileSystemUploadType["BINARY_CONTENT"] = 0] = "BINARY_CONTENT";
+    FileSystemUploadType[FileSystemUploadType["MULTIPART"] = 1] = "MULTIPART";
+})(FileSystemUploadType || (FileSystemUploadType = {}));
+export const DEFAULT_WATCH_DEBOUNCE_MS = 100;

package/build/next/url-utilities.d.ts

@@ -0,0 +1,3 @@
+export declare function encodeURLChars(path: string): string;
+export declare function isUrl(url: string): boolean;
+export declare function asUrl(url: string | URL): URL | null;

package/build/next/url-utilities.js

@@ -0,0 +1,62 @@
+// Ported verbatim from expo-file-system's own vendored copy (Copyright Joyent, Inc. and other
+// Node contributors, MIT licensed) — url-encoding helpers used when a path is a `file://`/URL
+// rather than a bare posix path.
+import { resolve, sep } from './node-path.js';
+const percentRegEx = /%/g;
+const backslashRegEx = /\\/g;
+const newlineRegEx = /\n/g;
+const carriageReturnRegEx = /\r/g;
+const tabRegEx = /\t/g;
+const questionRegex = /\?/g;
+const hashRegex = /#/g;
+const spaceRegEx = / /g;
+function encodePathChars(filepath) {
+    if (filepath.indexOf('%') !== -1)
+        filepath = filepath.replace(percentRegEx, '%25');
+    if (filepath.indexOf('\\') !== -1)
+        filepath = filepath.replace(backslashRegEx, '%5C');
+    if (filepath.indexOf('\n') !== -1)
+        filepath = filepath.replace(newlineRegEx, '%0A');
+    if (filepath.indexOf('\r') !== -1)
+        filepath = filepath.replace(carriageReturnRegEx, '%0D');
+    if (filepath.indexOf('\t') !== -1)
+        filepath = filepath.replace(tabRegEx, '%09');
+    if (filepath.indexOf(' ') !== -1)
+        filepath = filepath.replace(spaceRegEx, '%20');
+    return filepath;
+}
+export function encodeURLChars(path) {
+    let resolved = resolve(path);
+    const filePathLast = path.charAt(path.length - 1);
+    if (filePathLast === '/' && resolved[resolved.length - 1] !== sep)
+        resolved += '/';
+    resolved = encodePathChars(resolved);
+    if (resolved.indexOf('?') !== -1)
+        resolved = resolved.replace(questionRegex, '%3F');
+    if (resolved.indexOf('#') !== -1)
+        resolved = resolved.replace(hashRegex, '%23');
+    return resolved;
+}
+export function isUrl(url) {
+    try {
+        return !!new URL(url);
+    }
+    catch {
+        return false;
+    }
+}
+export function asUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.hash === '') {
+            return parsed;
+        }
+        // Strip the hash by reconstructing rather than assigning `.hash = ''` — this project's
+        // resolved `URL` type declares its setters read-only (see path-utilities.ts's own note).
+        const hashIndex = parsed.href.indexOf('#');
+        return new URL(hashIndex === -1 ? parsed.href : parsed.href.slice(0, hashIndex));
+    }
+    catch {
+        return null;
+    }
+}

package/build/next/watcher.d.ts

@@ -0,0 +1,19 @@
+import type { Directory } from './directory';
+import type { File } from './file';
+import type { IFileSystemWatchEvent, IFileSystemWatchOptions, IFileSystemWatchSubscription } from './types';
+type ITargetFactory<T> = (uri: string, isDirectory: boolean) => T;
+/**
+ * @hidden
+ * Internal implementation of file system watching. Use `File.watch()` or `Directory.watch()` instead.
+ */
+export declare class FileSystemWatcher<T extends File | Directory> implements IFileSystemWatchSubscription {
+    private readonly targetFactory;
+    private nativeWatcher;
+    private subscription;
+    private removed;
+    private readonly normalizedWatchedPath;
+    constructor(path: string, callback: (event: IFileSystemWatchEvent<T>) => void, options: IFileSystemWatchOptions | undefined, targetFactory: ITargetFactory<T>);
+    private mapEvent;
+    remove(): void;
+}
+export {};

package/build/next/watcher.js

@@ -0,0 +1,64 @@
+import { expoFileSystemNext, } from './native-module.js';
+import { DEFAULT_WATCH_DEBOUNCE_MS } from './types.js';
+function normalizePath(path) {
+    return path.replace(/\/+$/, '');
+}
+/**
+ * @hidden
+ * Internal implementation of file system watching. Use `File.watch()` or `Directory.watch()` instead.
+ */
+export class FileSystemWatcher {
+    targetFactory;
+    nativeWatcher;
+    subscription = null;
+    removed = false;
+    normalizedWatchedPath;
+    constructor(path, callback, options = {}, targetFactory) {
+        this.targetFactory = targetFactory;
+        this.normalizedWatchedPath = normalizePath(path);
+        this.nativeWatcher = new expoFileSystemNext.FileSystemWatcher(path, {
+            debounce: options.debounce ?? DEFAULT_WATCH_DEBOUNCE_MS,
+            events: options.events,
+        });
+        this.subscription = this.nativeWatcher.addListener('change', (raw) => {
+            const event = this.mapEvent(raw);
+            const isWatchedTarget = normalizePath(raw.path) === this.normalizedWatchedPath;
+            if (!options.events || options.events.includes(event.type)) {
+                callback(event);
+            }
+            if ((event.type === 'deleted' || event.type === 'renamed') &&
+                isWatchedTarget) {
+                this.remove();
+            }
+        });
+        try {
+            this.nativeWatcher.start();
+        }
+        catch (error) {
+            this.subscription.remove();
+            this.subscription = null;
+            this.nativeWatcher = null;
+            throw error;
+        }
+    }
+    mapEvent(raw) {
+        return {
+            type: raw.type,
+            target: this.targetFactory(raw.path, raw.isDirectory),
+            newTarget: raw.newPath
+                ? this.targetFactory(raw.newPath, raw.newPathIsDirectory ?? raw.isDirectory)
+                : undefined,
+            nativeEventFlags: raw.nativeEventFlags,
+        };
+    }
+    remove() {
+        if (this.removed) {
+            return;
+        }
+        this.removed = true;
+        this.subscription?.remove();
+        this.subscription = null;
+        this.nativeWatcher?.stop();
+        this.nativeWatcher = null;
+    }
+}

package/build-ngc/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../next';

package/build-ngc/angular/index.js

@@ -0,0 +1,2 @@
+export * from '../next';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/build-ngc/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;
+}