@rozenite/storage-plugin 1.8.1 → 1.10.0

package/dist/react-native/chunks/useRozeniteStoragePlugin.require.js

@@ -1,95 +1,142 @@
-import { useRozeniteDevToolsClient as A } from "@rozenite/plugin-bridge";
-import { useCallback as P, useMemo as T, useEffect as R } from "react";
-import { g as k, s as M } from "./types.js";
-import { useRozenitePluginAgentTool as l } from "@rozenite/agent-bridge";
+import { useRozeniteDevToolsClient as v } from "@rozenite/plugin-bridge";
+import { useCallback as A, useMemo as T, useEffect as P } from "react";
+import { g as R, s as M } from "./types.js";
+import { useRozenitePluginAgentTool as p } from "@rozenite/agent-bridge";
 import { defineAgentToolContract as g } from "@rozenite/agent-shared";
-const x = 1500, h = (e) => e.kind === "async", w = (e) => e.type === "buffer" ? `${e.type}:${e.value.join(",")}` : `${e.type}:${String(e.value)}`, N = (e) => new Map(e.map((t) => [t.key, t])), I = (e, t) => e.blacklist ? (e.blacklist.lastIndex = 0, e.blacklist.test(t)) : !1, z = (e, t, r) => {
-  if (!M(e, t))
+const x = async (t, e, r) => {
+  const o = t.find(
+    (n) => n.target.adapterId === e.target.adapterId && n.target.storageId === e.target.storageId
+  );
+  if (!o) {
+    r({
+      type: "import-result",
+      target: e.target,
+      ok: !1,
+      written: 0,
+      total: e.entries.length,
+      error: "Target storage not found"
+    });
+    return;
+  }
+  for (let n = 0; n < e.entries.length; n++) {
+    const s = e.entries[n];
+    try {
+      await o.set(s);
+    } catch (i) {
+      r({
+        type: "import-result",
+        target: e.target,
+        ok: !1,
+        written: n,
+        total: e.entries.length,
+        failedKey: s.key,
+        error: i instanceof Error ? i.message : String(i)
+      });
+      return;
+    }
+    r({
+      type: "set-entry",
+      target: e.target,
+      entry: s
+    });
+  }
+  r({
+    type: "import-result",
+    target: e.target,
+    ok: !0,
+    written: e.entries.length,
+    total: e.entries.length
+  });
+}, N = 1500, m = (t) => t.kind === "async", w = (t) => t.type === "buffer" ? `${t.type}:${t.value.join(",")}` : `${t.type}:${String(t.value)}`, K = (t) => new Map(t.map((e) => [e.key, e])), I = (t, e) => t.shouldFilterKey?.(e) ? !0 : t.blacklist ? (t.blacklist.lastIndex = 0, t.blacklist.test(e)) : !1, z = (t, e, r) => {
+  if (!M(t, e))
     throw new Error(
-      `Type "${t}" is not supported by storage "${r.storageId}" in adapter "${r.adapterId}".`
+      `Type "${e}" is not supported by storage "${r.storageId}" in adapter "${r.adapterId}".`
     );
-}, b = async (e) => (h(e), e.getAllKeys()), E = async (e, t) => (h(e), e.get(t)), K = async (e, t) => {
-  if (h(e)) {
-    await e.set(t);
+}, b = async (t) => (m(t), t.getAllKeys()), E = async (t, e) => (m(t), t.get(e)), j = async (t, e) => {
+  if (m(t)) {
+    await t.set(e);
     return;
   }
-  e.set(t);
-}, j = async (e, t) => {
-  if (h(e)) {
-    await e.delete(t);
+  t.set(e);
+}, F = async (t, e) => {
+  if (m(t)) {
+    await t.delete(e);
     return;
   }
-  e.delete(t);
-}, S = async (e) => {
-  const t = await e();
-  return N(t);
-}, V = (e, t, r) => {
-  t.forEach((s, n) => {
-    const o = e.get(n);
-    if (!o) {
-      r.onSet(s);
+  t.delete(e);
+}, S = async (t) => {
+  const e = await t();
+  return K(e);
+}, V = (t, e, r) => {
+  e.forEach((o, n) => {
+    const s = t.get(n);
+    if (!s) {
+      r.onSet(o);
       return;
     }
-    w(o) !== w(s) && r.onSet(s);
-  }), e.forEach((s, n) => {
-    t.has(n) || r.onDelete(n);
+    w(s) !== w(o) && r.onSet(o);
+  }), t.forEach((o, n) => {
+    e.has(n) || r.onDelete(n);
   });
-}, _ = async (e, t) => {
-  let r = await S(e);
-  const s = setInterval(async () => {
+}, _ = async (t, e) => {
+  let r = await S(t);
+  const o = setInterval(async () => {
     try {
-      const n = await S(e);
-      V(r, n, t), r = n;
+      const n = await S(t);
+      V(r, n, e), r = n;
     } catch {
     }
-  }, x);
+  }, N);
   return {
     remove: () => {
-      clearInterval(s);
+      clearInterval(o);
     }
   };
-}, D = (e, t) => {
-  const r = t.storage, s = {
-    adapterId: e.id,
-    storageId: t.id
-  }, n = async (d) => {
-    if (!I(t, d))
-      return E(r, d);
-  }, o = async () => {
-    const d = await b(r);
+}, D = (t, e) => {
+  const r = e.storage, o = {
+    adapterId: t.id,
+    storageId: e.id
+  }, n = async (i) => {
+    if (!I(e, i))
+      return E(r, i);
+  }, s = async () => {
+    const i = await b(r);
     return (await Promise.all(
-      d.filter((c) => !I(t, c)).map((c) => E(r, c))
-    )).filter((c) => !!c);
+      i.filter((l) => !I(e, l)).map((l) => E(r, l))
+    )).filter((l) => !!l);
   };
   return {
-    id: k(s),
-    target: s,
-    adapterName: e.name,
-    storageName: t.name,
-    capabilities: t.capabilities,
+    id: R(o),
+    target: o,
+    adapterName: t.name,
+    storageName: e.name,
+    capabilities: e.capabilities,
+    blacklist: e.blacklist,
     get: n,
-    set: async (d) => {
-      z(t.capabilities, d.type, s), await K(r, d);
+    set: async (i) => {
+      z(e.capabilities, i.type, o), await j(r, i);
     },
-    delete: async (d) => {
-      await j(r, d);
+    delete: async (i) => {
+      await F(r, i);
     },
-    getAllKeys: async () => (await b(r)).filter((a) => !I(t, a)),
-    getAllEntries: o,
-    watch: async ({ onSet: d, onDelete: a }) => r.subscribe ? r.subscribe(async (c) => {
+    getAllKeys: async () => (await b(r)).filter((a) => !I(e, a)),
+    getAllEntries: s,
+    watch: async ({ onSet: i, onDelete: a }) => r.subscribe ? r.subscribe(async (l) => {
       try {
-        const i = await n(c);
-        if (!i) {
-          a(c);
+        const d = await n(l);
+        if (!d) {
+          a(l);
           return;
         }
-        d(i);
+        i(d);
       } catch {
       }
-    }) : _(o, { onSet: d, onDelete: a })
+    }) : _(s, { onSet: i, onDelete: a })
   };
-}, F = (e) => e.flatMap(
-  (t) => t.storages.map((r) => D(t, r))
+}, q = (t) => t.flatMap(
+  (e) => e.storages.map(
+    (r) => D(e, r)
+  )
 ), f = {
   adapterId: {
     type: "string",
@@ -192,59 +239,59 @@ const x = 1500, h = (e) => e.kind === "async", w = (e) => e.type === "buffer" ?
       required: ["key"]
     }
   })
-}, v = (e, t) => {
-  if (e === "string") {
-    if (typeof t != "string")
+}, k = (t, e) => {
+  if (t === "string") {
+    if (typeof e != "string")
       throw new Error("Expected string value for type=string");
-    return t;
+    return e;
   }
-  if (e === "number") {
-    if (typeof t != "number" || Number.isNaN(t))
+  if (t === "number") {
+    if (typeof e != "number" || Number.isNaN(e))
       throw new Error("Expected number value for type=number");
-    return t;
+    return e;
   }
-  if (e === "boolean") {
-    if (typeof t != "boolean")
+  if (t === "boolean") {
+    if (typeof e != "boolean")
       throw new Error("Expected boolean value for type=boolean");
-    return t;
+    return e;
   }
-  if (!Array.isArray(t) || !t.every((r) => Number.isInteger(r)))
+  if (!Array.isArray(e) || !e.every((r) => Number.isInteger(r)))
     throw new Error("Expected number[] value for type=buffer");
-  return t;
-}, m = (e) => `${e.target.adapterId}/${e.target.storageId}`, q = (e) => {
-  const t = P(
-    (r, s) => {
-      if (e.length === 0)
+  return e;
+}, h = (t) => `${t.target.adapterId}/${t.target.storageId}`, L = (t) => {
+  const e = A(
+    (r, o) => {
+      if (t.length === 0)
         throw new Error("No storages are registered.");
-      if (r !== void 0 || s !== void 0) {
-        const n = e.find(
-          (o) => (r === void 0 || o.target.adapterId === r) && (s === void 0 || o.target.storageId === s)
+      if (r !== void 0 || o !== void 0) {
+        const n = t.find(
+          (s) => (r === void 0 || s.target.adapterId === r) && (o === void 0 || s.target.storageId === o)
         );
         if (!n) {
-          const o = [
+          const s = [
             r && `adapterId="${r}"`,
-            s && `storageId="${s}"`
+            o && `storageId="${o}"`
           ].filter(Boolean).join(", ");
           throw new Error(
-            `No storage matched ${o}. Available: ${e.map(m).join(", ")}`
+            `No storage matched ${s}. Available: ${t.map(h).join(", ")}`
           );
         }
         return n;
       }
-      if (e.length > 1)
+      if (t.length > 1)
         throw new Error(
-          `Multiple storages detected. Provide adapterId and/or storageId. Available: ${e.map(m).join(", ")}`
+          `Multiple storages detected. Provide adapterId and/or storageId. Available: ${t.map(h).join(", ")}`
         );
-      return e[0];
+      return t[0];
     },
-    [e]
+    [t]
   );
-  l({
+  p({
     pluginId: u,
     tool: y.listStorages,
     handler: async () => ({
       storages: await Promise.all(
-        e.map(async (r) => ({
+        t.map(async (r) => ({
           adapterId: r.target.adapterId,
           storageId: r.target.storageId,
           adapterName: r.adapterName,
@@ -254,203 +301,218 @@ const x = 1500, h = (e) => e.kind === "async", w = (e) => e.type === "buffer" ?
         }))
       )
     })
-  }), l({
+  }), p({
     pluginId: u,
     tool: y.listEntries,
-    handler: async ({ adapterId: r, storageId: s, offset: n = 0, limit: o = 100 }) => {
-      const d = t(r, s), a = await d.getAllKeys(), c = Math.max(0, Math.floor(n)), i = Math.max(1, Math.floor(o)), p = a.slice(c, c + i);
+    handler: async ({ adapterId: r, storageId: o, offset: n = 0, limit: s = 100 }) => {
+      const i = e(r, o), a = await i.getAllKeys(), l = Math.max(0, Math.floor(n)), d = Math.max(1, Math.floor(s)), c = a.slice(l, l + d);
       return {
-        adapterId: d.target.adapterId,
-        storageId: d.target.storageId,
+        adapterId: i.target.adapterId,
+        storageId: i.target.storageId,
         total: a.length,
-        offset: c,
-        limit: i,
-        keys: p
+        offset: l,
+        limit: d,
+        keys: c
       };
     }
-  }), l({
+  }), p({
     pluginId: u,
     tool: y.readEntry,
-    handler: async ({ adapterId: r, storageId: s, key: n }) => {
-      const o = t(r, s), d = await o.get(n);
-      if (!d)
+    handler: async ({ adapterId: r, storageId: o, key: n }) => {
+      const s = e(r, o), i = await s.get(n);
+      if (!i)
         throw new Error(
-          `Key "${n}" not found in storage "${m(o)}".`
+          `Key "${n}" not found in storage "${h(s)}".`
         );
       return {
-        adapterId: o.target.adapterId,
-        storageId: o.target.storageId,
-        entry: d
+        adapterId: s.target.adapterId,
+        storageId: s.target.storageId,
+        entry: i
       };
     }
-  }), l({
+  }), p({
     pluginId: u,
     tool: y.createEntry,
-    handler: async ({ adapterId: r, storageId: s, key: n, type: o, value: d }) => {
-      const a = t(r, s);
+    handler: async ({ adapterId: r, storageId: o, key: n, type: s, value: i }) => {
+      const a = e(r, o);
       if (await a.get(n))
         throw new Error(
-          `Key "${n}" already exists in storage "${m(a)}". Use edit-entry instead.`
+          `Key "${n}" already exists in storage "${h(a)}". Use edit-entry instead.`
         );
-      const i = v(o, d);
-      return await a.set({ key: n, type: o, value: i }), {
+      const d = k(s, i);
+      return await a.set({ key: n, type: s, value: d }), {
         adapterId: a.target.adapterId,
         storageId: a.target.storageId,
         created: !0,
         key: n
       };
     }
-  }), l({
+  }), p({
     pluginId: u,
     tool: y.editEntry,
-    handler: async ({ adapterId: r, storageId: s, key: n, type: o, value: d }) => {
-      const a = t(r, s);
+    handler: async ({ adapterId: r, storageId: o, key: n, type: s, value: i }) => {
+      const a = e(r, o);
       if (!await a.get(n))
         throw new Error(
-          `Key "${n}" not found in storage "${m(a)}". Use create-entry instead.`
+          `Key "${n}" not found in storage "${h(a)}". Use create-entry instead.`
         );
-      const i = v(o, d);
-      return await a.set({ key: n, type: o, value: i }), {
+      const d = k(s, i);
+      return await a.set({ key: n, type: s, value: d }), {
         adapterId: a.target.adapterId,
         storageId: a.target.storageId,
         edited: !0,
         key: n
       };
     }
-  }), l({
+  }), p({
     pluginId: u,
     tool: y.removeEntry,
-    handler: async ({ adapterId: r, storageId: s, key: n }) => {
-      const o = t(r, s), d = !!await o.get(n);
-      return await o.delete(n), {
-        adapterId: o.target.adapterId,
-        storageId: o.target.storageId,
-        removed: d,
+    handler: async ({ adapterId: r, storageId: o, key: n }) => {
+      const s = e(r, o), i = !!await s.get(n);
+      return await s.delete(n), {
+        adapterId: s.target.adapterId,
+        storageId: s.target.storageId,
+        removed: i,
         key: n
       };
     }
   });
-}, Y = ({
-  storages: e
+}, B = ({
+  storages: t
 }) => {
-  const t = T(() => F(e), [e]);
-  q(t);
-  const r = A({
+  const e = T(() => q(t), [t]);
+  L(e);
+  const r = v({
     pluginId: "@rozenite/storage-plugin"
   });
-  return R(() => {
+  return P(() => {
     if (!r)
       return;
-    const s = async (a) => {
-      const c = a ? t.filter((i) => i.id === a) : t;
-      for (const i of c)
+    const o = async (a) => {
+      const l = a ? e.filter((d) => d.id === a) : e;
+      for (const d of l)
         try {
-          const p = await i.getAllEntries();
+          const c = await d.getAllEntries();
           r.send("snapshot", {
             type: "snapshot",
-            target: i.target,
-            adapterName: i.adapterName,
-            storageName: i.storageName,
-            capabilities: i.capabilities,
-            entries: p
+            target: d.target,
+            adapterName: d.adapterName,
+            storageName: d.storageName,
+            capabilities: d.capabilities,
+            blacklist: d.blacklist ? { source: d.blacklist.source, flags: d.blacklist.flags } : void 0,
+            entries: c
           });
-        } catch (p) {
+        } catch (c) {
           console.warn(
-            `[Rozenite] Storage Plugin: Failed to snapshot ${i.target.adapterId}/${i.target.storageId}.`,
-            p
+            `[Rozenite] Storage Plugin: Failed to snapshot ${d.target.adapterId}/${d.target.storageId}.`,
+            c
           );
         }
     };
-    s();
+    o();
     const n = [];
-    let o = !1;
+    let s = !1;
     Promise.all(
-      t.map(async (a) => {
+      e.map(async (a) => {
         try {
-          const c = await a.watch({
-            onSet: (i) => {
+          const l = await a.watch({
+            onSet: (d) => {
               r.send("set-entry", {
                 type: "set-entry",
                 target: a.target,
-                entry: i
+                entry: d
               });
             },
-            onDelete: (i) => {
+            onDelete: (d) => {
               r.send("delete-entry", {
                 type: "delete-entry",
                 target: a.target,
-                key: i
+                key: d
               });
             }
           });
-          if (o) {
-            c.remove();
+          if (s) {
+            l.remove();
             return;
           }
-          n.push(c);
-        } catch (c) {
+          n.push(l);
+        } catch (l) {
           console.warn(
             `[Rozenite] Storage Plugin: Failed to attach watcher for ${a.target.adapterId}/${a.target.storageId}.`,
-            c
+            l
           );
         }
       })
     );
-    const d = [
-      r.onMessage("set-entry", async ({ target: a, entry: c }) => {
-        const i = t.find(
-          (p) => p.target.adapterId === a.adapterId && p.target.storageId === a.storageId
-        );
-        if (!i) {
-          console.warn(
-            `[Rozenite] Storage Plugin: Storage target not found for ${a.adapterId}/${a.storageId}`
-          );
-          return;
-        }
-        try {
-          await i.set(c);
-        } catch (p) {
-          console.warn(
-            `[Rozenite] Storage Plugin: Failed to set entry in ${a.adapterId}/${a.storageId}.`,
-            p
+    const i = [
+      r.onMessage(
+        "set-entry",
+        async ({ target: a, entry: l }) => {
+          const d = e.find(
+            (c) => c.target.adapterId === a.adapterId && c.target.storageId === a.storageId
           );
+          if (!d) {
+            console.warn(
+              `[Rozenite] Storage Plugin: Storage target not found for ${a.adapterId}/${a.storageId}`
+            );
+            return;
+          }
+          try {
+            await d.set(l);
+          } catch (c) {
+            console.warn(
+              `[Rozenite] Storage Plugin: Failed to set entry in ${a.adapterId}/${a.storageId}.`,
+              c
+            );
+          }
         }
-      }),
+      ),
       r.onMessage(
         "delete-entry",
-        async ({ target: a, key: c }) => {
-          const i = t.find(
-            (p) => p.target.adapterId === a.adapterId && p.target.storageId === a.storageId
+        async ({ target: a, key: l }) => {
+          const d = e.find(
+            (c) => c.target.adapterId === a.adapterId && c.target.storageId === a.storageId
           );
-          if (!i) {
+          if (!d) {
             console.warn(
               `[Rozenite] Storage Plugin: Storage target not found for ${a.adapterId}/${a.storageId}`
             );
             return;
           }
           try {
-            await i.delete(c);
-          } catch (p) {
+            await d.delete(l);
+          } catch (c) {
             console.warn(
               `[Rozenite] Storage Plugin: Failed to delete entry in ${a.adapterId}/${a.storageId}.`,
-              p
+              c
             );
           }
         }
       ),
-      r.onMessage("get-snapshot", async ({ target: a }) => {
-        if (a === "all") {
-          await s();
-          return;
+      r.onMessage(
+        "get-snapshot",
+        async ({ target: a }) => {
+          if (a === "all") {
+            await o();
+            return;
+          }
+          await o(`${a.adapterId}:${a.storageId}`);
         }
-        await s(`${a.adapterId}:${a.storageId}`);
-      })
+      ),
+      r.onMessage(
+        "import-entries",
+        async (a) => {
+          await x(e, a, (l) => {
+            l.type === "set-entry" ? r.send("set-entry", l) : r.send("import-result", l);
+          });
+        }
+      )
     ];
     return () => {
-      o = !0, n.forEach((a) => a.remove()), d.forEach((a) => a.remove());
+      s = !0, n.forEach((a) => a.remove()), i.forEach((a) => a.remove());
     };
-  }, [r, t]), r;
+  }, [r, e]), r;
 };
 export {
-  Y as useRozeniteStoragePlugin
+  B as useRozeniteStoragePlugin
 };