@componentor/fs 1.2.4 → 1.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@componentor/fs",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "A blazing-fast, Node.js-compatible filesystem for the browser using OPFS",
   "type": "module",
   "main": "./dist/index.js",

package/src/index.ts

@@ -188,10 +188,13 @@ export default class OPFS {
 
         if (this.useSync) {
           const access = await fileHandle.createSyncAccessHandle()
-          const size = access.getSize()
-          buffer = new Uint8Array(size)
-          access.read(buffer)
-          access.close()
+          try {
+            const size = access.getSize()
+            buffer = new Uint8Array(size)
+            access.read(buffer)
+          } finally {
+            access.close()
+          }
         } else {
           const file = await fileHandle.getFile()
           buffer = new Uint8Array(await file.arrayBuffer())
@@ -270,10 +273,13 @@ export default class OPFS {
               let buffer: Uint8Array
               if (this.useSync) {
                 const access = await fileHandle.createSyncAccessHandle()
-                const size = access.getSize()
-                buffer = new Uint8Array(size)
-                access.read(buffer)
-                access.close()
+                try {
+                  const size = access.getSize()
+                  buffer = new Uint8Array(size)
+                  access.read(buffer)
+                } finally {
+                  access.close()
+                }
               } else {
                 const file = await fileHandle.getFile()
                 buffer = new Uint8Array(await file.arrayBuffer())
@@ -311,10 +317,13 @@ export default class OPFS {
 
       if (this.useSync) {
         const access = await fileHandle!.createSyncAccessHandle()
-        // Set exact size (more efficient than truncate(0) + write)
-        access.truncate(buffer.length)
-        access.write(buffer, { at: 0 })
-        access.close()
+        try {
+          // Set exact size (more efficient than truncate(0) + write)
+          access.truncate(buffer.length)
+          access.write(buffer, { at: 0 })
+        } finally {
+          access.close()
+        }
       } else {
         const writable = await fileHandle!.createWritable()
         await writable.write(buffer)
@@ -1037,8 +1046,11 @@ export default class OPFS {
 
       if (this.useSync) {
         const access = await fileHandle.createSyncAccessHandle()
-        access.truncate(len)
-        access.close()
+        try {
+          access.truncate(len)
+        } finally {
+          access.close()
+        }
       } else {
         const file = await fileHandle.getFile()
         const data = new Uint8Array(await file.arrayBuffer())

package/src/packed-storage.ts

@@ -128,7 +128,6 @@ export class PackedStorage {
   private useChecksum: boolean
   private index: PackIndex | null = null
   private indexLoaded = false
-  private lockPromise: Promise<void> | null = null
 
   constructor(handleManager: HandleManager, useSync: boolean, useCompression = false, useChecksum = true) {
     this.handleManager = handleManager
@@ -138,23 +137,6 @@ export class PackedStorage {
     this.useChecksum = useChecksum
   }
 
-  /**
-   * Acquire lock for pack file access (prevents concurrent handle conflicts)
-   */
-  private async acquireLock(): Promise<() => void> {
-    while (this.lockPromise) {
-      await this.lockPromise
-    }
-    let release: () => void
-    this.lockPromise = new Promise(resolve => {
-      release = () => {
-        this.lockPromise = null
-        resolve()
-      }
-    })
-    return release!
-  }
-
   /**
    * Reset pack storage state (memory only)
    */
@@ -256,13 +238,8 @@ export class PackedStorage {
    * Check if a path exists in the pack
    */
   async has(path: string): Promise<boolean> {
-    const release = await this.acquireLock()
-    try {
-      const index = await this.loadIndex()
-      return path in index
-    } finally {
-      release()
-    }
+    const index = await this.loadIndex()
+    return path in index
   }
 
   /**
@@ -270,15 +247,10 @@ export class PackedStorage {
    * Returns originalSize if compressed, otherwise size
    */
   async getSize(path: string): Promise<number | null> {
-    const release = await this.acquireLock()
-    try {
-      const index = await this.loadIndex()
-      const entry = index[path]
-      if (!entry) return null
-      return entry.originalSize ?? entry.size
-    } finally {
-      release()
-    }
+    const index = await this.loadIndex()
+    const entry = index[path]
+    if (!entry) return null
+    return entry.originalSize ?? entry.size
   }
 
   /**
@@ -286,40 +258,35 @@ export class PackedStorage {
    * Handles decompression if file was stored compressed
    */
   async read(path: string): Promise<Uint8Array | null> {
-    const release = await this.acquireLock()
-    try {
-      const index = await this.loadIndex()
-      const entry = index[path]
-      if (!entry) return null
-
-      const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
-      if (!fileHandle) return null
+    const index = await this.loadIndex()
+    const entry = index[path]
+    if (!entry) return null
 
-      let buffer: Uint8Array
+    const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
+    if (!fileHandle) return null
 
-      if (this.useSync) {
-        const access = await fileHandle.createSyncAccessHandle()
-        try {
-          buffer = new Uint8Array(entry.size)
-          access.read(buffer, { at: entry.offset })
-        } finally {
-          access.close()
-        }
-      } else {
-        const file = await fileHandle.getFile()
-        const data = new Uint8Array(await file.arrayBuffer())
-        buffer = data.slice(entry.offset, entry.offset + entry.size)
-      }
+    let buffer: Uint8Array
 
-      // Decompress if needed
-      if (entry.originalSize !== undefined) {
-        return decompress(buffer)
+    if (this.useSync) {
+      const access = await fileHandle.createSyncAccessHandle()
+      try {
+        buffer = new Uint8Array(entry.size)
+        access.read(buffer, { at: entry.offset })
+      } finally {
+        access.close()
       }
+    } else {
+      const file = await fileHandle.getFile()
+      const data = new Uint8Array(await file.arrayBuffer())
+      buffer = data.slice(entry.offset, entry.offset + entry.size)
+    }
 
-      return buffer
-    } finally {
-      release()
+    // Decompress if needed
+    if (entry.originalSize !== undefined) {
+      return decompress(buffer)
     }
+
+    return buffer
   }
 
   /**
@@ -331,74 +298,69 @@ export class PackedStorage {
     const results = new Map<string, Uint8Array | null>()
     if (paths.length === 0) return results
 
-    const release = await this.acquireLock()
-    try {
-      const index = await this.loadIndex()
-
-      // Find which paths are in the pack
-      const toRead: Array<{ path: string; offset: number; size: number; originalSize?: number }> = []
-      for (const path of paths) {
-        const entry = index[path]
-        if (entry) {
-          toRead.push({ path, offset: entry.offset, size: entry.size, originalSize: entry.originalSize })
-        } else {
-          results.set(path, null)
-        }
+    const index = await this.loadIndex()
+
+    // Find which paths are in the pack
+    const toRead: Array<{ path: string; offset: number; size: number; originalSize?: number }> = []
+    for (const path of paths) {
+      const entry = index[path]
+      if (entry) {
+        toRead.push({ path, offset: entry.offset, size: entry.size, originalSize: entry.originalSize })
+      } else {
+        results.set(path, null)
       }
+    }
 
-      if (toRead.length === 0) return results
+    if (toRead.length === 0) return results
 
-      const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
-      if (!fileHandle) {
-        for (const { path } of toRead) {
-          results.set(path, null)
-        }
-        return results
+    const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
+    if (!fileHandle) {
+      for (const { path } of toRead) {
+        results.set(path, null)
       }
+      return results
+    }
 
-      // Read all files
-      const decompressPromises: Array<{ path: string; promise: Promise<Uint8Array> }> = []
+    // Read all files
+    const decompressPromises: Array<{ path: string; promise: Promise<Uint8Array> }> = []
 
-      if (this.useSync) {
-        const access = await fileHandle.createSyncAccessHandle()
-        try {
-          for (const { path, offset, size, originalSize } of toRead) {
-            const buffer = new Uint8Array(size)
-            access.read(buffer, { at: offset })
-
-            if (originalSize !== undefined) {
-              // Queue for decompression
-              decompressPromises.push({ path, promise: decompress(buffer) })
-            } else {
-              results.set(path, buffer)
-            }
-          }
-        } finally {
-          access.close()
-        }
-      } else {
-        const file = await fileHandle.getFile()
-        const data = new Uint8Array(await file.arrayBuffer())
+    if (this.useSync) {
+      const access = await fileHandle.createSyncAccessHandle()
+      try {
         for (const { path, offset, size, originalSize } of toRead) {
-          const buffer = data.slice(offset, offset + size)
+          const buffer = new Uint8Array(size)
+          access.read(buffer, { at: offset })
 
           if (originalSize !== undefined) {
+            // Queue for decompression
             decompressPromises.push({ path, promise: decompress(buffer) })
           } else {
             results.set(path, buffer)
           }
         }
+      } finally {
+        access.close()
       }
+    } else {
+      const file = await fileHandle.getFile()
+      const data = new Uint8Array(await file.arrayBuffer())
+      for (const { path, offset, size, originalSize } of toRead) {
+        const buffer = data.slice(offset, offset + size)
 
-      // Wait for all decompressions
-      for (const { path, promise } of decompressPromises) {
-        results.set(path, await promise)
+        if (originalSize !== undefined) {
+          decompressPromises.push({ path, promise: decompress(buffer) })
+        } else {
+          results.set(path, buffer)
+        }
       }
+    }
 
-      return results
-    } finally {
-      release()
+    // Wait for all decompressions
+    for (const { path, promise } of decompressPromises) {
+      results.set(path, await promise)
     }
+
+    return results
   }
 
   /**
@@ -411,86 +373,81 @@ export class PackedStorage {
   async writeBatch(entries: Array<{ path: string; data: Uint8Array }>): Promise<void> {
     if (entries.length === 0) return
 
-    const release = await this.acquireLock()
-    try {
-      const encoder = new TextEncoder()
-
-      // Compress data if enabled
-      let processedEntries: Array<{ path: string; data: Uint8Array; originalSize?: number }>
-      if (this.useCompression) {
-        processedEntries = await Promise.all(
-          entries.map(async ({ path, data }) => {
-            const compressed = await compress(data)
-            // Only use compressed if it's actually smaller
-            if (compressed.length < data.length) {
-              return { path, data: compressed, originalSize: data.length }
-            }
-            return { path, data }
-          })
-        )
-      } else {
-        processedEntries = entries
-      }
-
-      // Calculate total data size (using compressed sizes where applicable)
-      let totalDataSize = 0
-      for (const { data } of processedEntries) {
-        totalDataSize += data.length
-      }
-
-      // Build index - iterate until offsets stabilize
-      // (offset changes -> JSON length changes -> header size changes -> offset changes)
-      // Header format: [index length: 4][CRC32: 4][JSON index][file data...]
-      const newIndex: PackIndex = {}
-      let headerSize = 8 // 4 bytes index length + 4 bytes CRC32
-      let prevHeaderSize = 0
+    const encoder = new TextEncoder()
+
+    // Compress data if enabled
+    let processedEntries: Array<{ path: string; data: Uint8Array; originalSize?: number }>
+    if (this.useCompression) {
+      processedEntries = await Promise.all(
+        entries.map(async ({ path, data }) => {
+          const compressed = await compress(data)
+          // Only use compressed if it's actually smaller
+          if (compressed.length < data.length) {
+            return { path, data: compressed, originalSize: data.length }
+          }
+          return { path, data }
+        })
+      )
+    } else {
+      processedEntries = entries
+    }
 
-      // Iterate until stable (usually 2-3 iterations)
-      while (headerSize !== prevHeaderSize) {
-        prevHeaderSize = headerSize
+    // Calculate total data size (using compressed sizes where applicable)
+    let totalDataSize = 0
+    for (const { data } of processedEntries) {
+      totalDataSize += data.length
+    }
 
-        let currentOffset = headerSize
-        for (const { path, data, originalSize } of processedEntries) {
-          const entry: PackIndexEntry = { offset: currentOffset, size: data.length }
-          if (originalSize !== undefined) {
-            entry.originalSize = originalSize
-          }
-          newIndex[path] = entry
-          currentOffset += data.length
+    // Build index - iterate until offsets stabilize
+    // (offset changes -> JSON length changes -> header size changes -> offset changes)
+    // Header format: [index length: 4][CRC32: 4][JSON index][file data...]
+    const newIndex: PackIndex = {}
+    let headerSize = 8 // 4 bytes index length + 4 bytes CRC32
+    let prevHeaderSize = 0
+
+    // Iterate until stable (usually 2-3 iterations)
+    while (headerSize !== prevHeaderSize) {
+      prevHeaderSize = headerSize
+
+      let currentOffset = headerSize
+      for (const { path, data, originalSize } of processedEntries) {
+        const entry: PackIndexEntry = { offset: currentOffset, size: data.length }
+        if (originalSize !== undefined) {
+          entry.originalSize = originalSize
         }
-
-        const indexBuf = encoder.encode(JSON.stringify(newIndex))
-        headerSize = 8 + indexBuf.length
+        newIndex[path] = entry
+        currentOffset += data.length
       }
 
-      // Build the complete pack file
-      const finalIndexBuf = encoder.encode(JSON.stringify(newIndex))
-      const totalSize = headerSize + totalDataSize
-      const packBuffer = new Uint8Array(totalSize)
-      const view = new DataView(packBuffer.buffer)
+      const indexBuf = encoder.encode(JSON.stringify(newIndex))
+      headerSize = 8 + indexBuf.length
+    }
+
+    // Build the complete pack file
+    const finalIndexBuf = encoder.encode(JSON.stringify(newIndex))
+    const totalSize = headerSize + totalDataSize
+    const packBuffer = new Uint8Array(totalSize)
+    const view = new DataView(packBuffer.buffer)
 
-      // Write index JSON at offset 8
-      packBuffer.set(finalIndexBuf, 8)
+    // Write index JSON at offset 8
+    packBuffer.set(finalIndexBuf, 8)
 
-      // Write data at correct offsets
-      for (const { path, data } of processedEntries) {
-        const entry = newIndex[path]
-        packBuffer.set(data, entry.offset)
-      }
+    // Write data at correct offsets
+    for (const { path, data } of processedEntries) {
+      const entry = newIndex[path]
+      packBuffer.set(data, entry.offset)
+    }
 
-      // Calculate CRC32 over content (index + data, everything after header) if enabled
-      const content = packBuffer.subarray(8)
-      const checksum = this.useChecksum ? crc32(content) : 0
+    // Calculate CRC32 over content (index + data, everything after header) if enabled
+    const content = packBuffer.subarray(8)
+    const checksum = this.useChecksum ? crc32(content) : 0
 
-      // Write header (index length + CRC32)
-      view.setUint32(0, finalIndexBuf.length, true)
-      view.setUint32(4, checksum, true)
+    // Write header (index length + CRC32)
+    view.setUint32(0, finalIndexBuf.length, true)
+    view.setUint32(4, checksum, true)
 
-      await this.writePackFile(packBuffer)
-      this.index = newIndex
-    } finally {
-      release()
-    }
+    await this.writePackFile(packBuffer)
+    this.index = newIndex
   }
 
   /**
@@ -521,111 +478,101 @@ export class PackedStorage {
    * Note: Doesn't reclaim space, just removes from index and recalculates CRC32
    */
   async remove(path: string): Promise<boolean> {
-    const release = await this.acquireLock()
-    try {
-      const index = await this.loadIndex()
-      if (!(path in index)) return false
-
-      delete index[path]
-
-      const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
-      if (!fileHandle) return true
-
-      // Need to read existing file to recalculate CRC32
-      const encoder = new TextEncoder()
-      const newIndexBuf = encoder.encode(JSON.stringify(index))
-
-      if (this.useSync) {
-        const access = await fileHandle.createSyncAccessHandle()
-        try {
-          const size = access.getSize()
-
-          // Read old header to get old index length
-          const oldHeader = new Uint8Array(8)
-          access.read(oldHeader, { at: 0 })
-          const oldIndexLen = new DataView(oldHeader.buffer).getUint32(0, true)
-
-          // Read data portion (after old index)
-          const dataStart = 8 + oldIndexLen
-          const dataSize = size - dataStart
-          const dataPortion = new Uint8Array(dataSize)
-          if (dataSize > 0) {
-            access.read(dataPortion, { at: dataStart })
-          }
-
-          // Build new content (new index + data)
-          const newContent = new Uint8Array(newIndexBuf.length + dataSize)
-          newContent.set(newIndexBuf, 0)
-          if (dataSize > 0) {
-            newContent.set(dataPortion, newIndexBuf.length)
-          }
+    const index = await this.loadIndex()
+    if (!(path in index)) return false
 
-          // Calculate new CRC32 if enabled
-          const checksum = this.useChecksum ? crc32(newContent) : 0
+    delete index[path]
 
-          // Build new header
-          const newHeader = new Uint8Array(8)
-          const view = new DataView(newHeader.buffer)
-          view.setUint32(0, newIndexBuf.length, true)
-          view.setUint32(4, checksum, true)
+    const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
+    if (!fileHandle) return true
 
-          // Write new file
-          const newFile = new Uint8Array(8 + newContent.length)
-          newFile.set(newHeader, 0)
-          newFile.set(newContent, 8)
+    // Need to read existing file to recalculate CRC32
+    const encoder = new TextEncoder()
+    const newIndexBuf = encoder.encode(JSON.stringify(index))
 
-          access.truncate(newFile.length)
-          access.write(newFile, { at: 0 })
-        } finally {
-          access.close()
-        }
-      } else {
-        // For non-sync, rewrite the whole file
-        const file = await fileHandle.getFile()
-        const oldData = new Uint8Array(await file.arrayBuffer())
+    if (this.useSync) {
+      const access = await fileHandle.createSyncAccessHandle()
+      try {
+        const size = access.getSize()
 
-        if (oldData.length < 8) return true
+        // Read old header to get old index length
+        const oldHeader = new Uint8Array(8)
+        access.read(oldHeader, { at: 0 })
+        const oldIndexLen = new DataView(oldHeader.buffer).getUint32(0, true)
 
-        const oldIndexLen = new DataView(oldData.buffer).getUint32(0, true)
+        // Read data portion (after old index)
         const dataStart = 8 + oldIndexLen
-        const dataPortion = oldData.subarray(dataStart)
+        const dataSize = size - dataStart
+        const dataPortion = new Uint8Array(dataSize)
+        if (dataSize > 0) {
+          access.read(dataPortion, { at: dataStart })
+        }
 
-        // Build new content
-        const newContent = new Uint8Array(newIndexBuf.length + dataPortion.length)
+        // Build new content (new index + data)
+        const newContent = new Uint8Array(newIndexBuf.length + dataSize)
         newContent.set(newIndexBuf, 0)
-        newContent.set(dataPortion, newIndexBuf.length)
+        if (dataSize > 0) {
+          newContent.set(dataPortion, newIndexBuf.length)
+        }
 
-        // Calculate CRC32 if enabled
+        // Calculate new CRC32 if enabled
         const checksum = this.useChecksum ? crc32(newContent) : 0
 
-        // Build new file
-        const newFile = new Uint8Array(8 + newContent.length)
-        const view = new DataView(newFile.buffer)
+        // Build new header
+        const newHeader = new Uint8Array(8)
+        const view = new DataView(newHeader.buffer)
         view.setUint32(0, newIndexBuf.length, true)
         view.setUint32(4, checksum, true)
+
+        // Write new file
+        const newFile = new Uint8Array(8 + newContent.length)
+        newFile.set(newHeader, 0)
         newFile.set(newContent, 8)
 
-        const writable = await fileHandle.createWritable()
-        await writable.write(newFile)
-        await writable.close()
+        access.truncate(newFile.length)
+        access.write(newFile, { at: 0 })
+      } finally {
+        access.close()
       }
+    } else {
+      // For non-sync, rewrite the whole file
+      const file = await fileHandle.getFile()
+      const oldData = new Uint8Array(await file.arrayBuffer())
+
+      if (oldData.length < 8) return true
+
+      const oldIndexLen = new DataView(oldData.buffer).getUint32(0, true)
+      const dataStart = 8 + oldIndexLen
+      const dataPortion = oldData.subarray(dataStart)
+
+      // Build new content
+      const newContent = new Uint8Array(newIndexBuf.length + dataPortion.length)
+      newContent.set(newIndexBuf, 0)
+      newContent.set(dataPortion, newIndexBuf.length)
 
-      return true
-    } finally {
-      release()
+      // Calculate CRC32 if enabled
+      const checksum = this.useChecksum ? crc32(newContent) : 0
+
+      // Build new file
+      const newFile = new Uint8Array(8 + newContent.length)
+      const view = new DataView(newFile.buffer)
+      view.setUint32(0, newIndexBuf.length, true)
+      view.setUint32(4, checksum, true)
+      newFile.set(newContent, 8)
+
+      const writable = await fileHandle.createWritable()
+      await writable.write(newFile)
+      await writable.close()
     }
+
+    return true
   }
 
   /**
    * Check if pack file is being used (has entries)
    */
   async isEmpty(): Promise<boolean> {
-    const release = await this.acquireLock()
-    try {
-      const index = await this.loadIndex()
-      return Object.keys(index).length === 0
-    } finally {
-      release()
-    }
+    const index = await this.loadIndex()
+    return Object.keys(index).length === 0
   }
 }