shelving 1.157.2 → 1.158.0

package/api/Endpoint.d.ts

@@ -1,5 +1,5 @@
+import { type Schema } from "../schema/Schema.js";
 import type { AbsolutePath } from "../util/path.js";
-import { type Validator } from "../util/validate.js";
 import type { EndpointCallback, EndpointHandler } from "./util.js";
 /** Types for an HTTP request or response that does something. */
 export type EndpointMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
@@ -8,8 +8,8 @@ export type EndpointMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
  *
  * @param method The method of the resource, e.g. `GET`
  * @param path The path of the resource optionally including `{placeholder}` values, e.g. `/patient/{id}`
- * @param payload A `Validator` for the payload of the resource.
- * @param result A `Validator` for the result of the resource.
+ * @param payload A `Schema` for the payload of the resource.
+ * @param result A `Schema` for the result of the resource.
  */
 export declare class Endpoint<P, R> {
     /** Endpoint method. */
@@ -17,10 +17,10 @@ export declare class Endpoint<P, R> {
     /** Endpoint path, e.g. `/patient/{id}` */
     readonly path: AbsolutePath;
     /** Payload validator. */
-    readonly payload: Validator<P>;
+    readonly payload: Schema<P>;
     /** Result validator. */
-    readonly result: Validator<R>;
-    constructor(method: EndpointMethod, path: AbsolutePath, payload: Validator<P>, result: Validator<R>);
+    readonly result: Schema<R>;
+    constructor(method: EndpointMethod, path: AbsolutePath, payload: Schema<P>, result: Schema<R>);
     /**
      * Return an `EndpointHandler` for this endpoint.
      *
@@ -46,34 +46,34 @@ export type EndpointType<X extends Endpoint<unknown, unknown>> = X extends Endpo
  * Represent a GET request to a specified path, with validated payload and return types.
  * "The GET method requests a representation of the specified resource. Requests using GET should only retrieve data and should not contain a request content."
  */
-export declare function GET<P, R>(path: AbsolutePath, payload?: Validator<P>, result?: Validator<R>): Endpoint<P, R>;
-export declare function GET<P>(path: AbsolutePath, payload: Validator<P>): Endpoint<P, undefined>;
-export declare function GET<R>(path: AbsolutePath, payload: undefined, result: Validator<R>): Endpoint<undefined, R>;
+export declare function GET<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function GET<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function GET<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
 /**
  * Represent a POST request to a specified path, with validated payload and return types.
  * "The POST method submits an entity to the specified resource, often causing a change in state or side effects on the server.
  */
-export declare function POST<P, R>(path: AbsolutePath, payload?: Validator<P>, result?: Validator<R>): Endpoint<P, R>;
-export declare function POST<P>(path: AbsolutePath, payload: Validator<P>): Endpoint<P, undefined>;
-export declare function POST<R>(path: AbsolutePath, payload: undefined, result: Validator<R>): Endpoint<undefined, R>;
+export declare function POST<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function POST<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function POST<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
 /**
  * Represent a PUT request to a specified path, with validated payload and return types.
  * "The PUT method replaces all current representations of the target resource with the request content."
  */
-export declare function PUT<P, R>(path: AbsolutePath, payload?: Validator<P>, result?: Validator<R>): Endpoint<P, R>;
-export declare function PUT<P>(path: AbsolutePath, payload: Validator<P>): Endpoint<P, undefined>;
-export declare function PUT<R>(path: AbsolutePath, payload: undefined, result: Validator<R>): Endpoint<undefined, R>;
+export declare function PUT<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function PUT<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function PUT<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
 /**
  * Represent a PATCH request to a specified path, with validated payload and return types.
  * "The PATCH method applies partial modifications to a resource."
  */
-export declare function PATCH<P, R>(path: AbsolutePath, payload?: Validator<P>, result?: Validator<R>): Endpoint<P, R>;
-export declare function PATCH<P>(path: AbsolutePath, payload: Validator<P>): Endpoint<P, undefined>;
-export declare function PATCH<R>(path: AbsolutePath, payload: undefined, result: Validator<R>): Endpoint<undefined, R>;
+export declare function PATCH<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function PATCH<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function PATCH<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;
 /**
  * Represent a DELETE request to a specified path, with validated payload and return types.
  * "The DELETE method deletes the specified resource."
  */
-export declare function DELETE<P, R>(path: AbsolutePath, payload?: Validator<P>, result?: Validator<R>): Endpoint<P, R>;
-export declare function DELETE<P>(path: AbsolutePath, payload: Validator<P>): Endpoint<P, undefined>;
-export declare function DELETE<R>(path: AbsolutePath, payload: undefined, result: Validator<R>): Endpoint<undefined, R>;
+export declare function DELETE<P, R>(path: AbsolutePath, payload?: Schema<P>, result?: Schema<R>): Endpoint<P, R>;
+export declare function DELETE<P>(path: AbsolutePath, payload: Schema<P>): Endpoint<P, undefined>;
+export declare function DELETE<R>(path: AbsolutePath, payload: undefined, result: Schema<R>): Endpoint<undefined, R>;

package/api/Endpoint.js

@@ -1,12 +1,13 @@
+import { UNDEFINED } from "../schema/Schema.js";
 import { getResponse } from "../util/http.js";
-import { UNDEFINED, getValid } from "../util/validate.js";
+import { getValid } from "../util/validate.js";
 /**
  * An abstract API resource definition, used to specify types for e.g. serverless functions.
  *
  * @param method The method of the resource, e.g. `GET`
  * @param path The path of the resource optionally including `{placeholder}` values, e.g. `/patient/{id}`
- * @param payload A `Validator` for the payload of the resource.
- * @param result A `Validator` for the result of the resource.
+ * @param payload A `Schema` for the payload of the resource.
+ * @param result A `Schema` for the result of the resource.
  */
 export class Endpoint {
     /** Endpoint method. */
@@ -53,18 +54,18 @@ export class Endpoint {
         return `${this.method} ${this.path}`;
     }
 }
-export function GET(path, payload, result) {
-    return new Endpoint("GET", path, payload || UNDEFINED, result || UNDEFINED);
+export function GET(path, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("GET", path, payload, result);
 }
-export function POST(path, payload, result) {
-    return new Endpoint("POST", path, payload || UNDEFINED, result || UNDEFINED);
+export function POST(path, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("POST", path, payload, result);
 }
-export function PUT(path, payload, result) {
-    return new Endpoint("PUT", path, payload || UNDEFINED, result || UNDEFINED);
+export function PUT(path, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("PUT", path, payload, result);
 }
-export function PATCH(path, payload, result) {
-    return new Endpoint("PATCH", path, payload || UNDEFINED, result || UNDEFINED);
+export function PATCH(path, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("PATCH", path, payload, result);
 }
-export function DELETE(path, payload, result) {
-    return new Endpoint("DELETE", path, payload || UNDEFINED, result || UNDEFINED);
+export function DELETE(path, payload = UNDEFINED, result = UNDEFINED) {
+    return new Endpoint("DELETE", path, payload, result);
 }

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.157.2",
+	"version": "1.158.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/schema/ArraySchema.d.ts

@@ -1,11 +1,10 @@
 import type { ImmutableArray } from "../util/array.js";
-import type { Validator } from "../util/validate.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `ArraySchema` */
 export interface ArraySchemaOptions<T> extends SchemaOptions {
     readonly value?: ImmutableArray;
-    readonly items: Validator<T>;
+    readonly items: Schema<T>;
     readonly min?: number;
     readonly max?: number;
     readonly unique?: boolean;
@@ -39,7 +38,7 @@ export interface ArraySchemaOptions<T> extends SchemaOptions {
  */
 export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     readonly value: ImmutableArray;
-    readonly items: Validator<T>;
+    readonly items: Schema<T>;
     readonly unique: boolean;
     readonly min: number;
     readonly max: number;
@@ -47,4 +46,4 @@ export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     validate(unsafeValue?: unknown): ImmutableArray<T>;
 }
 /** Valid array with specifed items. */
-export declare const ARRAY: <T>(items: Validator<T>) => ArraySchema<T>;
+export declare const ARRAY: <T>(items: Schema<T>) => ArraySchema<T>;

package/schema/DataSchema.d.ts

@@ -1,19 +1,18 @@
 import type { Data, Database } from "../util/data.js";
 import type { Identifier, Item } from "../util/item.js";
-import type { Validator, Validators } from "../util/validate.js";
 import type { NullableSchema } from "./NullableSchema.js";
-import type { SchemaOptions } from "./Schema.js";
+import type { SchemaOptions, Schemas } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `PropsSchema` (a schema that has props). */
 export interface DataSchemaOptions<T extends Data> extends SchemaOptions {
-    readonly id?: Validator<string>;
-    readonly props: Validators<T>;
+    readonly id?: Schema<string>;
+    readonly props: Schemas<T>;
     readonly value?: Partial<T> | undefined;
 }
 /** Validate a data object. */
 export declare class DataSchema<T extends Data> extends Schema<unknown> {
     readonly value: Partial<T>;
-    readonly props: Validators<T>;
+    readonly props: Schemas<T>;
     constructor({ props, title, value, ...options }: DataSchemaOptions<T>);
     validate(unsafeValue?: unknown): T;
 }
@@ -22,10 +21,10 @@ export type DataSchemas<T extends Database> = {
     [K in keyof T]: DataSchema<T[K]>;
 };
 /** Create a `DataSchema` for a set of properties. */
-export declare const DATA: <T extends Data>(props: Validators<T>) => DataSchema<T>;
+export declare const DATA: <T extends Data>(props: Schemas<T>) => DataSchema<T>;
 /** Valid data object with specifed properties, or `null` */
-export declare const NULLABLE_DATA: <T extends Data>(props: Validators<T>) => NullableSchema<T>;
+export declare const NULLABLE_DATA: <T extends Data>(props: Schemas<T>) => NullableSchema<T>;
 /** Create a `DataSchema` that validates partially, i.e. properties can be their value, or `undefined` */
-export declare function PARTIAL<T extends Data>(source: Validators<T> | DataSchema<T>): DataSchema<Partial<T>>;
+export declare function PARTIAL<T extends Data>(source: Schemas<T> | DataSchema<T>): DataSchema<Partial<T>>;
 /** Create a `DataSchema` that validates a data item, i.e. it has a string or number `.id` identifier property. */
-export declare function ITEM<I extends Identifier, T extends Data>(id: Validator<I>, validators: Validators<T> | DataSchema<T>): DataSchema<Item<I, T>>;
+export declare function ITEM<I extends Identifier, T extends Data>(id: Schema<I>, schemas: Schemas<T> | DataSchema<T>): DataSchema<Item<I, T>>;

package/schema/DataSchema.js

@@ -1,6 +1,6 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { isData } from "../util/data.js";
-import { mapObject } from "../util/transform.js";
+import { mapProps } from "../util/transform.js";
 import { validateData } from "../util/validate.js";
 import { NULLABLE } from "./NullableSchema.js";
 import { OPTIONAL } from "./OptionalSchema.js";
@@ -22,16 +22,18 @@ export class DataSchema extends Schema {
 export const DATA = (props) => new DataSchema({ props });
 /** Valid data object with specifed properties, or `null` */
 export const NULLABLE_DATA = (props) => NULLABLE(new DataSchema({ props }));
-/** Create a `DataSchema` that validates partially, i.e. properties can be their value, or `undefined` */
 export function PARTIAL(source) {
     const props = source instanceof DataSchema ? source.props : source;
     return new DataSchema({
-        props: mapObject(props, OPTIONAL),
+        props: mapProps(props, _optionalProp),
     });
 }
+function _optionalProp([, v]) {
+    return OPTIONAL(v);
+}
 /** Create a `DataSchema` that validates a data item, i.e. it has a string or number `.id` identifier property. */
-export function ITEM(id, validators) {
-    const props = validators instanceof DataSchema ? validators.props : validators;
+export function ITEM(id, schemas) {
+    const props = schemas instanceof DataSchema ? schemas.props : schemas;
     return new DataSchema({
         props: { id, ...props },
     });

package/schema/DictionarySchema.d.ts

@@ -1,10 +1,9 @@
 import type { ImmutableDictionary } from "../util/dictionary.js";
-import type { Validator } from "../util/validate.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `DictionarySchema` */
 export interface DictionarySchemaOptions<T> extends SchemaOptions {
-    readonly items: Validator<T>;
+    readonly items: Schema<T>;
     readonly value?: ImmutableDictionary | undefined;
     readonly min?: number | undefined;
     readonly max?: number | undefined;
@@ -12,11 +11,11 @@ export interface DictionarySchemaOptions<T> extends SchemaOptions {
 /** 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 items: Schema<T>;
     readonly min: number;
     readonly max: number;
     constructor({ items, min, max, title, value, ...options }: DictionarySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableDictionary<T>;
 }
 /** Valid dictionary object with specifed items. */
-export declare const DICTIONARY: <T>(items: Validator<T>) => DictionarySchema<T>;
+export declare const DICTIONARY: <T>(items: Schema<T>) => DictionarySchema<T>;

package/schema/Schema.d.ts

@@ -1,3 +1,4 @@
+import type { Data } from "../util/data.js";
 import type { Validator } from "../util/validate.js";
 /** Options allowed by a `Schema` instance. */
 export type SchemaOptions = {
@@ -28,3 +29,10 @@ export declare abstract class Schema<T = unknown> implements Validator<T> {
     /** Every schema must implement a `validate()` method. */
     abstract validate(unsafeValue: unknown): T;
 }
+/** A set of named schemas in `{ name: schema }` format. */
+export type Schemas<T extends Data = Data> = {
+    readonly [K in keyof T]: Schema<T[K]>;
+};
+export declare const UNKNOWN: Schema<unknown>;
+export declare const UNDEFINED: Schema<undefined>;
+export declare const NULL: Schema<null>;

package/schema/Schema.js

@@ -1,3 +1,6 @@
+import { PASSTHROUGH } from "../util/function.js";
+import { getNull } from "../util/null.js";
+import { getUndefined } from "../util/undefined.js";
 /**
  * Schema is an object instance with a `validate()` method.
  * - Type `T` represents the type of value `validate()` returns.
@@ -19,3 +22,9 @@ export class Schema {
         this.value = value;
     }
 }
+// Unknown validator always passes through its input value as `unknown`
+export const UNKNOWN = { title: "", description: "", placeholder: "", value: undefined, validate: PASSTHROUGH };
+// Undefined validator always returns `undefined`
+export const UNDEFINED = { ...UNKNOWN, validate: getUndefined };
+// Null validator always returns `null`
+export const NULL = { ...UNKNOWN, validate: getNull };

package/schema/ThroughSchema.d.ts

@@ -1,14 +1,13 @@
 import type { Sourceable } from "../util/source.js";
-import type { Validator } from "../util/validate.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `ThroughSchema` */
 export interface ThroughSchemaOptions<T> extends SchemaOptions {
-    source: Validator<T>;
+    source: Schema<T>;
 }
 /** Schema that passes through to a source schema. */
-export declare abstract class ThroughSchema<T> extends Schema<T> implements Sourceable<Validator<T>> {
-    readonly source: Validator<T>;
+export declare abstract class ThroughSchema<T> extends Schema<T> implements Sourceable<Schema<T>> {
+    readonly source: Schema<T>;
     constructor({ source, ...options }: ThroughSchemaOptions<T>);
     validate(unsafeValue: unknown): T;
 }

package/util/hydrate.js

@@ -5,7 +5,7 @@ import { isMap } from "./map.js";
 import { getProps, getPrototype, isObject, isPlainObject } from "./object.js";
 import { isSet } from "./set.js";
 import { isString } from "./string.js";
-import { mapArray, mapObject } from "./transform.js";
+import { mapArray, mapProps } from "./transform.js";
 /** Is an unknown value a dehydrated object with a `$type` key. */
 function _isDehydrated(value) {
     return isString(value.$type);
@@ -22,7 +22,7 @@ export function hydrate(value, hydrations) {
         return mapArray(value, hydrate, hydrations);
     if (isPlainObject(value)) {
         if (!_isDehydrated(value))
-            return mapObject(value, hydrate, hydrations);
+            return mapProps(value, _hydrateProp, hydrations);
         const { $type, $value } = value;
         if ($type === "Map")
             return new Map($value);
@@ -33,11 +33,14 @@ export function hydrate(value, hydrations) {
         // Complex object, check the hydrations list.
         const hydration = hydrations[$type];
         if (hydration)
-            return { __proto__: hydration.prototype, ...mapObject($value, hydrate, hydrations) };
+            return { __proto__: hydration.prototype, ...mapProps($value, _hydrateProp, hydrations) };
         throw new ValueError(`Cannot hydrate object "${$type}"`, { type: $type, received: $value, caller: hydrate });
     }
     return value;
 }
+function _hydrateProp([, v], hydrations) {
+    return hydrate(v, hydrations);
+}
 /**
  * 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.
@@ -59,13 +62,16 @@ export function dehydrate(value, hydrations) {
         if (isDate(value))
             return { $type: "Date", $value: value.getTime() };
         if (isPlainObject(value))
-            return mapObject(value, dehydrate, hydrations);
+            return mapProps(value, _dehydrateProp, hydrations);
         // Complex object, check the hydrations list.
         const proto = getPrototype(value);
         for (const [$type, hydration] of getProps(hydrations))
             if (proto === hydration.prototype)
-                return { $type, $value: mapObject(value, dehydrate, hydrations) };
+                return { $type, $value: mapProps(value, _dehydrateProp, hydrations) };
         throw new ValueError("Cannot dehydrate object", { received: value, caller: dehydrate });
     }
     return value;
 }
+function _dehydrateProp([, v], hydrations) {
+    return dehydrate(v, hydrations);
+}

package/util/transform.d.ts

@@ -1,32 +1,22 @@
-import type { ArrayItem, ImmutableArray } from "./array.js";
-import type { ImmutableDictionary } from "./dictionary.js";
+import type { ImmutableArray } from "./array.js";
+import type { DictionaryItem, ImmutableDictionary } from "./dictionary.js";
 import type { Entry } from "./entry.js";
 import type { Arguments } from "./function.js";
-import type { ImmutableObject, Value } from "./object.js";
-/** Function that can transform an input value into an output value. */
-export type Transform<I, O, A extends Arguments = []> = (input: I, ...args: A) => O;
-/** Function that can transform an input value into an output value. */
-export type AsyncTransform<I, O, A extends Arguments = []> = (input: I, ...args: A) => O | PromiseLike<O>;
+import type { ImmutableObject, Prop, Value } from "./object.js";
 /** Set of named transforms for a data object (or `undefined` to skip the transform). */
 export type Transforms<I extends ImmutableObject, O extends ImmutableObject, A extends Arguments = []> = {
-    readonly [K in keyof I]?: Transform<I[K], O[K], A>;
+    readonly [K in keyof I]?: (input: I[K], ...args: A) => O[K];
 };
 /** Modify a set of items using a transform. */
 export declare function mapItems<I, O, A extends Arguments = []>(items: Iterable<I>, transform: (v: I, ...args: A) => O, ...args: A): Iterable<O>;
-export declare function mapItems<I, O, A extends Arguments = []>(items: Iterable<I>, transform: Transform<I, O, A>, ...args: A): Iterable<O>;
 /** Modify the items of an array using a transform. */
-export declare function mapArray<T extends ImmutableArray>(arr: T, transform: Transform<ArrayItem<T>, ArrayItem<T>>): T;
 export declare function mapArray<I, O, A extends Arguments = []>(arr: Iterable<I>, transform: (v: I, ...args: A) => O, ...args: A): ImmutableArray<O>;
-export declare function mapArray<I, O, A extends Arguments = []>(arr: Iterable<I>, transform: Transform<I, O, A>, ...args: A): ImmutableArray<O>;
-/** Modify the values of the props of an object using a transform. */
-export declare function mapObject<T extends ImmutableObject>(obj: T, transform: Transform<Value<T>, Value<T>>): T;
-export declare function mapObject<I extends ImmutableObject, O extends ImmutableObject, A extends Arguments = []>(obj: I, transform: (v: Value<I>, ...args: A) => Value<O>, ...args: A): O;
-export declare function mapObject<I extends ImmutableObject, O extends ImmutableObject, A extends Arguments = []>(obj: I, transform: Transform<Value<I>, Value<O>, A>, ...args: A): O;
-/** Modify the values of a dictionary using a transform. */
-export declare function mapDictionary<I, O, A extends Arguments = []>(dictionary: ImmutableDictionary<I>, transform: (v: I, ...args: A) => O, ...args: A): ImmutableDictionary<O>;
-export declare function mapDictionary<I, O, A extends Arguments = []>(dictionary: ImmutableDictionary<I>, transform: Transform<I, O, A>, ...args: A): ImmutableDictionary<O>;
-/** Modify the values of a set of entries using a transform. */
-export declare function mapEntries<K, I, O, A extends Arguments = []>(entries: Iterable<Entry<K, I>>, transform: Transform<I, O, A>, ...args: A): Iterable<Entry<K, O>>;
+/** Modify the _values_ of the props of an object using a transform. */
+export declare function mapProps<I extends ImmutableObject, O extends ImmutableObject, A extends Arguments = []>(obj: I, transform: (prop: Prop<I>, ...args: A) => Value<O>, ...args: A): O;
+/** Modify the _values_ of a dictionary using a transform. */
+export declare function mapDictionary<I, O, A extends Arguments = []>(dictionary: ImmutableDictionary<I>, transform: (item: DictionaryItem<I>, ...args: A) => O, ...args: A): ImmutableDictionary<O>;
+/** Modify the _values_ of a set of entries using a transform. */
+export declare function mapEntries<K, I, O, A extends Arguments = []>(entries: Iterable<Entry<K, I>>, transform: (entry: Entry<K, I>, ...args: A) => O, ...args: A): Iterable<Entry<K, O>>;
 /**
  * Transform an object using a set of named transforms.
  *
@@ -38,4 +28,3 @@ export declare function transformObject<I extends ImmutableObject, O extends Imm
 export declare function transformObject<I extends ImmutableObject, O extends ImmutableObject, A extends Arguments = []>(obj: I | Partial<I>, transforms: Transforms<I, O | Partial<O>, A>, ...args: A): Partial<O>;
 /** Transform items in a sequence as they are yielded using a (potentially async) transform. */
 export declare function mapSequence<I, O, A extends Arguments = []>(sequence: AsyncIterable<I>, transform: (input: I, ...args: A) => O | PromiseLike<O>, ...args: A): AsyncIterable<O>;
-export declare function mapSequence<I, O, A extends Arguments = []>(sequence: AsyncIterable<I>, transform: AsyncTransform<I, O, A>, ...args: A): AsyncIterable<O>;

package/util/transform.js

@@ -1,22 +1,26 @@
 import { getDictionaryItems } from "./dictionary.js";
 import { getProps } from "./object.js";
+/** Modify a set of items using a transform. */
 export function* mapItems(items, transform, ...args) {
     for (const item of items)
         yield transform(item, ...args);
 }
+/** Modify the items of an array using a transform. */
 export function mapArray(arr, transform, ...args) {
     return Array.from(mapItems(arr, transform, ...args));
 }
-export function mapObject(obj, transform, ...args) {
+/** Modify the _values_ of the props of an object using a transform. */
+export function mapProps(obj, transform, ...args) {
     return Object.fromEntries(mapEntries(getProps(obj), transform, ...args));
 }
+/** Modify the _values_ of a dictionary using a transform. */
 export function mapDictionary(dictionary, transform, ...args) {
     return Object.fromEntries(mapEntries(getDictionaryItems(dictionary), transform, ...args));
 }
-/** Modify the values of a set of entries using a transform. */
+/** Modify the _values_ of a set of entries using a transform. */
 export function* mapEntries(entries, transform, ...args) {
-    for (const [k, v] of entries)
-        yield [k, transform(v, ...args)];
+    for (const e of entries)
+        yield [e[0], transform(e, ...args)];
 }
 export function transformObject(input, transforms, ...args) {
     let changed = false;
@@ -37,6 +41,7 @@ export function transformObject(input, transforms, ...args) {
     }
     return changed ? output : input;
 }
+/** Transform items in a sequence as they are yielded using a (potentially async) transform. */
 export async function* mapSequence(sequence, transform, ...args) {
     for await (const item of sequence)
         yield transform(item, ...args);

package/util/validate.d.ts

@@ -64,6 +64,3 @@ export declare function validateDictionary<T>(unsafeDictionary: ImmutableDiction
  */
 export declare function validateData<T extends Data>(unsafeData: Data, validators: Validators<T>, partial: true): DeepPartial<T>;
 export declare function validateData<T extends Data>(unsafeData: Data, validators: Validators<T>, partial?: false): T;
-export declare const UNDEFINED: Validator<undefined>;
-export declare const NULL: Validator<null>;
-export declare const UNKNOWN: Validator<unknown>;

package/util/validate.js

@@ -4,10 +4,7 @@ import { isArray } from "./array.js";
 import { getDataKeys, getDataProps } from "./data.js";
 import { getDictionaryItems } from "./dictionary.js";
 import { getNamedMessage } from "./error.js";
-import { PASSTHROUGH } from "./function.js";
 import { isIterable } from "./iterate.js";
-import { getNull } from "./null.js";
-import { getUndefined } from "./undefined.js";
 /** Get value that validates against a given `Validator`, or throw `ValueError` */
 export function getValid(value, validator, ErrorConstructor = ValueError, caller = getValid) {
     try {
@@ -135,9 +132,3 @@ export function validateData(unsafeData, validators, partial = isDeeplyPartial)
         isDeeplyPartial = false;
     }
 }
-// Undefined validator always returns `undefined`
-export const UNDEFINED = { validate: getUndefined };
-// Null validator always returns `null`
-export const NULL = { validate: getNull };
-// Unknown validator always passes through its input value as `unknown`
-export const UNKNOWN = { validate: PASSTHROUGH };