shelving 1.76.1 → 1.78.0

package/react/useItem.d.ts

@@ -1,17 +1,17 @@
 import type { Unsubscribe } from "../observe/Observable.js";
-import { Datas, Value } from "../util/data.js";
+import { Datas, Key } from "../util/data.js";
 import { ItemValue, ItemData, AsyncItem, Item } from "../db/Item.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> extends State<ItemValue<Value<T>>> {
-    readonly ref: Item<T> | AsyncItem<T>;
+export declare class ItemState<T extends Datas, K extends Key<T> = Key<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). */
-    get data(): ItemData<Value<T>>;
+    get data(): ItemData<T[K]>;
     /** Does the item exist (i.e. its value isn't `null`)? */
     get exists(): boolean;
-    constructor(ref: Item<T> | AsyncItem<T>);
+    constructor(ref: Item<T, K> | AsyncItem<T, K>);
     /** Refresh this state from the source provider. */
     readonly refresh: () => void;
     _refresh(): Promise<void>;
@@ -28,5 +28,5 @@ export declare class ItemState<T extends Datas> extends State<ItemValue<Value<T>
  * 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>(ref: Item<T> | AsyncItem<T>): ItemState<T>;
-export declare function useItem<T extends Datas>(ref?: Item<T> | AsyncItem<T>): ItemState<T> | undefined;
+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;

package/react/useQuery.d.ts

@@ -1,30 +1,30 @@
 import type { Unsubscribe } from "../observe/Observable.js";
-import type { Datas, Value } from "../util/data.js";
+import type { Datas, Key } from "../util/data.js";
 import type { ItemArray, ItemValue, ItemData } from "../db/Item.js";
 import { 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> extends State<ItemArray<Value<T>>> {
-    readonly ref: Query<T> | AsyncQuery<T>;
+export declare class QueryState<T extends Datas, K extends Key<T> = Key<T>> extends State<ItemArray<T[K]>> {
+    readonly ref: Query<T, K> | AsyncQuery<T, K>;
     readonly busy: BooleanState;
     readonly limit: number;
     /** Can more items be loaded after the current result. */
     get hasMore(): boolean;
     private _hasMore;
     /** Get the first document matched by this query or `null` if this query has no items. */
-    get firstValue(): ItemValue<Value<T>>;
+    get firstValue(): ItemValue<T[K]>;
     /** Get the first document matched by this query. */
-    get firstData(): ItemData<Value<T>>;
+    get firstData(): ItemData<T[K]>;
     /** Get the last document matched by this query or `null` if this query has no items. */
-    get lastValue(): ItemValue<Value<T>>;
+    get lastValue(): ItemValue<T[K]>;
     /** Get the last document matched by this query. */
-    get lastData(): ItemData<Value<T>>;
+    get lastData(): ItemData<T[K]>;
     /** Does the document have at least one result. */
     get exists(): boolean;
     /** Get the number of items matching this query. */
     get count(): number;
-    constructor(ref: Query<T> | AsyncQuery<T>);
+    constructor(ref: Query<T, K> | AsyncQuery<T, K>);
     /** Refresh this state from the source provider. */
     readonly refresh: () => void;
     _refresh(): Promise<void>;
@@ -47,5 +47,5 @@ export declare class QueryState<T extends Datas> extends State<ItemArray<Value<T
  * 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>(ref: Query<T> | AsyncQuery<T>): QueryState<T>;
-export declare function useQuery<T extends Datas>(ref?: Query<T> | AsyncQuery<T>): QueryState<T> | undefined;
+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;

package/schema/DataSchema.d.ts

@@ -1,4 +1,4 @@
-import type { Data } from "../util/data.js";
+import type { Data, Datas } from "../util/data.js";
 import { Validators } from "../util/validate.js";
 import { OptionalSchema } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
@@ -12,6 +12,10 @@ export declare class DataSchema<T extends Data> extends Schema<T> {
     });
     validate(unsafeValue?: unknown): T;
 }
+/** Set of named data schemas. */
+export declare type DataSchemas<T extends Datas> = {
+    [K in keyof T]: DataSchema<T[K]>;
+};
 /** Valid data object with specifed properties. */
 export declare const DATA: <T extends Data>(props: Validators<T>) => DataSchema<T>;
 /** Valid data object with specifed properties, or `null` */

package/state/DataState.d.ts

@@ -1,5 +1,5 @@
 import { Data, Key, OptionalData } from "../util/data.js";
-import { PropTransformers } from "../util/transform.js";
+import { Transformers } from "../util/transform.js";
 import { State } from "./State.js";
 /** State that stores a data object and has additional methods to help with that. */
 export declare class DataState<T extends Data> extends State<T> {
@@ -8,7 +8,7 @@ export declare class DataState<T extends Data> extends State<T> {
     /** Set a prop in this object to a new value. */
     set<K extends Key<T>>(key: K, value: T[K]): void;
     /** Update several props in this object. */
-    update(updates: PropTransformers<T>): void;
+    update(updates: Transformers<T>): void;
 }
 /** State that stores an optional data object and has additional methods to help with that. */
 export declare class OptionalDataState<T extends Data> extends State<OptionalData<T>> {
@@ -19,7 +19,7 @@ export declare class OptionalDataState<T extends Data> extends State<OptionalDat
     /** Set a prop in this object to a new value. */
     set<K extends Key<T>>(key: K, value: T[K]): void;
     /** Update several props in this object. */
-    update(updates: PropTransformers<T>): void;
+    update(updates: Transformers<T>): void;
     /** Delete this result. */
     delete(): void;
 }

package/update/DataUpdate.d.ts

@@ -1,7 +1,7 @@
 import { Data, Key, Prop } from "../util/data.js";
 import { Nullish } from "../util/null.js";
 import { Transformable } from "../util/transform.js";
-import { Validator } from "../util/validate.js";
+import { Validator, Validators } from "../util/validate.js";
 import { Update } from "./Update.js";
 /**
  * Set of named transforms for the props of a data object.
@@ -10,19 +10,27 @@ import { Update } from "./Update.js";
  * - If a prop contains a transform, the existing value is transformed.
  * - This is a subset of `Dispatchers`
  */
-export declare type PropUpdates<T extends Data> = {
+export declare type Updates<T extends Data = Data> = {
     readonly [K in keyof T]?: T[K] | Update<T[K]>;
 };
-/** Update that can be applied to a data object to update its props. */
-export declare class DataUpdate<T extends Data = Data> extends Update<T> implements Iterable<Prop<PropUpdates<T>>>, Transformable<T, T> {
+/**
+ * Validate a set of updates against a set of validators.
+ */
+export declare function validateUpdates<T extends Data>(unsafeUpdates: Updates<T>, validators: Validators<T>): {
+    [k: string]: import("../util/data.js").Value<Updates<T>>;
+};
+/**
+ * Update that can be applied to a data object to update its props.
+ */
+export declare class DataUpdate<T extends Data = Data> extends Update<T> implements Iterable<Prop<Updates<T>>>, Transformable<T, T> {
     /** Return a data update with a specific prop marked for update. */
     static with<X extends Data, K extends Key<X>>(key: Nullish<K>, value: X[K] | Update<X[K]>): DataUpdate<X>;
-    readonly updates: PropUpdates<T>;
-    constructor(props: PropUpdates<T>);
+    readonly updates: Updates<T>;
+    constructor(props: Updates<T>);
     transform(data: T): T;
     validate(validator: Validator<T>): this;
     /** Return a data update with a specific prop marked for update. */
     with<K extends Key<T>>(key: Nullish<K>, value: T[K] | Update<T[K]>): this;
     /** Iterate over the transforms in this object. */
-    [Symbol.iterator](): Iterator<Prop<PropUpdates<T>>, void>;
+    [Symbol.iterator](): Iterator<Prop<Updates<T>>, void>;
 }

package/update/DataUpdate.js

@@ -6,7 +6,33 @@ import { isNullish } from "../util/null.js";
 import { transformData } from "../util/transform.js";
 import { validate } from "../util/validate.js";
 import { Update } from "./Update.js";
-/** Update that can be applied to a data object to update its props. */
+/**
+ * Validate a set of updates against a set of validators.
+ */
+export function validateUpdates(unsafeUpdates, validators) {
+    return Object.fromEntries(_validateUpdates(unsafeUpdates, validators));
+}
+function* _validateUpdates(unsafeUpdates, validators) {
+    const feedbacks = new Map();
+    for (const [key, validator] of getProps(validators)) {
+        const unsafeUpdate = unsafeUpdates[key];
+        if (unsafeUpdate !== undefined) {
+            try {
+                yield [key, unsafeUpdate instanceof Update ? unsafeUpdate.validate(validator) : validate(unsafeUpdate, validator)];
+            }
+            catch (thrown) {
+                if (!isFeedback(thrown))
+                    throw thrown;
+                feedbacks.set(key, thrown);
+            }
+        }
+    }
+    if (feedbacks.size)
+        throw new InvalidFeedback("Invalid updates", feedbacks);
+}
+/**
+ * Update that can be applied to a data object to update its props.
+ */
 export class DataUpdate extends Update {
     constructor(props) {
         super();
@@ -25,7 +51,7 @@ export class DataUpdate extends Update {
         return {
             __proto__: Object.getPrototypeOf(this),
             ...this,
-            updates: Object.fromEntries(_validateUpdates(this.updates, validator.props)),
+            updates: validateUpdates(this.updates, validator.props),
         };
     }
     /** Return a data update with a specific prop marked for update. */
@@ -43,22 +69,3 @@ export class DataUpdate extends Update {
         return Object.entries(this.updates).values();
     }
 }
-/** Validate a set of transforms against a set of validators. */
-function* _validateUpdates(unsafeUpdates, validators) {
-    const feedbacks = new Map();
-    for (const [key, validator] of getProps(validators)) {
-        const unsafeUpdate = unsafeUpdates[key];
-        if (unsafeUpdate !== undefined) {
-            try {
-                yield [key, unsafeUpdate instanceof Update ? unsafeUpdate.validate(validator) : validate(unsafeUpdate, validator)];
-            }
-            catch (thrown) {
-                if (!isFeedback(thrown))
-                    throw thrown;
-                feedbacks.set(key, thrown);
-            }
-        }
-    }
-    if (feedbacks.size)
-        throw new InvalidFeedback("Invalid updates", feedbacks);
-}

package/util/transform.d.ts

@@ -16,19 +16,19 @@ export declare type Transformer<I, O> = Transformable<I, O> | Transform<I, O> |
 export declare function transform<I, O>(input: I, transformer: (v: I) => O): O;
 export declare function transform<I, O>(input: I, transformer: Transformer<I, O>): O;
 /** Set of named transformers for a data object. */
-export declare type PropTransformers<T extends Data> = {
+export declare type Transformers<T extends Data> = {
     readonly [K in keyof T]?: Transformer<T[K], T[K]>;
 };
 /**
  * Transform the props of a data object using a set of transformers for its props.
  * @returns New object with changed props (or the same object if no changes were made).
  */
-export declare function transformData<T extends Data>(data: T, transforms: PropTransformers<T>): T;
+export declare function transformData<T extends Data>(data: T, transforms: Transformers<T>): T;
 /**
  * Transform the props of a data object using a set of prop transformers.
  * @yield Transformed prop entry after calling the corresponding prop transformer.
  */
-export declare function transformProps<T extends Data>(data: T, transforms: PropTransformers<T>): Iterable<Prop<T>>;
+export declare function transformProps<T extends Data>(data: T, transforms: Transformers<T>): Iterable<Prop<T>>;
 /**
  * Transform the _values_ of an iterable set of entries using a transformer.
  * @yield Transformed entry after calling transforming the new value for each entry.