sliftutils 1.2.37 → 1.2.38

package/index.d.ts

@@ -929,6 +929,9 @@ declare module "sliftutils/storage/FileFolderAPI" {
             size: number;
             lastModified: number;
             arrayBuffer(): Promise<ArrayBuffer>;
+            slice(start: number, end: number): {
+                arrayBuffer(): Promise<ArrayBuffer>;
+            };
         }>;
         createWritable(config?: {
             keepExistingData?: boolean;
@@ -1026,6 +1029,10 @@ declare module "sliftutils/storage/IStorage" {
     };
     export type IStorageRaw = {
         get(key: string): Promise<Buffer | undefined>;
+        getRange(key: string, config: {
+            start: number;
+            end: number;
+        }): Promise<Buffer | undefined>;
         append(key: string, value: Buffer): Promise<void>;
         set(key: string, value: Buffer): Promise<void>;
         remove(key: string): Promise<void>;
@@ -1117,6 +1124,10 @@ declare module "sliftutils/storage/PrivateFileSystemStorage" {
         private getFileHandle;
         private fileExists;
         get(key: string): Promise<Buffer | undefined>;
+        getRange(key: string, config: {
+            start: number;
+            end: number;
+        }): Promise<Buffer | undefined>;
         set(key: string, value: Buffer): Promise<void>;
         append(key: string, value: Buffer): Promise<void>;
         remove(key: string): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.2.37",
+    "version": "1.2.38",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/storage/FileFolderAPI.d.ts

@@ -32,6 +32,9 @@ type FileWrapper = {
         size: number;
         lastModified: number;
         arrayBuffer(): Promise<ArrayBuffer>;
+        slice(start: number, end: number): {
+            arrayBuffer(): Promise<ArrayBuffer>;
+        };
     }>;
     createWritable(config?: {
         keepExistingData?: boolean;

package/storage/FileFolderAPI.tsx

@@ -40,6 +40,9 @@ type FileWrapper = {
         size: number;
         lastModified: number;
         arrayBuffer(): Promise<ArrayBuffer>;
+        // Matches Blob.slice (which the native File object provides), so the browser
+        //  implementation works vanilla. End is exclusive, both clamped to the file size.
+        slice(start: number, end: number): { arrayBuffer(): Promise<ArrayBuffer> };
     }>;
     createWritable(config?: { keepExistingData?: boolean }): Promise<{
         seek(offset: number): Promise<void>;
@@ -99,13 +102,29 @@ class NodeJSFileHandleWrapper implements FileWrapper {
 
     async getFile() {
         const stats = await fs.promises.stat(this.filePath);
+        const filePath = this.filePath;
         return {
             size: stats.size,
             lastModified: stats.mtimeMs,
             arrayBuffer: async () => {
-                const buffer = await fs.promises.readFile(this.filePath);
+                const buffer = await fs.promises.readFile(filePath);
                 return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-            }
+            },
+            slice: (start: number, end: number) => ({
+                arrayBuffer: async () => {
+                    const clampedStart = Math.min(Math.max(start, 0), stats.size);
+                    const clampedEnd = Math.min(Math.max(end, clampedStart), stats.size);
+                    const length = clampedEnd - clampedStart;
+                    const fileHandle = await fs.promises.open(filePath, "r");
+                    try {
+                        const buffer = Buffer.alloc(length);
+                        await fileHandle.read(buffer, 0, length, clampedStart);
+                        return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+                    } finally {
+                        await fileHandle.close();
+                    }
+                }
+            })
         };
     }
 
@@ -440,6 +459,17 @@ function wrapHandleFiles(handle: DirectoryWrapper): IStorageRaw {
             }
         },
 
+        async getRange(key: string, config: { start: number; end: number }): Promise<Buffer | undefined> {
+            try {
+                const file = await handle.getFileHandle(key);
+                const fileContent = await file.getFile();
+                const arrayBuffer = await fileContent.slice(config.start, config.end).arrayBuffer();
+                return Buffer.from(arrayBuffer);
+            } catch (error) {
+                return undefined;
+            }
+        },
+
         async append(key: string, value: Buffer): Promise<void> {
             await appendQueue(key)(async () => {
                 // NOTE: Interesting point. Chrome doesn't optimize this to be an append, and instead

package/storage/IStorage.d.ts

@@ -27,6 +27,10 @@ export type IStorage<T> = {
 };
 export type IStorageRaw = {
     get(key: string): Promise<Buffer | undefined>;
+    getRange(key: string, config: {
+        start: number;
+        end: number;
+    }): Promise<Buffer | undefined>;
     append(key: string, value: Buffer): Promise<void>;
     set(key: string, value: Buffer): Promise<void>;
     remove(key: string): Promise<void>;

package/storage/IStorage.ts

@@ -29,6 +29,9 @@ export type IStorage<T> = {
 //  (/ makes a folder). And there are even more rules, such as lengths per folder, etc, etc.
 export type IStorageRaw = {
     get(key: string): Promise<Buffer | undefined>;
+    // Reads bytes in the range [start, end) (end is exclusive, clamped to the file size).
+    //  Returns undefined if the file doesn't exist.
+    getRange(key: string, config: { start: number; end: number }): Promise<Buffer | undefined>;
     // May or may not be efficient in the underlying storage
     append(key: string, value: Buffer): Promise<void>;
     set(key: string, value: Buffer): Promise<void>;

package/storage/IndexedDBFileFolderAPI.ts

@@ -44,6 +44,12 @@ class VirtualFileStorage implements FileStorage {
         return badBuffer;
     }
 
+    async getRange(key: string, config: { start: number; end: number }): Promise<Buffer | undefined> {
+        const fullBuffer = await this.get(key);
+        if (!fullBuffer) return undefined;
+        return fullBuffer.subarray(config.start, config.end);
+    }
+
     async append(key: string, value: Buffer): Promise<void> {
         const store = this.getStore("readwrite");
         const fullPath = this.id + key;

package/storage/PrivateFileSystemStorage.d.ts

@@ -11,6 +11,10 @@ export declare class PrivateFileSystemStorage implements IStorageRaw {
     private getFileHandle;
     private fileExists;
     get(key: string): Promise<Buffer | undefined>;
+    getRange(key: string, config: {
+        start: number;
+        end: number;
+    }): Promise<Buffer | undefined>;
     set(key: string, value: Buffer): Promise<void>;
     append(key: string, value: Buffer): Promise<void>;
     remove(key: string): Promise<void>;

package/storage/PrivateFileSystemStorage.ts

@@ -114,6 +114,17 @@ export class PrivateFileSystemStorage implements IStorageRaw {
         }
     }
 
+    public async getRange(key: string, config: { start: number; end: number }): Promise<Buffer | undefined> {
+        const fileHandle = await this.getFileHandle(key, false);
+        if (!fileHandle) {
+            return undefined;
+        }
+
+        const file = await fileHandle.getFile();
+        const arrayBuffer = await file.slice(config.start, config.end).arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+
     public async set(key: string, value: Buffer): Promise<void> {
         try {
             const fileHandle = await this.getFileHandle(key, true);