@peerbit/any-store-opfs 1.1.4 → 1.1.5

package/dist/assets/opfs/opfs.worker.min.js

@@ -8099,6 +8099,35 @@
     throw lastError ?? createTimeoutError(options);
   };
 
+  // src/protocol.ts
+  var REQUEST_TYPES = /* @__PURE__ */ new Set([
+    "open",
+    "close",
+    "clear",
+    "size",
+    "status",
+    "get",
+    "del",
+    "put",
+    "sublevel",
+    "iterator-next",
+    "iterator-stop"
+  ]);
+  var isOPFSRequest = (value) => {
+    return typeof value === "object" && value !== null && typeof value.messageId === "string" && Array.isArray(value.level) && REQUEST_TYPES.has(value.type);
+  };
+  var getTransferables = (message) => {
+    if (message.type === "get" && "bytes" in message && message.bytes) {
+      return [message.bytes.buffer];
+    }
+    if (message.type === "iterator-next" && "values" in message) {
+      return message.values.map(
+        (value) => value.buffer
+      );
+    }
+    return [];
+  };
+
   // src/worker.ts
   var directory = location.hash.split("#")?.[1];
   var encodeName = (name) => {
@@ -8215,7 +8244,8 @@
               create: true
             });
             const writeFileHandle = await createWriteHandle(fileHandle);
-            writeFileHandle.write(value);
+            writeFileHandle.write(value, { at: 0 });
+            writeFileHandle.truncate(value.byteLength);
             writeFileHandle.flush();
             writeFileHandle.close();
             const prevSize = sizeMap.get(encodedKey);
@@ -8261,7 +8291,7 @@
       };
       this._rootStore = createMemory();
       self.addEventListener("message", async (ev) => {
-        const message = deserialize(ev["data"], MemoryRequest);
+        const message = this.parseMessage(ev.data);
         try {
           if (message instanceof MemoryMessage) {
             if (message instanceof REQ_Open) {
@@ -8369,22 +8399,145 @@
               );
             }
           }
+          if (isOPFSRequest(message)) {
+            if (message.type === "open") {
+              if (await this._rootStore.status() === "closed") {
+                await this._rootStore.open();
+              }
+              await this.respond(message, {
+                type: "ack",
+                level: message.level,
+                messageId: message.messageId
+              });
+              return;
+            }
+            const m = message.level.length === 0 ? this._rootStore : this._levels.get(levelKey(message.level));
+            if (!m) {
+              throw new Error("Recieved memory message for an undefined level");
+            }
+            if (message.type === "clear") {
+              await m.clear();
+              await this.respond(message, {
+                type: "ack",
+                level: message.level,
+                messageId: message.messageId
+              });
+            } else if (message.type === "close") {
+              await m.close();
+              await this.respond(message, {
+                type: "ack",
+                level: message.level,
+                messageId: message.messageId
+              });
+            } else if (message.type === "del") {
+              await m.del(message.key);
+              await this.respond(message, {
+                type: "ack",
+                level: message.level,
+                messageId: message.messageId
+              });
+            } else if (message.type === "iterator-next") {
+              let iterator = this._memoryIterator.get(message.id);
+              if (!iterator) {
+                iterator = m.iterator()[Symbol.asyncIterator]();
+                this._memoryIterator.set(message.id, iterator);
+              }
+              const next = await iterator.next();
+              const nextValue = next.done ? void 0 : next.value;
+              const response = {
+                type: "iterator-next",
+                keys: nextValue ? [nextValue[0]] : [],
+                values: nextValue ? [nextValue[1]] : [],
+                level: message.level,
+                messageId: message.messageId
+              };
+              await this.respond(message, response);
+              if (next.done) {
+                this._memoryIterator.delete(message.id);
+              }
+            } else if (message.type === "iterator-stop") {
+              this._memoryIterator.delete(message.id);
+              await this.respond(message, {
+                type: "ack",
+                level: message.level,
+                messageId: message.messageId
+              });
+            } else if (message.type === "get") {
+              await this.respond(message, {
+                type: "get",
+                bytes: await m.get(message.key),
+                level: message.level,
+                messageId: message.messageId
+              });
+            } else if (message.type === "put") {
+              await m.put(message.key, message.bytes);
+              await this.respond(message, {
+                type: "ack",
+                level: message.level,
+                messageId: message.messageId
+              });
+            } else if (message.type === "size") {
+              await this.respond(message, {
+                type: "size",
+                size: await m.size(),
+                level: message.level,
+                messageId: message.messageId
+              });
+            } else if (message.type === "status") {
+              await this.respond(message, {
+                type: "status",
+                status: await m.status(),
+                level: message.level,
+                messageId: message.messageId
+              });
+            } else if (message.type === "sublevel") {
+              await m.sublevel(message.name);
+              await this.respond(message, {
+                type: "ack",
+                level: message.level,
+                messageId: message.messageId
+              });
+            }
+          }
         } catch (error) {
-          await this.respond(
-            message,
-            new RESP_Error({
-              error: error?.["message"] || error?.constructor.name,
-              level: message["level"] || []
-            }),
-            postMessageFn
-          );
+          if (message instanceof MemoryRequest) {
+            await this.respond(
+              message,
+              new RESP_Error({
+                error: error?.["message"] || error?.constructor.name,
+                level: message["level"] || []
+              }),
+              postMessageFn
+            );
+            return;
+          }
+          await this.respond(message, {
+            type: "error",
+            error: error?.["message"] || error?.constructor.name,
+            level: message?.level || [],
+            messageId: message?.messageId || ""
+          });
         }
       });
     }
+    parseMessage(data) {
+      if (isOPFSRequest(data)) {
+        return data;
+      }
+      const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+      return deserialize(bytes, MemoryRequest);
+    }
     async respond(request, response, postMessageFn = postMessage) {
-      response.messageId = request.messageId;
-      const bytes = serialize(response);
-      postMessageFn(bytes, { transfer: [bytes.buffer] });
+      if (request instanceof MemoryRequest) {
+        const legacyResponse = response;
+        legacyResponse.messageId = request.messageId;
+        const bytes = serialize(legacyResponse);
+        postMessageFn(bytes, { transfer: [bytes.buffer] });
+        return;
+      }
+      const cloneResponse = response;
+      cloneResponse.messageId = request.messageId;
+      postMessageFn(cloneResponse, { transfer: getTransferables(cloneResponse) });
     }
   };
   new OPFSStoreWorker();