react-native-buffered-blob 1.0.0

package/src/paths.ts

@@ -0,0 +1,35 @@
+import { NativeModule } from './module';
+
+const constants = NativeModule.getConstants();
+
+export const Dirs = Object.freeze({
+  document: constants.documentDir,
+  cache: constants.cacheDir,
+  temp: constants.tempDir,
+  download: constants.downloadDir,
+});
+
+export function join(...parts: string[]): string {
+  const result = parts.filter(Boolean).join('/').replace(/\/+/g, '/');
+  return result.length > 1 ? result.replace(/\/$/, '') : result;
+}
+
+export function dirname(path: string): string {
+  const idx = path.lastIndexOf('/');
+  return idx === -1 ? '.' : path.substring(0, idx);
+}
+
+export function basename(path: string, ext?: string): string {
+  const idx = path.lastIndexOf('/');
+  const name = idx === -1 ? path : path.substring(idx + 1);
+  if (ext && name.endsWith(ext)) {
+    return name.substring(0, name.length - ext.length);
+  }
+  return name;
+}
+
+export function extname(path: string): string {
+  const name = basename(path);
+  const idx = name.lastIndexOf('.');
+  return idx <= 0 ? '' : name.substring(idx);
+}

package/src/types.ts

@@ -0,0 +1,42 @@
+// NOTE: Enums changed from numeric (Nitro) to string (Turbo Module compatibility)
+export enum HashAlgorithm {
+  SHA256 = 'sha256',
+  MD5 = 'md5',
+}
+
+export enum FileType {
+  FILE = 'file',
+  DIRECTORY = 'directory',
+  UNKNOWN = 'unknown',
+}
+
+export interface FileInfo {
+  path: string;
+  name: string;
+  size: number;
+  type: FileType;
+  lastModified: number;
+}
+
+export interface DownloadProgress {
+  bytesDownloaded: number;
+  totalBytes: number;
+  progress: number;
+}
+
+export interface BlobReader extends Disposable {
+  readonly handleId: number;
+  readonly fileSize: number;
+  readonly bytesRead: number;
+  readonly isEOF: boolean;
+  readNextChunk(): Promise<ArrayBuffer | null>;
+  close(): void;
+}
+
+export interface BlobWriter extends Disposable {
+  readonly handleId: number;
+  readonly bytesWritten: number;
+  write(data: ArrayBuffer): Promise<number>;
+  flush(): Promise<void>;
+  close(): void;
+}

package/src/wrappers.ts

@@ -0,0 +1,123 @@
+import type { StreamingProxy } from './module';
+import type { BlobReader, BlobWriter } from './types';
+import { BlobError, ErrorCode } from './errors';
+
+/**
+ * Wraps a native reader handle with explicit getter delegation.
+ * IMPORTANT: Does NOT use spread operator on HostObject (getters would be lost).
+ * Instead, proxies each property access through getReaderInfo().
+ */
+export function wrapReader(
+  handleId: number,
+  streaming: StreamingProxy
+): BlobReader {
+  let closed = false;
+
+  return {
+    get handleId() {
+      return handleId;
+    },
+    get fileSize() {
+      return streaming.getReaderInfo(handleId).fileSize;
+    },
+    get bytesRead() {
+      return streaming.getReaderInfo(handleId).bytesRead;
+    },
+    get isEOF() {
+      return streaming.getReaderInfo(handleId).isEOF;
+    },
+    readNextChunk() {
+      if (closed) {
+        throw new BlobError(
+          ErrorCode.READER_CLOSED,
+          'Reader is already closed'
+        );
+      }
+      return streaming.readNextChunk(handleId);
+    },
+    close() {
+      if (!closed) {
+        closed = true;
+        streaming.close(handleId);
+      }
+    },
+    [Symbol.dispose]() {
+      if (!closed) {
+        closed = true;
+        streaming.close(handleId);
+      }
+    },
+  };
+}
+
+/**
+ * Wraps a native writer handle with explicit getter delegation.
+ * IMPORTANT: Does NOT use spread operator on HostObject (getters would be lost).
+ */
+export function wrapWriter(
+  handleId: number,
+  streaming: StreamingProxy
+): BlobWriter {
+  let closed = false;
+
+  return {
+    get handleId() {
+      return handleId;
+    },
+    get bytesWritten() {
+      return streaming.getWriterInfo(handleId).bytesWritten;
+    },
+    /**
+     * Write data to the file.
+     *
+     * **Backpressure warning:** Each call queues data to the native write
+     * pipeline. You MUST await each write() call before issuing the next
+     * one. Failing to await writes can cause unbounded memory growth as
+     * ArrayBuffer copies accumulate in the native queue.
+     *
+     * @example
+     * ```ts
+     * // Correct - sequential writes with await
+     * for (const chunk of chunks) {
+     *   await writer.write(chunk);
+     * }
+     *
+     * // WRONG - parallel writes without backpressure
+     * chunks.forEach(chunk => writer.write(chunk)); // Do NOT do this
+     * ```
+     *
+     * @param data - The ArrayBuffer to write
+     * @returns Promise resolving to the number of bytes written
+     */
+    write(data: ArrayBuffer) {
+      if (closed) {
+        throw new BlobError(
+          ErrorCode.WRITER_CLOSED,
+          'Writer is already closed'
+        );
+      }
+      return streaming.write(handleId, data);
+    },
+    flush() {
+      if (closed) {
+        throw new BlobError(
+          ErrorCode.WRITER_CLOSED,
+          'Writer is already closed'
+        );
+      }
+      return streaming.flush(handleId);
+    },
+    close() {
+      if (!closed) {
+        closed = true;
+        streaming.close(handleId);
+      }
+    },
+    [Symbol.dispose]() {
+      if (!closed) {
+        closed = true;
+        streaming.close(handleId);
+      }
+    },
+  };
+}