muya 2.4.3 → 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 M}from"./select-sql";import{createTable as O,DEFAULT_STEP_SIZE as R}from"./table/table";function q(g){const k=P();function m(e){return`state-${k}-search-${e}`}let h;async function s(){if(!h){const{backend:e,...n}=g,t=e instanceof Promise?await e:e;h=await O({backend:t,...n})}return h}const r=new Map,i=new Map,y=new Map;async function p(e,n){const t=y.get(e),{options:a={}}=n,{stepSize:c=R}=a;if(!t)return!1;const o=[];for(let u=0;u<c;u++){const d=await t.next();if(d.done){y.delete(e);break}n.keys.has(String(d.value.key))||(o.push(d.value.document),n.keys.add(String(d.value.key)))}return o.length===0||v(n.items,o)?!1:(n.items=[...n.items,...o],!0)}function b(e){const n=i.get(e);if(n)for(const[,t]of n)t()}async function x(e){const n=await s(),t=r.get(e);if(!t)return;const{options:a}=t,c=n.search({...a,select:(o,{rowId:u,key:d})=>({document:o,rowId:u,key:d})});y.set(e,c),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[c,{keys:o}]of r)switch(t){case"delete":case"update":{o.has(String(n))&&a.add(c);break}case"insert":{a.add(c);break}}return a}async function l(e){const n=new Set;for(const t of e){const a=T(t);for(const c of a)n.add(c)}for(const t of n){const a=m(t);f.schedule(a,{searchId:t})}}const w=new Set;function D(e,n){r.has(e)||(r.set(e,{items:[],options:n,keys:new Set}),n&&S(e));const t=r.get(e);return n&&(t.options=n),t}const I={clear(e){r.delete(e)},async set(e){const t=await(await s()).set(e);return await l([t]),t},async batchSet(e){const t=await(await s()).batchSet(e);return await l(t),t},async delete(e){const t=await(await s()).delete(e);return t&&await l([t]),t},async deleteBy(e){const t=await(await s()).deleteBy(e);return await l(t),t},async get(e,n){return(await s()).get(e,n)},async*search(e={}){const n=await s();for await(const t of n.search(e))yield t},async count(e){return await(await s()).count(e)},updateSearchOptions(e,n){const t=D(e,n);t.options=n;const a=m(e);f.schedule(a,{searchId:e})},subscribe(e,n,t){const a=m(e),c=f.add(a,{onScheduleDone(){S(e)}});w.add(c),i.has(e)||i.set(e,new Map);const o=i.get(e);return o.set(n,t),()=>{o.delete(n),o.size===0&&i.delete(e),c()}},getSnapshot(e){return D(e).items},refresh:S,destroy(){for(const e of w)e();r.clear(),i.clear()},async next(e){const n=r.get(e);if(n){const t=await p(e,n);return t&&b(e),t}return!1},select(e){return M(I,e)}};return I}export{q 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muya",
-  "version": "2.4.3",
+  "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

@@ -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 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 }
   }
 
   /**
@@ -140,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
@@ -158,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>()
@@ -188,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, {})
     }
   }
 
@@ -211,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)
     },
@@ -282,6 +315,8 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
           refresh(searchId)
         },
       })
+      // console.log('Subscribing to searchId:', searchId)
+      this.load(searchId)
       clearSchedulers.add(clearScheduler)
 
       if (!listeners.has(searchId)) {
@@ -289,6 +324,7 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
       }
       const searchListeners = listeners.get(searchId)!
       searchListeners.set(componentId, listener)
+
       return () => {
         searchListeners.delete(componentId)
         if (searchListeners.size === 0) {
@@ -310,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/use-sqlite.ts

@@ -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>
 }
 
@@ -73,6 +81,7 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
   }, deps)
 
   useEffect(() => {
+    // state.load(searchId)
     return () => {
       state.clear(searchId)
     }

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

@@ -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> {