@peerbit/please-lib 2.0.1 → 2.0.2

package/lib/esm/index.d.ts

@@ -3,22 +3,35 @@ import { Documents } from "@peerbit/document";
 import { PublicSignKey } from "@peerbit/crypto";
 import { TrustedNetwork } from "@peerbit/trusted-network";
 import { ReplicationOptions } from "@peerbit/shared-log";
+type FileReadOptions = {
+    timeout?: number;
+    progress?: (progress: number) => any;
+};
+export interface ReReadableChunkSource {
+    size: bigint;
+    readChunks(chunkSize: number): AsyncIterable<Uint8Array>;
+}
+interface ChunkWritable {
+    write(chunk: Uint8Array): Promise<void> | void;
+    close?(): Promise<void> | void;
+    abort?(reason?: unknown): Promise<void> | void;
+}
 export declare abstract class AbstractFile {
     abstract id: string;
     abstract name: string;
-    abstract size: number;
+    abstract size: bigint;
     abstract parentId?: string;
-    abstract getFile<OutputType extends "chunks" | "joined" = "joined", Output = OutputType extends "chunks" ? Uint8Array[] : Uint8Array>(files: Files, properties?: {
+    abstract streamFile(files: Files, properties?: FileReadOptions): AsyncIterable<Uint8Array>;
+    getFile<OutputType extends "chunks" | "joined" = "joined", Output = OutputType extends "chunks" ? Uint8Array[] : Uint8Array>(files: Files, properties?: {
         as: OutputType;
-        timeout?: number;
-        progress?: (progress: number) => any;
-    }): Promise<Output>;
+    } & FileReadOptions): Promise<Output>;
+    writeFile(files: Files, writable: ChunkWritable, properties?: FileReadOptions): Promise<void>;
     abstract delete(files: Files): Promise<void>;
 }
 export declare class IndexableFile {
     id: string;
     name: string;
-    size: number;
+    size: bigint;
     parentId?: string;
     constructor(file: AbstractFile);
 }
@@ -26,40 +39,43 @@ export declare class TinyFile extends AbstractFile {
     id: string;
     name: string;
     file: Uint8Array;
+    hash: string;
     parentId?: string;
-    get size(): number;
+    index?: number;
+    get size(): bigint;
     constructor(properties: {
         id?: string;
         name: string;
         file: Uint8Array;
+        hash?: string;
         parentId?: string;
+        index?: number;
     });
-    getFile<OutputType extends "chunks" | "joined" = "joined", Output = OutputType extends "chunks" ? Uint8Array[] : Uint8Array>(_files: Files, properties?: {
-        as: OutputType;
-        progress?: (progress: number) => any;
-    }): Promise<Output>;
+    streamFile(_files: Files, properties?: FileReadOptions): AsyncIterable<Uint8Array>;
     delete(): Promise<void>;
 }
 export declare class LargeFile extends AbstractFile {
     id: string;
     name: string;
-    fileIds: string[];
-    size: number;
+    size: bigint;
+    chunkCount: number;
+    ready: boolean;
+    finalHash?: string;
     constructor(properties: {
-        id: string;
+        id?: string;
         name: string;
-        fileIds: string[];
-        size: number;
+        size: bigint;
+        chunkCount: number;
+        ready?: boolean;
+        finalHash?: string;
     });
-    static create(name: string, file: Uint8Array, files: Files, progress?: (progress: number) => void): Promise<LargeFile>;
     get parentId(): undefined;
-    fetchChunks(files: Files): Promise<import("@peerbit/document").WithIndexedContext<AbstractFile, IndexableFile>[]>;
-    delete(files: Files): Promise<void>;
-    getFile<OutputType extends "chunks" | "joined" = "joined", Output = OutputType extends "chunks" ? Uint8Array[] : Uint8Array>(files: Files, properties?: {
-        as: OutputType;
+    fetchChunks(files: Files, properties?: {
         timeout?: number;
-        progress?: (progress: number) => any;
-    }): Promise<Output>;
+    }): Promise<TinyFile[]>;
+    delete(files: Files): Promise<void>;
+    private resolveChunk;
+    streamFile(files: Files, properties?: FileReadOptions): AsyncIterable<Uint8Array>;
 }
 type Args = {
     replicate: ReplicationOptions;
@@ -69,16 +85,29 @@ export declare class Files extends Program<Args> {
     name: string;
     trustGraph?: TrustedNetwork;
     files: Documents<AbstractFile, IndexableFile>;
+    persistChunkReads: boolean;
     constructor(properties?: {
         id?: Uint8Array;
         name?: string;
         rootKey?: PublicSignKey;
     });
-    add(name: string, file: Uint8Array, parentId?: string, progress?: (progress: number) => void): Promise<string>;
+    add(name: string, file: Uint8Array | Blob, parentId?: string, progress?: (progress: number) => void): Promise<string>;
+    addBlob(name: string, file: Blob, parentId?: string, progress?: (progress: number) => void): Promise<string>;
+    addSource(name: string, source: ReReadableChunkSource, parentId?: string, progress?: (progress: number) => void): Promise<string>;
+    private cleanupChunkedUpload;
+    private addChunkedFile;
     removeById(id: string): Promise<void>;
     removeByName(name: string): Promise<void>;
     list(): Promise<import("@peerbit/document").WithIndexedContext<AbstractFile, IndexableFile>[]>;
     countLocalChunks(parent: LargeFile): Promise<number>;
+    resolveById(id: string, properties?: {
+        timeout?: number;
+        replicate?: boolean;
+    }): Promise<AbstractFile | undefined>;
+    resolveByName(name: string, properties?: {
+        timeout?: number;
+        replicate?: boolean;
+    }): Promise<AbstractFile | undefined>;
     /**
      * Get by name
      * @param id