muya 2.4.2 → 2.4.4

package/esm/sqlite/create-sqlite.js

@@ -1 +1 @@
-import{STATE_SCHEDULER as f}from"../create";import{getId as P}from"../utils/id";import{shallow as v}from"../utils/shallow";import{selectSql as O}from"./select-sql";import{createTable as R,DEFAULT_STEP_SIZE as M}from"./table/table";function A(k){const g=P();function m(e){return`state-${g}-search-${e}`}let h;async function o(){if(!h){const{backend:e,...n}=k,t=e instanceof Promise?await e:e;h=await R({backend:t,...n})}return h}const c=new Map,d=new Map,y=new Map;async function p(e,n){const t=y.get(e),{options:a={}}=n,{stepSize:s=M}=a;if(!t)return!1;const r=[];for(let u=0;u<s;u++){const i=await t.next();if(i.done){y.delete(e);break}n.keys.has(String(i.value.key))||(r.push(i.value.document),n.keys.add(String(i.value.key)))}return r.length===0||v(n.items,r)?!1:(n.items=[...n.items,...r],!0)}function b(e){const n=d.get(e);n&&n()}async function x(e){const n=await o(),t=c.get(e);if(!t)return;const{options:a}=t,s=n.search({...a,select:(r,{rowId:u,key:i})=>({document:r,rowId:u,key:i})});y.set(e,s),t.keys=new Set,t.items=[],await p(e,t)}async function S(e){await x(e),b(e)}function T(e){const{key:n,op:t}=e,a=new Set;for(const[s,{keys:r}]of c)switch(t){case"delete":case"update":{r.has(String(n))&&a.add(s);break}case"insert":{a.add(s);break}}return a}async function l(e){const n=new Set;for(const t of e){const a=T(t);for(const s of a)n.add(s)}for(const t of n){const a=m(t);f.schedule(a,{searchId:t})}}const D=new Set;function w(e,n){c.has(e)||(c.set(e,{items:[],options:n,keys:new Set}),n&&S(e));const t=c.get(e);return n&&(t.options=n),t}const I={clear(e){c.delete(e)},async set(e){const t=await(await o()).set(e);return await l([t]),t},async batchSet(e){const t=await(await o()).batchSet(e);return await l(t),t},async delete(e){const t=await(await o()).delete(e);return t&&await l([t]),t},async deleteBy(e){const t=await(await o()).deleteBy(e);return await l(t),t},async get(e,n){return(await o()).get(e,n)},async*search(e={}){const n=await o();for await(const t of n.search(e))yield t},async count(e){return await(await o()).count(e)},updateSearchOptions(e,n){const t=w(e,n);t.options=n;const a=m(e);f.schedule(a,{searchId:e})},subscribe(e,n){const t=m(e),a=f.add(t,{onScheduleDone(){S(e)}});return D.add(a),d.has(e)||d.set(e,n),()=>{d.delete(e),a()}},getSnapshot(e){return w(e).items},refresh:S,destroy(){for(const e of D)e();c.clear(),d.clear()},async next(e){const n=c.get(e);if(n){const t=await p(e,n);return t&&b(e),t}return!1},select(e){return O(I,e)}};return I}export{A as createSqliteState};
+import{STATE_SCHEDULER as y}from"../create";import{getId as v}from"../utils/id";import{shallow as N}from"../utils/shallow";import{selectSql as C}from"./select-sql";import{createTable as M,DEFAULT_STEP_SIZE as B}from"./table/table";function L(g){const x=v();function u(e){return`state-${x}-search-${e}`}let f;async function r(){if(!f){const{backend:e,...t}=g,n=e instanceof Promise?await e:e;f=await M({backend:n,...t})}return f}const s=new Map,d=new Map,S=new Map;async function p(e,t,n){const a=S.get(e),{options:o={}}=t,{stepSize:c=B}=o;if(!a)return{isOk:!1};const i=[];n&&t.keys.clear();for(let h=0;h<c;h++){const l=await a.next();if(l.done){S.delete(e);break}t.keys.has(String(l.value.key))||(i.push(l.value.document),t.keys.add(String(l.value.key)))}return i.length===0?{isOk:!0,newItems:n?[]:t.items,isDone:!0}:N(t.items,i)?{isOk:!1}:n?{isOk:!0,newItems:i}:{newItems:[...t.items,...i],isOk:!0}}function w(e){const t=d.get(e);if(t)for(const[,n]of t)n()}async function O(e){const t=await r(),n=s.get(e);if(!n)return;const{options:a}=n,o=t.search({...a,select:(h,{rowId:l,key:P})=>({document:h,rowId:l,key:P})});S.set(e,o);const{isOk:c,newItems:i}=await p(e,n,!0);c&&(n.items=i)}async function b(e){await O(e),w(e)}function T(e){const{key:t,op:n}=e,a=new Set;for(const[o,{keys:c}]of s)switch(n){case"delete":case"update":{c.has(String(t))&&a.add(o);break}case"insert":{a.add(o);break}}return a}async function m(e){const t=new Set;for(const n of e){const a=T(n);for(const o of a)t.add(o)}for(const n of t){const a=u(n);y.schedule(a,{})}}const D=new Set;function I(e,t){if(!s.has(e)){const a={items:[],options:t,keys:new Set,wasInitialized:!1};s.set(e,a)}const n=s.get(e);return t&&(n.options=t),n}const k={load(e){const t=s.get(e);if(t&&!t.wasInitialized){t.wasInitialized=!0;const n=u(e);y.schedule(n,{searchId:e})}},clear(e){s.delete(e)},async set(e){const n=await(await r()).set(e);return await m([n]),n},async batchSet(e){const n=await(await r()).batchSet(e);return await m(n),n},async delete(e){const n=await(await r()).delete(e);return n&&await m([n]),n},async deleteBy(e){const n=await(await r()).deleteBy(e);return await m(n),n},async get(e,t){return(await r()).get(e,t)},async*search(e={}){const t=await r();for await(const n of t.search(e))yield n},async count(e){return await(await r()).count(e)},updateSearchOptions(e,t){const n=I(e,t);n.options=t;const a=u(e);y.schedule(a,{searchId:e})},subscribe(e,t,n){const a=u(e),o=y.add(a,{onScheduleDone(){b(e)}});this.load(e),D.add(o),d.has(e)||d.set(e,new Map);const c=d.get(e);return c.set(t,n),()=>{c.delete(t),c.size===0&&d.delete(e),o()}},getSnapshot(e){return I(e).items},refresh:b,destroy(){for(const e of D)e();s.clear(),d.clear()},async next(e){const t=s.get(e);if(t){const n=await p(e,t,!1);return n.isOk&&(t.items=n.newItems,w(e)),n.isDone??!1}return!1},select(e){return C(k,e)}};return k}export{L as createSqliteState};

package/esm/sqlite/select-sql.js

@@ -1 +1 @@
-import{createState as p}from"../create-state";let n=0;function i(){return n++,`${n.toString(36)}-sql`}function S(r,o){const{subscribe:a,updateSearchOptions:s}=r;return(...c)=>{const e=i(),m=a(e,()=>{t.emitter.emit()}),u=o(...c),t=p({destroy(){m(),t.emitter.clear(),t.cache.current=void 0},get(){return r.getSnapshot(e)},getSnapshot(){return r.getSnapshot(e)}});return s(e,u),t}}export{S as selectSql};
+import{createState as l}from"../create-state";let n=0;function o(){return n++,`${n.toString(36)}-sql`}function S(r,a){const{subscribe:c,updateSearchOptions:s}=r,m=o();return(...u)=>{const e=o(),p=c(e,m,()=>{t.emitter.emit()}),i=a(...u),t=l({destroy(){p(),t.emitter.clear(),t.cache.current=void 0},get(){return r.getSnapshot(e)},getSnapshot(){return r.getSnapshot(e)}});return s(e,i),t}}export{S as selectSql};

package/esm/sqlite/use-sqlite.js

@@ -1 +1 @@
-import{useCallback as l,useDebugValue as m,useEffect as a,useLayoutEffect as p,useMemo as f}from"react";import{isError as y,isPromise as D}from"../utils/is";import{useSyncExternalStoreWithSelector as h}from"use-sync-external-store/shim/with-selector";function x(n){const{limit:o,offset:i,order:c,sortBy:t,where:s,stepSize:u,select:r}=n;let e="";return o!==void 0&&(e+=`l${o}`),i!==void 0&&(e+=`o${i}`),c!==void 0&&(e+=`r${c}`),t!==void 0&&(e+=`s${t}`),s!==void 0&&(e+=`w${JSON.stringify(s)}`),u!==void 0&&(e+=`t${u}`),r!==void 0&&(e+=`f${r.toString()}`),e}function O(n,o={},i=[]){const{select:c}=o,t=f(()=>x({...o,select:void 0}),[o]);p(()=>{n.updateSearchOptions(t,{...o,select:void 0})},i),a(()=>()=>{n.clear(t)},[]);const s=l(d=>c?d.map(c):d,[c]),u=l(d=>n.subscribe(t,d),[n,t]),r=l(()=>n.getSnapshot(t),[n,t]),e=h(u,r,r,s);if(m(e),D(e)||y(e))throw e;const S=f(()=>({next:()=>n.next(t),reset:()=>n.refresh(t)}),[t,n]);return[e,S]}export{O as useSqliteValue};
+import{useCallback as f,useDebugValue as p,useEffect as a,useId as y,useLayoutEffect as D,useMemo as S}from"react";import{isError as h,isPromise as x}from"../utils/is";import{useSyncExternalStoreWithSelector as b}from"use-sync-external-store/shim/with-selector";function q(t){const{limit:o,offset:s,order:c,sortBy:e,where:i,stepSize:u,select:d}=t;let n="";return o!==void 0&&(n+=`l${o}`),s!==void 0&&(n+=`o${s}`),c!==void 0&&(n+=`r${c}`),e!==void 0&&(n+=`s${e}`),i!==void 0&&(n+=`w${JSON.stringify(i)}`),u!==void 0&&(n+=`t${u}`),d!==void 0&&(n+=`f${d.toString()}`),n}function w(t,o={},s=[]){const{select:c}=o,e=S(()=>q({...o,select:void 0}),[o]),i=y();D(()=>{t.updateSearchOptions(e,{...o,select:void 0})},s),a(()=>()=>{t.clear(e)},[]);const u=f(l=>c?l.map(c):l,[c]),d=f(l=>t.subscribe(e,i,l),[t,e,i]),n=f(()=>t.getSnapshot(e),[t,e]),r=b(d,n,n,u);if(p(r),x(r)||h(r))throw r;const m=S(()=>({next:()=>t.next(e),reset:()=>t.refresh(e)}),[e,t]);return[r,m]}export{w as useSqliteValue};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muya",
-  "version": "2.4.2",
+  "version": "2.4.4",
   "author": "samuel.gjabel@gmail.com",
   "repository": "https://github.com/samuelgjabel/muya",
   "main": "cjs/index.js",

package/src/sqlite/__tests__/use-sqlite.test.tsx

@@ -230,13 +230,13 @@ describe('use-sqlite-state', () => {
     })
 
     act(() => {
-      for (let index = 0; index < ITEMS_COUNT / stepSize; index++) {
-        result.current[1].next()
+      while (!result.current[1].next()) {
+        /* empty */
       }
     })
 
     await waitFor(() => {
-      expect(reRenders).toBe(4)
+      expect(reRenders).toBe(3)
       expect(result.current[0].length).toBe(ITEMS_COUNT)
     })
 
@@ -244,7 +244,7 @@ describe('use-sqlite-state', () => {
       result.current[1].reset()
     })
     await waitFor(() => {
-      expect(reRenders).toBe(5)
+      expect(reRenders).toBe(4)
       expect(result.current[0].length).toBe(stepSize)
     })
   })
@@ -305,7 +305,7 @@ describe('use-sqlite-state', () => {
       )
     })
     await waitFor(() => {
-      expect(reRenders).toBe(2)
+      expect(reRenders).toBe(1)
       expect(result1.current[0].length).toBe(0)
     })
 
@@ -341,7 +341,7 @@ describe('use-sqlite-state', () => {
     })
 
     await waitFor(() => {
-      expect(reRenders).toBe(2)
+      expect(reRenders).toBe(1)
       expect(result.current[0].length).toBe(0)
     })
 
@@ -358,7 +358,7 @@ describe('use-sqlite-state', () => {
       sql.set({ person: { id: 'some_id', name: 'Alice', age: 31 } })
     })
     await waitFor(() => {
-      // expect(reRenders).toBe(4)
+      expect(reRenders).toBe(4)
       expect(result.current[0]).toEqual([{ person: { id: 'some_id', name: 'Alice', age: 31 } }])
     })
 

package/src/sqlite/create-sqlite.ts

@@ -17,7 +17,7 @@ export interface CreateSqliteOptions<Document extends DocType> extends Omit<DbOp
 export interface SyncTable<Document extends DocType> {
   // readonly registerSearch: <Selected = Document>(searchId: SearchId, options: SearchOptions<Document, Selected>) => () => void
   readonly updateSearchOptions: <Selected = Document>(searchId: SearchId, options: SearchOptions<Document, Selected>) => void
-  readonly subscribe: (searchId: SearchId, listener: () => void) => () => void
+  readonly subscribe: (searchId: SearchId, componentId: string, listener: () => void) => () => void
   readonly getSnapshot: (searchId: SearchId) => Document[]
   readonly refresh: (searchId: SearchId) => Promise<void>
 
@@ -32,16 +32,18 @@ export interface SyncTable<Document extends DocType> {
   readonly destroy: () => void
   readonly next: (searchId: SearchId) => Promise<boolean>
   readonly clear: (searchId: SearchId) => void
+  readonly load: (searchId: SearchId) => void
 
   readonly select: <Params extends unknown[]>(
     compute: (...args: Params) => SearchOptions<Document>,
   ) => CreateState<Document, Params>
 }
 
-interface DataItems<Document extends DocType> {
+interface CachedItem<Document extends DocType> {
   items: Document[]
   keys: Set<Key>
   options?: SearchOptions<Document, unknown>
+  wasInitialized: boolean
 }
 
 /**
@@ -80,22 +82,40 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
     key: Key
   }
   // const emitter = createEmitter<Table<Document>>()
-  const cachedData = new Map<SearchId, DataItems<Document>>()
-  const listeners = new Map<SearchId, () => void>()
+  const cachedData = new Map<SearchId, CachedItem<Document>>()
+  const listeners = new Map<SearchId, Map<string, () => void>>()
   const iterators = new Map<SearchId, AsyncIterableIterator<NextResult>>()
 
+  interface GetNextBase {
+    readonly newItems?: Document[]
+    readonly isOk: boolean
+    readonly isDone?: boolean
+  }
+
+  interface GetNextTrue extends GetNextBase {
+    readonly isOk: true
+    readonly newItems: Document[]
+  }
+  interface GetNextFalse extends GetNextBase {
+    readonly isOk: false
+  }
+  type GetNext = GetNextTrue | GetNextFalse
   /**
    * Next step in the iterator
    * @param searchId The search ID
    * @param data The data items to process
+   * @param shouldReset Whether to reset the items
    * @returns boolean indicating if new items were added
    */
-  async function next(searchId: SearchId, data: DataItems<Document>): Promise<boolean> {
+  async function getNext(searchId: SearchId, data: CachedItem<Document>, shouldReset: boolean): Promise<GetNext> {
     const iterator = iterators.get(searchId)
     const { options: nextOptions = {} } = data
     const { stepSize = DEFAULT_STEP_SIZE } = nextOptions
-    if (!iterator) return false
+    if (!iterator) return { isOk: false }
     const newItems: Document[] = []
+    if (shouldReset) {
+      data.keys.clear()
+    }
 
     for (let index = 0; index < stepSize; index++) {
       const result = await iterator.next()
@@ -110,10 +130,10 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
       }
     }
 
-    if (newItems.length === 0) return false
-    if (shallow(data.items, newItems)) return false
-    data.items = [...data.items, ...newItems]
-    return true
+    if (newItems.length === 0) return { isOk: true, newItems: shouldReset ? [] : data.items, isDone: true }
+    if (shallow(data.items, newItems)) return { isOk: false }
+    if (shouldReset) return { isOk: true, newItems }
+    return { newItems: [...data.items, ...newItems], isOk: true }
   }
 
   /**
@@ -123,7 +143,9 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
   function notifyListeners(searchId: SearchId) {
     const searchListeners = listeners.get(searchId)
     if (searchListeners) {
-      searchListeners()
+      for (const [, listener] of searchListeners) {
+        listener()
+      }
     }
   }
 
@@ -138,9 +160,10 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
     const { options: refreshOptions } = data
     const iterator = table.search({ ...refreshOptions, select: (document, { rowId, key }) => ({ document, rowId, key }) })
     iterators.set(searchId, iterator)
-    data.keys = new Set()
-    data.items = []
-    await next(searchId, data)
+    const { isOk, newItems } = await getNext(searchId, data, true)
+    if (isOk) {
+      data.items = newItems
+    }
   }
   /**
    * Refresh the data and notify listeners
@@ -156,7 +179,7 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
    * @param mutationResult The mutation result
    * @returns A set of search IDs that need to be updated
    */
-  function handleChange(mutationResult: MutationResult) {
+  function getChangedKeys(mutationResult: MutationResult) {
     const { key, op } = mutationResult
     // find all cached data with key
     const searchIds = new Set<SearchId>()
@@ -186,16 +209,15 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
   async function handleChanges(mutationResults: MutationResult[]) {
     const updateSearchIds = new Set<SearchId>()
     for (const mutationResult of mutationResults) {
-      const searchIds = handleChange(mutationResult)
+      const searchIds = getChangedKeys(mutationResult)
       for (const searchId of searchIds) {
         updateSearchIds.add(searchId)
       }
     }
 
-    // const promises = []
     for (const searchId of updateSearchIds) {
       const scheduleId = getScheduleId(searchId)
-      STATE_SCHEDULER.schedule(scheduleId, { searchId })
+      STATE_SCHEDULER.schedule(scheduleId, {})
     }
   }
 
@@ -209,19 +231,32 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
    */
   function registerData(searchId: SearchId, registerDataOptions?: SearchOptions<Document, unknown>) {
     if (!cachedData.has(searchId)) {
-      cachedData.set(searchId, { items: [], options: registerDataOptions, keys: new Set() })
-      if (registerDataOptions) {
-        refresh(searchId)
+      const cachedItem: CachedItem<Document> = {
+        items: [],
+        options: registerDataOptions,
+        keys: new Set(),
+        wasInitialized: false,
       }
+      cachedData.set(searchId, cachedItem)
     }
-    const data = cachedData.get(searchId)!
+    const cachedItem = cachedData.get(searchId)!
+
     if (registerDataOptions) {
-      data.options = registerDataOptions
+      cachedItem.options = registerDataOptions
     }
-    return data
+    return cachedItem
   }
 
   const state: SyncTable<Document> = {
+    load(searchId: SearchId) {
+      const cachedItem = cachedData.get(searchId)
+      if (!cachedItem) return
+      if (!cachedItem.wasInitialized) {
+        cachedItem.wasInitialized = true
+        const scheduleId = getScheduleId(searchId)
+        STATE_SCHEDULER.schedule(scheduleId, { searchId })
+      }
+    },
     clear(searchId: SearchId) {
       cachedData.delete(searchId)
     },
@@ -273,20 +308,28 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
       STATE_SCHEDULER.schedule(scheduleId, { searchId })
     },
 
-    subscribe(searchId, listener) {
+    subscribe(searchId, componentId, listener) {
       const scheduleId = getScheduleId(searchId)
       const clearScheduler = STATE_SCHEDULER.add(scheduleId, {
         onScheduleDone() {
           refresh(searchId)
         },
       })
+      // console.log('Subscribing to searchId:', searchId)
+      this.load(searchId)
       clearSchedulers.add(clearScheduler)
 
       if (!listeners.has(searchId)) {
-        listeners.set(searchId, listener)
+        listeners.set(searchId, new Map())
       }
+      const searchListeners = listeners.get(searchId)!
+      searchListeners.set(componentId, listener)
+
       return () => {
-        listeners.delete(searchId)
+        searchListeners.delete(componentId)
+        if (searchListeners.size === 0) {
+          listeners.delete(searchId)
+        }
         clearScheduler()
       }
     },
@@ -303,11 +346,12 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
     async next(searchId) {
       const data = cachedData.get(searchId)
       if (data) {
-        const hasNext = await next(searchId, data)
-        if (hasNext) {
+        const hasNext = await getNext(searchId, data, false)
+        if (hasNext.isOk) {
+          data.items = hasNext.newItems
           notifyListeners(searchId)
         }
-        return hasNext
+        return hasNext.isDone ?? false
       }
       return false
     },

package/src/sqlite/select-sql.ts

@@ -36,10 +36,10 @@ export function selectSql<Document extends DocType, Params extends unknown[] = [
   compute: (...args: Params) => SqlSeachOptions<Document>,
 ): CreateState<Document, Params> {
   const { subscribe, updateSearchOptions } = state
-
+  const componentId = getStateId()
   const result: CreateState<Document, Params> = (...params) => {
     const searchId = getStateId()
-    const destroy = subscribe(searchId, () => {
+    const destroy = subscribe(searchId, componentId, () => {
       getState.emitter.emit()
     })
 

package/src/sqlite/use-sqlite.ts

@@ -1,4 +1,4 @@
-import { useCallback, useDebugValue, useEffect, useLayoutEffect, useMemo, type DependencyList } from 'react'
+import { useCallback, useDebugValue, useEffect, useId, useLayoutEffect, useMemo, type DependencyList } from 'react'
 import type { SyncTable } from './create-sqlite'
 import type { DocType } from './table/table.types'
 import { isError, isPromise } from '../utils/is'
@@ -6,7 +6,15 @@ import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/w
 import type { SqlSeachOptions } from './select-sql'
 
 export interface SqLiteActions {
+  /**
+   * Load the next page of results and return if isDone to show more results.
+   * @returns isDone: boolean
+   */
   readonly next: () => Promise<boolean>
+  /**
+   * Reset the pagination and load the first page of results.
+   * @returns void
+   */
   readonly reset: () => Promise<void>
 }
 
@@ -65,6 +73,7 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
   const { select } = options
 
   const searchId = useMemo(() => generateCacheKey({ ...options, select: undefined }), [options])
+  const componentId = useId()
 
   useLayoutEffect(() => {
     state.updateSearchOptions(searchId, { ...options, select: undefined })
@@ -72,6 +81,7 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
   }, deps)
 
   useEffect(() => {
+    // state.load(searchId)
     return () => {
       state.clear(searchId)
     }
@@ -88,9 +98,9 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
 
   const subscribe = useCallback(
     (onStorageChange: () => void) => {
-      return state.subscribe(searchId, onStorageChange)
+      return state.subscribe(searchId, componentId, onStorageChange)
     },
-    [state, searchId],
+    [state, searchId, componentId],
   )
 
   const getSnapshot = useCallback(() => {

package/types/sqlite/create-sqlite.d.ts

@@ -8,7 +8,7 @@ export interface CreateSqliteOptions<Document extends DocType> extends Omit<DbOp
 }
 export interface SyncTable<Document extends DocType> {
     readonly updateSearchOptions: <Selected = Document>(searchId: SearchId, options: SearchOptions<Document, Selected>) => void;
-    readonly subscribe: (searchId: SearchId, listener: () => void) => () => void;
+    readonly subscribe: (searchId: SearchId, componentId: string, listener: () => void) => () => void;
     readonly getSnapshot: (searchId: SearchId) => Document[];
     readonly refresh: (searchId: SearchId) => Promise<void>;
     readonly set: (document: Document) => Promise<MutationResult>;
@@ -23,6 +23,7 @@ export interface SyncTable<Document extends DocType> {
     readonly destroy: () => void;
     readonly next: (searchId: SearchId) => Promise<boolean>;
     readonly clear: (searchId: SearchId) => void;
+    readonly load: (searchId: SearchId) => void;
     readonly select: <Params extends unknown[]>(compute: (...args: Params) => SearchOptions<Document>) => CreateState<Document, Params>;
 }
 /**

package/types/sqlite/use-sqlite.d.ts

@@ -3,7 +3,15 @@ import type { SyncTable } from './create-sqlite';
 import type { DocType } from './table/table.types';
 import type { SqlSeachOptions } from './select-sql';
 export interface SqLiteActions {
+    /**
+     * Load the next page of results and return if isDone to show more results.
+     * @returns isDone: boolean
+     */
     readonly next: () => Promise<boolean>;
+    /**
+     * Reset the pagination and load the first page of results.
+     * @returns void
+     */
     readonly reset: () => Promise<void>;
 }
 export interface UseSearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {