npm - @rozenite/sqlite-plugin - Versions diffs - 1.7.0 → 1.8.1 - Mend

@rozenite/sqlite-plugin 1.7.0 → 1.8.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/CHANGELOG.md +20 -0
package/dist/devtools/assets/{panel-B3paLkwG.js → panel-DjRs5NTl.js} +28 -28
package/dist/devtools/panel.html +1 -1
package/dist/react-native/chunks/useRozeniteSqlitePlugin.require.cjs +1 -1
package/dist/react-native/chunks/useRozeniteSqlitePlugin.require.js +208 -97
package/dist/react-native/index.cjs +1 -1
package/dist/react-native/index.d.ts +1 -1
package/dist/react-native/index.js +2 -2
package/dist/rozenite.json +1 -1
package/package.json +6 -5
package/react-native.ts +1 -1
package/src/react-native/useRozeniteSqlitePlugin.ts +3 -0
package/src/react-native/useSqliteAgentTools.ts +152 -0
package/vite.config.ts +3 -0

package/dist/devtools/panel.html CHANGED Viewed

@@ -22,7 +22,7 @@
     <script>
       var __ROZENITE_PANEL__ = true;
     </script>
-    <script type="module" crossorigin src="../devtools/assets/panel-B3paLkwG.js"></script>
+    <script type="module" crossorigin src="../devtools/assets/panel-DjRs5NTl.js"></script>
     <link rel="stylesheet" crossorigin href="../devtools/assets/panel-CIU0JBOs.css">
   </head>
   <body>

package/dist/react-native/chunks/useRozeniteSqlitePlugin.require.cjs CHANGED Viewed

	@@ -1 +1 @@
1	- "use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const R=require("@rozenite/plugin-bridge"),h=require("react"),f=require("./bridge-values.cjs"),v="@rozenite/sqlite-plugin",M=a=>a.flatMap(l=>l.databases.map(s=>({id:s.id,name:s.name,adapterId:l.id,adapterName:l.name,executeStatements:s.executeStatements}))),q=a=>f.~~formatSqliteError~~(a),b=a=>a instanceof Error&&("completedResults"in a\|\|"failedStatementIndex"in a),z=({adapters:a})=>{const l=h.useMemo(()=>M(a),[a]),s=R.useRozeniteDevToolsClient({pluginId:v}),m=h.useRef([]),S=h.useRef(new Map);return h.useEffect(()=>{if(!s)return;const g=async(n,t)=>{const r=(S.current.get(n)??Promise.resolve()).catch(()=>{}).then(t);return S.current.set(n,r.then(()=>{},()=>{})),r},w=n=>{const t=l.find(o=>o.id===n);if(!t)throw new Error(`Unknown database "${n}".`);return t},y=async(n,t)=>{const o=w(n),r=t.map(({sql:i,params:u})=>({sql:f.normalizeSingleStatementSql(i),params:u})),e=await o.executeStatements(r);if(e.length!==r.length)throw new Error(`Expected ${r.length} statement result(s), received ${e.length}.`);return{inputs:r,results:e}},x=async(n,t,o)=>{const e=(await y(n,[{sql:t,params:o}])).results[0];if(!e)throw new Error("The query completed without a result payload.");return e};return s.send("sqlite:ready",{timestamp:Date.now()}),m.current.push(s.onMessage("sqlite:list-databases",({requestId:n})=>{s.send("sqlite:list-databases:result",{requestId:n,databases:l.map(({id:t,name:o,adapterId:r,adapterName:e})=>({id:t,name:o,adapterId:r,adapterName:e}))})})),m.current.push(s.onMessage("sqlite:query",async({requestId:n,databaseId:t,sql:o,params:r})=>{try{const e=await g(t,()=>x(t,o,r));s.send("sqlite:query:result",{requestId:n,databaseId:t,result:e})}catch(e){s.send("sqlite:query:result",{requestId:n,databaseId:t,error:q(e)})}})),m.current.push(s.onMessage("sqlite:execute-script",async({requestId:n,databaseId:t,sql:o})=>{try{const r=await g(t,async()=>{const e=f.splitSqlStatements(o);if(e.length===0)throw new Error("Query cannot be empty.");const i=e.map(u=>({sql:u.text}));try{const u=await y(t,i);return{statements:e.map((c,p)=>({index:p,start:c.start,end:c.end,input:u.inputs[p],execution:{input:u.inputs[p],result:u.results[p]}})),totalStatementCount:e.length,failedStatementIndex:null}}catch(u){if(!b(u))throw u;const c=Math.max(0,Math.min(typeof u.failedStatementIndex=="number"?u.failedStatementIndex:u.completedResults?.length??0,e.length-1));return{statements:[...(u.completedResults??[]).slice(0,c).map((E,d)=>({index:d,start:e[d].start,end:e[d].end,input:i[d],execution:{input:i[d],result:E}})),{index:c,start:e[c].start,end:e[c].end,input:i[c],error:q(u)}],totalStatementCount:e.length,failedStatementIndex:c}}});s.send("sqlite:execute-script:result",{requestId:n,databaseId:t,result:r})}catch(r){s.send("sqlite:execute-script:result",{requestId:n,databaseId:t,error:q(r)})}})),()=>{m.current.forEach(n=>n.remove()),m.current=[],S.current.clear()}},[s,l]),s};exports.useRozeniteSqlitePlugin=z;
1	+ "use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const D=require("@rozenite/plugin-bridge"),y=require("react"),g=require("./bridge-values.cjs"),E=require("@rozenite/agent-bridge"),M="@rozenite/sqlite-plugin",T=r=>r.flatMap(p=>p.databases.map(t=>({id:t.id,name:t.name,adapterId:p.id,adapterName:p.name,executeStatements:t.executeStatements}))),b="@rozenite/sqlite-plugin",v={name:"list-databases",description:"List all registered SQLite databases.",inputSchema:{type:"object",properties:{}}},z={name:"execute-sql",description:"Execute one or more SQL statements against a database. Supports SELECT, INSERT, UPDATE, DELETE, PRAGMA, DDL, and multi-statement scripts. Returns per-statement results including rows, columns, and metadata. Statements are executed in order and stop on first error.",inputSchema:{type:"object",properties:{databaseId:{type:"string",description:"Database ID from list-databases."},sql:{type:"string",description:"SQL to execute. May contain multiple semicolon-separated statements."}},required:["databaseId","sql"]}},I=r=>r instanceof Error&&("completedResults"in r\|\|"failedStatementIndex"in r),L=r=>{const p=y.useCallback(t=>{const u=r.find(m=>m.id===t);if(!u){const m=r.map(c=>c.id).join(", ");throw new Error(`Unknown databaseId "${t}". Available: ${m\|\|"(none)"}`)}return u},[r]);E.useRozenitePluginAgentTool({pluginId:b,tool:v,handler:()=>({databases:r.map(({id:t,name:u,adapterId:m,adapterName:c})=>({id:t,name:u,adapterId:m,adapterName:c}))})}),E.useRozenitePluginAgentTool({pluginId:b,tool:z,handler:async({databaseId:t,sql:u})=>{const m=p(t),c=g.splitSqlStatements(u);if(c.length===0)throw new Error("SQL cannot be empty.");const q=c.map(i=>({sql:g.normalizeSingleStatementSql(i.text)}));try{const i=await m.executeStatements(q);return{databaseId:t,totalStatementCount:c.length,failedStatementIndex:null,statements:c.map((S,n)=>{const e=i[n];return{index:n,sql:q[n].sql,rows:e.rows,columns:e.columns,metadata:e.metadata}})}}catch(i){if(!I(i))throw new Error(g.formatSqliteError(i));const S=Math.max(0,Math.min(typeof i.failedStatementIndex=="number"?i.failedStatementIndex:i.completedResults?.length??0,c.length-1)),n=(i.completedResults??[]).slice(0,S);return{databaseId:t,totalStatementCount:c.length,failedStatementIndex:S,statements:[...n.map((e,o)=>({index:o,sql:q[o].sql,rows:e.rows,columns:e.columns,metadata:e.metadata})),{index:S,sql:q[S].sql,error:g.formatSqliteError(i)}]}}}})},x=r=>g.formatSqliteError(r),P=r=>r instanceof Error&&("completedResults"in r\|\|"failedStatementIndex"in r),A=({adapters:r})=>{const p=y.useMemo(()=>T(r),[r]);L(p);const t=D.useRozeniteDevToolsClient({pluginId:M}),u=y.useRef([]),m=y.useRef(new Map);return y.useEffect(()=>{if(!t)return;const c=async(n,e)=>{const a=(m.current.get(n)??Promise.resolve()).catch(()=>{}).then(e);return m.current.set(n,a.then(()=>{},()=>{})),a},q=n=>{const e=p.find(o=>o.id===n);if(!e)throw new Error(`Unknown database "${n}".`);return e},i=async(n,e)=>{const o=q(n),a=e.map(({sql:h,params:l})=>({sql:g.normalizeSingleStatementSql(h),params:l})),s=await o.executeStatements(a);if(s.length!==a.length)throw new Error(`Expected ${a.length} statement result(s), received ${s.length}.`);return{inputs:a,results:s}},S=async(n,e,o)=>{const s=(await i(n,[{sql:e,params:o}])).results[0];if(!s)throw new Error("The query completed without a result payload.");return s};return t.send("sqlite:ready",{timestamp:Date.now()}),u.current.push(t.onMessage("sqlite:list-databases",({requestId:n})=>{t.send("sqlite:list-databases:result",{requestId:n,databases:p.map(({id:e,name:o,adapterId:a,adapterName:s})=>({id:e,name:o,adapterId:a,adapterName:s}))})})),u.current.push(t.onMessage("sqlite:query",async({requestId:n,databaseId:e,sql:o,params:a})=>{try{const s=await c(e,()=>S(e,o,a));t.send("sqlite:query:result",{requestId:n,databaseId:e,result:s})}catch(s){t.send("sqlite:query:result",{requestId:n,databaseId:e,error:x(s)})}})),u.current.push(t.onMessage("sqlite:execute-script",async({requestId:n,databaseId:e,sql:o})=>{try{const a=await c(e,async()=>{const s=g.splitSqlStatements(o);if(s.length===0)throw new Error("Query cannot be empty.");const h=s.map(l=>({sql:l.text}));try{const l=await i(e,h);return{statements:s.map((d,f)=>({index:f,start:d.start,end:d.end,input:l.inputs[f],execution:{input:l.inputs[f],result:l.results[f]}})),totalStatementCount:s.length,failedStatementIndex:null}}catch(l){if(!P(l))throw l;const d=Math.max(0,Math.min(typeof l.failedStatementIndex=="number"?l.failedStatementIndex:l.completedResults?.length??0,s.length-1));return{statements:[...(l.completedResults??[]).slice(0,d).map((R,w)=>({index:w,start:s[w].start,end:s[w].end,input:h[w],execution:{input:h[w],result:R}})),{index:d,start:s[d].start,end:s[d].end,input:h[d],error:x(l)}],totalStatementCount:s.length,failedStatementIndex:d}}});t.send("sqlite:execute-script:result",{requestId:n,databaseId:e,result:a})}catch(a){t.send("sqlite:execute-script:result",{requestId:n,databaseId:e,error:x(a)})}})),()=>{u.current.forEach(n=>n.remove()),u.current=[],m.current.clear()}},[t,p]),t};exports.useRozeniteSqlitePlugin=A;

package/dist/react-native/chunks/useRozeniteSqlitePlugin.require.js CHANGED Viewed

@@ -1,27 +1,138 @@
-import { useRozeniteDevToolsClient as E } from "@rozenite/plugin-bridge";
-import { useMemo as R, useRef as w, useEffect as v } from "react";
-import { f as M, a as D, n as z } from "./bridge-values.js";
-const b = "@rozenite/sqlite-plugin", C = (u) => u.flatMap(
-  (l) => l.databases.map((s) => ({
-    id: s.id,
-    name: s.name,
-    adapterId: l.id,
-    adapterName: l.name,
-    executeStatements: s.executeStatements
+import { useRozeniteDevToolsClient as T } from "@rozenite/plugin-bridge";
+import { useCallback as v, useMemo as I, useRef as y, useEffect as L } from "react";
+import { a as R, n as D, f as x } from "./bridge-values.js";
+import { useRozenitePluginAgentTool as E } from "@rozenite/agent-bridge";
+const z = "@rozenite/sqlite-plugin", C = (a) => a.flatMap(
+  (p) => p.databases.map((e) => ({
+    id: e.id,
+    name: e.name,
+    adapterId: p.id,
+    adapterName: p.name,
+    executeStatements: e.executeStatements
   }))
-), d = (u) => M(u), P = (u) => u instanceof Error && ("completedResults" in u || "failedStatementIndex" in u), N = ({
-  adapters: u
+), b = "@rozenite/sqlite-plugin", Q = {
+  name: "list-databases",
+  description: "List all registered SQLite databases.",
+  inputSchema: { type: "object", properties: {} }
+}, A = {
+  name: "execute-sql",
+  description: "Execute one or more SQL statements against a database. Supports SELECT, INSERT, UPDATE, DELETE, PRAGMA, DDL, and multi-statement scripts. Returns per-statement results including rows, columns, and metadata. Statements are executed in order and stop on first error.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      databaseId: {
+        type: "string",
+        description: "Database ID from list-databases."
+      },
+      sql: {
+        type: "string",
+        description: "SQL to execute. May contain multiple semicolon-separated statements."
+      }
+    },
+    required: ["databaseId", "sql"]
+  }
+}, P = (a) => a instanceof Error && ("completedResults" in a || "failedStatementIndex" in a), $ = (a) => {
+  const p = v(
+    (e) => {
+      const u = a.find((m) => m.id === e);
+      if (!u) {
+        const m = a.map((i) => i.id).join(", ");
+        throw new Error(
+          `Unknown databaseId "${e}". Available: ${m || "(none)"}`
+        );
+      }
+      return u;
+    },
+    [a]
+  );
+  E({
+    pluginId: b,
+    tool: Q,
+    handler: () => ({
+      databases: a.map(({ id: e, name: u, adapterId: m, adapterName: i }) => ({
+        id: e,
+        name: u,
+        adapterId: m,
+        adapterName: i
+      }))
+    })
+  }), E({
+    pluginId: b,
+    tool: A,
+    handler: async ({ databaseId: e, sql: u }) => {
+      const m = p(e), i = R(u);
+      if (i.length === 0)
+        throw new Error("SQL cannot be empty.");
+      const h = i.map((c) => ({
+        sql: D(c.text)
+      }));
+      try {
+        const c = await m.executeStatements(h);
+        return {
+          databaseId: e,
+          totalStatementCount: i.length,
+          failedStatementIndex: null,
+          statements: i.map((S, n) => {
+            const t = c[n];
+            return {
+              index: n,
+              sql: h[n].sql,
+              rows: t.rows,
+              columns: t.columns,
+              metadata: t.metadata
+            };
+          })
+        };
+      } catch (c) {
+        if (!P(c))
+          throw new Error(x(c));
+        const S = Math.max(
+          0,
+          Math.min(
+            typeof c.failedStatementIndex == "number" ? c.failedStatementIndex : c.completedResults?.length ?? 0,
+            i.length - 1
+          )
+        ), n = (c.completedResults ?? []).slice(
+          0,
+          S
+        );
+        return {
+          databaseId: e,
+          totalStatementCount: i.length,
+          failedStatementIndex: S,
+          statements: [
+            ...n.map((t, o) => ({
+              index: o,
+              sql: h[o].sql,
+              rows: t.rows,
+              columns: t.columns,
+              metadata: t.metadata
+            })),
+            {
+              index: S,
+              sql: h[S].sql,
+              error: x(c)
+            }
+          ]
+        };
+      }
+    }
+  });
+}, w = (a) => x(a), k = (a) => a instanceof Error && ("completedResults" in a || "failedStatementIndex" in a), V = ({
+  adapters: a
 }) => {
-  const l = R(() => C(u), [u]), s = E({
-    pluginId: b
-  }), m = w([]), f = w(/* @__PURE__ */ new Map());
-  return v(() => {
-    if (!s)
+  const p = I(() => C(a), [a]);
+  $(p);
+  const e = T({
+    pluginId: z
+  }), u = y([]), m = y(/* @__PURE__ */ new Map());
+  return L(() => {
+    if (!e)
       return;
-    const S = async (n, t) => {
-      const r = (f.current.get(n) ?? Promise.resolve()).catch(() => {
+    const i = async (n, t) => {
+      const r = (m.current.get(n) ?? Promise.resolve()).catch(() => {
       }).then(t);
-      return f.current.set(
+      return m.current.set(
         n,
         r.then(
           () => {
@@ -30,160 +141,160 @@ const b = "@rozenite/sqlite-plugin", C = (u) => u.flatMap(
           }
         )
       ), r;
-    }, g = (n) => {
-      const t = l.find((a) => a.id === n);
+    }, h = (n) => {
+      const t = p.find((o) => o.id === n);
       if (!t)
         throw new Error(`Unknown database "${n}".`);
       return t;
-    }, q = async (n, t) => {
-      const a = g(n), r = t.map(({ sql: i, params: o }) => ({
-        sql: z(i),
-        params: o
-      })), e = await a.executeStatements(r);
-      if (e.length !== r.length)
+    }, c = async (n, t) => {
+      const o = h(n), r = t.map(({ sql: f, params: l }) => ({
+        sql: D(f),
+        params: l
+      })), s = await o.executeStatements(r);
+      if (s.length !== r.length)
         throw new Error(
-          `Expected ${r.length} statement result(s), received ${e.length}.`
+          `Expected ${r.length} statement result(s), received ${s.length}.`
         );
       return {
         inputs: r,
-        results: e
+        results: s
       };
-    }, y = async (n, t, a) => {
-      const e = (await q(n, [
+    }, S = async (n, t, o) => {
+      const s = (await c(n, [
         {
           sql: t,
-          params: a
+          params: o
         }
       ])).results[0];
-      if (!e)
+      if (!s)
         throw new Error("The query completed without a result payload.");
-      return e;
+      return s;
     };
-    return s.send("sqlite:ready", { timestamp: Date.now() }), m.current.push(
-      s.onMessage("sqlite:list-databases", ({ requestId: n }) => {
-        s.send("sqlite:list-databases:result", {
+    return e.send("sqlite:ready", { timestamp: Date.now() }), u.current.push(
+      e.onMessage("sqlite:list-databases", ({ requestId: n }) => {
+        e.send("sqlite:list-databases:result", {
           requestId: n,
-          databases: l.map(({ id: t, name: a, adapterId: r, adapterName: e }) => ({
+          databases: p.map(({ id: t, name: o, adapterId: r, adapterName: s }) => ({
             id: t,
-            name: a,
+            name: o,
             adapterId: r,
-            adapterName: e
+            adapterName: s
           }))
         });
       })
-    ), m.current.push(
-      s.onMessage(
+    ), u.current.push(
+      e.onMessage(
         "sqlite:query",
-        async ({ requestId: n, databaseId: t, sql: a, params: r }) => {
+        async ({ requestId: n, databaseId: t, sql: o, params: r }) => {
           try {
-            const e = await S(
+            const s = await i(
               t,
-              () => y(t, a, r)
+              () => S(t, o, r)
             );
-            s.send("sqlite:query:result", {
+            e.send("sqlite:query:result", {
               requestId: n,
               databaseId: t,
-              result: e
+              result: s
             });
-          } catch (e) {
-            s.send("sqlite:query:result", {
+          } catch (s) {
+            e.send("sqlite:query:result", {
               requestId: n,
               databaseId: t,
-              error: d(e)
+              error: w(s)
             });
           }
         }
       )
-    ), m.current.push(
-      s.onMessage(
+    ), u.current.push(
+      e.onMessage(
         "sqlite:execute-script",
-        async ({ requestId: n, databaseId: t, sql: a }) => {
+        async ({ requestId: n, databaseId: t, sql: o }) => {
           try {
-            const r = await S(t, async () => {
-              const e = D(a);
-              if (e.length === 0)
+            const r = await i(t, async () => {
+              const s = R(o);
+              if (s.length === 0)
                 throw new Error("Query cannot be empty.");
-              const i = e.map((o) => ({
-                sql: o.text
+              const f = s.map((l) => ({
+                sql: l.text
               }));
               try {
-                const o = await q(
+                const l = await c(
                   t,
-                  i
+                  f
                 );
                 return {
-                  statements: e.map((c, p) => ({
-                    index: p,
-                    start: c.start,
-                    end: c.end,
-                    input: o.inputs[p],
+                  statements: s.map((d, q) => ({
+                    index: q,
+                    start: d.start,
+                    end: d.end,
+                    input: l.inputs[q],
                     execution: {
-                      input: o.inputs[p],
-                      result: o.results[p]
+                      input: l.inputs[q],
+                      result: l.results[q]
                     }
                   })),
-                  totalStatementCount: e.length,
+                  totalStatementCount: s.length,
                   failedStatementIndex: null
                 };
-              } catch (o) {
-                if (!P(o))
-                  throw o;
-                const c = Math.max(
+              } catch (l) {
+                if (!k(l))
+                  throw l;
+                const d = Math.max(
                   0,
                   Math.min(
-                    typeof o.failedStatementIndex == "number" ? o.failedStatementIndex : o.completedResults?.length ?? 0,
-                    e.length - 1
+                    typeof l.failedStatementIndex == "number" ? l.failedStatementIndex : l.completedResults?.length ?? 0,
+                    s.length - 1
                   )
                 );
                 return {
                   statements: [
-                    ...(o.completedResults ?? []).slice(
+                    ...(l.completedResults ?? []).slice(
                       0,
-                      c
+                      d
                     ).map(
-                      (x, h) => ({
-                        index: h,
-                        start: e[h].start,
-                        end: e[h].end,
-                        input: i[h],
+                      (M, g) => ({
+                        index: g,
+                        start: s[g].start,
+                        end: s[g].end,
+                        input: f[g],
                         execution: {
-                          input: i[h],
-                          result: x
+                          input: f[g],
+                          result: M
                         }
                       })
                     ),
                     {
-                      index: c,
-                      start: e[c].start,
-                      end: e[c].end,
-                      input: i[c],
-                      error: d(o)
+                      index: d,
+                      start: s[d].start,
+                      end: s[d].end,
+                      input: f[d],
+                      error: w(l)
                     }
                   ],
-                  totalStatementCount: e.length,
-                  failedStatementIndex: c
+                  totalStatementCount: s.length,
+                  failedStatementIndex: d
                 };
               }
             });
-            s.send("sqlite:execute-script:result", {
+            e.send("sqlite:execute-script:result", {
               requestId: n,
               databaseId: t,
               result: r
             });
           } catch (r) {
-            s.send("sqlite:execute-script:result", {
+            e.send("sqlite:execute-script:result", {
               requestId: n,
               databaseId: t,
-              error: d(r)
+              error: w(r)
             });
           }
         }
       )
     ), () => {
-      m.current.forEach((n) => n.remove()), m.current = [], f.current.clear();
+      u.current.forEach((n) => n.remove()), u.current = [], m.current.clear();
     };
-  }, [s, l]), s;
+  }, [e, p]), e;
 };
 export {
-  N as useRozeniteSqlitePlugin
+  V as useRozeniteSqlitePlugin
 };

package/dist/react-native/index.cjs CHANGED Viewed

	@@ -1 +1 @@
1	- "use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});exports.createSqliteAdapter=void 0;exports.createExpoSqliteAdapter=void 0;exports.useRozeniteSqlitePlugin=void 0;const t=typeof window<"u"&&window.navigator.product!=="ReactNative",~~i=process.env.NODE_ENV!=="production",~~a=typeof window>"u";i&&!~~t&&!~~a?(exports.createSqliteAdapter=require("./chunks/index.require.cjs").createSqliteAdapter,exports.createExpoSqliteAdapter=require("./chunks/index.require.cjs").createExpoSqliteAdapter,exports.useRozeniteSqlitePlugin=require("./chunks/useRozeniteSqlitePlugin.require.cjs").useRozeniteSqlitePlugin):(exports.createSqliteAdapter=e=>({id:e.adapterId??"sqlite",name:e.adapterName??"SQLite",databases:[]}),exports.createExpoSqliteAdapter=e=>({id:e.adapterId??"expo-sqlite",name:e.adapterName??"Expo SQLite",databases:[]}),exports.useRozeniteSqlitePlugin=()=>null);
1	+ "use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});exports.createSqliteAdapter=void 0;exports.createExpoSqliteAdapter=void 0;exports.useRozeniteSqlitePlugin=void 0;const t=process.env.NODE_ENV!=="production",i=typeof window<"u"&&window.navigator.product!=="ReactNative",a=typeof window>"u";t&&!i&&!a?(exports.createSqliteAdapter=require("./chunks/index.require.cjs").createSqliteAdapter,exports.createExpoSqliteAdapter=require("./chunks/index.require.cjs").createExpoSqliteAdapter,exports.useRozeniteSqlitePlugin=require("./chunks/useRozeniteSqlitePlugin.require.cjs").useRozeniteSqlitePlugin):(exports.createSqliteAdapter=e=>({id:e.adapterId??"sqlite",name:e.adapterName??"SQLite",databases:[]}),exports.createExpoSqliteAdapter=e=>({id:e.adapterId??"expo-sqlite",name:e.adapterName??"Expo SQLite",databases:[]}),exports.useRozeniteSqlitePlugin=()=>null);

package/dist/react-native/index.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { RozeniteDevToolsClient } from '../../../plugin-bridge/src/index.ts';
+import { RozeniteDevToolsClient } from '@rozenite/plugin-bridge';
 declare type CreateExpoSqliteAdapter = createExpoSqliteAdapter_2;

package/dist/react-native/index.js CHANGED Viewed

@@ -1,6 +1,6 @@
 let t, a, i;
-const r = typeof window < "u" && window.navigator.product !== "ReactNative", d = process.env.NODE_ENV !== "production", n = typeof window > "u";
-d && !r && !n ? (t = require("./chunks/index.require.js").createSqliteAdapter, a = require("./chunks/index.require.js").createExpoSqliteAdapter, i = require("./chunks/useRozeniteSqlitePlugin.require.js").useRozeniteSqlitePlugin) : (t = (e) => ({
+const r = process.env.NODE_ENV !== "production", d = typeof window < "u" && window.navigator.product !== "ReactNative", n = typeof window > "u";
+r && !d && !n ? (t = require("./chunks/index.require.js").createSqliteAdapter, a = require("./chunks/index.require.js").createExpoSqliteAdapter, i = require("./chunks/useRozeniteSqlitePlugin.require.js").useRozeniteSqlitePlugin) : (t = (e) => ({
   id: e.adapterId ?? "sqlite",
   name: e.adapterName ?? "SQLite",
   databases: []

package/dist/rozenite.json CHANGED Viewed

	@@ -1 +1 @@
1	- {"name":"@rozenite/sqlite-plugin","version":"1.7.0","description":"SQLite inspector for Rozenite.","panels":[{"name":"SQLite","source":"/devtools/panel.html"}]}
1	+ {"name":"@rozenite/sqlite-plugin","version":"1.8.1","description":"SQLite inspector for Rozenite.","panels":[{"name":"SQLite","source":"/devtools/panel.html"}]}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@rozenite/sqlite-plugin",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "description": "SQLite inspector for Rozenite.",
   "type": "module",
   "main": "./dist/react-native/index.cjs",
@@ -15,7 +15,8 @@
     "url": "https://github.com/callstackincubator/rozenite.git"
   },
   "dependencies": {
-    "@rozenite/plugin-bridge": "1.7.0"
+    "@rozenite/agent-bridge": "1.8.1",
+    "@rozenite/plugin-bridge": "1.8.1"
   },
   "devDependencies": {
     "@dnd-kit/core": "^6.3.1",
@@ -48,8 +49,8 @@
     "typescript": "~5.9.3",
     "vite": "^7.3.1",
     "vitest": "^3.2.4",
-    "@rozenite/vite-plugin": "1.7.0",
-    "rozenite": "1.7.0"
+    "@rozenite/vite-plugin": "1.8.1",
+    "rozenite": "1.8.1"
   },
   "peerDependencies": {
     "expo-sqlite": "*",
@@ -78,6 +79,6 @@
     "dev": "rozenite dev",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "eslint .",
-    "test": "vitest --run"
+    "test": "vitest --run --passWithNoTests"
   }
 }

package/react-native.ts CHANGED Viewed

@@ -28,9 +28,9 @@ export let createSqliteAdapter: CreateSqliteAdapter;
 export let createExpoSqliteAdapter: CreateExpoSqliteAdapter;
 export let useRozeniteSqlitePlugin: typeof import('./src/react-native/useRozeniteSqlitePlugin').useRozeniteSqlitePlugin;
+const isDev = process.env.NODE_ENV !== 'production';
 const isWeb =
   typeof window !== 'undefined' && window.navigator.product !== 'ReactNative';
-const isDev = process.env.NODE_ENV !== 'production';
 const isServer = typeof window === 'undefined';
 if (isDev && !isWeb && !isServer) {

package/src/react-native/useRozeniteSqlitePlugin.ts CHANGED Viewed

@@ -10,6 +10,7 @@ import type {
   SqliteStatementInput,
 } from '../shared/types';
 import { createSqliteDatabaseViews } from './sqlite-view';
+import { useSqliteAgentTools } from './useSqliteAgentTools';
 export type RozeniteSqlitePluginOptions = {
   adapters: SqliteAdapter[];
@@ -27,6 +28,8 @@ export const useRozeniteSqlitePlugin = ({
   adapters,
 }: RozeniteSqlitePluginOptions) => {
   const views = useMemo(() => createSqliteDatabaseViews(adapters), [adapters]);
+  useSqliteAgentTools(views);
   const client = useRozeniteDevToolsClient<SqliteEventMap>({
     pluginId: PLUGIN_ID,
   });