shelving 1.82.0 → 1.83.0

package/provider/Provider.d.ts

@@ -1,5 +1,5 @@
 import type { Updates } from "../update/DataUpdate.js";
-import type { Datas, Key } from "../util/data.js";
+import type { Datas, DataKey } 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> {
@@ -8,11 +8,11 @@ declare abstract class AbstractProvider<T extends Datas = Datas> {
      *
      * @return The item value, or `null` if it doesn't exist.
      */
-    abstract getItem<K extends Key<T>>(collection: K, id: string): ItemValue<T[K]> | PromiseLike<ItemValue<T[K]>>;
+    abstract getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]> | PromiseLike<ItemValue<T[K]>>;
     /**
      * Subscribe to the value of this item with an async iterator.
      */
-    abstract getItemSequence<K extends Key<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
+    abstract getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
     /**
      * 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 Key<T>>(collection: K, data: T[K]): string | PromiseLike<string>;
+    abstract addItem<K extends DataKey<T>>(collection: K, data: T[K]): 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 Key<T>>(collection: K, id: string, data: T[K]): void | PromiseLike<void>;
+    abstract setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): 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 Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void | PromiseLike<void>;
+    abstract updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void | PromiseLike<void>;
     /**
      * Delete a specified item.
      */
-    abstract deleteItem<K extends Key<T>>(collection: K, id: string): void | PromiseLike<void>;
+    abstract deleteItem<K extends DataKey<T>>(collection: K, id: string): void | PromiseLike<void>;
     /**
      * Get all matching items.
      *
      * @return Set of values in `id: data` format.
      */
-    abstract getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]> | PromiseLike<ItemArray<T[K]>>;
+    abstract getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]> | PromiseLike<ItemArray<T[K]>>;
     /**
      * Subscribe to all matching items with an async iterator.
      */
-    abstract getQuerySequence<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
+    abstract getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
     /**
      * 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 Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number | PromiseLike<number>;
+    abstract setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): 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 Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number | PromiseLike<number>;
+    abstract updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number | PromiseLike<number>;
     /**
      * Delete all matching items.
      * @return Number of items that were deleted.
      */
-    abstract deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number | PromiseLike<number>;
+    abstract deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): 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 Key<T>>(collection: K, id: string): ItemValue<T[K]>;
-    abstract addItem<K extends Key<T>>(collection: K, data: T[K]): string;
-    abstract setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): void;
-    abstract updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    abstract deleteItem<K extends Key<T>>(collection: K, id: string): void;
-    abstract getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
-    abstract setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    abstract updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
-    abstract deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
+    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;
 }
 /** Provider with a fully asynchronous interface */
 export declare abstract class AsyncProvider<T extends Datas = Datas> extends AbstractProvider<T> {
-    abstract getItem<K extends Key<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    abstract addItem<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
-    abstract setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    abstract updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    abstract deleteItem<K extends Key<T>>(collection: K, id: string): Promise<void>;
-    abstract getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
-    abstract setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    abstract updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
-    abstract deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
+    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 {};

package/provider/ThroughProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Datas, Key } from "../util/data.js";
+import type { Datas, DataKey } 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";
@@ -7,31 +7,31 @@ import type { Provider, AsyncProvider } from "./Provider.js";
 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 Key<T>>(collection: K, id: string): ItemValue<T[K]>;
-    getItemSequence<K extends Key<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
-    addItem<K extends Key<T>>(collection: K, data: T[K]): string;
-    setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): void;
-    updateItem<K extends Key<T>>(collection: K, id: string, update: Updates<T[K]>): void;
-    deleteItem<K extends Key<T>>(collection: K, id: string): void;
-    getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
-    getQuerySequence<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
-    setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: Updates<T[K]>): number;
-    deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
+    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;
 }
 /** 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 Key<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    getItemSequence<K extends Key<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
-    addItem<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
-    setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    deleteItem<K extends Key<T>>(collection: K, id: string): Promise<void>;
-    getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
-    getQuerySequence<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
-    setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
-    deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
+    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>;
 }

package/provider/ValidationProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Key, Datas } from "../util/data.js";
+import type { DataKey, Datas } from "../util/data.js";
 import type { ItemArray, ItemValue, ItemConstraints } from "../db/Item.js";
 import type { DataSchemas, DataSchema } from "../schema/DataSchema.js";
 import { Updates } from "../update/DataUpdate.js";
@@ -9,36 +9,36 @@ declare abstract class BaseValidationProvider<T extends Datas> {
     abstract source: Provider | AsyncProvider;
     readonly schemas: DataSchemas<T>;
     constructor(schemas: DataSchemas<T>);
-    getSchema<K extends Key<T>>(collection: K): DataSchema<T[K]>;
-    getItemSequence<K extends Key<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
-    getQuerySequence<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): AsyncIterable<ItemArray<T[K]>>;
+    getSchema<K extends DataKey<T>>(collection: K): DataSchema<T[K]>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
+    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> {
     readonly source: Provider;
     constructor(source: Provider, schemas: DataSchemas<T>);
-    getItem<K extends Key<T>>(collection: K, id: string): ItemValue<T[K]>;
-    addItem<K extends Key<T>>(collection: K, data: T[K]): string;
-    setItem<K extends Key<T>>(collection: K, id: string, value: T[K]): void;
-    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    deleteItem<K extends Key<T>>(collection: K, id: string): void;
-    getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
-    setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, value: T[K]): number;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
-    deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
+    getItem<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
+    setItem<K extends DataKey<T>>(collection: K, id: string, value: 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;
+    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
+    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, value: 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;
 }
 /** 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> {
     readonly source: AsyncProvider;
     constructor(source: AsyncProvider, schemas: DataSchemas<T>);
-    getItem<K extends Key<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
-    addItem<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
-    setItem<K extends Key<T>>(collection: K, id: string, value: T[K]): Promise<void>;
-    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    deleteItem<K extends Key<T>>(collection: K, id: string): Promise<void>;
-    getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
-    setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, value: T[K]): Promise<number>;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
-    deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
+    getItem<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
+    setItem<K extends DataKey<T>>(collection: K, id: string, value: 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]>>;
+    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemConstraints<T[K]>, value: 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 {};

package/provider/ValidationProvider.js

@@ -103,9 +103,9 @@ function _validateItem(collection, unsafeEntity, schema) {
 }
 /** Validate a set of entities for this query reference. */
 function _validateItems(collection, unsafeEntities, schema) {
-    return Array.from(_yieldItems(collection, unsafeEntities, schema));
+    return Array.from(_yieldValidItems(collection, unsafeEntities, schema));
 }
-function* _yieldItems(collection, unsafeEntities, schema) {
+function* _yieldValidItems(collection, unsafeEntities, schema) {
     let invalid = false;
     const details = {};
     for (const unsafeEntity of unsafeEntities) {

package/react/useItem.d.ts

@@ -1,10 +1,10 @@
 import type { ItemValue, ItemData, AsyncItem, Item } from "../db/Item.js";
 import type { Dispatch } from "../util/function.js";
-import { Datas, Key } from "../util/data.js";
+import { Datas, DataKey } from "../util/data.js";
 import { State } from "../state/State.js";
 import { BooleanState } from "../state/BooleanState.js";
 /** Hold the current state of a item. */
-export declare class ItemState<T extends Datas, K extends Key<T> = Key<T>> extends State<ItemValue<T[K]>> {
+export declare class ItemState<T extends Datas, K extends DataKey<T> = DataKey<T>> extends State<ItemValue<T[K]>> {
     readonly ref: Item<T, K> | AsyncItem<T, K>;
     readonly busy: BooleanState;
     /** Get the data of the item (throws `RequiredError` if item doesn't exist). */
@@ -24,5 +24,5 @@ export declare class ItemState<T extends Datas, K extends Key<T> = Key<T>> exten
  * Use an item in a React component.
  * - Uses the default cache, so will error if not used inside `<Cache>`
  */
-export declare function useItem<T extends Datas, K extends Key<T>>(ref: Item<T, K> | AsyncItem<T, K>): ItemState<T, K>;
-export declare function useItem<T extends Datas, K extends Key<T>>(ref?: Item<T, K> | AsyncItem<T, K>): ItemState<T, K> | undefined;
+export declare function useItem<T extends Datas, K extends DataKey<T>>(ref: Item<T, K> | AsyncItem<T, K>): ItemState<T, K>;
+export declare function useItem<T extends Datas, K extends DataKey<T>>(ref?: Item<T, K> | AsyncItem<T, K>): ItemState<T, K> | undefined;

package/react/useQuery.d.ts

@@ -1,11 +1,11 @@
-import type { Datas, Key } from "../util/data.js";
+import type { Datas, DataKey } from "../util/data.js";
 import type { Stop } from "../util/function.js";
 import type { ItemArray, ItemValue, ItemData } from "../db/Item.js";
 import type { AsyncQuery, Query } from "../db/Query.js";
 import { State } from "../state/State.js";
 import { BooleanState } from "../state/BooleanState.js";
 /** Hold the current state of a query. */
-export declare class QueryState<T extends Datas, K extends Key<T> = Key<T>> extends State<ItemArray<T[K]>> implements Iterable<ItemData<T[K]>> {
+export declare class QueryState<T extends Datas, K extends DataKey<T> = DataKey<T>> extends State<ItemArray<T[K]>> implements Iterable<ItemData<T[K]>> {
     readonly ref: Query<T, K> | AsyncQuery<T, K>;
     readonly busy: BooleanState;
     readonly limit: number;
@@ -45,5 +45,5 @@ export declare class QueryState<T extends Datas, K extends Key<T> = Key<T>> exte
  * Use a query in a React component.
  * - Uses the default cache, so will error if not used inside `<Cache>`
  */
-export declare function useQuery<T extends Datas, K extends Key<T>>(ref: Query<T, K> | AsyncQuery<T, K>): QueryState<T, K>;
-export declare function useQuery<T extends Datas, K extends Key<T>>(ref?: Query<T, K> | AsyncQuery<T, K>): QueryState<T, K> | undefined;
+export declare function useQuery<T extends Datas, K extends DataKey<T>>(ref: Query<T, K> | AsyncQuery<T, K>): QueryState<T, K>;
+export declare function useQuery<T extends Datas, K extends DataKey<T>>(ref?: Query<T, K> | AsyncQuery<T, K>): QueryState<T, K> | undefined;

package/schema/AllowSchema.d.ts

@@ -1,28 +1,29 @@
-import { Schema } from "./Schema.js";
-/** Specify a specific list of allowed values. */
-export declare type Allowed<T extends string | number> = ReadonlyArray<T> | {
-    readonly [K in T]: unknown;
+import type { Entry } from "../util/entry.js";
+import { ImmutableRequiredMap, PossibleMap, PossibleStringMap } from "../util/map.js";
+import { Schema, SchemaOptions } from "./Schema.js";
+/** Options for an `AllowSchema` instance. */
+declare type AllowSchemaOptions<K, T> = SchemaOptions & {
+    allow: PossibleMap<K, T>;
+    value?: K | null;
 };
-/** Validate a value against a specific set of allowed values. */
-export declare function validateAllowed<T extends string | number>(value: unknown, allowed: Allowed<T>): T;
 /** Define a valid value from an allowed set of values. */
-export declare abstract class AllowSchema<T extends string | number> extends Schema<T> {
-    readonly value: T | null;
-    readonly allow: Allowed<T>;
-    constructor({ allow, value, ...options }: ConstructorParameters<typeof Schema>[0] & {
-        allow: Allowed<T>;
-        value?: T | null;
-    });
-}
-/** Define a valid string from an allowed set of strings. */
-export declare class AllowStringSchema<T extends string> extends AllowSchema<T> {
-    validate(unsafeValue?: unknown): T;
+export declare class AllowSchema<K, T> extends Schema<K> implements Iterable<Entry<K, T>> {
+    readonly value: K | null;
+    readonly allow: ImmutableRequiredMap<K, T>;
+    constructor({ allow, value, ...options }: AllowSchemaOptions<K, T>);
+    validate(value?: unknown): K;
+    /** Iterate over the the allowed options in `[key, value]` format. */
+    [Symbol.iterator](): Iterator<Entry<K, T>>;
 }
-/** Define a valid number from an allowed set of numbers. */
-export declare class AllowNumberSchema<T extends number> extends AllowSchema<T> {
-    validate(unsafeValue?: unknown): T;
+/** Define a valid string value from an allowed set of values. */
+export declare class AllowStringSchema<K extends string, T> extends AllowSchema<K, T> {
+    constructor({ allow, ...options }: SchemaOptions & {
+        allow: PossibleStringMap<K, T>;
+    });
+    validator(value?: unknown): K;
 }
-/** Valid string from an allowed set of strings. */
-export declare const ALLOW_STRING: <T extends string>(allow: Allowed<T>) => AllowStringSchema<T>;
-/** Valid string from an allowed set of numbers. */
-export declare const ALLOW_NUMBER: <T extends number>(allow: Allowed<T>) => AllowNumberSchema<T>;
+/** Valid value from an allowed set of values. */
+export declare function ALLOW<K, T>(allow: PossibleMap<K, T>): AllowSchema<K, T>;
+/** Valid string from an allowed set of values. */
+export declare function ALLOW_STRING<K extends string, T>(allow: PossibleStringMap<K, T>): AllowSchema<K, T>;
+export {};

package/schema/AllowSchema.js

@@ -1,42 +1,38 @@
-import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { getString } from "../util/string.js";
-import { isArray, isItem } from "../util/array.js";
-import { getOptionalNumber } from "../util/number.js";
-import { isProp } from "../util/object.js";
+import { getRequiredMap, isMapKey } from "../util/map.js";
+import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { Schema } from "./Schema.js";
-/** Validate a value against a specific set of allowed values. */
-export function validateAllowed(value, allowed) {
-    if (isArray(allowed)) {
-        if (isItem(allowed, value))
-            return value;
-    }
-    else {
-        if (isProp(allowed, value))
-            return value;
-    }
-    throw new InvalidFeedback("Unknown value", { value });
-}
 /** Define a valid value from an allowed set of values. */
 export class AllowSchema extends Schema {
     constructor({ allow, value = null, ...options }) {
         super(options);
-        this.allow = allow;
+        this.allow = getRequiredMap(allow);
         this.value = value;
     }
+    validate(value = this.value) {
+        if (isMapKey(this.allow, value))
+            return value;
+        throw new InvalidFeedback("Unknown value", { value });
+    }
+    /** Iterate over the the allowed options in `[key, value]` format. */
+    [Symbol.iterator]() {
+        return this.allow[Symbol.iterator]();
+    }
 }
-/** Define a valid string from an allowed set of strings. */
+/** Define a valid string value from an allowed set of values. */
 export class AllowStringSchema extends AllowSchema {
-    validate(unsafeValue = this.value) {
-        return validateAllowed(getString(unsafeValue), this.allow);
+    constructor({ allow, ...options }) {
+        super({ allow: getRequiredMap(allow), ...options });
     }
-}
-/** Define a valid number from an allowed set of numbers. */
-export class AllowNumberSchema extends AllowSchema {
-    validate(unsafeValue = this.value) {
-        return validateAllowed(getOptionalNumber(unsafeValue), this.allow);
+    validator(value = this.value) {
+        return super.validate(getString(value));
     }
 }
-/** Valid string from an allowed set of strings. */
-export const ALLOW_STRING = (allow) => new AllowStringSchema({ allow });
-/** Valid string from an allowed set of numbers. */
-export const ALLOW_NUMBER = (allow) => new AllowNumberSchema({ allow });
+/** Valid value from an allowed set of values. */
+export function ALLOW(allow) {
+    return new AllowSchema({ allow });
+}
+/** Valid string from an allowed set of values. */
+export function ALLOW_STRING(allow) {
+    return new AllowStringSchema({ allow });
+}

package/schema/ArraySchema.d.ts

@@ -1,6 +1,6 @@
 import { ImmutableArray } from "../util/array.js";
 import { Validator } from "../util/validate.js";
-import { Schema } from "./Schema.js";
+import { Schema, SchemaOptions } from "./Schema.js";
 /**
  * Define a valid array.
  *
@@ -34,7 +34,7 @@ export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     readonly unique: boolean;
     readonly min: number;
     readonly max: number | null;
-    constructor({ value, items, unique, min, max, ...options }: ConstructorParameters<typeof Schema>[0] & {
+    constructor({ value, items, unique, min, max, ...options }: SchemaOptions & {
         readonly value?: ImmutableArray;
         readonly items: Validator<T>;
         readonly min?: number;

package/schema/BooleanSchema.d.ts

@@ -1,8 +1,8 @@
-import { Schema } from "./Schema.js";
+import { Schema, SchemaOptions } from "./Schema.js";
 /** Define a valid boolean. */
 export declare class BooleanSchema extends Schema<boolean> {
     readonly value: boolean;
-    constructor({ value, ...options }: ConstructorParameters<typeof Schema>[0] & {
+    constructor({ value, ...options }: SchemaOptions & {
         readonly value?: boolean;
     });
     validate(unsafeValue?: unknown): boolean;

package/schema/DataSchema.d.ts

@@ -1,12 +1,12 @@
 import type { Data, Datas } from "../util/data.js";
 import { Validators } from "../util/validate.js";
 import { OptionalSchema } from "./OptionalSchema.js";
-import { Schema } from "./Schema.js";
+import { Schema, SchemaOptions } from "./Schema.js";
 /** Validate a data object. */
 export declare class DataSchema<T extends Data> extends Schema<T> {
     readonly value: Partial<T>;
     readonly props: Validators<T>;
-    constructor({ value, props, ...options }: ConstructorParameters<typeof Schema>[0] & {
+    constructor({ value, props, ...options }: SchemaOptions & {
         readonly props: Validators<T>;
         readonly value?: Partial<T>;
     });

package/schema/DataSchema.js

@@ -1,6 +1,6 @@
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { validateData } from "../util/validate.js";
-import { isObject } from "../util/object.js";
+import { isData } from "../util/data.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /** Validate a data object. */
@@ -11,7 +11,7 @@ export class DataSchema extends Schema {
         this.value = value;
     }
     validate(unsafeValue = this.value) {
-        if (!isObject(unsafeValue))
+        if (!isData(unsafeValue))
             throw new InvalidFeedback("Must be object", { value: unsafeValue });
         return validateData(unsafeValue, this.props);
     }

package/schema/DateSchema.d.ts

@@ -1,11 +1,11 @@
 import { PossibleDate } from "../util/date.js";
-import { Schema } from "./Schema.js";
+import { Schema, SchemaOptions } from "./Schema.js";
 /** Define a valid date, e.g. `2005-09-12` */
 export declare class DateSchema extends Schema<string> {
     readonly value: PossibleDate;
     readonly min: PossibleDate | null;
     readonly max: PossibleDate | null;
-    constructor({ value, min, max, ...options }: ConstructorParameters<typeof Schema>[0] & {
+    constructor({ value, min, max, ...options }: SchemaOptions & {
         readonly value?: PossibleDate;
         readonly min?: PossibleDate | null;
         readonly max?: PossibleDate | null;

package/schema/DictionarySchema.d.ts

@@ -0,0 +1,19 @@
+import { ImmutableDictionary } from "../util/dictionary.js";
+import { Validator } from "../util/validate.js";
+import { Schema, SchemaOptions } from "./Schema.js";
+/** Validate a dictionary object (whose props are all the same with string keys). */
+export declare class DictionarySchema<T> extends Schema<ImmutableDictionary<T>> {
+    readonly value: ImmutableDictionary;
+    readonly items: Validator<T>;
+    readonly min: number | null;
+    readonly max: number | null;
+    constructor({ value, items, min, max, ...rest }: SchemaOptions & {
+        readonly items: Validator<T>;
+        readonly value?: ImmutableDictionary;
+        readonly min?: number | null;
+        readonly max?: number | null;
+    });
+    validate(unsafeValue?: unknown): ImmutableDictionary<T>;
+}
+/** Valid dictionary object with specifed items. */
+export declare const DICTIONARY: <T>(items: Validator<T>) => DictionarySchema<T>;

package/schema/{ObjectSchema.js → DictionarySchema.js}

@@ -1,9 +1,9 @@
-import { isObject } from "../util/object.js";
+import { isDictionary } from "../util/dictionary.js";
 import { validateEntries } from "../util/validate.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { Schema } from "./Schema.js";
-/** Validate a map-like object (whose props are all the same). */
-export class ObjectSchema extends Schema {
+/** Validate a dictionary object (whose props are all the same with string keys). */
+export class DictionarySchema extends Schema {
     constructor({ value = {}, items, min = null, max = null, ...rest }) {
         super(rest);
         this.min = null;
@@ -14,7 +14,7 @@ export class ObjectSchema extends Schema {
         this.max = max;
     }
     validate(unsafeValue = this.value) {
-        if (!isObject(unsafeValue))
+        if (!isDictionary(unsafeValue))
             throw new InvalidFeedback("Must be object", { value: unsafeValue });
         const unsafeEntries = Object.entries(unsafeValue);
         const safeObject = Object.fromEntries(validateEntries(unsafeEntries, this.items));
@@ -25,5 +25,5 @@ export class ObjectSchema extends Schema {
         return safeObject;
     }
 }
-/** Valid map-like object with specifed items. */
-export const OBJECT = (items) => new ObjectSchema({ items });
+/** Valid dictionary object with specifed items. */
+export const DICTIONARY = (items) => new DictionarySchema({ items });

package/schema/LinkSchema.d.ts

@@ -1,4 +1,4 @@
-import { StringSchema } from "./StringSchema.js";
+import { StringSchema, StringSchemaOptions } from "./StringSchema.js";
 /**
  * Type of `StringSchema` that defines a valid URL.
  * - Checks URL scheme against a whitelist (always), and checks URL domain against a whitelist (optional).
@@ -11,7 +11,7 @@ export declare class LinkSchema extends StringSchema {
     readonly max = 512;
     readonly schemes: string[];
     readonly hosts: string[] | null;
-    constructor({ schemes, hosts, ...rest }: ConstructorParameters<typeof StringSchema>[0] & {
+    constructor({ schemes, hosts, ...rest }: StringSchemaOptions & {
         readonly schemes?: string[];
         readonly hosts?: string[] | null;
     });

package/schema/NumberSchema.d.ts

@@ -1,11 +1,11 @@
-import { Schema } from "./Schema.js";
+import { Schema, SchemaOptions } from "./Schema.js";
 /** Schema that defines a valid number. */
 export declare class NumberSchema extends Schema<number> {
     readonly value: number | null;
     readonly min: number | null;
     readonly max: number | null;
     readonly step: number | null;
-    constructor({ value, min, max, step, ...rest }: ConstructorParameters<typeof Schema>[0] & {
+    constructor({ value, min, max, step, ...rest }: SchemaOptions & {
         readonly value?: number | null;
         readonly min?: number | null;
         readonly max?: number | null;