@symbiote-native/file-system 0.1.0

package/build/next/network-tasks.js

@@ -0,0 +1,333 @@
+import { Directory } from './directory.js';
+import { File } from './file.js';
+import { expoFileSystemNext } from './native-module.js';
+import { FileSystemUploadType, } from './types.js';
+function createAbortError(reason) {
+    const message = typeof reason === 'string' ? reason : 'The operation was aborted.';
+    const error = new Error(message);
+    error.name = 'AbortError';
+    return error;
+}
+function assertNetworkTaskState(state, allowedStates, methodName) {
+    if (!allowedStates.includes(state)) {
+        throw new Error(`Cannot call ${methodName}() in state "${state}"`);
+    }
+}
+function wireNetworkTaskAbortSignal(signal, cancel) {
+    if (signal?.aborted) {
+        throw createAbortError();
+    }
+    if (signal) {
+        const abortHandler = () => cancel();
+        signal.addEventListener('abort', abortHandler, { once: true });
+        return abortHandler;
+    }
+    return undefined;
+}
+function wireNetworkTaskProgress(onProgress, addListener) {
+    if (onProgress) {
+        return addListener(onProgress);
+    }
+    return undefined;
+}
+function cleanupNetworkTask(signal, subscription, abortHandler) {
+    subscription?.remove();
+    if (abortHandler && signal) {
+        signal.removeEventListener('abort', abortHandler);
+    }
+}
+/**
+ * Represents an upload task with progress tracking and cancellation support.
+ *
+ * Upload tasks start in the `idle` state. Calling `uploadAsync()` moves the task to `active`,
+ * then to `completed`, `cancelled`, or `error`.
+ */
+export class UploadTask {
+    _state = 'idle';
+    _file;
+    _url;
+    _options;
+    _subscription;
+    _abortHandler;
+    _nativeTask;
+    /**
+     * Creates an upload task. The task does not start automatically — call `uploadAsync()` to
+     * begin uploading.
+     */
+    constructor(file, url, options) {
+        this._nativeTask = new expoFileSystemNext.FileSystemUploadTask();
+        this._file = file;
+        this._url = url;
+        this._options = options;
+    }
+    /** The current state of the upload task. */
+    get state() {
+        return this._state;
+    }
+    /**
+     * Starts the upload operation. 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`.
+     */
+    async uploadAsync() {
+        assertNetworkTaskState(this._state, ['idle'], 'uploadAsync');
+        this._state = 'active';
+        try {
+            this._abortHandler = wireNetworkTaskAbortSignal(this._options?.signal, () => this.cancel());
+            this._subscription = wireNetworkTaskProgress(this._options?.onProgress, listener => this.addListener('progress', listener));
+            const nativeOpts = {
+                httpMethod: this._options?.httpMethod || 'POST',
+                uploadType: this._options?.uploadType ?? FileSystemUploadType.BINARY_CONTENT,
+                headers: this._options?.headers,
+                fieldName: this._options?.fieldName,
+                mimeType: this._options?.mimeType,
+                parameters: this._options?.parameters,
+                sessionType: this._options?.sessionType,
+            };
+            const result = await this._nativeTask.start(this._url, this._file, nativeOpts);
+            this._state = 'completed';
+            // Emit a synthetic final progress to guarantee 100% is reported. Native progress events
+            // may not fire for small files, and even when they do, the event can race with promise
+            // resolution (listener removed before delivery).
+            if (this._options?.onProgress && this._file.exists) {
+                const size = this._file.size ?? 0;
+                if (size > 0) {
+                    this._options.onProgress({ bytesSent: size, totalBytes: size });
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            if (this._options?.signal?.aborted) {
+                this._state = 'cancelled';
+                throw createAbortError();
+            }
+            if (this.state === 'cancelled') {
+                throw error;
+            }
+            this._state = 'error';
+            throw error;
+        }
+        finally {
+            cleanupNetworkTask(this._options?.signal, this._subscription, this._abortHandler);
+            this._subscription = undefined;
+            this._abortHandler = undefined;
+        }
+    }
+    /**
+     * Adds a listener for upload progress events. Prefer the `onProgress` option unless manual
+     * subscription control is needed.
+     */
+    addListener(eventName, listener) {
+        return this._nativeTask.addListener(eventName, listener);
+    }
+    /** Releases the native task handle manually. */
+    release() {
+        this._nativeTask.release();
+    }
+    /**
+     * Cancels the upload operation. If `uploadAsync()` is pending, its promise is rejected after
+     * the native request is cancelled. Has no effect once the task reaches a terminal state.
+     */
+    cancel() {
+        if (['completed', 'cancelled', 'error'].includes(this._state))
+            return;
+        this._state = 'cancelled';
+        this._nativeTask.cancel();
+        cleanupNetworkTask(this._options?.signal, this._subscription, this._abortHandler);
+        this._subscription = undefined;
+        this._abortHandler = undefined;
+    }
+}
+/**
+ * Represents a download task with pause/resume support and progress tracking.
+ *
+ * Download tasks start in the `idle` state. Calling `downloadAsync()` moves the task to
+ * `active`; pausing moves it to `paused`, and a completed, cancelled, or failed transfer moves
+ * it to the corresponding terminal state.
+ */
+export class DownloadTask {
+    _state = 'idle';
+    _url;
+    _destination;
+    _options;
+    _resumeData;
+    _subscription;
+    _abortHandler;
+    _inFlightOperation;
+    _pauseRequest;
+    _nativeTask;
+    /**
+     * Creates a download task. The task does not start automatically — call `downloadAsync()` to
+     * begin downloading.
+     */
+    constructor(url, destination, options) {
+        this._nativeTask = new expoFileSystemNext.FileSystemDownloadTask();
+        this._url = url;
+        this._destination = destination;
+        this._options = options;
+    }
+    /** The current state of the download task. */
+    get state() {
+        return this._state;
+    }
+    /**
+     * Starts the download operation. Can only be called once, while the task is `idle`. Resolves
+     * with the downloaded file when the transfer completes, or with `null` if the task is paused
+     * before completion.
+     */
+    async downloadAsync() {
+        assertNetworkTaskState(this._state, ['idle'], 'downloadAsync');
+        this._state = 'active';
+        this._pauseRequest = undefined;
+        const operation = this._runDownloadOperation(() => this._nativeTask.start(this._url, this._destination, {
+            headers: this._options?.headers,
+            sessionType: this._options?.sessionType,
+        }));
+        this._inFlightOperation = operation;
+        return operation;
+    }
+    /**
+     * Requests pausing the active download operation. The pending `downloadAsync()`/`resumeAsync()`
+     * promise resolves with `null` once native code produces resume data. Use `pauseAsync()` to
+     * wait for that to happen.
+     */
+    pause() {
+        assertNetworkTaskState(this._state, ['active'], 'pause');
+        this._pauseRequest = Promise.resolve(this._nativeTask.pause()).then(result => {
+            this._resumeData = result?.resumeData ?? undefined;
+        });
+    }
+    /**
+     * Requests pausing the active download operation and waits until the task reaches the
+     * `paused` state.
+     */
+    async pauseAsync() {
+        this.pause();
+        await this._pauseRequest;
+        await this._inFlightOperation;
+    }
+    /**
+     * Resumes a paused download operation. Resolves with the downloaded file when the transfer
+     * completes, or with `null` if paused again before completion.
+     */
+    async resumeAsync() {
+        assertNetworkTaskState(this._state, ['paused'], 'resumeAsync');
+        if (!this._resumeData) {
+            throw new Error('No resume data available. Was the download paused before any data was received?');
+        }
+        this._state = 'active';
+        this._pauseRequest = undefined;
+        const operation = this._runDownloadOperation(() => this._nativeTask.resume(this._url, this._destination, this._resumeData, {
+            headers: this._options?.headers,
+            sessionType: this._options?.sessionType,
+        }));
+        this._inFlightOperation = operation;
+        return operation;
+    }
+    /**
+     * Adds a listener for download progress events. Prefer the `onProgress` option unless manual
+     * subscription control is needed.
+     */
+    addListener(eventName, listener) {
+        return this._nativeTask.addListener(eventName, listener);
+    }
+    /** Releases the native task handle manually. */
+    release() {
+        this._nativeTask.release();
+    }
+    /**
+     * Cancels the download operation. If `downloadAsync()`/`resumeAsync()` is pending, its promise
+     * is rejected after the native request is cancelled. Has no effect once the task reaches a
+     * terminal state.
+     */
+    cancel() {
+        if (['completed', 'cancelled', 'error'].includes(this._state))
+            return;
+        this._state = 'cancelled';
+        this._pauseRequest = undefined;
+        this._nativeTask.cancel();
+        cleanupNetworkTask(this._options?.signal, this._subscription, this._abortHandler);
+        this._subscription = undefined;
+        this._abortHandler = undefined;
+    }
+    /**
+     * Returns the paused task state that can be persisted and restored later. Can only be called
+     * while the task is `paused`.
+     */
+    savable() {
+        assertNetworkTaskState(this._state, ['paused'], 'savable');
+        return {
+            url: this._url,
+            fileUri: this._destination.uri,
+            isDirectory: this._destination instanceof Directory,
+            headers: this._options?.headers,
+            resumeData: this._resumeData,
+        };
+    }
+    /**
+     * Creates a paused download task from saved state, to continue a download after persisting the
+     * value returned by `savable()`.
+     */
+    static fromSavable(state, options) {
+        if (!state.resumeData) {
+            throw new Error('Cannot restore task: DownloadPauseState has no resumeData');
+        }
+        const dest = state.isDirectory
+            ? new Directory(state.fileUri)
+            : new File(state.fileUri);
+        const mergedOptions = options || state.headers
+            ? { ...options, headers: { ...state.headers, ...options?.headers } }
+            : undefined;
+        const task = new DownloadTask(state.url, dest, mergedOptions);
+        task._resumeData = state.resumeData;
+        task._state = 'paused';
+        return task;
+    }
+    async _runDownloadOperation(operation) {
+        try {
+            this._abortHandler = wireNetworkTaskAbortSignal(this._options?.signal, () => this.cancel());
+            this._subscription = wireNetworkTaskProgress(this._options?.onProgress, listener => this.addListener('progress', listener));
+            const result = await operation();
+            if (result) {
+                this._state = 'completed';
+                this._resumeData = undefined;
+                const file = new File(result);
+                this._emitFinalProgressEvent(file.size);
+                return file;
+            }
+            await this._pauseRequest;
+            this._state = 'paused';
+            return null;
+        }
+        catch (error) {
+            if (this._options?.signal?.aborted) {
+                this._state = 'cancelled';
+                throw createAbortError();
+            }
+            if (this.state === 'cancelled') {
+                throw error;
+            }
+            this._state = 'error';
+            throw error;
+        }
+        finally {
+            cleanupNetworkTask(this._options?.signal, this._subscription, this._abortHandler);
+            this._subscription = undefined;
+            this._abortHandler = undefined;
+            this._inFlightOperation = undefined;
+        }
+    }
+    _emitFinalProgressEvent(fileSize) {
+        // Emit a synthetic final progress to guarantee 100% is reported. Native progress events may
+        // not fire for small files, and even when they do, the event can race with promise
+        // resolution (listener removed before delivery).
+        if (this._options?.onProgress && fileSize > 0) {
+            this._options.onProgress({
+                bytesWritten: fileSize,
+                totalBytes: fileSize,
+            });
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+export declare function resolve(...args: string[]): string;
+export declare function normalize(path: string): string;
+export declare function isAbsolute(path: string): boolean;
+export declare function join(...args: string[]): string;
+export declare function relative(from: string, to: string): string;
+export declare function dirname(path: string): string;
+export declare function basename(path: string, suffix?: string): string;
+export declare function extname(path: string): string;
+export declare function parse(path: string): {
+    root: string;
+    dir: string;
+    base: string;
+    ext: string;
+    name: string;
+};
+export declare const sep = "/";

package/build/next/node-path.js

@@ -0,0 +1,353 @@
+// Ported verbatim from expo-file-system's own vendored copy of Node's posix `path` module
+// (Copyright Joyent, Inc. and other Node contributors, MIT licensed) — a self-contained,
+// mechanical algorithm with zero native dependency, so a straight port carries low risk.
+function isPathSeparator(code) {
+    return code === '/';
+}
+// Resolves . and .. elements in a path with directory names
+function normalizeString(path, allowAboveRoot, separator) {
+    let res = '';
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let code = '';
+    for (let i = 0; i <= path.length; ++i) {
+        if (i < path.length)
+            code = path.charAt(i);
+        else if (isPathSeparator(code))
+            break;
+        else
+            code = '/';
+        if (isPathSeparator(code)) {
+            if (lastSlash === i - 1 || dots === 1) {
+                // NOOP
+            }
+            else if (dots === 2) {
+                if (res.length < 2 ||
+                    lastSegmentLength !== 2 ||
+                    res.charAt(res.length - 1) !== '.' ||
+                    res.charAt(res.length - 2) !== '.') {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.lastIndexOf(separator);
+                        if (lastSlashIndex === -1) {
+                            res = '';
+                            lastSegmentLength = 0;
+                        }
+                        else {
+                            res = res.slice(0, lastSlashIndex);
+                            lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
+                        }
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                    else if (res.length !== 0) {
+                        res = '';
+                        lastSegmentLength = 0;
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    res += res.length > 0 ? `${separator}..` : '..';
+                    lastSegmentLength = 2;
+                }
+            }
+            else {
+                if (res.length > 0)
+                    res += `${separator}${path.slice(lastSlash + 1, i)}`;
+                else
+                    res = path.slice(lastSlash + 1, i);
+                lastSegmentLength = i - lastSlash - 1;
+            }
+            lastSlash = i;
+            dots = 0;
+        }
+        else if (code === '.' && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+export function resolve(...args) {
+    let resolvedPath = '';
+    let resolvedAbsolute = false;
+    for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        const path = i >= 0 ? args[i] : '';
+        if (!path || path.length === 0) {
+            continue;
+        }
+        resolvedPath = `${path}/${resolvedPath}`;
+        resolvedAbsolute = !!(path && path.charAt(0) === '/');
+    }
+    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/');
+    if (resolvedAbsolute) {
+        return `/${resolvedPath}`;
+    }
+    return resolvedPath.length > 0 ? resolvedPath : '.';
+}
+export function normalize(path) {
+    if (path.length === 0)
+        return '.';
+    const isAbsolute = path.charAt(0) === '/';
+    const trailingSeparator = path.charAt(path.length - 1) === '/';
+    path = normalizeString(path, !isAbsolute, '/');
+    if (path.length === 0) {
+        if (isAbsolute)
+            return '/';
+        return trailingSeparator ? './' : '.';
+    }
+    if (trailingSeparator)
+        path += '/';
+    return isAbsolute ? `/${path}` : path;
+}
+export function isAbsolute(path) {
+    return path.length > 0 && path.charAt(0) === '/';
+}
+export function join(...args) {
+    if (args.length === 0)
+        return '.';
+    const path = [];
+    for (let i = 0; i < args.length; ++i) {
+        const arg = args[i];
+        if (arg && arg.length > 0) {
+            path.push(arg);
+        }
+    }
+    if (path.length === 0)
+        return '.';
+    return normalize(path.join('/'));
+}
+export function relative(from, to) {
+    if (from === to)
+        return '';
+    from = resolve(from);
+    to = resolve(to);
+    if (from === to)
+        return '';
+    const fromStart = 1;
+    const fromEnd = from.length;
+    const fromLen = fromEnd - fromStart;
+    const toStart = 1;
+    const toLen = to.length - toStart;
+    const length = fromLen < toLen ? fromLen : toLen;
+    let lastCommonSep = -1;
+    let i = 0;
+    for (; i < length; i++) {
+        const fromChar = from.charAt(fromStart + i);
+        if (fromChar !== to.charAt(toStart + i))
+            break;
+        else if (fromChar === '/')
+            lastCommonSep = i;
+    }
+    if (i === length) {
+        if (toLen > length) {
+            if (to.charAt(toStart + i) === '/') {
+                return to.slice(toStart + i + 1);
+            }
+            if (i === 0) {
+                return to.slice(toStart + i);
+            }
+        }
+        else if (fromLen > length) {
+            if (from.charAt(fromStart + i) === '/') {
+                lastCommonSep = i;
+            }
+            else if (i === 0) {
+                lastCommonSep = 0;
+            }
+        }
+    }
+    let out = '';
+    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+        if (i === fromEnd || from.charAt(i) === '/') {
+            out += out.length === 0 ? '..' : '/..';
+        }
+    }
+    return `${out}${to.slice(toStart + lastCommonSep)}`;
+}
+export function dirname(path) {
+    if (path.length === 0)
+        return '.';
+    const hasRoot = path.charAt(0) === '/';
+    let end = -1;
+    let matchedSlash = true;
+    for (let i = path.length - 1; i >= 1; --i) {
+        if (path.charAt(i) === '/') {
+            if (!matchedSlash) {
+                end = i;
+                break;
+            }
+        }
+        else {
+            matchedSlash = false;
+        }
+    }
+    if (end === -1)
+        return hasRoot ? '/' : '.';
+    if (hasRoot && end === 1)
+        return '//';
+    return path.slice(0, end);
+}
+export function basename(path, suffix) {
+    let start = 0;
+    let end = -1;
+    let matchedSlash = true;
+    if (suffix !== undefined &&
+        suffix.length > 0 &&
+        suffix.length <= path.length) {
+        if (suffix === path)
+            return '';
+        let extIdx = suffix.length - 1;
+        let firstNonSlashEnd = -1;
+        for (let i = path.length - 1; i >= 0; --i) {
+            const code = path.charAt(i);
+            if (code === '/') {
+                if (!matchedSlash) {
+                    start = i + 1;
+                    break;
+                }
+            }
+            else {
+                if (firstNonSlashEnd === -1) {
+                    matchedSlash = false;
+                    firstNonSlashEnd = i + 1;
+                }
+                if (extIdx >= 0) {
+                    if (code === suffix.charAt(extIdx)) {
+                        if (--extIdx === -1) {
+                            end = i;
+                        }
+                    }
+                    else {
+                        extIdx = -1;
+                        end = firstNonSlashEnd;
+                    }
+                }
+            }
+        }
+        if (start === end)
+            end = firstNonSlashEnd;
+        else if (end === -1)
+            end = path.length;
+        return path.slice(start, end);
+    }
+    for (let i = path.length - 1; i >= 0; --i) {
+        if (path.charAt(i) === '/') {
+            if (!matchedSlash) {
+                start = i + 1;
+                break;
+            }
+        }
+        else if (end === -1) {
+            matchedSlash = false;
+            end = i + 1;
+        }
+    }
+    if (end === -1)
+        return '';
+    return path.slice(start, end);
+}
+export function extname(path) {
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    let preDotState = 0;
+    for (let i = path.length - 1; i >= 0; --i) {
+        const code = path.charAt(i);
+        if (code === '/') {
+            if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+            }
+            continue;
+        }
+        if (end === -1) {
+            matchedSlash = false;
+            end = i + 1;
+        }
+        if (code === '.') {
+            if (startDot === -1)
+                startDot = i;
+            else if (preDotState !== 1)
+                preDotState = 1;
+        }
+        else if (startDot !== -1) {
+            preDotState = -1;
+        }
+    }
+    if (startDot === -1 ||
+        end === -1 ||
+        preDotState === 0 ||
+        (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
+        return '';
+    }
+    return path.slice(startDot, end);
+}
+export function parse(path) {
+    const ret = { root: '', dir: '', base: '', ext: '', name: '' };
+    if (path.length === 0)
+        return ret;
+    const isAbsolutePath = path.charAt(0) === '/';
+    let start;
+    if (isAbsolutePath) {
+        ret.root = '/';
+        start = 1;
+    }
+    else {
+        start = 0;
+    }
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    let i = path.length - 1;
+    let preDotState = 0;
+    for (; i >= start; --i) {
+        const code = path.charAt(i);
+        if (code === '/') {
+            if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+            }
+            continue;
+        }
+        if (end === -1) {
+            matchedSlash = false;
+            end = i + 1;
+        }
+        if (code === '.') {
+            if (startDot === -1)
+                startDot = i;
+            else if (preDotState !== 1)
+                preDotState = 1;
+        }
+        else if (startDot !== -1) {
+            preDotState = -1;
+        }
+    }
+    if (end !== -1) {
+        const nameStart = startPart === 0 && isAbsolutePath ? 1 : startPart;
+        if (startDot === -1 ||
+            preDotState === 0 ||
+            (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
+            ret.base = ret.name = path.slice(nameStart, end);
+        }
+        else {
+            ret.name = path.slice(nameStart, startDot);
+            ret.base = path.slice(nameStart, end);
+            ret.ext = path.slice(startDot, end);
+        }
+    }
+    if (startPart > 0)
+        ret.dir = path.slice(0, startPart - 1);
+    else if (isAbsolutePath)
+        ret.dir = '/';
+    return ret;
+}
+export const sep = '/';