muya 2.5.4 → 2.5.5

package/src/sqlite/table/where.ts

@@ -1,207 +0,0 @@
-/* eslint-disable unicorn/no-array-callback-reference */
-/* eslint-disable unicorn/no-nested-ternary */
-/* eslint-disable no-nested-ternary */
-/* eslint-disable sonarjs/no-nested-conditional */
-/* eslint-disable sonarjs/cognitive-complexity */
-
-import type { MakeAllFieldAsRequired } from './table.types'
-
-// -------------------------------------------------------------
-// Condition operators for each field
-// -------------------------------------------------------------
-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[] // 🔥 NEW
-}
-
-type WhereRaw<T extends Record<string, unknown>> =
-  | {
-      [K in keyof T]?: T[K] extends Record<string, unknown>
-        ? WhereRaw<T[K]> // nested object
-        : Condition<T[K]> | T[K] | T[K][]
-    }
-  | {
-      readonly AND?: Array<WhereRaw<T>>
-      readonly OR?: Array<WhereRaw<T>>
-      readonly NOT?: WhereRaw<T>
-    }
-
-// -------------------------------------------------------------
-// Where type: recursive object with operators or nested fields
-// -------------------------------------------------------------
-export type Where<T extends Record<string, unknown>> = WhereRaw<MakeAllFieldAsRequired<T>>
-/**
- * Inline a value for SQL query, with proper escaping for strings
- * @param value The value to inline
- * @returns The inlined value as a string
- */
-function inlineValue(value: unknown): string {
-  if (typeof value === 'string') return `'${value.replaceAll("'", "''")}'`
-  if (typeof value === 'number') return value.toString()
-  if (typeof value === 'boolean') return value ? '1' : '0'
-  return `'${String(value).replaceAll("'", "''")}'`
-}
-
-/**
- * Get SQL expression for a field, with proper casting based on value type
- * @param field The field name
- * @param value The field value
- * @param tableAlias Optional table alias to prefix the field name
- * @returns The SQL expression for the field
- */
-function getFieldExpr(field: string, value: unknown, tableAlias?: string): string {
-  const prefix = tableAlias ? `${tableAlias}.` : ''
-  if (field === 'KEY') return `"${prefix}key"`
-  if (typeof value === 'string') return `CAST(json_extract(${prefix}data, '$.${field}') AS TEXT)`
-  if (typeof value === 'number') return `CAST(json_extract(${prefix}data, '$.${field}') AS NUMERIC)`
-  if (typeof value === 'boolean') return `CAST(json_extract(${prefix}data, '$.${field}') AS INTEGER)`
-  return `json_extract(${prefix}data, '$.${field}')`
-}
-const OPS_SET: ReadonlySet<string> = new Set(['is', 'isNot', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn', 'like', 'fts'])
-
-/**
- * Flatten a nested Where object into a single-level object with dot-separated keys
- * @param object The nested Where object
- * @param prefix The prefix for the current recursion level (used internally)
- * @returns A flattened object with dot-separated keys
- */
-function flattenWhere(object: Record<string, unknown>, prefix = ''): Record<string, unknown> {
-  const result: Record<string, unknown> = {}
-
-  for (const [k, v] of Object.entries(object)) {
-    if (k === 'AND' || k === 'OR' || k === 'NOT') {
-      result[k] = v
-      continue
-    }
-
-    const path = prefix ? `${prefix}.${k}` : k
-
-    if (v && typeof v === 'object' && !Array.isArray(v) && !Object.keys(v).some((kk) => OPS_SET.has(kk))) {
-      Object.assign(result, flattenWhere(v as Record<string, unknown>, path))
-    } else {
-      result[path] = v
-    }
-  }
-
-  return result
-}
-
-/**
- * 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 function getWhere<T extends Record<string, unknown>>(where: Where<T>, tableAlias?: string, tableName?: string): string {
-  if (!where || typeof where !== 'object') return ''
-
-  if (where.AND) {
-    const clauses = Array.isArray(where.AND) ? where.AND.map((w) => getWhere(w, tableAlias, tableName)).filter(Boolean) : []
-    return clauses.length > 0 ? `(${clauses.join(' AND ')})` : ''
-  }
-
-  if (where.OR) {
-    const clauses = Array.isArray(where.OR) ? where.OR.map((w) => getWhere(w, tableAlias, tableName)).filter(Boolean) : []
-    return clauses.length > 0 ? `(${clauses.join(' OR ')})` : ''
-  }
-
-  if (where.NOT) {
-    const clause = getWhere(where.NOT, tableAlias, tableName)
-    return clause ? `(NOT ${clause})` : ''
-  }
-
-  const flat = flattenWhere(where as Record<string, unknown>)
-  let fieldClauses = ''
-  let anyField = false
-
-  for (const [key, rawValue] of Object.entries(flat)) {
-    if (rawValue == null) continue
-
-    let cond: Condition<unknown>
-    if (typeof rawValue !== 'object' || Array.isArray(rawValue)) {
-      cond = Array.isArray(rawValue) ? { in: rawValue } : { is: rawValue }
-    } else {
-      cond = rawValue as Condition<unknown>
-    }
-
-    for (const opKey of Object.keys(cond)) {
-      const opValue = cond[opKey as keyof Condition<unknown>]
-      if (opValue == null) continue
-
-      const values = Array.isArray(opValue) ? opValue : [opValue]
-      if (values.length === 0) continue
-
-      if (opKey === 'fts') {
-        if (!tableName) throw new Error('FTS requires tableName for JOIN reference')
-        const clause = values
-          .map(
-            (v) =>
-              `EXISTS (SELECT 1 FROM ${tableName}_fts f WHERE f.rowid = ${tableAlias ?? tableName}.rowid AND ${tableName}_fts MATCH ${inlineValue(v)})`,
-          )
-          .join(' AND ')
-        fieldClauses += (anyField ? ' AND ' : '') + clause
-        anyField = true
-        continue
-      }
-
-      if (opKey === 'is' || opKey === 'isNot' || opKey === 'in' || opKey === 'notIn') {
-        const fieldExpr = getFieldExpr(key, values[0], tableAlias)
-        const inList = values.map(inlineValue).join(',')
-        const clause =
-          opKey === 'is'
-            ? values.length > 1
-              ? `${fieldExpr} IN (${inList})`
-              : `${fieldExpr} = ${inlineValue(values[0])}`
-            : opKey === 'isNot'
-              ? values.length > 1
-                ? `${fieldExpr} NOT IN (${inList})`
-                : `${fieldExpr} <> ${inlineValue(values[0])}`
-              : opKey === 'in'
-                ? `${fieldExpr} IN (${inList})`
-                : `${fieldExpr} NOT IN (${inList})`
-        fieldClauses += (anyField ? ' AND ' : '') + clause
-        anyField = true
-        continue
-      }
-
-      for (const v of values) {
-        const fieldExpr = getFieldExpr(key, v, tableAlias)
-        const clause =
-          opKey === 'gt'
-            ? `${fieldExpr} > ${inlineValue(v)}`
-            : opKey === 'gte'
-              ? `${fieldExpr} >= ${inlineValue(v)}`
-              : opKey === 'lt'
-                ? `${fieldExpr} < ${inlineValue(v)}`
-                : opKey === 'lte'
-                  ? `${fieldExpr} <= ${inlineValue(v)}`
-                  : `${fieldExpr} LIKE ${inlineValue(v)}`
-        fieldClauses += (anyField ? ' AND ' : '') + clause
-        anyField = true
-      }
-    }
-  }
-
-  return anyField ? `(${fieldClauses})` : ''
-}
-
-/**
- * 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 function getWhereQuery<T extends Record<string, unknown>>(where?: Where<T>, tableName?: string): string {
-  if (!where) return ''
-  const clause = getWhere(where, undefined, tableName)
-  return clause ? `WHERE ${clause}` : ''
-}

package/src/sqlite/use-sqlite-count.ts

@@ -1,69 +0,0 @@
-import { useCallback, useEffect, useLayoutEffect, useReducer, useRef, 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 function useSqliteCount<Document extends DocType>(
-  state: SyncTable<Document>,
-  options: { where?: Where<Document> } = {},
-  deps: DependencyList = [],
-): number {
-  const countRef = useRef(0)
-  const [, rerender] = useReducer((c: number) => c + 1, 0)
-
-  const updateCount = useCallback(async () => {
-    const newCount = await state.count(options)
-    countRef.current = newCount
-    rerender()
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, deps)
-
-  useEffect(() => {
-    updateCount()
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, deps)
-
-  useLayoutEffect(() => {
-    const unsubscribe = state.subscribe((item) => {
-      const { mutations, removedAll } = item
-      if (removedAll) {
-        countRef.current = 0
-        rerender()
-        return
-      }
-      if (!mutations) {
-        return
-      }
-
-      let shouldUpdate = false
-      for (const mutation of mutations) {
-        const { op } = mutation
-        if (op === 'insert' || op === 'delete') {
-          shouldUpdate = true
-          break
-        }
-      }
-
-      if (shouldUpdate) {
-        updateCount()
-      }
-    })
-
-    return () => {
-      unsubscribe()
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [state])
-
-  return countRef.current
-}

package/src/sqlite/use-sqlite.ts

@@ -1,250 +0,0 @@
-/* eslint-disable sonarjs/cognitive-complexity */
-import { useCallback, useLayoutEffect, useReducer, useRef, useState, type DependencyList } from 'react'
-import type { SyncTable } from './create-sqlite'
-import type { DocType, Key, SqlSeachOptions } from './table/table.types'
-import { DEFAULT_PAGE_SIZE } from './table'
-import { shallow } from '../utils/shallow'
-const MAX_ITERATIONS = 10_000
-
-/**
- * Shallow compare two dependency arrays
- * @param previousDeps Previous deps array
- * @param nextDeps Next deps array
- * @returns True if arrays have same length and all items are strictly equal
- */
-function shallowEqualDeps(previousDeps: DependencyList, nextDeps: DependencyList): boolean {
-  if (previousDeps.length !== nextDeps.length) return false
-  for (const [index, previousDep] of previousDeps.entries()) {
-    if (!Object.is(previousDep, nextDeps[index])) return false
-  }
-  return true
-}
-
-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 function useSqliteValue<Document extends DocType, Selected = Document>(
-  state: SyncTable<Document>,
-  options: UseSearchOptions<Document, Selected> = {},
-  deps: DependencyList = [],
-): [(undefined extends Selected ? Document[] : Selected[]) | null, SqLiteActions] {
-  const { select, pageSize = DEFAULT_PAGE_SIZE } = options
-
-  const itemsRef = useRef<null | (Document | Selected)[]>(null)
-  const [, rerender] = useReducer((c: number) => c + 1, 0)
-  const keysIndex = useRef(new Map<Key, number>())
-  const iteratorRef = useRef<AsyncIterableIterator<{ doc: Document; meta: { key: Key } }> | null>(null)
-
-  // Track "settled" deps - the deps value when data last finished loading
-  // isStale is derived: true when current deps differ from settled deps
-  const [settledDeps, setSettledDeps] = useState<DependencyList | null>(null)
-  const isStale = settledDeps === null || !shallowEqualDeps(settledDeps, deps)
-
-  const updateIterator = useCallback(() => {
-    // eslint-disable-next-line sonarjs/no-unused-vars
-    const { select: _ignore, ...resetOptions } = options
-    iteratorRef.current = state.search({ select: (doc, meta) => ({ doc, meta }), ...resetOptions })
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [state, ...deps])
-
-  const resetDataAndUpdateIterator = useCallback(() => {
-    itemsRef.current = []
-    keysIndex.current.clear()
-    updateIterator()
-  }, [updateIterator])
-
-  const fillNextPage = useCallback(async (shouldReset: boolean) => {
-    if (itemsRef.current === null) {
-      itemsRef.current = []
-    }
-    if (shouldReset === true) {
-      resetDataAndUpdateIterator()
-    }
-
-    const { current: iterator } = iteratorRef
-    if (!iterator) {
-      return true
-    }
-    let isDone = false
-
-    for (let index = 0; index < pageSize; index++) {
-      const result = await iterator.next()
-      if (result.done) {
-        iteratorRef.current = null
-        isDone = true
-        break
-      }
-      if (keysIndex.current.has(result.value.meta.key)) {
-        continue
-      }
-      itemsRef.current.push(select ? select(result.value.doc) : (result.value.doc as unknown as Selected))
-      keysIndex.current.set(result.value.meta.key, itemsRef.current.length - 1)
-    }
-    itemsRef.current = [...itemsRef.current]
-    return isDone
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [])
-
-  const nextPage = useCallback(async () => {
-    const isDone = await fillNextPage(false)
-    rerender()
-    return isDone
-  }, [fillNextPage])
-
-  useLayoutEffect(() => {
-    const unsubscribe = state.subscribe(async (item) => {
-      const { mutations, removedAll } = item
-      if (removedAll) {
-        resetDataAndUpdateIterator()
-      }
-      if (!mutations) {
-        return
-      }
-
-      const oldLength = itemsRef.current?.length ?? 0
-      let newLength = oldLength
-      let hasUpdate = false
-      const removeIndexes = new Set<number>()
-      for (const mutation of mutations) {
-        const { key, op, document } = mutation
-        switch (op) {
-          case 'insert': {
-            newLength += 1
-            break
-          }
-          case 'delete': {
-            if (itemsRef.current && itemsRef.current.length > 0 && keysIndex.current.has(key)) {
-              const index = keysIndex.current.get(key)
-              if (index === undefined) break
-              removeIndexes.add(index)
-              hasUpdate = true
-            }
-            break
-          }
-          case 'update': {
-            if (keysIndex.current.has(key)) {
-              const index = keysIndex.current.get(key)
-              if (index !== undefined && itemsRef.current) {
-                const newItem = select ? select(document as Document) : (document as unknown as Selected)
-                const previousItem = itemsRef.current[index]
-
-                // 🆕 Only update & rerender if shallow comparison fails
-                if (!shallow(previousItem, newItem)) {
-                  itemsRef.current[index] = newItem
-                  itemsRef.current = [...itemsRef.current]
-                  hasUpdate = true
-                }
-              }
-            } else {
-              // Handle updates to non-visible items
-              const updatedItem = await state.get(key, select)
-              if (updatedItem) {
-                itemsRef.current = [...(itemsRef.current ?? []), updatedItem]
-                keysIndex.current.set(key, itemsRef.current.length - 1)
-                hasUpdate = true
-              }
-            }
-            break
-          }
-        }
-      }
-
-      if (removeIndexes.size > 0 && itemsRef.current && itemsRef.current.length > 0) {
-        const newIndex = new Map<Key, number>()
-        itemsRef.current = itemsRef.current?.filter((_, index) => {
-          return !removeIndexes.has(index)
-        })
-        let newIdx = 0
-        for (const [key, index] of keysIndex.current) {
-          if (removeIndexes.has(index)) {
-            continue
-          }
-          newIndex.set(key, newIdx)
-          newIdx++
-        }
-        keysIndex.current = newIndex
-      }
-
-      const isLengthChanged = oldLength !== newLength
-      const isChanged = isLengthChanged || hasUpdate
-      if (!isChanged) return
-      if (isLengthChanged) {
-        await fillNextPage(true)
-        let iterations = 0
-        while ((itemsRef.current?.length ?? 0) < newLength && iterations < MAX_ITERATIONS) {
-          await fillNextPage(false)
-          iterations++
-        }
-        if (iterations === MAX_ITERATIONS) {
-          // Optionally log a warning to help with debugging
-          // eslint-disable-next-line no-console
-          console.warn('Reached maximum iterations in fillNextPage loop. Possible duplicate or data issue.')
-        }
-      }
-      rerender()
-    })
-    return () => {
-      unsubscribe()
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [state])
-
-  useLayoutEffect(() => {
-    // Capture current deps for this effect invocation
-    const currentDeps = deps
-    resetDataAndUpdateIterator()
-    nextPage().then(() => {
-      // Mark these deps as settled when data finishes loading
-      setSettledDeps(currentDeps)
-    })
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, deps)
-
-  const resetCb = useCallback(async () => {
-    // Set settledDeps to null to make isStale=true during reset
-    setSettledDeps(null)
-    resetDataAndUpdateIterator()
-    await nextPage()
-    // After data loads, mark current deps as settled
-    setSettledDeps(deps)
-  }, [nextPage, resetDataAndUpdateIterator, deps])
-
-  return [itemsRef.current, { nextPage, reset: resetCb, keysIndex: keysIndex.current, isStale }] as [
-    (undefined extends Selected ? Document[] : Selected[]) | null,
-    SqLiteActions,
-  ]
-}

package/types/__tests__/test-utils.d.ts

@@ -1,25 +0,0 @@
-import { Component } from 'react';
-/**
- * Create a promise that resolves after a specified time
- * @param time Time in ms to wait
- * @returns A promise that resolves after the specified time
- */
-export declare function longPromise(time?: number): Promise<number>;
-export declare class ErrorBoundary extends Component<{
-    fallback: React.ReactNode;
-    children: React.ReactNode;
-}, {
-    hasError: boolean;
-    error: Error | null;
-}> {
-    constructor(props: {
-        fallback: React.ReactNode;
-        children: React.ReactNode;
-    });
-    static getDerivedStateFromError(error: Error): {
-        hasError: boolean;
-        error: Error;
-    };
-    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
-    render(): import("react").ReactNode;
-}

package/types/debug/development-tools.d.ts

@@ -1,8 +0,0 @@
-import type { GetState, State } from '../types';
-export type StateType = 'state' | 'derived';
-/**
- * Subscribe a state to development tools if available
- * @param state The state to subscribe
- * @returns A function to unsubscribe from development tools
- */
-export declare function subscribeToDevelopmentTools<T>(state: State<T> | GetState<T>): (() => void) | undefined;

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

@@ -1,31 +0,0 @@
-import type { Backend } from './table';
-import type { DbOptions, DocType, DotPath, GetFieldType, GroupByOptions, GroupByResult, Key, MutationResult, SearchOptions } from './table/table.types';
-import type { Where } from './table/where';
-export interface CreateSqliteOptions<Document extends DocType> extends Omit<DbOptions<Document>, 'backend'> {
-    readonly backend: Backend | Promise<Backend>;
-}
-export interface MutationItems<Doc> {
-    mutations?: MutationResult<Doc>[];
-    removedAll?: boolean;
-}
-export interface SyncTable<Document extends DocType> {
-    readonly subscribe: (listener: (mutation: MutationItems<Document>) => void) => () => void;
-    readonly set: (document: Document) => 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) => 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>>>>;
-}
-/**
- * Create a SyncTable that wraps a Table and provides reactive capabilities
- * @param options Options to create the SyncTable, including the backend and table name
- * @returns A SyncTable instance with methods to interact with the underlying Table and manage reactive searches
- */
-export declare function createSqliteState<Document extends DocType>(options: CreateSqliteOptions<Document>): SyncTable<Document>;

package/types/sqlite/index.d.ts

@@ -1,4 +0,0 @@
-export * from './create-sqlite';
-export * from './table';
-export * from './use-sqlite-count';
-export * from './use-sqlite';

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

@@ -1,20 +0,0 @@
-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

@@ -1,6 +0,0 @@
-import type { Backend } from './backend';
-/**
- * Create an in-memory SQLite backend using Bun's SQLite implementation
- * @returns A Backend instance for in-memory SQLite operations
- */
-export declare function bunMemoryBackend(): Backend;

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

@@ -1,6 +0,0 @@
-export * from './backend';
-export * from './table.types';
-export * from './where';
-export * from './table';
-export * from './map-deque';
-export * from './tokenizer';

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

@@ -1,5 +0,0 @@
-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

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