muya 2.1.0 → 2.1.2

package/src/use-value.ts

@@ -1,16 +1,18 @@
-import { useDebugValue, useSyncExternalStore } from 'react'
+import { useDebugValue } from 'react'
 import { EMPTY_SELECTOR, type GetState } from './types'
 import { isError, isPromise } from './utils/is'
+import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector'
 
 export function useValue<T, S>(
   state: GetState<T>,
   selector: (stateValue: Awaited<T>) => S = EMPTY_SELECTOR,
 ): undefined extends S ? Awaited<T> : S {
   const { emitter } = state
-  const value = useSyncExternalStore<S>(
+  const value = useSyncExternalStoreWithSelector<T, S>(
     state.emitter.subscribe,
-    () => selector(emitter.getSnapshot() as Awaited<T>),
-    () => selector((emitter.getInitialSnapshot ? emitter.getInitialSnapshot() : emitter.getSnapshot()) as Awaited<T>),
+    emitter.getSnapshot,
+    emitter.getInitialSnapshot,
+    selector as (stateValue: T) => S,
   )
   useDebugValue(value)
   if (isPromise(value)) {

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-state.d.ts

@@ -0,0 +1,22 @@
+import type { DbOptions, DocType, Key, MutationResult, SearchOptions } from './table/table.types';
+import type { Where } from './table/where';
+type SearchId = string;
+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>;
+}
+export declare function createSqliteState<Document extends DocType>(options: DbOptions<Document>): Promise<SyncTable<Document>>;
+export {};

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-value.d.ts

@@ -0,0 +1,21 @@
+import { type DependencyList } from 'react';
+import type { SyncTable } from './create-sqlite-state';
+import type { DocType } from './table/table.types';
+import type { Where } from './table/where';
+export interface SqLiteActions {
+    readonly next: () => Promise<boolean>;
+    readonly reset: () => Promise<void>;
+}
+export interface UseSearchOptions<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) => 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;