muya 2.1.1 → 2.1.3

package/src/sqlite/table/where.ts

@@ -0,0 +1,267 @@
+/* eslint-disable sonarjs/no-nested-conditional */
+/* eslint-disable sonarjs/cognitive-complexity */
+// -------------------------------------------------------------
+// Simplified `Where` type: each field may be a `Condition`
+// *or* directly a `Document[K]`/`Document[K][]`, shorthand for "is"/"in".
+// We also allow the special literal "KEY" to filter by the primary‐key column.
+// -------------------------------------------------------------
+
+export interface Field {
+  readonly table: string
+  readonly field: string
+}
+
+interface Condition<Document extends Record<string, unknown>, K extends keyof Document = keyof Document> {
+  readonly is?: Document[K] | Array<Document[K]>
+  readonly isNot?: Document[K] | Array<Document[K]>
+  readonly gt?: Document[K] | Array<Document[K]>
+  readonly gte?: Document[K] | Array<Document[K]>
+  readonly lt?: Document[K] | Array<Document[K]>
+  readonly lte?: Document[K] | Array<Document[K]>
+  readonly in?: Document[K] | Array<Document[K]>
+  readonly notIn?: Document[K] | Array<Document[K]>
+  readonly like?: Document[K] | Array<Document[K]>
+}
+
+/**
+ * We extend `keyof Document` by the special literal "KEY".
+ * That means users can write `{ KEY: ... }` in addition to `{ someField: ... }`.
+ *
+ * - If K extends keyof Document, then primitive values must match Document[K].
+ * - If K === "KEY", then primitive values are treated as strings/Array<string>.
+ */
+export type Where<Document extends Record<string, unknown>> =
+  | {
+      [K in keyof Document | 'KEY']?:
+        | Condition<Document, K extends keyof Document ? K : keyof Document>
+        | (K extends keyof Document ? Document[K] : string)
+        | (K extends keyof Document ? Array<Document[K]> : string[])
+    }
+  | {
+      readonly AND?: Array<Where<Document>>
+      readonly OR?: Array<Where<Document>>
+      readonly NOT?: Where<Document>
+    }
+
+// -------------------------------------------------------------
+// A tiny helper to escape/inline a single primitive into SQL.
+// -------------------------------------------------------------
+function inlineValue(value: unknown): string {
+  if (typeof value === 'string') {
+    return `'${(value as string).split("'").join("''")}'`
+  }
+  if (typeof value === 'number') {
+    return (value as number).toString()
+  }
+  if (typeof value === 'boolean') {
+    return (value as boolean) ? '1' : '0'
+  }
+  return `'${String(value).split("'").join("''")}'`
+}
+
+// -------------------------------------------------------------
+// Build the expression for a given field.
+// If field === "KEY", refer directly to the primary‐key column (`key`).
+// Otherwise, extract from JSON `data`.
+// -------------------------------------------------------------
+function getFieldExpr(field: string, value: unknown, tableAlias?: string): string {
+  const prefix = tableAlias ? `${tableAlias}.` : ''
+  if (field === 'KEY') {
+    // Use double‐quotes around key to avoid conflicts with reserved words
+    return `"${prefix}key"`
+  }
+
+  // Otherwise, treat as JSON field under "data"
+  if (typeof value === 'string') {
+    return `CAST(json_extract(${prefix}data, '$.${field}') AS TEXT)`
+  }
+  if (typeof value === 'boolean') {
+    return `CAST(json_extract(${prefix}data, '$.${field}') AS INTEGER)`
+  }
+  if (typeof value === 'number') {
+    return `CAST(json_extract(${prefix}data, '$.${field}') AS NUMERIC)`
+  }
+  return `json_extract(${prefix}data, '$.${field}')`
+}
+
+// -------------------------------------------------------------
+// Valid operators set (for quick membership checks).
+// -------------------------------------------------------------
+const OPS_SET: ReadonlySet<string> = new Set(['is', 'isNot', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn', 'like'])
+
+function isUndefined(value: unknown): value is undefined {
+  return value === undefined
+}
+
+// -------------------------------------------------------------
+// Main recursive parser: turn a `Where<Document>` into a SQL clause
+// (without the leading "WHERE").
+// -------------------------------------------------------------
+export function getWhere<Document extends Record<string, unknown>>(where: Where<Document>, tableAlias?: string): string {
+  if (!where || typeof where !== 'object') {
+    return ''
+  }
+
+  // ----- Logical branches: AND / OR / NOT -----
+  if (!isUndefined(where.AND)) {
+    const array = where.AND as Array<Where<Document>>
+    if (Array.isArray(array) && array.length > 0) {
+      let combined = ''
+      let firstAdded = false
+      for (const sub of array) {
+        const clause = getWhere(sub, tableAlias)
+        if (!clause) continue
+        if (firstAdded) combined += ' AND '
+        combined += clause
+        firstAdded = true
+      }
+      return firstAdded ? `(${combined})` : ''
+    }
+    return ''
+  }
+
+  if (!isUndefined(where.OR)) {
+    const array = where.OR as Array<Where<Document>>
+    if (Array.isArray(array) && array.length > 0) {
+      let combined = ''
+      let firstAdded = false
+      for (const sub of array) {
+        const clause = getWhere(sub, tableAlias)
+        if (!clause) continue
+        if (firstAdded) combined += ' OR '
+        combined += clause
+        firstAdded = true
+      }
+      return firstAdded ? `(${combined})` : ''
+    }
+    return ''
+  }
+
+  if (!isUndefined(where.NOT)) {
+    const sub = where.NOT as Where<Document>
+    if (sub && typeof sub === 'object') {
+      const clause = getWhere(sub, tableAlias)
+      return clause ? `(NOT ${clause})` : ''
+    }
+    return ''
+  }
+
+  // ----- Field‐based conditions: default is AND across fields -----
+  let fieldClauses = ''
+  let anyFieldClause = false
+
+  for (const key in where as Record<string, unknown>) {
+    if (key === 'AND' || key === 'OR' || key === 'NOT') continue
+
+    const rawValue = (where as Record<string, unknown>)[key]
+    if (rawValue == null) continue
+
+    // If the user provided a primitive or an array, coerce it to a Condition:
+    //  - single primitive → { is: rawVal }
+    //  - array           → { in: rawVal }
+    let cond: Condition<Document, typeof key>
+    if (typeof rawValue !== 'object' || Array.isArray(rawValue)) {
+      cond = Array.isArray(rawValue) ? { in: rawValue } : ({ is: rawValue } as Condition<Document, typeof key>)
+    } else {
+      cond = rawValue as Condition<Document, typeof key>
+    }
+
+    // Iterate only over real operator keys that exist on this `cond`
+    for (const opKey of Object.keys(cond) as Array<keyof typeof cond>) {
+      if (!OPS_SET.has(opKey as string)) continue
+      const rawOpValue = cond[opKey]
+      if (rawOpValue == null) continue
+
+      // Always treat it as an array for uniformity:
+      const array = Array.isArray(rawOpValue) ? (rawOpValue as unknown[]) : [rawOpValue]
+      if (array.length === 0) continue
+
+      // Handle `is` / `isNot` / `in` / `notIn`
+      if (opKey === 'is' || opKey === 'isNot' || opKey === 'in' || opKey === 'notIn') {
+        const [firstValue] = array
+        const fieldExpr = getFieldExpr(key, firstValue, tableAlias)
+
+        // Build comma‐separated list without using `.map()`
+        let inList = ''
+        if (array.length > 1) {
+          for (const [index, elt] of array.entries()) {
+            if (index > 0) inList += ','
+            inList += inlineValue(elt)
+          }
+        }
+
+        switch (opKey) {
+          case 'is': {
+            fieldClauses +=
+              array.length > 1
+                ? (anyFieldClause ? ' AND ' : '') + `${fieldExpr} IN (${inList})`
+                : (anyFieldClause ? ' AND ' : '') + `${fieldExpr} = ${inlineValue(array[0])}`
+            break
+          }
+          case 'isNot': {
+            fieldClauses +=
+              array.length > 1
+                ? (anyFieldClause ? ' AND ' : '') + `${fieldExpr} NOT IN (${inList})`
+                : (anyFieldClause ? ' AND ' : '') + `${fieldExpr} <> ${inlineValue(array[0])}`
+            break
+          }
+          case 'in': {
+            fieldClauses +=
+              array.length > 1
+                ? (anyFieldClause ? ' AND ' : '') + `${fieldExpr} IN (${inList})`
+                : (anyFieldClause ? ' AND ' : '') + `${fieldExpr} IN (${inlineValue(array[0])})`
+            break
+          }
+          case 'notIn': {
+            fieldClauses +=
+              array.length > 1
+                ? (anyFieldClause ? ' AND ' : '') + `${fieldExpr} NOT IN (${inList})`
+                : (anyFieldClause ? ' AND ' : '') + `${fieldExpr} NOT IN (${inlineValue(array[0])})`
+            break
+          }
+        }
+
+        anyFieldClause = true
+        continue
+      }
+
+      // Handle comparisons: gt, gte, lt, lte, like
+      for (const v of array) {
+        const fieldExpr = getFieldExpr(key, v, tableAlias)
+        switch (opKey) {
+          case 'gt': {
+            fieldClauses += (anyFieldClause ? ' AND ' : '') + `${fieldExpr} > ${inlineValue(v)}`
+            break
+          }
+          case 'gte': {
+            fieldClauses += (anyFieldClause ? ' AND ' : '') + `${fieldExpr} >= ${inlineValue(v)}`
+            break
+          }
+          case 'lt': {
+            fieldClauses += (anyFieldClause ? ' AND ' : '') + `${fieldExpr} < ${inlineValue(v)}`
+            break
+          }
+          case 'lte': {
+            fieldClauses += (anyFieldClause ? ' AND ' : '') + `${fieldExpr} <= ${inlineValue(v)}`
+            break
+          }
+          case 'like': {
+            fieldClauses += (anyFieldClause ? ' AND ' : '') + `${fieldExpr} LIKE ${inlineValue(v)}`
+            break
+          }
+        }
+        anyFieldClause = true
+      }
+    }
+  }
+
+  return anyFieldClause ? `(${fieldClauses})` : ''
+}
+
+// -------------------------------------------------------------
+// Wrap `parse(...)` in "WHERE (…)". If empty, return "".
+// -------------------------------------------------------------
+export function getWhereQuery<Document extends Record<string, unknown>>(where: Where<Document>): string {
+  const clause = getWhere(where)
+  return clause ? `WHERE ${clause}` : ''
+}

package/src/sqlite/use-sqlite.ts

@@ -0,0 +1,70 @@
+import { useCallback, useDebugValue, 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'
+import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector'
+import type { SqlSeachOptions } from './select-sql'
+
+export interface SqLiteActions {
+  readonly next: () => Promise<boolean>
+  readonly reset: () => Promise<void>
+}
+
+export interface UseSearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {
+  /**
+   * Naive projection. Prefer specialized queries for heavy fan-out graphs.
+   */
+  readonly select?: (document: Document) => Selected
+}
+
+export function useSqliteValue<Document extends DocType, Selected = Document>(
+  state: SyncTable<Document>,
+  options: UseSearchOptions<Document, Selected> = {},
+  deps: DependencyList = [],
+): [undefined extends Selected ? Document[] : Selected[], SqLiteActions] {
+  const { select } = options
+
+  const id = useId()
+
+  useLayoutEffect(() => {
+    state.updateSearchOptions(id, { ...options, select: undefined })
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, deps)
+
+  const selector = useCallback(
+    (documents: Document[]) => {
+      // eslint-disable-next-line unicorn/no-array-callback-reference
+      return select ? documents.map(select) : (documents as unknown as Selected[])
+    },
+    [select],
+  )
+
+  const subscribe = useCallback(
+    (onStorageChange: () => void) => {
+      return state.subscribe(id, onStorageChange)
+    },
+    [state, id],
+  )
+
+  const getSnapshot = useCallback(() => {
+    return state.getSnapshot(id)
+  }, [state, id])
+
+  const value = useSyncExternalStoreWithSelector<Document[], Selected[]>(subscribe, getSnapshot, getSnapshot, selector)
+
+  useDebugValue(value)
+  if (isPromise(value)) {
+    throw value
+  }
+  if (isError(value)) {
+    throw value
+  }
+
+  const actions = useMemo((): SqLiteActions => {
+    return {
+      next: () => state.next(id),
+      reset: () => state.refresh(id),
+    }
+  }, [id, state])
+  return [value as undefined extends Selected ? Document[] : Selected[], actions]
+}

package/src/types.ts

@@ -63,4 +63,5 @@ export interface State<T> extends GetState<T> {
    */
   withName: (name: string) => State<T>
   isSet: true
+  cache: Cache<T>
 }

package/src/utils/common.ts

@@ -1,4 +1,4 @@
-import type { Cache, IsEqual } from '../types'
+import type { Cache, IsEqual, State } from '../types'
 import { isAbortError, isEqualBase, isPromise, isUndefined } from './is'
 
 export interface CancelablePromise<T> {
@@ -46,7 +46,11 @@ export function canUpdate<T>(cache: Cache<T>, isEqual: IsEqual<T> = isEqualBase)
 /**
  * Handle async updates for `create` and `select`
  */
-export function handleAsyncUpdate<T>(cache: Cache<T>, emit: () => void, value: T): T {
+export function handleAsyncUpdate<T>(state: State<T>, value: T): T {
+  const {
+    cache,
+    emitter: { emit },
+  } = state
   if (!isPromise(value)) {
     return value
   }

package/types/create.d.ts

@@ -1,7 +1,7 @@
 import type { DefaultValue, IsEqual, State } from './types';
-export declare const stateScheduler: {
-    add<T>(id: number, option: import("./scheduler").SchedulerOptions<T>): () => void;
-    schedule<T>(id: number, value: T): void;
+export declare const STATE_SCHEDULER: {
+    add<T>(id: string | number | symbol, option: import("./scheduler").SchedulerOptions<T>): () => void;
+    schedule<T>(id: string | number | symbol, value: T): void;
 };
 /**
  * Create state from a default value.

package/types/scheduler.d.ts

@@ -1,11 +1,20 @@
 export declare const THRESHOLD = 0.2;
 export declare const THRESHOLD_ITEMS = 10;
 export declare const RESCHEDULE_COUNT = 0;
+type ScheduleId = string | number | symbol;
 export interface SchedulerOptions<T> {
     readonly onResolveItem?: (item: T) => void;
-    readonly onFinish: () => void;
+    readonly onScheduleDone: () => void | Promise<void>;
 }
+/**
+ * A simple scheduler to batch updates and avoid blocking the main thread
+ * It uses a combination of time-based and count-based strategies to determine when to flush the queue.
+ * - Time-based: If the time taken to process the current batch is less than a threshold (THRESHOLD), it continues processing.
+ * - Count-based: If the ScheduleId of items in the batch exceeds a certain limit (THRESHOLD_ITEMS), it defers processing to the next microtask.
+ * @returns An object with methods to add listeners and schedule tasks.
+ */
 export declare function createScheduler(): {
-    add<T>(id: number, option: SchedulerOptions<T>): () => void;
-    schedule<T>(id: number, value: T): void;
+    add<T>(id: ScheduleId, option: SchedulerOptions<T>): () => void;
+    schedule<T>(id: ScheduleId, value: T): void;
 };
+export {};

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

@@ -0,0 +1,28 @@
+import { type CreateState } from './select-sql';
+import type { DbOptions, DocType, Key, MutationResult, SearchOptions } from './table/table.types';
+import type { Where } from './table/where';
+type SearchId = string;
+export interface SqLiteActions {
+    readonly next: () => Promise<boolean>;
+    readonly reset: () => Promise<void>;
+}
+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 getSnapshot: (searchId: SearchId) => Document[];
+    readonly refresh: (searchId: SearchId) => Promise<void>;
+    readonly set: (document: Document) => Promise<MutationResult>;
+    readonly batchSet: (documents: Document[]) => Promise<MutationResult[]>;
+    readonly get: <Selected = Document>(key: Key, selector?: (document: Document) => Selected) => Promise<Selected | undefined>;
+    readonly delete: (key: Key) => Promise<MutationResult | undefined>;
+    readonly search: <Selected = Document>(options?: SearchOptions<Document, Selected>) => AsyncIterableIterator<Selected>;
+    readonly count: (options?: {
+        where?: Where<Document>;
+    }) => Promise<number>;
+    readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>;
+    readonly destroy: () => void;
+    readonly next: (searchId: SearchId) => Promise<boolean>;
+    readonly select: <Params extends unknown[]>(compute: (...args: Params) => SearchOptions<Document>) => CreateState<Document, Params>;
+}
+export declare function createSqliteState<Document extends DocType>(options: DbOptions<Document>): SyncTable<Document>;
+export {};

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

@@ -0,0 +1,14 @@
+import type { GetState } from '../types';
+import type { SyncTable } from './create-sqlite';
+import type { DocType } 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 order?: 'asc' | 'desc';
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly where?: Where<Document>;
+    readonly stepSize?: number;
+}
+export declare function selectSql<Document extends DocType, Params extends unknown[] = []>(state: SyncTable<Document>, compute: (...args: Params) => SqlSeachOptions<Document>): CreateState<Document, Params>;

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

@@ -0,0 +1,20 @@
+export declare const IN_MEMORY_DB = ":memory:";
+export interface QueryResult {
+    /** The number of rows affected by the query. */
+    rowsAffected: number;
+    /**
+     * The last inserted `id`.
+     *
+     * This value is not set for Postgres databases. If the
+     * last inserted id is required on Postgres, the `select` function
+     * must be used, with a `RETURNING` clause
+     * (`INSERT INTO todos (title) VALUES ($1) RETURNING id`).
+     */
+    lastInsertId?: number;
+}
+export interface Backend {
+    execute: (query: string, bindValues?: unknown[]) => Promise<QueryResult>;
+    select: <T>(query: string, bindValues?: unknown[]) => Promise<T>;
+    transaction: (callback: (tx: Backend) => Promise<void>) => Promise<void>;
+    path: string;
+}

package/types/sqlite/table/bun-backend.d.ts

@@ -0,0 +1,2 @@
+import type { Backend } from './backend';
+export declare function bunMemoryBackend(): Backend;

package/types/sqlite/table/map-deque.d.ts

@@ -0,0 +1,5 @@
+export declare class MapDeque<K, V> extends Map<K, V> {
+    private maxSize;
+    constructor(maxSize: number, entries?: ReadonlyArray<readonly [K, V]> | null);
+    set(key: K, value: V): this;
+}

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

@@ -0,0 +1,3 @@
+import type { Table, DbOptions, DocType } from './table.types';
+export declare const DEFAULT_STEP_SIZE = 100;
+export declare function createTable<Document extends DocType>(options: DbOptions<Document>): Promise<Table<Document>>;

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

@@ -0,0 +1,52 @@
+import type { Backend } from './backend';
+import type { Where } from './where';
+export type DocType = {
+    [key: string]: any;
+};
+export type KeyTypeAvailable = 'string' | 'number';
+export interface DbOptions<Document extends DocType> {
+    readonly sorBy?: keyof Document;
+    readonly order?: 'asc' | 'desc';
+    readonly tableName: string;
+    readonly indexes?: Array<keyof Document>;
+    readonly backend: Backend;
+    /**
+     * Optional key. If omitted, the table uses implicit SQLite ROWID as the key.
+     */
+    readonly key?: keyof Document;
+}
+interface DbNotGeneric {
+    readonly backend: Backend;
+}
+export interface SearchOptions<Document extends DocType, Selected = Document> {
+    readonly sorBy?: keyof Document;
+    readonly order?: 'asc' | 'desc';
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly where?: Where<Document>;
+    readonly stepSize?: number;
+    /**
+     * Naive projection. Prefer specialized queries for heavy fan-out graphs.
+     */
+    readonly select?: (document: Document, meta: {
+        rowId: number;
+    }) => Selected;
+}
+export type Key = string | number;
+export type MutationOp = 'insert' | 'update' | 'delete';
+export interface MutationResult {
+    key: Key;
+    op: MutationOp;
+}
+export interface Table<Document extends DocType> extends DbNotGeneric {
+    readonly set: (document: Document, backendOverride?: Backend) => Promise<MutationResult>;
+    readonly batchSet: (documents: Document[]) => Promise<MutationResult[]>;
+    readonly get: <Selected = Document>(key: Key, selector?: (document: Document) => Selected) => Promise<Selected | undefined>;
+    readonly delete: (key: Key) => Promise<MutationResult | undefined>;
+    readonly search: <Selected = Document>(options?: SearchOptions<Document, Selected>) => AsyncIterableIterator<Selected>;
+    readonly count: (options?: {
+        where?: Where<Document>;
+    }) => Promise<number>;
+    readonly deleteBy: (where: Where<Document>) => Promise<MutationResult[]>;
+}
+export {};

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

@@ -0,0 +1,32 @@
+export interface Field {
+    readonly table: string;
+    readonly field: string;
+}
+interface Condition<Document extends Record<string, unknown>, K extends keyof Document = keyof Document> {
+    readonly is?: Document[K] | Array<Document[K]>;
+    readonly isNot?: Document[K] | Array<Document[K]>;
+    readonly gt?: Document[K] | Array<Document[K]>;
+    readonly gte?: Document[K] | Array<Document[K]>;
+    readonly lt?: Document[K] | Array<Document[K]>;
+    readonly lte?: Document[K] | Array<Document[K]>;
+    readonly in?: Document[K] | Array<Document[K]>;
+    readonly notIn?: Document[K] | Array<Document[K]>;
+    readonly like?: Document[K] | Array<Document[K]>;
+}
+/**
+ * We extend `keyof Document` by the special literal "KEY".
+ * That means users can write `{ KEY: ... }` in addition to `{ someField: ... }`.
+ *
+ * - If K extends keyof Document, then primitive values must match Document[K].
+ * - If K === "KEY", then primitive values are treated as strings/Array<string>.
+ */
+export type Where<Document extends Record<string, unknown>> = {
+    [K in keyof Document | 'KEY']?: Condition<Document, K extends keyof Document ? K : keyof Document> | (K extends keyof Document ? Document[K] : string) | (K extends keyof Document ? Array<Document[K]> : string[]);
+} | {
+    readonly AND?: Array<Where<Document>>;
+    readonly OR?: Array<Where<Document>>;
+    readonly NOT?: Where<Document>;
+};
+export declare function getWhere<Document extends Record<string, unknown>>(where: Where<Document>, tableAlias?: string): string;
+export declare function getWhereQuery<Document extends Record<string, unknown>>(where: Where<Document>): string;
+export {};

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

@@ -0,0 +1,15 @@
+import { type DependencyList } from 'react';
+import type { SyncTable } from './create-sqlite';
+import type { DocType } from './table/table.types';
+import type { SqlSeachOptions } from './select-sql';
+export interface SqLiteActions {
+    readonly next: () => Promise<boolean>;
+    readonly reset: () => Promise<void>;
+}
+export interface UseSearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {
+    /**
+     * Naive projection. Prefer specialized queries for heavy fan-out graphs.
+     */
+    readonly select?: (document: Document) => Selected;
+}
+export declare function useSqliteValue<Document extends DocType, Selected = Document>(state: SyncTable<Document>, options?: UseSearchOptions<Document, Selected>, deps?: DependencyList): [undefined extends Selected ? Document[] : Selected[], SqLiteActions];

package/types/types.d.ts

@@ -59,4 +59,5 @@ export interface State<T> extends GetState<T> {
      */
     withName: (name: string) => State<T>;
     isSet: true;
+    cache: Cache<T>;
 }

package/types/utils/common.d.ts

@@ -1,4 +1,4 @@
-import type { Cache, IsEqual } from '../types';
+import type { Cache, IsEqual, State } from '../types';
 export interface CancelablePromise<T> {
     promise: Promise<T>;
     controller?: AbortController;
@@ -17,4 +17,4 @@ export declare function canUpdate<T>(cache: Cache<T>, isEqual?: IsEqual<T>): boo
 /**
  * Handle async updates for `create` and `select`
  */
-export declare function handleAsyncUpdate<T>(cache: Cache<T>, emit: () => void, value: T): T;
+export declare function handleAsyncUpdate<T>(state: State<T>, value: T): T;