muya 2.5.4 → 2.5.6

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

@@ -1,21 +0,0 @@
-import type { Table, DbOptions, DocType } from './table.types';
-export declare const DEFAULT_PAGE_SIZE = 100;
-/**
- * Convert a dot-separated path to a JSON path
- * @param dot The dot-separated path string
- * @returns The JSON path string
- */
-export declare function toJsonPath(dot: string): string;
-/**
- * Get a nested value from an object using a dot-separated path
- * @param object The object to retrieve the value from
- * @param path The dot-separated path string
- * @returns The value at the specified path, or undefined if not found
- */
-export declare function getByPath<T extends object>(object: T, path: string): unknown;
-/**
- * Create and initialize a table in the database with the specified options
- * @param options The options for creating the table, including table name, indexes, backend, and key
- * @returns A promise that resolves to the created Table instance
- */
-export declare function createTable<Document extends DocType>(options: DbOptions<Document>): Promise<Table<Document>>;

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

@@ -1,91 +0,0 @@
-import type { Backend } from './backend';
-import type { FtsTokenizerOptions } from './tokenizer';
-import type { Where } from './where';
-export type DocType = {
-    [key: string]: any;
-};
-export type KeyTypeAvailable = 'string' | 'number';
-export interface SqlSeachOptions<Document extends DocType> {
-    readonly sortBy?: DotPath<Document>;
-    readonly order?: 'asc' | 'desc';
-    readonly limit?: number;
-    readonly offset?: number;
-    readonly where?: Where<Document>;
-    readonly pageSize?: number;
-}
-export type DotPrefix<T extends string> = T extends '' ? '' : `.${T}`;
-type Previous = [never, 0, 1, 2, 3, 4, 5];
-type DotPathRaw<T, D extends number = 5> = [D] extends [never] ? never : T extends object ? {
-    [K in Extract<keyof T, string>]: T[K] extends object ? K | `${K}.${DotPathRaw<T[K], Previous[D]>}` : K;
-}[Extract<keyof T, string>] : never;
-export type DotPath<T> = DotPathRaw<MakeAllFieldAsRequired<T>>;
-/**
- * Extract the value type at a given dot path
- * e.g., GetFieldType<{ user: { name: string } }, 'user.name'> = string
- */
-export type GetFieldType<T, Path extends string> = Path extends `${infer First}.${infer Rest}` ? First extends keyof T ? GetFieldType<T[First], Rest> : never : Path extends keyof T ? T[Path] : never;
-export type FtsTokenizer = 'porter' | 'simple' | 'icu' | 'unicode61' | FtsTokenizerOptions;
-export interface FtsType<Document extends DocType> {
-    readonly type: 'fts';
-    readonly path: DotPath<Document>;
-    readonly tokenizer?: FtsTokenizer;
-}
-export type IndexDeclaration<Document extends DocType> = DotPath<Document> | `fts:${DotPath<Document>}` | FtsType<Document>;
-export interface DbOptions<Document extends DocType> {
-    readonly tableName: string;
-    readonly indexes?: Array<IndexDeclaration<Document>>;
-    readonly backend: Backend;
-    readonly key?: DotPath<Document>;
-    readonly disablePragmaOptimization?: boolean;
-}
-export interface SearchOptions<Document extends DocType, Selected = Document> extends SqlSeachOptions<Document> {
-    readonly select?: (document: Document, meta: {
-        rowId: number;
-        key: Key;
-    }) => Selected;
-}
-interface DbNotGeneric {
-    readonly backend: Backend;
-}
-export type Key = string | number;
-export type MutationOp = 'insert' | 'update' | 'delete';
-interface MutationResultBase<T> {
-    key: Key;
-    op: MutationOp;
-    document?: T;
-}
-interface MutationResultDelete<T> extends MutationResultBase<T> {
-    key: Key;
-    op: 'delete';
-}
-interface MutationResultUpdateInsert<T> extends MutationResultBase<T> {
-    key: Key;
-    op: 'update' | 'insert';
-    document: T;
-}
-export type MutationResult<T> = MutationResultDelete<T> | MutationResultUpdateInsert<T>;
-export interface GroupByResult<K> {
-    readonly key: K;
-    readonly count: number;
-}
-export interface GroupByOptions<Document extends DocType> {
-    readonly where?: Where<Document>;
-}
-export interface Table<Document extends DocType> extends DbNotGeneric {
-    readonly set: (document: Document, backendOverride?: Backend) => Promise<MutationResult<Document>>;
-    readonly batchSet: (documents: Document[]) => Promise<MutationResult<Document>[]>;
-    readonly batchDelete: (keys: Key[]) => Promise<MutationResult<Document>[]>;
-    readonly get: <Selected = Document>(key: Key, selector?: (document: Document) => Selected) => Promise<Selected | undefined>;
-    readonly delete: (key: Key, backendOverride?: Backend) => Promise<MutationResult<Document> | 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<Document>[]>;
-    readonly clear: () => Promise<void>;
-    readonly groupBy: <Field extends DotPath<Document>>(field: Field, options?: GroupByOptions<Document>) => Promise<Array<GroupByResult<GetFieldType<Document, Field>>>>;
-}
-export type MakeAllFieldAsRequired<T> = {
-    [K in keyof T]-?: T[K] extends object ? MakeAllFieldAsRequired<T[K]> : T[K];
-};
-export {};

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

@@ -1,11 +0,0 @@
-export interface FtsTokenizerOptions {
-    readonly removeDiacritics?: 0 | 1 | 2;
-    readonly tokenChars?: string;
-    readonly separators?: string;
-}
-/**
- * Create a custom FTS5 tokenizer string based on the provided options
- * @param options Options to customize the tokenizer
- * @returns A string representing the FTS5 tokenizer configuration
- */
-export declare function unicodeTokenizer(options?: FtsTokenizerOptions): string;

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

@@ -1,37 +0,0 @@
-import type { MakeAllFieldAsRequired } from './table.types';
-interface Condition<T> {
-    readonly is?: T | T[];
-    readonly isNot?: T | T[];
-    readonly gt?: T;
-    readonly gte?: T;
-    readonly lt?: T;
-    readonly lte?: T;
-    readonly in?: T[];
-    readonly notIn?: T[];
-    readonly like?: T | T[];
-    readonly fts?: string | string[];
-}
-type WhereRaw<T extends Record<string, unknown>> = {
-    [K in keyof T]?: T[K] extends Record<string, unknown> ? WhereRaw<T[K]> : Condition<T[K]> | T[K] | T[K][];
-} | {
-    readonly AND?: Array<WhereRaw<T>>;
-    readonly OR?: Array<WhereRaw<T>>;
-    readonly NOT?: WhereRaw<T>;
-};
-export type Where<T extends Record<string, unknown>> = WhereRaw<MakeAllFieldAsRequired<T>>;
-/**
- * Write SQL WHERE clause from a Where object
- * @param where The Where object defining the conditions
- * @param tableAlias Optional table alias to prefix field names
- * @param tableName Optional table name (required for FTS conditions)
- * @returns The SQL WHERE clause string (without the "WHERE" keyword)
- */
-export declare function getWhere<T extends Record<string, unknown>>(where: Where<T>, tableAlias?: string, tableName?: string): string;
-/**
- * Get SQL WHERE clause from a Where object
- * @param where The Where object defining the conditions
- * @param tableName Optional table name (required for FTS conditions)
- * @returns The SQL WHERE clause string (without the "WHERE" keyword)
- */
-export declare function getWhereQuery<T extends Record<string, unknown>>(where?: Where<T>, tableName?: string): string;
-export {};

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

@@ -1,17 +0,0 @@
-import { type DependencyList } from 'react';
-import type { SyncTable } from './create-sqlite';
-import type { DocType } from './table/table.types';
-import type { Where } from './table/where';
-/**
- * A React hook to count the number of items in a SyncTable reactively.
- * It updates the count when items are inserted or deleted, but ignores updates.
- * Supports filtering the count using a `where` clause.
- * @param state The SyncTable instance to observe.
- * @param options Optional filtering options.
- * @param options.where A `where` clause to filter the count.
- * @param deps Dependency list to control when to re-run the effect.
- * @returns The current count of items in the table.
- */
-export declare function useSqliteCount<Document extends DocType>(state: SyncTable<Document>, options?: {
-    where?: Where<Document>;
-}, deps?: DependencyList): number;

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

@@ -1,39 +0,0 @@
-import { type DependencyList } from 'react';
-import type { SyncTable } from './create-sqlite';
-import type { DocType, Key, SqlSeachOptions } from './table/table.types';
-export interface SqLiteActions {
-    /**
-     * Load the next page of results and return if isDone to show more results.
-     * @returns isDone: boolean
-     */
-    readonly nextPage: () => Promise<boolean>;
-    /**
-     * Reset the pagination and load the first page of results.
-     * @returns void
-     */
-    readonly reset: () => Promise<void>;
-    /**
-     * Map of document keys to their index in the results array.
-     */
-    readonly keysIndex: Map<Key, number>;
-    /**
-     * True when deps changed but fresh data hasn't loaded yet.
-     * Use this to show stale/dimmed UI while new results are loading.
-     */
-    readonly isStale: boolean;
-}
-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;
-}
-/**
- * A React hook to perform paginated searches on a SyncTable and reactively update the results.
- * It supports pagination, resetting the search, and selecting specific fields from the documents.
- * @param state The SyncTable instance to perform searches on.
- * @param options Options to customize the search behavior, including pagination size and selection function.
- * @param deps Dependency list to control when to re-run the search and reset the iterator.
- * @returns A tuple containing the current list of results and an object with actions to manage pagination and resetting.
- */
-export declare function useSqliteValue<Document extends DocType, Selected = Document>(state: SyncTable<Document>, options?: UseSearchOptions<Document, Selected>, deps?: DependencyList): [(undefined extends Selected ? Document[] : Selected[]) | null, SqLiteActions];