shelving 1.91.2 → 1.92.0

package/provider/ValidationProvider.js

@@ -1,9 +1,9 @@
 import { ValidationError } from "../error/ValidationError.js";
 import { Feedback } from "../feedback/Feedback.js";
-import { transformObject } from "../util/transform.js";
+import { updateData } from "../util/update.js";
 import { validate, validateWithContext } from "../util/validate.js";
 // Constants.
-const VALIDATION_CONTEXT_GET = { action: "get" };
+const VALIDATION_CONTEXT_GET = { action: "get", id: true };
 const VALIDATION_CONTEXT_ADD = { action: "add" };
 const VALIDATION_CONTEXT_SET = { action: "set" };
 const VALIDATION_CONTEXT_UPDATE = { action: "update", partial: true };
@@ -42,7 +42,8 @@ export class ValidationProvider extends BaseValidationProvider {
         return this.source.setItem(collection, id, validateWithContext(value, this.getSchema(collection), VALIDATION_CONTEXT_SET));
     }
     updateItem(collection, id, updates) {
-        return this.source.updateItem(collection, id, validateWithContext(transformObject({}, updates), this.getSchema(collection), VALIDATION_CONTEXT_UPDATE));
+        validateWithContext(updateData({}, updates), this.getSchema(collection), VALIDATION_CONTEXT_UPDATE);
+        return this.source.updateItem(collection, id, updates);
     }
     deleteItem(collection, id) {
         return this.source.deleteItem(collection, id);
@@ -54,7 +55,8 @@ export class ValidationProvider extends BaseValidationProvider {
         return this.source.setQuery(collection, constraints, validate(value, this.getSchema(collection)));
     }
     updateQuery(collection, constraints, updates) {
-        return this.source.updateQuery(collection, constraints, validateWithContext(transformObject({}, updates), this.getSchema(collection), VALIDATION_CONTEXT_UPDATE));
+        validateWithContext(updateData({}, updates), this.getSchema(collection), VALIDATION_CONTEXT_UPDATE);
+        return this.source.updateQuery(collection, constraints, updates);
     }
     deleteQuery(collection, constraints) {
         return this.source.deleteQuery(collection, constraints);
@@ -76,7 +78,8 @@ export class AsyncValidationProvider extends BaseValidationProvider {
         return this.source.setItem(collection, id, validateWithContext(value, this.getSchema(collection), VALIDATION_CONTEXT_SET));
     }
     updateItem(collection, id, updates) {
-        return this.source.updateItem(collection, id, validateWithContext(updates, this.getSchema(collection), VALIDATION_CONTEXT_UPDATE));
+        validateWithContext(updateData({}, updates), this.getSchema(collection), VALIDATION_CONTEXT_UPDATE);
+        return this.source.updateItem(collection, id, updates);
     }
     deleteItem(collection, id) {
         return this.source.deleteItem(collection, id);
@@ -88,7 +91,8 @@ export class AsyncValidationProvider extends BaseValidationProvider {
         return this.source.setQuery(collection, constraints, validateWithContext(value, this.getSchema(collection), VALIDATION_CONTEXT_SET));
     }
     updateQuery(collection, constraints, updates) {
-        return this.source.updateQuery(collection, constraints, validateWithContext(updates, this.getSchema(collection), VALIDATION_CONTEXT_UPDATE));
+        validateWithContext(updateData({}, updates), this.getSchema(collection), VALIDATION_CONTEXT_UPDATE);
+        return this.source.updateQuery(collection, constraints, updates);
     }
     deleteQuery(collection, constraints) {
         return this.source.deleteQuery(collection, constraints);
@@ -99,12 +103,12 @@ function _validateItem(collection, unsafeEntity, schema) {
     if (!unsafeEntity)
         return null;
     try {
-        return { ...validateWithContext(unsafeEntity, schema, VALIDATION_CONTEXT_GET), id: unsafeEntity.id };
+        return validateWithContext(unsafeEntity, schema, VALIDATION_CONTEXT_GET);
     }
     catch (thrown) {
         if (!(thrown instanceof Feedback))
             throw thrown;
-        throw new ValidationError(`Invalid data for "${collection}"`, unsafeEntity);
+        throw new ValidationError(`Invalid data for "${collection}"`, thrown.message);
     }
 }
 /** Validate a set of entities for this query reference. */
@@ -113,18 +117,18 @@ function _validateItems(collection, unsafeEntities, schema) {
 }
 function* _yieldValidItems(collection, unsafeEntities, schema) {
     let invalid = false;
-    const details = {};
+    const messages = {};
     for (const unsafeEntity of unsafeEntities) {
         try {
-            yield { ...validateWithContext(unsafeEntity, schema, VALIDATION_CONTEXT_GET), id: unsafeEntity.id };
+            yield validateWithContext(unsafeEntity, schema, VALIDATION_CONTEXT_GET);
         }
         catch (thrown) {
             if (!(thrown instanceof Feedback))
                 throw thrown;
             invalid = true;
-            details[unsafeEntity.id] = thrown.message;
+            messages[unsafeEntity.id] = thrown.message;
         }
     }
     if (invalid)
-        throw new ValidationError(`Invalid data for "${collection}"`, details);
+        throw new ValidationError(`Invalid data for "${collection}"`, messages);
 }

package/react/useData.d.ts

@@ -1,13 +1,13 @@
 /// <reference types="react" />
-import type { AsyncQuery } from "../db/Query.js";
+import type { AsyncQueryReference } from "../db/QueryReference.js";
 import type { ImmutableArray } from "../util/array.js";
-import { AsyncItem } from "../db/Item.js";
+import { AsyncItemReference } from "../db/ItemReference.js";
 import { ItemState } from "../db/ItemState.js";
 import { QueryState } from "../db/QueryState.js";
-type RefToState<T> = T extends undefined ? undefined : T extends AsyncItem<infer X> ? ItemState<X> : T extends AsyncQuery<infer X> ? QueryState<X> : never;
+type RefToState<T> = T extends undefined ? undefined : T extends AsyncItemReference<infer X> ? ItemState<X> : T extends AsyncQueryReference<infer X> ? QueryState<X> : never;
 /** Use one or more data items or queries. */
-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): {
+export declare function useData<T extends AsyncItemReference | AsyncQueryReference | undefined>(ref: T): RefToState<T>;
+export declare function useData<T extends ImmutableArray<AsyncItemReference | AsyncQueryReference | undefined>>(...refs: T): {
     [K in keyof T]: RefToState<T[K]>;
 };
 /** Wrap components with `<DataCache>` to allow the use of `useData()`. */

package/react/useData.js

@@ -1,4 +1,4 @@
-import { AsyncItem } from "../db/Item.js";
+import { AsyncItemReference } from "../db/ItemReference.js";
 import { ItemState } from "../db/ItemState.js";
 import { QueryState } from "../db/QueryState.js";
 import { setMapItem } from "../util/map.js";
@@ -15,7 +15,7 @@ export function useData(...refs) {
 /** Get the corresponding `ItemState` or `QueryState` instance from the cache for a given `Item` or `Query`. */
 function _getRefState(ref, cache) {
     const key = ref === null || ref === void 0 ? void 0 : ref.toString();
-    return ref && key ? cache.get(key) || setMapItem(cache, key, ref instanceof AsyncItem ? new ItemState(ref) : new QueryState(ref)) : undefined;
+    return ref && key ? cache.get(key) || setMapItem(cache, key, ref instanceof AsyncItemReference ? new ItemState(ref) : new QueryState(ref)) : undefined;
 }
 /** Wrap components with `<DataCache>` to allow the use of `useData()`. */
 export const DataCache = Cache;

package/state/DataState.d.ts

@@ -1,18 +1,16 @@
 import type { Data, DataKey } from "../util/data.js";
-import type { Transformer, Transformers } from "../util/transform.js";
+import type { Updates } from "../util/update.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> {
     /** Get the data value of this state. */
     get data(): T;
+    /** Update several props in this data. */
+    update(updates: Updates<T>): void;
     /** Update a single named prop in this data. */
     getProp<K extends DataKey<T>>(name: K): T[K];
     /** Update a single named prop in this data. */
     setProp<K extends DataKey<T>>(name: K, value: T[K]): void;
-    /** Update a single named prop in this data. */
-    updateProp<K extends DataKey<T>>(name: K, update: Transformer<T[K], T[K]>): void;
-    /** Update several props in this data. */
-    update(updates: Transformers<T, 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<T | null> {
@@ -21,13 +19,11 @@ export declare class OptionalDataState<T extends Data> extends State<T | null> {
     /** Does the data exist or not? */
     get exists(): boolean;
     /** Update several props in this data. */
-    update(updates: Transformers<T, T>): void;
+    update(updates: Updates<T>): void;
     /** Update a single named prop in this data. */
     getProp<K extends DataKey<T>>(name: K): T[K];
     /** Update a single named prop in this data. */
     setProp<K extends DataKey<T>>(name: K, value: T[K]): void;
-    /** Update a single named prop in this data. */
-    updateProp<K extends DataKey<T>>(name: K, update: Transformer<T[K], T[K]>): void;
     /** Set the data to `null`. */
     unset(): void;
 }

package/state/DataState.js

@@ -1,6 +1,6 @@
 import { getData } from "../util/data.js";
 import { withProp } from "../util/object.js";
-import { transform, transformObject } from "../util/transform.js";
+import { updateData } from "../util/update.js";
 import { State } from "./State.js";
 /** State that stores a data object and has additional methods to help with that. */
 export class DataState extends State {
@@ -8,6 +8,10 @@ export class DataState extends State {
     get data() {
         return this.value;
     }
+    /** Update several props in this data. */
+    update(updates) {
+        this.set(updateData(this.data, updates));
+    }
     /** Update a single named prop in this data. */
     getProp(name) {
         return this.data[name];
@@ -16,15 +20,6 @@ export class DataState extends State {
     setProp(name, value) {
         this.set(withProp(this.data, name, value));
     }
-    /** Update a single named prop in this data. */
-    updateProp(name, update) {
-        const data = this.data;
-        this.set(withProp(data, name, transform(data[name], update)));
-    }
-    /** Update several props in this data. */
-    update(updates) {
-        this.set(transformObject(this.data, updates));
-    }
 }
 /** State that stores an optional data object and has additional methods to help with that. */
 export class OptionalDataState extends State {
@@ -38,7 +33,7 @@ export class OptionalDataState extends State {
     }
     /** Update several props in this data. */
     update(updates) {
-        this.set(transformObject(this.data, updates));
+        this.set(updateData(this.data, updates));
     }
     /** Update a single named prop in this data. */
     getProp(name) {
@@ -48,11 +43,6 @@ export class OptionalDataState extends State {
     setProp(name, value) {
         this.set(withProp(this.data, name, value));
     }
-    /** Update a single named prop in this data. */
-    updateProp(name, update) {
-        const data = this.data;
-        this.set(withProp(data, name, transform(data[name], update)));
-    }
     /** Set the data to `null`. */
     unset() {
         this.set(null);

package/state/DictionaryState.d.ts

@@ -1,5 +1,5 @@
 import type { DictionaryItem, ImmutableDictionary } from "../util/dictionary.js";
-import type { Transformer, Transformers } from "../util/transform.js";
+import type { Updates } from "../util/update.js";
 import { State } from "./State.js";
 /** State that stores a dictionary object and has additional methods to help with that. */
 export declare class DictionaryState<T> extends State<ImmutableDictionary<T>> implements Iterable<DictionaryItem<T>> {
@@ -7,15 +7,13 @@ export declare class DictionaryState<T> extends State<ImmutableDictionary<T>> im
     /** Get the length of the current value of this state. */
     get count(): number;
     /** Set a named entry in this object with a different value. */
-    update(updates: Transformers<ImmutableDictionary<T>, Partial<ImmutableDictionary<T>>>): void;
+    update(updates: Updates<ImmutableDictionary<T>>): void;
     /** Remove a named entry from this object. */
     delete(...keys: string[]): void;
-    /** Update a single named prop in this data. */
+    /** Get an item in this dictionary. */
     getItem(name: string): T | undefined;
-    /** Update a single named prop in this data. */
+    /** Set an item in this dictionary. */
     setItem(name: string, value: T): void;
-    /** Update a single named prop in this data. */
-    updateItem(name: string, update: Transformer<T | undefined, T>): void;
     /** Iterate over the entries of the object. */
     [Symbol.iterator](): Iterator<DictionaryItem<T>>;
 }

package/state/DictionaryState.js

@@ -1,6 +1,6 @@
 import { omitDictionaryItems } from "../util/dictionary.js";
 import { withProp } from "../util/object.js";
-import { transform, transformObject } from "../util/transform.js";
+import { updateData } from "../util/update.js";
 import { State } from "./State.js";
 /** State that stores a dictionary object and has additional methods to help with that. */
 export class DictionaryState extends State {
@@ -13,25 +13,20 @@ export class DictionaryState extends State {
     }
     /** Set a named entry in this object with a different value. */
     update(updates) {
-        this.set(transformObject(this.value, updates));
+        this.set(updateData(this.value, updates));
     }
     /** Remove a named entry from this object. */
     delete(...keys) {
         this.set(omitDictionaryItems(this.value, ...keys));
     }
-    /** Update a single named prop in this data. */
+    /** Get an item in this dictionary. */
     getItem(name) {
         return this.value[name];
     }
-    /** Update a single named prop in this data. */
+    /** Set an item in this dictionary. */
     setItem(name, value) {
         this.set(withProp(this.value, name, value));
     }
-    /** Update a single named prop in this data. */
-    updateItem(name, update) {
-        const value = this.value;
-        this.set(withProp(value, name, transform(value[name], update)));
-    }
     /** Iterate over the entries of the object. */
     [Symbol.iterator]() {
         return Object.entries(this.value)[Symbol.iterator]();

package/test/basics.d.ts

@@ -1,4 +1,4 @@
-import type { ItemData } from "../db/Item.js";
+import type { ItemData } from "../db/ItemReference.js";
 import type { ValidatorType } from "../util/validate.js";
 export declare const BASIC_SCHEMA: import("../schema/DataSchema.js").DataSchema<{
     str: string;

package/test/people.d.ts

@@ -1,4 +1,4 @@
-import type { ItemData } from "../db/Item.js";
+import type { ItemData } from "../db/ItemReference.js";
 import type { ValidatorType } from "../util/validate.js";
 export declare const PERSON_SCHEMA: import("../schema/DataSchema.js").DataSchema<{
     name: {

package/test/util.d.ts

@@ -1,4 +1,4 @@
-import type { ItemData } from "../db/Item.js";
+import type { ItemData } from "../db/ItemReference.js";
 import type { Data } from "../util/data.js";
 import type { AnyFunction } from "../util/function.js";
 import type { NotString } from "../util/string.js";

package/test/util.js

@@ -1,5 +1,5 @@
 import { expect } from "@jest/globals";
-import { getIDs } from "../db/Item.js";
+import { getIDs } from "../db/ItemReference.js";
 /** Match any `Promiselike` object. */
 export const PromiseLike = expect.objectContaining({
     then: expect.any(Function),

package/util/data.d.ts

@@ -10,7 +10,7 @@ export type DataKey<T extends Data> = keyof T & string;
 export type DataValue<T extends Data> = T[keyof T & string];
 /** Prop for a data object. */
 export type DataProp<T extends Data> = {
-    readonly [K in DataKey<T>]: [K, T[K]];
+    readonly [K in DataKey<T>]: readonly [K, T[K]];
 }[DataKey<T>];
 /** Data or `null` to indicate the data doesn't exist. */
 export type OptionalData<T extends Data> = T | null;
@@ -26,7 +26,7 @@ export type FlatDataKey<T extends Data> = FlatDataProp<T>[0];
 export type FlatDataValue<T extends Data> = FlatDataProp<T>[1];
 /** Prop for a flattened data object with deep keys flattened into `a.c.b` format. */
 export type FlatDataProp<T extends Data> = {
-    readonly [K in DataKey<T>]: (T[K] extends Data ? FlatDataProp<T[K]> : [null, T[K]]) extends infer E ? E extends [infer KK, infer VV] ? [KK extends string ? `${K}.${KK}` : K, VV] : never : never;
+    readonly [K in DataKey<T>]: (T[K] extends Data ? FlatDataProp<T[K]> : readonly [null, T[K]]) extends infer E ? E extends readonly [infer KK, infer VV] ? readonly [KK extends string ? `${K}.${KK}` : K, VV] : never : never;
 }[DataKey<T>];
 /** Is an unknown value a data object? */
 export declare const isData: <T extends Data>(value: unknown) => value is T;

package/util/equal.js

@@ -1,19 +1,19 @@
 import { isArray } from "./array.js";
 import { isMap } from "./map.js";
 import { isObject, isProp } from "./object.js";
-import { rankAsc } from "./sort.js";
+import { compareAscending } from "./sort.js";
 /** Is unknown value `left` exactly equal to `right`? */
 export const isEqual = (left, right) => left === right;
 /** Is unknown value `left` not exactly equal to `right`? */
 export const notEqual = (left, right) => !isEqual(left, right);
 /** Is unknown value `left` less than `right`? */
-export const isLess = (left, right) => rankAsc(left, right) < 0;
+export const isLess = (left, right) => compareAscending(left, right) < 0;
 /** Is unknown value `left` less than or equal to `right`? */
-export const isEqualLess = (left, right) => rankAsc(left, right) <= 0;
+export const isEqualLess = (left, right) => compareAscending(left, right) <= 0;
 /** Is unknown value `left` greater than `right`? */
-export const isGreater = (left, right) => rankAsc(left, right) > 0;
+export const isGreater = (left, right) => compareAscending(left, right) > 0;
 /** Is unknown value `left` greater than or equal to `right`? */
-export const isEqualGreater = (left, right) => rankAsc(left, right) >= 0;
+export const isEqualGreater = (left, right) => compareAscending(left, right) >= 0;
 // Internal shared by shallow/deep equal.
 function _isEqualRecursively(left, right, recursor) {
     if (left === right)

package/util/hydrate.d.ts

@@ -1,11 +1,23 @@
 import type { Class } from "./class.js";
 import type { ImmutableDictionary } from "./dictionary.js";
-import type { Transformable } from "./transform.js";
 /**
  * A set of hydrations describes a set of string keys and the class constructor to be dehydrated and rehydrated.
  * - We can't use `class.name` because we don't know that the name of the class will survive minification.
  */
 export type Hydrations = ImmutableDictionary<Class<unknown>>;
+/** A dehydrated object with a `$type` key. */
+export type DehydratedObject = {
+    readonly $type: string;
+    readonly $value: unknown;
+};
+/**
+ * Deeply hydrate a class instance based on a set of `Hydrations`
+ * - Hydration allows a client to receive class instances from a server.
+ * - By its nature hydration is an unsafe operation.
+ * - Deeply iterates into arrays and plain objects to hydrate their items and props too.
+ * - Note: the recursion in this function does not currently protect against infinite loops.
+ */
+export declare function hydrate(value: unknown, hydrations: Hydrations): unknown;
 /**
  * Deeply dehydrate a class instance based on a set of `Hydrations`
  * - Dehydration allows you to pass class instances from a server back to a client.
@@ -17,28 +29,3 @@ export type Hydrations = ImmutableDictionary<Class<unknown>>;
  * @throws `Error` if the value is a class instance that cannot be dehydrated (i.e. is not matched by any constructor in `hydrations`).
  */
 export declare function dehydrate(value: unknown, hydrations: Hydrations): unknown;
-/**
- * Deeply hydrate a class instance based on a set of `Hydrations`
- * - Hydration allows a client to receive class instances from a server.
- * - By its nature hydration is an unsafe operation.
- * - Deeply iterates into arrays and plain objects to hydrate their items and props too.
- * - Note: the recursion in this function does not currently protect against infinite loops.
- */
-export declare function hydrate(value: unknown, hydrations: Hydrations): unknown;
-/** A dehydrated object with a `$type` key. */
-export type DehydratedObject = {
-    readonly $type: string;
-    readonly $value: unknown;
-};
-/** Hydrates a value with a set of hydrations. */
-export declare class Hydrator implements Transformable<unknown, unknown> {
-    private _hydrations;
-    constructor(hydrations: Hydrations);
-    transform(value: unknown): unknown;
-}
-/** Dehydrates a value with a set of hydrations. */
-export declare class Dehydrator implements Transformable<unknown, unknown> {
-    private _hydrations;
-    constructor(hydrations: Hydrations);
-    transform(value: unknown): unknown;
-}

package/util/hydrate.js

@@ -2,10 +2,39 @@ import { AssertionError } from "../error/AssertionError.js";
 import { isArray } from "./array.js";
 import { isDate } from "./date.js";
 import { isMap } from "./map.js";
-import { getPrototype, isObject, isPlainObject } from "./object.js";
+import { getProps, getPrototype, isObject, isPlainObject } from "./object.js";
 import { isSet } from "./set.js";
 import { isString } from "./string.js";
-import { mapArray, mapEntries, mapItems, mapObject } from "./transform.js";
+import { mapArray, mapObject } from "./transform.js";
+/** Is an unknown value a dehydrated object with a `$type` key. */
+const isDehydrated = (value) => isString(value.$type);
+/**
+ * Deeply hydrate a class instance based on a set of `Hydrations`
+ * - Hydration allows a client to receive class instances from a server.
+ * - By its nature hydration is an unsafe operation.
+ * - Deeply iterates into arrays and plain objects to hydrate their items and props too.
+ * - Note: the recursion in this function does not currently protect against infinite loops.
+ */
+export function hydrate(value, hydrations) {
+    if (isArray(value))
+        return mapArray(value, hydrate, hydrations);
+    if (isPlainObject(value)) {
+        if (!isDehydrated(value))
+            return mapObject(value, hydrate, hydrations);
+        const { $type, $value } = value;
+        if ($type === "Map")
+            return new Map($value);
+        if ($type === "Set")
+            return new Set($value);
+        if ($type === "Date")
+            return new Date($value);
+        const hydration = hydrations[$type];
+        if (hydration)
+            return { __proto__: hydration.prototype, ...mapObject($value, hydrate, hydrations) };
+        throw new AssertionError(`Cannot hydrate "${$type}" object`, value);
+    }
+    return value;
+}
 /**
  * Deeply dehydrate a class instance based on a set of `Hydrations`
  * - Dehydration allows you to pass class instances from a server back to a client.
@@ -17,69 +46,24 @@ import { mapArray, mapEntries, mapItems, mapObject } from "./transform.js";
  * @throws `Error` if the value is a class instance that cannot be dehydrated (i.e. is not matched by any constructor in `hydrations`).
  */
 export function dehydrate(value, hydrations) {
-    return new Dehydrator(hydrations).transform(value);
-}
-/**
- * Deeply hydrate a class instance based on a set of `Hydrations`
- * - Hydration allows a client to receive class instances from a server.
- * - By its nature hydration is an unsafe operation.
- * - Deeply iterates into arrays and plain objects to hydrate their items and props too.
- * - Note: the recursion in this function does not currently protect against infinite loops.
- */
-export function hydrate(value, hydrations) {
-    return new Hydrator(hydrations).transform(value);
-}
-/** Is an unknown value a dehydrated object with a `$type` key. */
-const isDehydrated = (value) => isString(value.$type);
-/** Hydrates a value with a set of hydrations. */
-export class Hydrator {
-    constructor(hydrations) {
-        this._hydrations = hydrations;
-    }
-    transform(value) {
-        if (isArray(value))
-            return mapArray(value, this);
-        if (isPlainObject(value)) {
-            if (!isDehydrated(value))
-                return mapObject(value, this);
-            const { $type, $value } = value;
-            if ($type === "Map")
-                return new Map($value);
-            if ($type === "Set")
-                return new Set($value);
-            if ($type === "Date")
-                return new Date($value);
-            const hydration = this._hydrations[$type];
-            if (hydration)
-                return { __proto__: hydration.prototype, ...mapObject($value, this) };
-            throw new AssertionError(`Cannot hydrate "${$type}" object`, value);
-        }
-        return value;
-    }
-}
-/** Dehydrates a value with a set of hydrations. */
-export class Dehydrator {
-    constructor(hydrations) {
-        this._hydrations = hydrations;
-    }
-    transform(value) {
+    if (isObject(value)) {
         if (isArray(value))
-            return mapArray(value, this);
-        if (isMap(value))
-            return { $type: "Map", $value: Array.from(mapEntries(value.entries(), this)) };
-        if (isSet(value))
-            return { $type: "Set", $value: Array.from(mapItems(value.values(), this)) };
-        if (isDate(value))
+            return mapArray(value, dehydrate, hydrations);
+        else if (isMap(value))
+            return { $type: "Map", $value: mapArray(value.entries(), dehydrate, hydrations) };
+        else if (isSet(value))
+            return { $type: "Set", $value: mapArray(value.values(), dehydrate, hydrations) };
+        else if (isDate(value))
             return { $type: "Date", $value: value.getTime() };
-        if (isObject(value)) {
+        else if (isPlainObject(value))
+            return mapObject(value, dehydrate, hydrations);
+        else {
             const proto = getPrototype(value);
-            if (proto === Object.prototype || proto === null)
-                return mapObject(value, this);
-            for (const [$type, hydration] of Object.entries(this._hydrations))
+            for (const [$type, hydration] of getProps(hydrations))
                 if (proto === hydration.prototype)
-                    return { $type, $value: mapObject(value, this) };
+                    return { $type, $value: mapObject(value, dehydrate, hydrations) };
             throw new AssertionError(`Cannot dehydrate object`, value);
         }
-        return value;
     }
+    return value;
 }

package/util/index.d.ts

@@ -26,6 +26,7 @@ export * from "./merge.js";
 export * from "./null.js";
 export * from "./number.js";
 export * from "./object.js";
+export * from "./query.js";
 export * from "./random.js";
 export * from "./regexp.js";
 export * from "./sequence.js";
@@ -39,5 +40,6 @@ export * from "./timeout.js";
 export * from "./transform.js";
 export * from "./undefined.js";
 export * from "./units.js";
+export * from "./update.js";
 export * from "./url.js";
 export * from "./validate.js";

package/util/index.js

@@ -26,6 +26,7 @@ export * from "./merge.js";
 export * from "./null.js";
 export * from "./number.js";
 export * from "./object.js";
+export * from "./query.js";
 export * from "./random.js";
 export * from "./regexp.js";
 export * from "./sequence.js";
@@ -39,5 +40,6 @@ export * from "./timeout.js";
 export * from "./transform.js";
 export * from "./undefined.js";
 export * from "./units.js";
+export * from "./update.js";
 export * from "./url.js";
 export * from "./validate.js";

package/util/iterate.d.ts

@@ -35,6 +35,8 @@ export declare function omitItems<T>(items: Iterable<T>, ...omit: T[]): Iterable
 /** Reduce an iterable set of items using a reducer function. */
 export declare function reduceItems<T>(items: Iterable<T>, reducer: (previous: T, item: T) => T, initial: T): T;
 export declare function reduceItems<T>(items: Iterable<T>, reducer: (previous: T | undefined, item: T) => T, initial?: T): T | undefined;
+export declare function reduceItems<I, O>(items: Iterable<I>, reducer: (previous: O, item: I) => O, initial: O): O;
+export declare function reduceItems<I, O>(items: Iterable<I>, reducer: (previous: O | undefined, item: I) => O, initial?: O): O | undefined;
 /** Yield chunks of a given size. */
 export declare function getChunks<T>(items: Iterable<T>, size: 1): Iterable<readonly [T]>;
 export declare function getChunks<T>(items: Iterable<T>, size: 2): Iterable<readonly [T, T]>;

package/util/match.d.ts

@@ -1,16 +1,8 @@
 import type { ImmutableArray } from "./array.js";
 import type { Arguments } from "./function.js";
-/** Object that can match an item against a target with its `match()` function. */
-export interface Matchable<A extends Arguments = unknown[]> {
-    match(...args: A): boolean;
-}
 /** Function that can match an item against a target. */
 export type Match<A extends Arguments = unknown[]> = (...args: A) => boolean;
-/** Match is either a `Matcherable` object, or matcher function. */
-export type Matcher<A extends Arguments = unknown[]> = Matchable<A> | Match<A>;
-/** Match two values using a `Matcher`. */
-export declare function match<A extends Arguments>(matcher: Matcher<A>, ...args: A): boolean;
 /** Filter an iterable set of items using a matcher. */
-export declare function filterItems<T, A extends Arguments = []>(items: Iterable<T>, matcher: Matcher<[T, ...A]>, ...args: A): Iterable<T>;
+export declare function filterItems<T, A extends Arguments = []>(items: Iterable<T>, match: Match<[T, ...A]>, ...args: A): Iterable<T>;
 /** Filter an array (immutably) using a matcher. */
-export declare function filterArray<T, A extends Arguments = []>(input: ImmutableArray<T>, matcher: Matcher<[T, ...A]>, ...args: A): ImmutableArray<T>;
+export declare function filterArray<T, A extends Arguments = []>(input: ImmutableArray<T>, match: Match<[T, ...A]>, ...args: A): ImmutableArray<T>;

package/util/match.js

@@ -1,17 +1,13 @@
-/** Match two values using a `Matcher`. */
-export function match(matcher, ...args) {
-    return typeof matcher === "function" ? matcher(...args) : matcher.match(...args);
-}
 /** Filter an iterable set of items using a matcher. */
-export function* filterItems(items, matcher, ...args) {
+export function* filterItems(items, match, ...args) {
     for (const item of items)
-        if (match(matcher, item, ...args))
+        if (match(item, ...args))
             yield item;
 }
 /** Filter an array (immutably) using a matcher. */
-export function filterArray(input, matcher, ...args) {
+export function filterArray(input, match, ...args) {
     if (!input.length)
         return input;
-    const output = Array.from(filterItems(input, matcher, ...args));
+    const output = Array.from(filterItems(input, match, ...args));
     return output.length === input.length ? input : output;
 }