@componentor/fs 1.2.4 → 1.2.6

package/dist/opfs-hybrid.js

@@ -403,12 +403,15 @@ var SymlinkManager = class {
     const buffer = new TextEncoder().encode(data);
     if (this.useSync) {
       const access = await fileHandle.createSyncAccessHandle();
-      access.truncate(0);
-      let written = 0;
-      while (written < buffer.length) {
-        written += access.write(buffer.subarray(written), { at: written });
+      try {
+        access.truncate(0);
+        let written = 0;
+        while (written < buffer.length) {
+          written += access.write(buffer.subarray(written), { at: written });
+        }
+      } finally {
+        access.close();
       }
-      access.close();
     } else {
       const writable = await fileHandle.createWritable();
       await writable.write(buffer);
@@ -653,29 +656,12 @@ var PackedStorage = class {
   useChecksum;
   index = null;
   indexLoaded = false;
-  lockPromise = null;
   constructor(handleManager, useSync, useCompression = false, useChecksum = true) {
     this.handleManager = handleManager;
     this.useSync = useSync;
     this.useCompression = useCompression && typeof CompressionStream !== "undefined";
     this.useChecksum = useChecksum;
   }
-  /**
-   * Acquire lock for pack file access (prevents concurrent handle conflicts)
-   */
-  async acquireLock() {
-    while (this.lockPromise) {
-      await this.lockPromise;
-    }
-    let release;
-    this.lockPromise = new Promise((resolve) => {
-      release = () => {
-        this.lockPromise = null;
-        resolve();
-      };
-    });
-    return release;
-  }
   /**
    * Reset pack storage state (memory only)
    */
@@ -759,62 +745,47 @@ var PackedStorage = class {
    * Check if a path exists in the pack
    */
   async has(path) {
-    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;
   }
   /**
    * Get file size from pack (for stat)
    * Returns originalSize if compressed, otherwise size
    */
   async getSize(path) {
-    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;
   }
   /**
    * Read a file from the pack
    * Handles decompression if file was stored compressed
    */
   async read(path) {
-    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;
-      let 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);
-      }
-      if (entry.originalSize !== void 0) {
-        return decompress(buffer);
+    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;
+    let buffer;
+    if (this.useSync) {
+      const access = await fileHandle.createSyncAccessHandle();
+      try {
+        buffer = new Uint8Array(entry.size);
+        access.read(buffer, { at: entry.offset });
+      } finally {
+        access.close();
       }
-      return buffer;
-    } finally {
-      release();
+    } else {
+      const file = await fileHandle.getFile();
+      const data = new Uint8Array(await file.arrayBuffer());
+      buffer = data.slice(entry.offset, entry.offset + entry.size);
     }
+    if (entry.originalSize !== void 0) {
+      return decompress(buffer);
+    }
+    return buffer;
   }
   /**
    * Read multiple files from the pack in a single operation
@@ -824,61 +795,56 @@ var PackedStorage = class {
   async readBatch(paths) {
     const results = /* @__PURE__ */ new Map();
     if (paths.length === 0) return results;
-    const release = await this.acquireLock();
-    try {
-      const index = await this.loadIndex();
-      const toRead = [];
-      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();
+    const toRead = [];
+    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;
-      const { fileHandle } = await this.handleManager.getHandle(PACK_FILE);
-      if (!fileHandle) {
-        for (const { path } of toRead) {
-          results.set(path, null);
-        }
-        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);
       }
-      const decompressPromises = [];
-      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 !== void 0) {
-              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());
+      return results;
+    }
+    const decompressPromises = [];
+    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 !== void 0) {
             decompressPromises.push({ path, promise: decompress(buffer) });
           } else {
             results.set(path, buffer);
           }
         }
+      } finally {
+        access.close();
       }
-      for (const { path, promise } of decompressPromises) {
-        results.set(path, await promise);
+    } 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);
+        if (originalSize !== void 0) {
+          decompressPromises.push({ path, promise: decompress(buffer) });
+        } else {
+          results.set(path, buffer);
+        }
       }
-      return results;
-    } finally {
-      release();
     }
+    for (const { path, promise } of decompressPromises) {
+      results.set(path, await promise);
+    }
+    return results;
   }
   /**
    * Write multiple files to the pack in a single operation
@@ -889,62 +855,57 @@ var PackedStorage = class {
    */
   async writeBatch(entries) {
     if (entries.length === 0) return;
-    const release = await this.acquireLock();
-    try {
-      const encoder = new TextEncoder();
-      let processedEntries;
-      if (this.useCompression) {
-        processedEntries = await Promise.all(
-          entries.map(async ({ path, data }) => {
-            const compressed = await compress(data);
-            if (compressed.length < data.length) {
-              return { path, data: compressed, originalSize: data.length };
-            }
-            return { path, data };
-          })
-        );
-      } else {
-        processedEntries = entries;
-      }
-      let totalDataSize = 0;
-      for (const { data } of processedEntries) {
-        totalDataSize += data.length;
-      }
-      const newIndex = {};
-      let headerSize = 8;
-      let prevHeaderSize = 0;
-      while (headerSize !== prevHeaderSize) {
-        prevHeaderSize = headerSize;
-        let currentOffset = headerSize;
-        for (const { path, data, originalSize } of processedEntries) {
-          const entry = { offset: currentOffset, size: data.length };
-          if (originalSize !== void 0) {
-            entry.originalSize = originalSize;
+    const encoder = new TextEncoder();
+    let processedEntries;
+    if (this.useCompression) {
+      processedEntries = await Promise.all(
+        entries.map(async ({ path, data }) => {
+          const compressed = await compress(data);
+          if (compressed.length < data.length) {
+            return { path, data: compressed, originalSize: data.length };
           }
-          newIndex[path] = entry;
-          currentOffset += data.length;
+          return { path, data };
+        })
+      );
+    } else {
+      processedEntries = entries;
+    }
+    let totalDataSize = 0;
+    for (const { data } of processedEntries) {
+      totalDataSize += data.length;
+    }
+    const newIndex = {};
+    let headerSize = 8;
+    let prevHeaderSize = 0;
+    while (headerSize !== prevHeaderSize) {
+      prevHeaderSize = headerSize;
+      let currentOffset = headerSize;
+      for (const { path, data, originalSize } of processedEntries) {
+        const entry = { offset: currentOffset, size: data.length };
+        if (originalSize !== void 0) {
+          entry.originalSize = originalSize;
         }
-        const indexBuf = encoder.encode(JSON.stringify(newIndex));
-        headerSize = 8 + indexBuf.length;
-      }
-      const finalIndexBuf = encoder.encode(JSON.stringify(newIndex));
-      const totalSize = headerSize + totalDataSize;
-      const packBuffer = new Uint8Array(totalSize);
-      const view = new DataView(packBuffer.buffer);
-      packBuffer.set(finalIndexBuf, 8);
-      for (const { path, data } of processedEntries) {
-        const entry = newIndex[path];
-        packBuffer.set(data, entry.offset);
-      }
-      const content = packBuffer.subarray(8);
-      const checksum = this.useChecksum ? crc32(content) : 0;
-      view.setUint32(0, finalIndexBuf.length, true);
-      view.setUint32(4, checksum, true);
-      await this.writePackFile(packBuffer);
-      this.index = newIndex;
-    } finally {
-      release();
+        newIndex[path] = entry;
+        currentOffset += data.length;
+      }
+      const indexBuf = encoder.encode(JSON.stringify(newIndex));
+      headerSize = 8 + indexBuf.length;
+    }
+    const finalIndexBuf = encoder.encode(JSON.stringify(newIndex));
+    const totalSize = headerSize + totalDataSize;
+    const packBuffer = new Uint8Array(totalSize);
+    const view = new DataView(packBuffer.buffer);
+    packBuffer.set(finalIndexBuf, 8);
+    for (const { path, data } of processedEntries) {
+      const entry = newIndex[path];
+      packBuffer.set(data, entry.offset);
     }
+    const content = packBuffer.subarray(8);
+    const checksum = this.useChecksum ? crc32(content) : 0;
+    view.setUint32(0, finalIndexBuf.length, true);
+    view.setUint32(4, checksum, true);
+    await this.writePackFile(packBuffer);
+    this.index = newIndex;
   }
   /**
    * Write the pack file to OPFS
@@ -972,82 +933,72 @@ var PackedStorage = class {
    * Note: Doesn't reclaim space, just removes from index and recalculates CRC32
    */
   async remove(path) {
-    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;
-      const encoder = new TextEncoder();
-      const newIndexBuf = encoder.encode(JSON.stringify(index));
-      if (this.useSync) {
-        const access = await fileHandle.createSyncAccessHandle();
-        try {
-          const size = access.getSize();
-          const oldHeader = new Uint8Array(8);
-          access.read(oldHeader, { at: 0 });
-          const oldIndexLen = new DataView(oldHeader.buffer).getUint32(0, true);
-          const dataStart = 8 + oldIndexLen;
-          const dataSize = size - dataStart;
-          const dataPortion = new Uint8Array(dataSize);
-          if (dataSize > 0) {
-            access.read(dataPortion, { at: dataStart });
-          }
-          const newContent = new Uint8Array(newIndexBuf.length + dataSize);
-          newContent.set(newIndexBuf, 0);
-          if (dataSize > 0) {
-            newContent.set(dataPortion, newIndexBuf.length);
-          }
-          const checksum = this.useChecksum ? crc32(newContent) : 0;
-          const newHeader = new Uint8Array(8);
-          const view = new DataView(newHeader.buffer);
-          view.setUint32(0, newIndexBuf.length, true);
-          view.setUint32(4, checksum, true);
-          const newFile = new Uint8Array(8 + newContent.length);
-          newFile.set(newHeader, 0);
-          newFile.set(newContent, 8);
-          access.truncate(newFile.length);
-          access.write(newFile, { at: 0 });
-        } finally {
-          access.close();
-        }
-      } else {
-        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 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;
+    const encoder = new TextEncoder();
+    const newIndexBuf = encoder.encode(JSON.stringify(index));
+    if (this.useSync) {
+      const access = await fileHandle.createSyncAccessHandle();
+      try {
+        const size = access.getSize();
+        const oldHeader = new Uint8Array(8);
+        access.read(oldHeader, { at: 0 });
+        const oldIndexLen = new DataView(oldHeader.buffer).getUint32(0, true);
         const dataStart = 8 + oldIndexLen;
-        const dataPortion = oldData.subarray(dataStart);
-        const newContent = new Uint8Array(newIndexBuf.length + dataPortion.length);
+        const dataSize = size - dataStart;
+        const dataPortion = new Uint8Array(dataSize);
+        if (dataSize > 0) {
+          access.read(dataPortion, { at: dataStart });
+        }
+        const newContent = new Uint8Array(newIndexBuf.length + dataSize);
         newContent.set(newIndexBuf, 0);
-        newContent.set(dataPortion, newIndexBuf.length);
+        if (dataSize > 0) {
+          newContent.set(dataPortion, newIndexBuf.length);
+        }
         const checksum = this.useChecksum ? crc32(newContent) : 0;
-        const newFile = new Uint8Array(8 + newContent.length);
-        const view = new DataView(newFile.buffer);
+        const newHeader = new Uint8Array(8);
+        const view = new DataView(newHeader.buffer);
         view.setUint32(0, newIndexBuf.length, true);
         view.setUint32(4, checksum, true);
+        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();
       }
-      return true;
-    } finally {
-      release();
+    } else {
+      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);
+      const newContent = new Uint8Array(newIndexBuf.length + dataPortion.length);
+      newContent.set(newIndexBuf, 0);
+      newContent.set(dataPortion, newIndexBuf.length);
+      const checksum = this.useChecksum ? crc32(newContent) : 0;
+      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() {
-    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;
   }
 };
 
@@ -1284,10 +1235,13 @@ var OPFS = class {
         let buffer;
         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());
@@ -1345,10 +1299,13 @@ var OPFS = class {
               let buffer;
               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());
@@ -1381,9 +1338,12 @@ var OPFS = class {
       const buffer = typeof data === "string" ? new TextEncoder().encode(data) : data;
       if (this.useSync) {
         const access = await fileHandle.createSyncAccessHandle();
-        access.truncate(buffer.length);
-        access.write(buffer, { at: 0 });
-        access.close();
+        try {
+          access.truncate(buffer.length);
+          access.write(buffer, { at: 0 });
+        } finally {
+          access.close();
+        }
       } else {
         const writable = await fileHandle.createWritable();
         await writable.write(buffer);
@@ -1997,8 +1957,11 @@ var OPFS = class {
       if (!fileHandle) throw createENOENT(path);
       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());