muya 2.3.1 → 2.3.3

package/esm/sqlite/create-sqlite.js

@@ -1 +1 @@
-import{STATE_SCHEDULER as y}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 K(g){const k=P();function m(e){return`state-${k}-search-${e}`}let h;async function o(){if(!h){const{backend:e,...n}=g,t=e instanceof Promise?await e:e;h=await R({backend:t,...n})}return h}const c=new Map,i=new Map,S=new Map;async function p(e,n){const t=S.get(e),{options:a={}}=n,{stepSize:s=M}=a;if(!t)return!1;const r=[];for(let u=0;u<s;u++){const l=await t.next();if(l.done){S.delete(e);break}n.keys.has(String(l.value.rowId))||(r.push(l.value.document),n.keys.add(String(l.value.rowId)))}return r.length===0||v(n.items,r)?!1:(n.items=[...n.items,...r],!0)}function b(e){const n=i.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})=>({document:r,rowId:u})});S.set(e,s),t.keys=new Set,t.items=[],await p(e,t)}async function f(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 d(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);y.schedule(a,{searchId:t})}}const w=new Set;function D(e,n){c.has(e)||(c.set(e,{items:[],options:n,keys:new Set}),n&&f(e));const t=c.get(e);return n&&(t.options=n),t}const I={async set(e){const t=await(await o()).set(e);return await d([t]),t},async batchSet(e){const t=await(await o()).batchSet(e);return await d(t),t},async delete(e){const t=await(await o()).delete(e);return t&&await d([t]),t},async deleteBy(e){const t=await(await o()).deleteBy(e);return await d(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=D(e,n);t.options=n;const a=m(e);y.schedule(a,{searchId:e})},subscribe(e,n){const t=m(e),a=y.add(t,{onScheduleDone(){f(e)}});return w.add(a),i.has(e)||i.set(e,n),()=>{i.delete(e),a(),c.delete(e)}},getSnapshot(e){return D(e).items},refresh:f,destroy(){for(const e of w)e();c.clear(),i.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{K as createSqliteState};
+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 K(g){const k=P();function m(e){return`state-${k}-search-${e}`}let h;async function o(){if(!h){const{backend:e,...n}=g,t=e instanceof Promise?await e:e;h=await R({backend:t,...n})}return h}const c=new Map,i=new Map,S=new Map;async function p(e,n){const t=S.get(e),{options:a={}}=n,{stepSize:s=M}=a;if(!t)return!1;const r=[];for(let l=0;l<s;l++){const u=await t.next();if(u.done){S.delete(e);break}n.keys.has(String(u.value.rowId))||(r.push(u.value.document),n.keys.add(String(u.value.rowId)))}return r.length===0||v(n.items,r)?!1:(n.items=[...n.items,...r],!0)}function b(e){const n=i.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:l})=>({document:r,rowId:l})});S.set(e,s),t.keys=new Set,t.items=[],await p(e,t)}async function y(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 d(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 w=new Set;function D(e,n){c.has(e)||(c.set(e,{items:[],options:n,keys:new Set}),n&&y(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 d([t]),t},async batchSet(e){const t=await(await o()).batchSet(e);return await d(t),t},async delete(e){const t=await(await o()).delete(e);return t&&await d([t]),t},async deleteBy(e){const t=await(await o()).deleteBy(e);return await d(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=D(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(){y(e)}});return w.add(a),i.has(e)||i.set(e,n),()=>{i.delete(e),a()}},getSnapshot(e){return D(e).items},refresh:y,destroy(){for(const e of w)e();c.clear(),i.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{K as createSqliteState};

package/esm/sqlite/use-sqlite.js

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

package/package.json

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

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

@@ -4,7 +4,7 @@ import { createSqliteState } from '../create-sqlite'
 import { useSqliteValue } from '../use-sqlite'
 import { waitFor } from '@testing-library/react'
 import { bunMemoryBackend } from '../table/bun-backend'
-import { Suspense, useState } from 'react'
+import { StrictMode, Suspense, useState } from 'react'
 import { DEFAULT_STEP_SIZE } from '../table/table'
 
 const backend = bunMemoryBackend()
@@ -15,13 +15,17 @@ interface Person {
 }
 
 function Wrapper({ children }: Readonly<{ children: React.ReactNode }>) {
-  return <Suspense fallback={<div>Loading...</div>}>{children}</Suspense>
+  return (
+    <StrictMode>
+      <Suspense fallback={<div>Loading...</div>}>{children}</Suspense>
+    </StrictMode>
+  )
 }
 describe('use-sqlite-state', () => {
   it('should get basic value states', async () => {
     const sql = createSqliteState<Person>({ backend, tableName: 'State1', key: 'id' })
     let reRenders = 0
-    const { result } = renderHook(
+    const { result, rerender } = renderHook(
       () => {
         reRenders++
         const aha = useSqliteValue(sql, {}, [])
@@ -66,6 +70,14 @@ describe('use-sqlite-state', () => {
       expect(result.current[0].length).toBe(2)
       expect(reRenders).toBe(6)
     })
+
+    act(() => {
+      rerender()
+    })
+    await waitFor(() => {
+      expect(reRenders).toBe(7)
+      expect(result.current[0].length).toBe(2)
+    })
   })
 
   it('should use where clause changed via state', async () => {
@@ -79,11 +91,11 @@ describe('use-sqlite-state', () => {
     const { result } = renderHook(() => {
       reRenders++
       const [minAge, setMinAge] = useState(20)
-      return [useSqliteValue(sql, { where: { age: { gt: minAge } }, sorBy: 'age' }, [minAge]), setMinAge] as const
+      return [useSqliteValue(sql, { where: { age: { gt: minAge } }, sortBy: 'age' }, [minAge]), setMinAge] as const
     })
 
     await waitFor(() => {
-      expect(result.current[0][0].map((p) => p.name)).toEqual(['Alice', 'Bob', 'Carol'])
+      expect(result.current[0][0].map((p) => p.name)).toEqual(['Bob', 'Alice', 'Carol'])
       expect(reRenders).toBe(2)
     })
 
@@ -132,17 +144,17 @@ describe('use-sqlite-state', () => {
       { id: '3', name: 'Carol', age: 40 },
     ])
     const { result, rerender } = renderHook(
-      ({ order, limit }) => useSqliteValue(sql, { sorBy: 'age', order, limit }, [order, limit]),
+      ({ order, limit }) => useSqliteValue(sql, { sortBy: 'age', order, limit }, [order, limit]),
       { initialProps: { order: 'asc' as 'asc' | 'desc', limit: 2 } },
     )
     await waitFor(() => {
-      expect(result.current[0].map((p) => p.name)).toEqual(['Alice', 'Bob'])
+      expect(result.current[0].map((p) => p.name)).toEqual(['Bob', 'Alice'])
     })
     act(() => {
       rerender({ order: 'desc', limit: 2 })
     })
     await waitFor(() => {
-      expect(result.current[0].map((p) => p.name)).toEqual(['Alice', 'Bob'])
+      expect(result.current[0].map((p) => p.name)).toEqual(['Carol', 'Alice'])
     })
     act(() => {
       rerender({ order: 'desc', limit: 1 })
@@ -243,11 +255,11 @@ describe('use-sqlite-state', () => {
       people.push({ id: index.toString(), name: `Person${index}`, age: 20 + (index % 50) })
     }
     await sql.batchSet(people)
-    const { result, rerender } = renderHook(({ order }) => useSqliteValue(sql, { sorBy: 'age', order }, [order]), {
+    const { result, rerender } = renderHook(({ order }) => useSqliteValue(sql, { sortBy: 'age', order }, [order]), {
       initialProps: { order: 'asc' as 'asc' | 'desc' },
     })
     await waitFor(() => {
-      expect(result.current[0][0].age).toBe(21)
+      expect(result.current[0][0].age).toBe(20)
     })
     act(() => {
       rerender({ order: 'desc' })
@@ -268,14 +280,14 @@ describe('use-sqlite-state', () => {
       useSqliteValue(
         sql,
         {
-          sorBy: 'age',
+          sortBy: 'age',
           select: (d) => d.name,
         },
         [],
       ),
     )
     await waitFor(() => {
-      expect(result.current[0]).toEqual(['Alice', 'Bob', 'Carol'])
+      expect(result.current[0]).toEqual(['Bob', 'Alice', 'Carol'])
     })
   })
   it('should add 50 documents and then load with another hook', async () => {
@@ -286,7 +298,7 @@ describe('use-sqlite-state', () => {
       return useSqliteValue(
         sql,
         {
-          sorBy: 'age',
+          sortBy: 'age',
           order: 'desc',
         },
         [],

package/src/sqlite/create-sqlite.ts

@@ -31,6 +31,7 @@ export interface SyncTable<Document extends DocType> {
   readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>
   readonly destroy: () => void
   readonly next: (searchId: SearchId) => Promise<boolean>
+  readonly clear: (searchId: SearchId) => void
 
   readonly select: <Params extends unknown[]>(
     compute: (...args: Params) => SearchOptions<Document>,
@@ -221,6 +222,9 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
   }
 
   const state: SyncTable<Document> = {
+    clear(searchId: SearchId) {
+      cachedData.delete(searchId)
+    },
     async set(document) {
       const table = await getTable()
       const changes = await table.set(document)
@@ -271,20 +275,19 @@ export function createSqliteState<Document extends DocType>(options: CreateSqlit
 
     subscribe(searchId, listener) {
       const scheduleId = getScheduleId(searchId)
-      const clear = STATE_SCHEDULER.add(scheduleId, {
+      const clearScheduler = STATE_SCHEDULER.add(scheduleId, {
         onScheduleDone() {
           refresh(searchId)
         },
       })
-      clearSchedulers.add(clear)
+      clearSchedulers.add(clearScheduler)
 
       if (!listeners.has(searchId)) {
         listeners.set(searchId, listener)
       }
       return () => {
         listeners.delete(searchId)
-        clear()
-        cachedData.delete(searchId)
+        clearScheduler()
       }
     },
     getSnapshot(searchId) {

package/src/sqlite/select-sql.ts

@@ -1,13 +1,13 @@
 import { createState } from '../create-state'
 import type { GetState } from '../types'
 import type { SyncTable } from './create-sqlite'
-import type { DocType } from './table/table.types'
+import type { DocType, DotPath } from './table/table.types'
 import type { Where } from './table/where'
 
 export type CreateState<Document, Params extends unknown[]> = (...params: Params) => GetState<Document[]>
 
 export interface SqlSeachOptions<Document extends DocType> {
-  readonly sorBy?: keyof Document
+  readonly sortBy?: DotPath<Document>
   readonly order?: 'asc' | 'desc'
   readonly limit?: number
   readonly offset?: number

package/src/sqlite/table/table.types.ts

@@ -1,4 +1,5 @@
 // table.types.ts
+import type { SqlSeachOptions } from '../select-sql'
 import type { Backend } from './backend'
 import type { Where } from './where'
 
@@ -27,13 +28,7 @@ export interface DbOptions<Document extends DocType> {
   readonly disablePragmaOptimization?: boolean
 }
 
-export interface SearchOptions<Document extends DocType, Selected = Document> {
-  readonly sortBy?: DotPath<Document>
-  readonly order?: 'asc' | 'desc'
-  readonly limit?: number
-  readonly offset?: number
-  readonly where?: Where<Document>
-  readonly stepSize?: number
+export interface SearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {
   readonly select?: (document: Document, meta: { rowId: number }) => Selected
 }
 

package/src/sqlite/use-sqlite.ts

@@ -1,4 +1,4 @@
-import { useCallback, useDebugValue, useId, 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'
@@ -39,6 +39,13 @@ export function useSqliteValue<Document extends DocType, Selected = Document>(
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, deps)
 
+  useEffect(() => {
+    return () => {
+      state.clear(id)
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [])
+
   const selector = useCallback(
     (documents: Document[]) => {
       // eslint-disable-next-line unicorn/no-array-callback-reference

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

@@ -22,6 +22,7 @@ export interface SyncTable<Document extends DocType> {
     readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>;
     readonly destroy: () => void;
     readonly next: (searchId: SearchId) => Promise<boolean>;
+    readonly clear: (searchId: SearchId) => void;
     readonly select: <Params extends unknown[]>(compute: (...args: Params) => SearchOptions<Document>) => CreateState<Document, Params>;
 }
 /**

package/types/sqlite/select-sql.d.ts

@@ -1,10 +1,10 @@
 import type { GetState } from '../types';
 import type { SyncTable } from './create-sqlite';
-import type { DocType } from './table/table.types';
+import type { DocType, DotPath } from './table/table.types';
 import type { Where } from './table/where';
 export type CreateState<Document, Params extends unknown[]> = (...params: Params) => GetState<Document[]>;
 export interface SqlSeachOptions<Document extends DocType> {
-    readonly sorBy?: keyof Document;
+    readonly sortBy?: DotPath<Document>;
     readonly order?: 'asc' | 'desc';
     readonly limit?: number;
     readonly offset?: number;

package/types/sqlite/table/table.types.d.ts

@@ -1,3 +1,4 @@
+import type { SqlSeachOptions } from '../select-sql';
 import type { Backend } from './backend';
 import type { Where } from './where';
 export type DocType = {
@@ -16,13 +17,7 @@ export interface DbOptions<Document extends DocType> {
     readonly key?: DotPath<Document>;
     readonly disablePragmaOptimization?: boolean;
 }
-export interface SearchOptions<Document extends DocType, Selected = Document> {
-    readonly sortBy?: DotPath<Document>;
-    readonly order?: 'asc' | 'desc';
-    readonly limit?: number;
-    readonly offset?: number;
-    readonly where?: Where<Document>;
-    readonly stepSize?: number;
+export interface SearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {
     readonly select?: (document: Document, meta: {
         rowId: number;
     }) => Selected;