sliftutils 1.2.37 → 1.2.39

package/index.d.ts

@@ -156,6 +156,11 @@ declare module "sliftutils/misc/https/dns" {
 }
 
 declare module "sliftutils/misc/https/httpsCerts" {
+    /// <reference path="node-forge-ed25519.d.ts" />
+    /// <reference path="../../storage/storage.d.ts" />
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import * as forge from "node-forge";
     /** NOTE: We also generate the domain *.domain */
     export declare const getHTTPSCert: {
         (key: string): Promise<{
@@ -174,6 +179,18 @@ declare module "sliftutils/misc/https/httpsCerts" {
             cert: string;
         }> | undefined;
     };
+    export declare const getAccountKey: (domain: string) => Promise<string>;
+    export declare function parseCert(PEMorDER: string | Buffer): forge.pki.Certificate;
+    export declare function normalizeCertToPEM(PEMorDER: string | Buffer): string;
+    export declare function generateCert(config: {
+        accountKey: string;
+        domain: string;
+        altDomains?: string[];
+    }): Promise<{
+        domains: string[];
+        key: string;
+        cert: string;
+    }>;
 
 }
 
@@ -929,6 +946,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 +1046,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 +1141,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/misc/https/httpsCerts.d.ts

@@ -1,3 +1,8 @@
+/// <reference path="node-forge-ed25519.d.ts" />
+/// <reference path="../../storage/storage.d.ts" />
+/// <reference types="node" />
+/// <reference types="node" />
+import * as forge from "node-forge";
 /** NOTE: We also generate the domain *.domain */
 export declare const getHTTPSCert: {
     (key: string): Promise<{
@@ -16,3 +21,15 @@ export declare const getHTTPSCert: {
         cert: string;
     }> | undefined;
 };
+export declare const getAccountKey: (domain: string) => Promise<string>;
+export declare function parseCert(PEMorDER: string | Buffer): forge.pki.Certificate;
+export declare function normalizeCertToPEM(PEMorDER: string | Buffer): string;
+export declare function generateCert(config: {
+    accountKey: string;
+    domain: string;
+    altDomains?: string[];
+}): Promise<{
+    domains: string[];
+    key: string;
+    cert: string;
+}>;

package/misc/https/httpsCerts.ts

@@ -91,7 +91,7 @@ export const getHTTPSCert = cache(async (domain: string): Promise<{ key: string;
 });
 
 
-const getAccountKey = async function getAccountKey(domain: string) {
+export const getAccountKey = async function getAccountKey(domain: string) {
     let accountKey = getKeyStore<string>(domain, "letsEncryptAccountKey");
     let secret = await accountKey.get();
     if (!secret) {
@@ -105,11 +105,11 @@ const getAccountKey = async function getAccountKey(domain: string) {
 };
 
 
-function parseCert(PEMorDER: string | Buffer) {
+export function parseCert(PEMorDER: string | Buffer) {
     return forge.pki.certificateFromPem(normalizeCertToPEM(PEMorDER));
 }
 
-function normalizeCertToPEM(PEMorDER: string | Buffer): string {
+export function normalizeCertToPEM(PEMorDER: string | Buffer): string {
     if (PEMorDER.toString().startsWith("-----BEGIN CERTIFICATE-----")) {
         return PEMorDER.toString();
     }
@@ -118,7 +118,7 @@ function normalizeCertToPEM(PEMorDER: string | Buffer): string {
 }
 
 
-async function generateCert(config: {
+export async function generateCert(config: {
     accountKey: string;
     domain: string;
     altDomains?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.2.37",
+    "version": "1.2.39",
     "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);