shelving 1.89.2 → 1.89.4

package/provider/MemoryProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Data, Datas, DataKey } from "../util/data.js";
+import type { Data } from "../util/data.js";
 import type { ItemArray, ItemValue, ItemData, ItemConstraints } from "../db/Item.js";
 import { Updates } from "../update/DataUpdate.js";
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
@@ -8,30 +8,27 @@ import type { Provider } from "./Provider.js";
  * - Extremely fast (ideal for caching!), but does not persist data after the browser window is closed.
  * - `get()` etc return the exact same instance of an object that's passed into `set()`
  */
-export declare class MemoryProvider<T extends Datas> implements Provider<T> {
+export declare class MemoryProvider implements Provider {
     /** List of tables in `{ collection: Table }` format. */
     private _tables;
     /** Get a table for a collection. */
-    getTable<K extends DataKey<T>>(collection: K): MemoryTable<T[K]>;
-    getDocumentTime<K extends DataKey<T>>(collection: K, id: string): number | null;
-    getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
-    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
-    addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
-    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
-    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    deleteItem<K extends DataKey<T>>(collection: K, id: string): void;
-    getQueryTime<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): number | null;
-    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
-    getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
-    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
-    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
+    getTable(collection: string): MemoryTable;
+    getDocumentTime(collection: string, id: string): number | null;
+    getItem(collection: string, id: string): ItemValue;
+    getItemSequence(collection: string, id: string): AsyncIterable<ItemValue>;
+    addItem(collection: string, data: Data): string;
+    setItem(collection: string, id: string, data: Data): void;
+    updateItem(collection: string, id: string, updates: Updates): void;
+    deleteItem(collection: string, id: string): void;
+    getQueryTime(collection: string, constraints: ItemConstraints): number | null;
+    getQuery(collection: string, constraints: ItemConstraints): ItemArray;
+    getQuerySequence(collection: string, constraints: ItemConstraints): AsyncIterable<ItemArray>;
+    setQuery(collection: string, constraints: ItemConstraints, data: Data): number;
+    updateQuery(collection: string, constraints: ItemConstraints, updates: Updates): number;
+    deleteQuery(collection: string, constraints: ItemConstraints): number;
 }
-/**
- * An individual table of data.
- * - Fires with an array of string IDs.
- */
-export declare class MemoryTable<T extends Data> {
+/** An individual table of data. */
+export declare class MemoryTable<T extends Data = Data> {
     /** Actual data in this table. */
     protected readonly _data: Map<string, ItemData<T>>;
     /** Times data was last updated. */
@@ -47,7 +44,7 @@ export declare class MemoryTable<T extends Data> {
     private _setItemData;
     setItem(id: string, item: ItemData<T> | T): void;
     setItemValue(id: string, value: ItemData<T> | T | null): void;
-    setItemValueSequence(id: string, sequence: AsyncIterable<ItemValue<T>>): AsyncIterable<ItemValue<T>>;
+    setItemValueSequence(id: string, sequence: AsyncIterable<ItemValue<T>>): AsyncIterable<ItemValue>;
     updateItem(id: string, updates: Updates<T>): void;
     deleteItem(id: string): void;
     getQueryTime(constraints: ItemConstraints<T>): number | null;

package/provider/MemoryProvider.js

@@ -59,10 +59,7 @@ export class MemoryProvider {
         return this.getTable(collection).deleteQuery(constraints);
     }
 }
-/**
- * An individual table of data.
- * - Fires with an array of string IDs.
- */
+/** An individual table of data. */
 export class MemoryTable {
     constructor() {
         /** Actual data in this table. */

package/provider/Provider.d.ts

@@ -1,18 +1,18 @@
 import type { Updates } from "../update/DataUpdate.js";
-import type { Datas, DataKey } from "../util/data.js";
+import type { Data } from "../util/data.js";
 import type { ItemArray, ItemConstraints, ItemValue } from "../db/Item.js";
 /** Provides access to data (e.g. IndexedDB, Firebase, or in-memory cache providers). */
-declare abstract class AbstractProvider<T extends Datas = Datas> {
+declare abstract class AbstractProvider {
     /**
      * Get the value of a item.
      *
      * @return The item value, or `null` if it doesn't exist.
      */
-    abstract getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]> | PromiseLike<ItemValue<T[K]>>;
+    abstract getItem(collection: string, id: string): ItemValue | PromiseLike<ItemValue>;
     /**
      * Subscribe to the value of this item with an async iterator.
      */
-    abstract getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
+    abstract getItemSequence(collection: string, id: string): AsyncIterable<ItemValue>;
     /**
      * Create a new item with a random ID.
      * - Created item is guaranteed to have a unique ID.
@@ -20,75 +20,75 @@ declare abstract class AbstractProvider<T extends Datas = Datas> {
      * @param data Complete data to set the item to.
      * @return String ID for the created item (possibly promised).
      */
-    abstract addItem<K extends DataKey<T>>(collection: K, data: T[K]): string | PromiseLike<string>;
+    abstract addItem(collection: string, data: Data): string | PromiseLike<string>;
     /**
      * Set the data a item (whether it exists or not).
      * @param data Data to set the item to.
      */
-    abstract setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void | PromiseLike<void>;
+    abstract setItem(collection: string, id: string, data: Data): void | PromiseLike<void>;
     /**
      * Update the data an existing item.
      *
      * @param updates Set of property updates to apply to the item.
      * @throws Error If the item does not exist (ideally a `RequiredError` but may be provider-specific).
      */
-    abstract updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void | PromiseLike<void>;
+    abstract updateItem(collection: string, id: string, updates: Updates): void | PromiseLike<void>;
     /**
      * Delete a specified item.
      */
-    abstract deleteItem<K extends DataKey<T>>(collection: K, id: string): void | PromiseLike<void>;
+    abstract deleteItem(collection: string, id: string): void | PromiseLike<void>;
     /**
      * Get all matching items.
      *
      * @return Set of values in `id: data` format.
      */
-    abstract getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]> | PromiseLike<ItemArray<T[K]>>;
+    abstract getQuery(collection: string, constraints: ItemConstraints): ItemArray | PromiseLike<ItemArray>;
     /**
      * Subscribe to all matching items with an async iterator.
      */
-    abstract getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
+    abstract getQuerySequence(collection: string, constraints: ItemConstraints): AsyncIterable<ItemArray>;
     /**
      * Set the data of all matching items.
      *
      * @param data Data to set matching items to.
      * @return Number of items that were set.
      */
-    abstract setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number | PromiseLike<number>;
+    abstract setQuery(collection: string, constraints: ItemConstraints, data: Data): number | PromiseLike<number>;
     /**
      * Update the data of all matching items.
      *
      * @param updates Set of property updates to apply to matching items.
      * @return Number of items that were updated.
      */
-    abstract updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number | PromiseLike<number>;
+    abstract updateQuery(collection: string, constraints: ItemConstraints, updates: Updates): number | PromiseLike<number>;
     /**
      * Delete all matching items.
      * @return Number of items that were deleted.
      */
-    abstract deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): number | PromiseLike<number>;
+    abstract deleteQuery(collection: string, constraints: ItemConstraints): number | PromiseLike<number>;
 }
 /** Provider with a fully synchronous interface */
-export declare abstract class Provider<T extends Datas = Datas> extends AbstractProvider<T> {
-    abstract getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
-    abstract addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
-    abstract setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
-    abstract updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    abstract deleteItem<K extends DataKey<T>>(collection: K, id: string): void;
-    abstract getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
-    abstract setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    abstract updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
-    abstract deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
+export declare abstract class Provider extends AbstractProvider {
+    abstract getItem(collection: string, id: string): ItemValue;
+    abstract addItem(collection: string, data: Data): string;
+    abstract setItem(collection: string, id: string, data: Data): void;
+    abstract updateItem(collection: string, id: string, updates: Updates): void;
+    abstract deleteItem(collection: string, id: string): void;
+    abstract getQuery(collection: string, constraints: ItemConstraints): ItemArray;
+    abstract setQuery(collection: string, constraints: ItemConstraints, data: Data): number;
+    abstract updateQuery(collection: string, constraints: ItemConstraints, updates: Updates): number;
+    abstract deleteQuery(collection: string, constraints: ItemConstraints): number;
 }
 /** Provider with a fully asynchronous interface */
-export declare abstract class AsyncProvider<T extends Datas = Datas> extends AbstractProvider<T> {
-    abstract getItem<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    abstract addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
-    abstract setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    abstract updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    abstract deleteItem<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
-    abstract getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
-    abstract setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    abstract updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
-    abstract deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
+export declare abstract class AsyncProvider extends AbstractProvider {
+    abstract getItem(collection: string, id: string): Promise<ItemValue>;
+    abstract addItem(collection: string, data: Data): Promise<string>;
+    abstract setItem(collection: string, id: string, data: Data): Promise<void>;
+    abstract updateItem(collection: string, id: string, updates: Updates): Promise<void>;
+    abstract deleteItem(collection: string, id: string): Promise<void>;
+    abstract getQuery(collection: string, constraints: ItemConstraints): Promise<ItemArray>;
+    abstract setQuery(collection: string, constraints: ItemConstraints, data: Data): Promise<number>;
+    abstract updateQuery(collection: string, constraints: ItemConstraints, updates: Updates): Promise<number>;
+    abstract deleteQuery(collection: string, constraints: ItemConstraints): Promise<number>;
 }
 export {};

package/provider/ThroughProvider.d.ts

@@ -1,37 +1,37 @@
-import type { Datas, DataKey } from "../util/data.js";
+import type { Data } from "../util/data.js";
 import type { Sourceable } from "../util/source.js";
 import type { ItemArray, ItemConstraints, ItemValue } from "../db/Item.js";
 import type { Updates } from "../update/DataUpdate.js";
 import type { Provider, AsyncProvider } from "./Provider.js";
 /** A provider that passes through to a synchronous source. */
-export declare class ThroughProvider<T extends Datas = Datas> implements Provider<T>, Sourceable<Provider<T>> {
-    readonly source: Provider<T>;
-    constructor(source: Provider<T>);
-    getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
-    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
-    addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
-    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
-    updateItem<K extends DataKey<T>>(collection: K, id: string, update: Updates<T[K]>): void;
-    deleteItem<K extends DataKey<T>>(collection: K, id: string): void;
-    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
-    getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
-    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: Updates<T[K]>): number;
-    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
+export declare class ThroughProvider implements Provider, Sourceable<Provider> {
+    readonly source: Provider;
+    constructor(source: Provider);
+    getItem(collection: string, id: string): ItemValue;
+    getItemSequence(collection: string, id: string): AsyncIterable<ItemValue>;
+    addItem(collection: string, data: Data): string;
+    setItem(collection: string, id: string, data: Data): void;
+    updateItem(collection: string, id: string, update: Updates): void;
+    deleteItem(collection: string, id: string): void;
+    getQuery(collection: string, constraints: ItemConstraints): ItemArray;
+    getQuerySequence(collection: string, constraints: ItemConstraints): AsyncIterable<ItemArray>;
+    setQuery(collection: string, constraints: ItemConstraints, data: Data): number;
+    updateQuery(collection: string, constraints: ItemConstraints, update: Updates): number;
+    deleteQuery(collection: string, constraints: ItemConstraints): number;
 }
 /** A provider that passes through to an asynchronous source. */
-export declare class AsyncThroughProvider<T extends Datas = Datas> implements AsyncProvider<T>, Sourceable<AsyncProvider<T>> {
-    readonly source: AsyncProvider<T>;
-    constructor(source: AsyncProvider<T>);
-    getItem<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
-    addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
-    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    deleteItem<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
-    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
-    getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
-    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
-    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
+export declare class AsyncThroughProvider implements AsyncProvider, Sourceable<AsyncProvider> {
+    readonly source: AsyncProvider;
+    constructor(source: AsyncProvider);
+    getItem(collection: string, id: string): Promise<ItemValue>;
+    getItemSequence(collection: string, id: string): AsyncIterable<ItemValue>;
+    addItem(collection: string, data: Data): Promise<string>;
+    setItem(collection: string, id: string, data: Data): Promise<void>;
+    updateItem(collection: string, id: string, updates: Updates): Promise<void>;
+    deleteItem(collection: string, id: string): Promise<void>;
+    getQuery(collection: string, constraints: ItemConstraints): Promise<ItemArray>;
+    getQuerySequence(collection: string, constraints: ItemConstraints): AsyncIterable<ItemArray>;
+    setQuery(collection: string, constraints: ItemConstraints, data: Data): Promise<number>;
+    updateQuery(collection: string, constraints: ItemConstraints, updates: Updates): Promise<number>;
+    deleteQuery(collection: string, constraints: ItemConstraints): Promise<number>;
 }

package/provider/ValidationProvider.d.ts

@@ -14,7 +14,7 @@ declare abstract class BaseValidationProvider<T extends Datas> {
     getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
 }
 /** Validate a synchronous source provider (source can have any type because validation guarantees the type). */
-export declare class ValidationProvider<T extends Datas> extends BaseValidationProvider<T> implements Provider<T>, Sourceable<Provider> {
+export declare class ValidationProvider<T extends Datas> extends BaseValidationProvider<T> implements Provider, Sourceable<Provider> {
     readonly source: Provider;
     constructor(source: Provider, schemas: DataSchemas<T>);
     getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
@@ -28,7 +28,7 @@ export declare class ValidationProvider<T extends Datas> extends BaseValidationP
     deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
 }
 /** Validate an asynchronous source provider (source can have any type because validation guarantees the type). */
-export declare class AsyncValidationProvider<T extends Datas> extends BaseValidationProvider<T> implements AsyncProvider<T>, Sourceable<AsyncProvider> {
+export declare class AsyncValidationProvider<T extends Datas> extends BaseValidationProvider<T> implements AsyncProvider, Sourceable<AsyncProvider> {
     readonly source: AsyncProvider;
     constructor(source: AsyncProvider, schemas: DataSchemas<T>);
     getItem<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;

package/react/useData.d.ts

@@ -4,11 +4,10 @@ import { AsyncItem } from "../db/Item.js";
 import { ItemState } from "../db/ItemState.js";
 import { AsyncQuery } from "../db/Query.js";
 import { QueryState } from "../db/QueryState.js";
-type AnyRef = AsyncItem<any, any> | AsyncQuery<any, any>;
-type RefToState<T> = T extends undefined ? undefined : T extends AsyncItem<infer D, infer K> ? ItemState<D, K> : T extends AsyncQuery<infer D, infer K> ? QueryState<D, K> : never;
+type RefToState<T> = T extends undefined ? undefined : T extends AsyncItem<infer X> ? ItemState<X> : T extends AsyncQuery<infer X> ? QueryState<X> : never;
 /** Use one or more data items or queries. */
-export declare function useData<T extends AnyRef | undefined>(ref: T): RefToState<T>;
-export declare function useData<T extends ImmutableArray<AnyRef | undefined>>(...refs: T): {
+export declare function useData<T extends AsyncItem | AsyncQuery | undefined>(ref: T): RefToState<T>;
+export declare function useData<T extends ImmutableArray<AsyncItem | AsyncQuery | undefined>>(...refs: T): {
     [K in keyof T]: RefToState<T[K]>;
 };
 /** Wrap components with `<DataCache>` to allow the use of `useData()`. */