shelving 1.186.1 → 1.187.1

package/api/store/EndpointStore.d.ts

@@ -35,7 +35,6 @@ export declare class EndpointStore<P, R> extends Store<R> implements Disposable
     refreshStale(maxAge: number): void;
     /** Abort any in-flight request now. */
     private abort;
-    /** Fetch the result from the API endpoint now. */
     private _fetch;
     [Symbol.dispose](): void;
 }

package/firestore/server/FirestoreServerProvider.d.ts

@@ -16,7 +16,6 @@ export declare class FirestoreServerProvider<I extends string = string, T extend
     private _getCollection;
     /** Create a corresponding `FirestoreQuery` reference from a collection and query. */
     private _getQuery;
-    /** Perform a bulk update on a set of documents using a `BulkWriter` */
     private _bulkWrite;
     getItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<OptionalItem<II, TT>>;
     getItemSequence<II extends I, TT extends T>(c: Collection<string, II, TT>, id: II): AsyncIterable<OptionalItem<II, TT>>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shelving",
-	"version": "1.186.1",
+	"version": "1.187.1",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"repository": {
 		"type": "git",
@@ -9,11 +9,12 @@
 	"main": "./index.js",
 	"module": "./index.js",
 	"devDependencies": {
-		"@biomejs/biome": "^2.4.11",
-		"@google-cloud/firestore": "^8.3.0",
+		"@biomejs/biome": "^2.4.12",
+		"@google-cloud/firestore": "^8.5.0",
 		"@types/bun": "^1.3.12",
 		"@types/react": "^19.2.14",
 		"@types/react-dom": "^19.2.3",
+		"@typescript/native-preview": "^7.0.0-dev.20260417.1",
 		"firebase": "^12.12.0",
 		"react": "^19.2.5",
 		"react-dom": "^19.2.5",
@@ -62,14 +63,14 @@
 	"scripts": {
 		"test": "bun run --parallel test:*",
 		"test:lint": "biome check .",
-		"test:type": "tsc --noEmit",
-		"test:unit": "bun test --concurrent",
+		"test:type": "tsgo --noEmit",
+		"test:unit": "bun test --concurrent --only-failures",
 		"fix": "bun run --sequential fix:*",
 		"fix:lint": "biome check --write .",
 		"build": "bun run build:setup && bun run build:copy && bun run build:emit && bun run build:test:syntax && bun run build:test:unit",
 		"build:setup": "rm -rf ./dist && mkdir -p ./dist",
 		"build:copy": "cp package.json dist/package.json && cp LICENSE.md dist/LICENSE.md && cp README.md dist/README.md && cp .npmignore dist/.npmignore",
-		"build:emit": "tsc",
+		"build:emit": "tsgo",
 		"build:test:syntax": "bun run ./dist/index.js",
 		"build:test:unit": "bun test ./dist/**/*.test.js --bail"
 	},

package/schema/AddressSchema.d.ts

@@ -1,4 +1,4 @@
-import type { AddressData } from "../util/geo.js";
+import { type AddressData } from "../util/geo.js";
 import { DataSchema, type DataSchemaOptions } from "./DataSchema.js";
 /** Allowed options for `AddressSchema` */
 export interface AddressSchemaOptions extends Omit<DataSchemaOptions<AddressData>, "props"> {
@@ -6,6 +6,7 @@ export interface AddressSchemaOptions extends Omit<DataSchemaOptions<AddressData
 /** Schema that validates a postal address. */
 export declare class AddressSchema extends DataSchema<AddressData> {
     constructor({ one, title, ...options }?: AddressSchemaOptions);
+    format(value: AddressData): string;
 }
 /** Valid postal address data. */
 export declare const ADDRESS: AddressSchema;

package/schema/AddressSchema.js

@@ -1,3 +1,4 @@
+import { formatAddress } from "../util/geo.js";
 import { COUNTRY } from "./CountrySchema.js";
 import { DataSchema } from "./DataSchema.js";
 import { NULLABLE } from "./NullableSchema.js";
@@ -15,6 +16,9 @@ export class AddressSchema extends DataSchema {
     constructor({ one = "address", title = "Address", ...options } = {}) {
         super({ one, title, props: ADDRESS_PROPS, ...options });
     }
+    format(value) {
+        return formatAddress(value);
+    }
 }
 /** Valid postal address data. */
 export const ADDRESS = new AddressSchema({});

package/schema/ArraySchema.d.ts

@@ -45,6 +45,7 @@ export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     readonly separator: string | RegExp;
     constructor({ items, one, many, title, placeholder, unique, min, max, separator, value, ...options }: ArraySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableArray<T>;
+    format(arr: ImmutableArray<T>): string;
 }
 /** Valid array with specifed items. */
 export declare const ARRAY: <T>(items: Schema<T>) => ArraySchema<T>;

package/schema/ArraySchema.js

@@ -1,4 +1,5 @@
 import { getUniqueArray, isArray } from "../util/array.js";
+import { formatArray } from "../util/format.js";
 import { validateArray } from "../util/validate.js";
 import { Schema } from "./Schema.js";
 /**
@@ -47,6 +48,9 @@ export class ArraySchema extends Schema {
             throw `Maximum ${this.max} ${this.many}`;
         return uniqueArray;
     }
+    format(arr) {
+        return formatArray(arr.map(v => this.items.format(v)), undefined, this.format);
+    }
 }
 /** Valid array with specifed items. */
 export const ARRAY = (items) => new ArraySchema({ items });

package/schema/BooleanSchema.d.ts

@@ -11,6 +11,7 @@ export declare class BooleanSchema extends Schema<boolean> {
     readonly required: boolean;
     constructor({ value, required, ...options }: BooleanSchemaOptions);
     validate(unsafeValue?: unknown): boolean;
+    format(value: boolean): string;
 }
 /** Valid boolean. */
 export declare const BOOLEAN: BooleanSchema;

package/schema/BooleanSchema.js

@@ -1,3 +1,4 @@
+import { formatBoolean } from "../util/format.js";
 import { Schema } from "./Schema.js";
 const NEGATIVE = ["", "false", "0", "no", "n", "off"];
 /** Define a valid boolean. */
@@ -12,6 +13,9 @@ export class BooleanSchema extends Schema {
             throw "Required";
         return value;
     }
+    format(value) {
+        return formatBoolean(value);
+    }
 }
 /** Valid boolean. */
 export const BOOLEAN = new BooleanSchema({});

package/schema/ChoiceSchema.d.ts

@@ -1,32 +1,36 @@
 import { type ImmutableArray } from "../util/array.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
-export type ChoiceOptions<K extends string> = ImmutableArray<K> | {
-    readonly [KK in K]: unknown;
+/**
+ * Set of options for a `ChoiceSchema` can be either:
+ * - Dictionary of string options in `{ key: title }` format.
+ */
+export type ChoiceOptions<K extends string> = {
+    readonly [KK in K]: string;
 };
-export type ChoiceOption<K extends string> = readonly [K, unknown];
-/** Get the options for a choice field as an array. */
-export declare function getChoiceEntries<K extends string>(options: ChoiceOptions<K>): ImmutableArray<ChoiceOption<K>>;
-/** Get the keys for a choice field as an array. */
-export declare function getChoiceKeys<K extends string>(options: ChoiceOptions<K>): ImmutableArray<K>;
-/** Get the options for a choice field as an array. */
-export declare function isOption<K extends string>(options: ChoiceOptions<K>, option: string): option is K;
+/**
+ * Things that can be converted to a choice options dictionary.
+ * - Array of string options in `[key]` format (`key` will be used as the `title` too).
+ */
+export type PossibleChoiceOptions<K extends string> = ImmutableArray<K> | ChoiceOptions<K>;
+/** A single tuple for a choice option in `[key, title]` format. */
+export type ChoiceOption<K extends string> = readonly [title: K, title: string];
+/** Get a `ChoiceOptions` object for a set of `PossibleChoiceOptions`. */
+export declare function getChoiceOptions<K extends string>(options: PossibleChoiceOptions<K>): ChoiceOptions<K>;
 /** Allowed options for `ChoiceSchema` */
 export interface ChoiceSchemaOptions<K extends string> extends Omit<SchemaOptions, "value"> {
     /** Specify correct options using a dictionary of entries. */
-    readonly options: ChoiceOptions<K>;
+    readonly options: PossibleChoiceOptions<K>;
     /** Default option for the value. */
     readonly value?: K;
 }
 /** Choose from an allowed set of values. */
-export declare class ChoiceSchema<K extends string> extends Schema<K> implements Iterable<ChoiceOption<K>> {
+export declare class ChoiceSchema<K extends string> extends Schema<K> {
     readonly value: K | undefined;
     readonly options: ChoiceOptions<K>;
     constructor({ one, title, placeholder, options, value, ...rest }: ChoiceSchemaOptions<K>);
     validate(unsafeValue?: unknown): K;
-    [Symbol.iterator](): Iterator<ChoiceOption<K>>;
-    keys(): ImmutableArray<K>;
-    entries(): ImmutableArray<ChoiceOption<K>>;
+    format(value: K): string;
 }
 /** Choose from an allowed set of values. */
-export declare function CHOICE<K extends string>(options: ChoiceOptions<K>): ChoiceSchema<K>;
+export declare function CHOICE<K extends string>(options: PossibleChoiceOptions<K> | ImmutableArray<K>): ChoiceSchema<K>;

package/schema/ChoiceSchema.js

@@ -1,44 +1,27 @@
 import { isArray } from "../util/array.js";
-import { getKeys, getProps, isProp } from "../util/object.js";
+import { isProp } from "../util/object.js";
 import { Schema } from "./Schema.js";
-/** Get the options for a choice field as an array. */
-export function getChoiceEntries(options) {
-    return isArray(options) ? options.map(_makeKeyEntry) : getProps(options);
+/** Get a `ChoiceOptions` object for a set of `PossibleChoiceOptions`. */
+export function getChoiceOptions(options) {
+    return isArray(options) ? Object.fromEntries(options.map(_getChoiceOption)) : options;
 }
-function _makeKeyEntry(k) {
+function _getChoiceOption(k) {
     return [k, k];
 }
-/** Get the keys for a choice field as an array. */
-export function getChoiceKeys(options) {
-    return isArray(options) ? options : getKeys(options);
-}
-/** Get the options for a choice field as an array. */
-export function isOption(options, option) {
-    return isArray(options) ? options.includes(option) : isProp(options, option);
-}
 /** Choose from an allowed set of values. */
 export class ChoiceSchema extends Schema {
     options;
     constructor({ one = "choice", title = "Choice", placeholder = `No ${one}`, options, value, ...rest }) {
         super({ one, title, value, placeholder, ...rest });
-        this.options = options;
+        this.options = getChoiceOptions(options);
     }
     validate(unsafeValue = this.value) {
-        if (typeof unsafeValue === "string" && isOption(this.options, unsafeValue))
+        if (typeof unsafeValue === "string" && isProp(this.options, unsafeValue))
             return unsafeValue;
         throw unsafeValue ? `Unknown ${this.one}` : "Required";
     }
-    // Implement iterable.
-    *[Symbol.iterator]() {
-        yield* getChoiceEntries(this.options);
-    }
-    // Get the current list of keys for this choice.
-    keys() {
-        return getChoiceKeys(this.options);
-    }
-    // Get the current list of entries for this choice.
-    entries() {
-        return getChoiceEntries(this.options);
+    format(value) {
+        return this.options[value];
     }
 }
 /** Choose from an allowed set of values. */

package/schema/ColorSchema.d.ts

@@ -1,4 +1,7 @@
 import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
+/** Options for a `ColorSchema` */
+export interface ColorSchemaOptions extends Omit<StringSchemaOptions, "type" | "min" | "max" | "match" | "multiline"> {
+}
 /**
  * Define a valid color hex string, e.g `#00CCFF`
  *
@@ -9,7 +12,7 @@ import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
  * Colors are limited to 512 characters (this can be changed with `max`), but generally these won't be data: URIs so this is a reasonable limit.
  */
 export declare class ColorSchema extends StringSchema {
-    constructor({ one, title, value, ...options }: Omit<StringSchemaOptions, "type" | "min" | "max" | "match" | "multiline">);
+    constructor({ one, title, value, ...options }: ColorSchemaOptions);
     sanitize(insaneString: string): string;
 }
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */

package/schema/CountrySchema.d.ts

@@ -14,4 +14,4 @@ export declare class CountrySchema extends ChoiceSchema<Country> {
 /** Valid country code, e.g. `GB` (required because falsy values are invalid). */
 export declare const COUNTRY: CountrySchema;
 /** Valid country code, e.g. `GB`, or `null` */
-export declare const NULLABLE_COUNTRY: import("./NullableSchema.js").NullableSchema<"ID" | "AF" | "AX" | "AL" | "DZ" | "AS" | "AD" | "AO" | "AI" | "AQ" | "AG" | "AR" | "AM" | "AW" | "AU" | "AT" | "AZ" | "BS" | "BH" | "BD" | "BB" | "BY" | "BE" | "BZ" | "BJ" | "BM" | "BT" | "BO" | "BA" | "BW" | "BV" | "BR" | "IO" | "BN" | "BG" | "BF" | "BI" | "KH" | "CM" | "CA" | "CV" | "KY" | "CF" | "TD" | "CL" | "CN" | "CX" | "CC" | "CO" | "KM" | "CG" | "CD" | "CK" | "CR" | "CI" | "HR" | "CU" | "CY" | "CZ" | "DK" | "DJ" | "DM" | "DO" | "EC" | "EG" | "SV" | "GQ" | "ER" | "EE" | "ET" | "FK" | "FO" | "FJ" | "FI" | "FR" | "GF" | "PF" | "TF" | "GA" | "GM" | "GE" | "DE" | "GH" | "GI" | "GR" | "GL" | "GD" | "GP" | "GU" | "GT" | "GG" | "GN" | "GW" | "GY" | "HT" | "HM" | "VA" | "HN" | "HK" | "HU" | "IS" | "IN" | "IR" | "IQ" | "IE" | "IM" | "IL" | "IT" | "JM" | "JP" | "JE" | "JO" | "KZ" | "KE" | "KI" | "KR" | "KP" | "KW" | "KG" | "LA" | "LV" | "LB" | "LS" | "LR" | "LY" | "LI" | "LT" | "LU" | "MO" | "MK" | "MG" | "MW" | "MY" | "MV" | "ML" | "MT" | "MH" | "MQ" | "MR" | "MU" | "YT" | "MX" | "FM" | "MD" | "MC" | "MN" | "ME" | "MS" | "MA" | "MZ" | "MM" | "NA" | "NR" | "NP" | "NL" | "AN" | "NC" | "NZ" | "NI" | "NE" | "NG" | "NU" | "NF" | "MP" | "NO" | "OM" | "PK" | "PW" | "PS" | "PA" | "PG" | "PY" | "PE" | "PH" | "PN" | "PL" | "PT" | "PR" | "QA" | "RE" | "RO" | "RU" | "RW" | "BL" | "SH" | "KN" | "LC" | "MF" | "PM" | "VC" | "WS" | "SM" | "ST" | "SA" | "SN" | "RS" | "SC" | "SL" | "SG" | "SK" | "SI" | "SB" | "SO" | "ZA" | "GS" | "ES" | "LK" | "SD" | "SR" | "SJ" | "SZ" | "SE" | "CH" | "SY" | "TW" | "TJ" | "TZ" | "TH" | "TL" | "TG" | "TK" | "TO" | "TT" | "TN" | "TR" | "TM" | "TC" | "TV" | "UG" | "UA" | "AE" | "GB" | "US" | "UM" | "UY" | "UZ" | "VU" | "VE" | "VN" | "VG" | "VI" | "WF" | "EH" | "YE" | "ZM" | "ZW">;
+export declare const NULLABLE_COUNTRY: import("./NullableSchema.js").NullableSchema<"AD" | "AE" | "AF" | "AG" | "AI" | "AL" | "AM" | "AN" | "AO" | "AQ" | "AR" | "AS" | "AT" | "AU" | "AW" | "AX" | "AZ" | "BA" | "BB" | "BD" | "BE" | "BF" | "BG" | "BH" | "BI" | "BJ" | "BL" | "BM" | "BN" | "BO" | "BR" | "BS" | "BT" | "BV" | "BW" | "BY" | "BZ" | "CA" | "CC" | "CD" | "CF" | "CG" | "CH" | "CI" | "CK" | "CL" | "CM" | "CN" | "CO" | "CR" | "CU" | "CV" | "CX" | "CY" | "CZ" | "DE" | "DJ" | "DK" | "DM" | "DO" | "DZ" | "EC" | "EE" | "EG" | "EH" | "ER" | "ES" | "ET" | "FI" | "FJ" | "FK" | "FM" | "FO" | "FR" | "GA" | "GB" | "GD" | "GE" | "GF" | "GG" | "GH" | "GI" | "GL" | "GM" | "GN" | "GP" | "GQ" | "GR" | "GS" | "GT" | "GU" | "GW" | "GY" | "HK" | "HM" | "HN" | "HR" | "HT" | "HU" | "ID" | "IE" | "IL" | "IM" | "IN" | "IO" | "IQ" | "IR" | "IS" | "IT" | "JE" | "JM" | "JO" | "JP" | "KE" | "KG" | "KH" | "KI" | "KM" | "KN" | "KP" | "KR" | "KW" | "KY" | "KZ" | "LA" | "LB" | "LC" | "LI" | "LK" | "LR" | "LS" | "LT" | "LU" | "LV" | "LY" | "MA" | "MC" | "MD" | "ME" | "MF" | "MG" | "MH" | "MK" | "ML" | "MM" | "MN" | "MO" | "MP" | "MQ" | "MR" | "MS" | "MT" | "MU" | "MV" | "MW" | "MX" | "MY" | "MZ" | "NA" | "NC" | "NE" | "NF" | "NG" | "NI" | "NL" | "NO" | "NP" | "NR" | "NU" | "NZ" | "OM" | "PA" | "PE" | "PF" | "PG" | "PH" | "PK" | "PL" | "PM" | "PN" | "PR" | "PS" | "PT" | "PW" | "PY" | "QA" | "RE" | "RO" | "RS" | "RU" | "RW" | "SA" | "SB" | "SC" | "SD" | "SE" | "SG" | "SH" | "SI" | "SJ" | "SK" | "SL" | "SM" | "SN" | "SO" | "SR" | "ST" | "SV" | "SY" | "SZ" | "TC" | "TD" | "TF" | "TG" | "TH" | "TJ" | "TK" | "TL" | "TM" | "TN" | "TO" | "TR" | "TT" | "TV" | "TW" | "TZ" | "UA" | "UG" | "UM" | "US" | "UY" | "UZ" | "VA" | "VC" | "VE" | "VG" | "VI" | "VN" | "VU" | "WF" | "WS" | "YE" | "YT" | "ZA" | "ZM" | "ZW">;

package/schema/CurrencyAmountSchema.d.ts

@@ -17,9 +17,11 @@ export interface CurrencyAmountSchemaOptions extends NumberSchemaOptions {
  * PRICE.format(12.3); // "£12.30"
  */
 export declare class CurrencyAmountSchema extends NumberSchema {
+    readonly step: number;
     readonly currency: CurrencyCode;
     readonly symbol: string;
-    constructor({ currency, one, title, symbol, step, format, ...options }: CurrencyAmountSchemaOptions);
+    constructor({ currency, one, title, symbol, step, ...options }: CurrencyAmountSchemaOptions);
+    format(value: number): string;
 }
 /** Valid non-negative monetary amount in the a currency. */
 export declare const CURRENCY_AMOUNT: (currency: CurrencyCode) => CurrencyAmountSchema;

package/schema/CurrencyAmountSchema.js

@@ -16,18 +16,21 @@ import { NumberSchema } from "./NumberSchema.js";
 export class CurrencyAmountSchema extends NumberSchema {
     currency;
     symbol;
-    constructor({ currency, one = "amount", title = "Amount", symbol, step, format = (value, options) => formatCurrency(value, currency, options), ...options }) {
+    constructor({ currency, one = "amount", title = "Amount", symbol, step, ...options }) {
         const validCurrency = requireCurrencyCode(currency, CurrencyAmountSchema);
         super({
             one,
             title,
             step: step ?? getCurrencyStep(validCurrency, CurrencyAmountSchema),
-            format,
             ...options,
         });
         this.currency = validCurrency;
         this.symbol = symbol ?? getCurrencySymbol(validCurrency, CurrencyAmountSchema);
     }
+    format(value) {
+        const options = this.step >= 1 ? { maximumFractionDigits: 0 } : {}; // Skip showing decimal places if step is 1 or more.
+        return formatCurrency(value, this.currency, options, this.format);
+    }
 }
 /** Valid non-negative monetary amount in the a currency. */
 export const CURRENCY_AMOUNT = (currency) => new CurrencyAmountSchema({ currency });

package/schema/DataSchema.d.ts

@@ -19,6 +19,7 @@ export declare class DataSchema<T extends Data> extends Schema<unknown> {
     pick<K extends Key<T>>(...keys: K[]): DataSchema<Pick<T, K>>;
     /** Make a new `DataSchema` that omits one or more of the current props. */
     omit<K extends Key<T>>(...keys: K[]): DataSchema<Omit<T, K>>;
+    format(value: T): string;
 }
 /** Create a `DataSchema` for a set of properties. */
 export declare const DATA: <T extends Data>(props: Schemas<T>) => DataSchema<T>;

package/schema/DataSchema.js

@@ -1,4 +1,5 @@
 import { isData } from "../util/data.js";
+import { formatObject } from "../util/format.js";
 import { omitProps, pickProps } from "../util/object.js";
 import { mapProps } from "../util/transform.js";
 import { validateData } from "../util/validate.js";
@@ -27,6 +28,9 @@ export class DataSchema extends Schema {
     omit(...keys) {
         return new DataSchema({ ...this, props: omitProps(this.props, ...keys) });
     }
+    format(value) {
+        return formatObject(value);
+    }
 }
 function _getSchemaValue([, { value }]) {
     return value;

package/schema/DateSchema.d.ts

@@ -1,5 +1,4 @@
 import type { PossibleDate } from "../util/date.js";
-import { formatDate } from "../util/format.js";
 import type { Nullish } from "../util/null.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
@@ -11,8 +10,6 @@ export interface DateSchemaOptions extends SchemaOptions {
     readonly min?: Nullish<PossibleDate>;
     readonly max?: Nullish<PossibleDate>;
     readonly input?: DateInputType | undefined;
-    /** Format the date for display in downstream UIs. */
-    readonly format?: typeof formatDate | undefined;
     /**
      * Rounding step (in milliseconds, because that's the base unit for time).
      * - E.g. `1000 * 60` will round to the nearest minute.
@@ -26,10 +23,10 @@ export declare class DateSchema extends Schema<string> {
     readonly max: Date | undefined;
     readonly input: DateInputType;
     readonly step: number | undefined;
-    format: typeof formatDate;
-    constructor({ one, min, max, value, input, step, format, ...options }: DateSchemaOptions);
+    constructor({ one, min, max, value, input, step, ...options }: DateSchemaOptions);
     validate(value?: unknown): string;
     stringify(value: Date): string;
+    format(value: string): string;
 }
 /** Valid date, e.g. `2005-09-12` (required because falsy values are invalid). */
 export declare const DATE: DateSchema;

package/schema/DateSchema.js

@@ -8,14 +8,12 @@ export class DateSchema extends Schema {
     max;
     input;
     step;
-    format;
-    constructor({ one = "date", min, max, value, input = "date", step, format = formatDate, ...options }) {
+    constructor({ one = "date", min, max, value, input = "date", step, ...options }) {
         super({ one, title: "Date", value, ...options });
         this.min = getDate(min);
         this.max = getDate(max);
         this.input = input;
         this.step = step;
-        this.format = format;
     }
     validate(value = this.value) {
         const date = getDate(value);
@@ -23,14 +21,17 @@ export class DateSchema extends Schema {
             throw value ? `Invalid ${this.one} format` : "Required";
         const stepped = typeof this.step === "number" ? new Date(roundStep(date.getTime(), this.step)) : date;
         if (this.min && stepped < this.min)
-            throw `Minimum ${this.format(this.min)}`;
+            throw `Minimum ${this.format(this.stringify(this.min))}`;
         if (this.max && stepped > this.max)
-            throw `Maximum ${this.format(this.max)}`;
+            throw `Maximum ${this.format(this.stringify(this.max))}`;
         return this.stringify(stepped);
     }
     stringify(value) {
         return requireDateString(value);
     }
+    format(value) {
+        return formatDate(value, undefined, this.format);
+    }
 }
 /** Valid date, e.g. `2005-09-12` (required because falsy values are invalid). */
 export const DATE = new DateSchema({});

package/schema/DateTimeSchema.d.ts

@@ -6,8 +6,9 @@ import { DateSchema, type DateSchemaOptions } from "./DateSchema.js";
  * - If you wish to define an _abstract_ time without a timezone, e.g. a daily alarm, use `TimeSchema` instead.
  */
 export declare class DateTimeSchema extends DateSchema {
-    constructor({ one, title, input, format, ...options }: DateSchemaOptions);
+    constructor({ one, title, input, ...options }: DateSchemaOptions);
     stringify(value: Date): string;
+    format(value: string): string;
 }
 /** Valid datetime, e.g. `2005-09-12T08:00:00Z` (required because falsy values are invalid). */
 export declare const DATETIME: DateTimeSchema;

package/schema/DateTimeSchema.js

@@ -8,12 +8,15 @@ import { NULLABLE } from "./NullableSchema.js";
  * - If you wish to define an _abstract_ time without a timezone, e.g. a daily alarm, use `TimeSchema` instead.
  */
 export class DateTimeSchema extends DateSchema {
-    constructor({ one = "time", title = "Time", input = "datetime-local", format = formatDateTime, ...options }) {
-        super({ one, title, input, format, ...options });
+    constructor({ one = "time", title = "Time", input = "datetime-local", ...options }) {
+        super({ one, title, input, ...options });
     }
     stringify(value) {
         return value.toISOString();
     }
+    format(value) {
+        return formatDateTime(value, undefined, this.format);
+    }
 }
 /** Valid datetime, e.g. `2005-09-12T08:00:00Z` (required because falsy values are invalid). */
 export const DATETIME = new DateTimeSchema({});

package/schema/DictionarySchema.d.ts

@@ -16,6 +16,7 @@ export declare class DictionarySchema<T> extends Schema<ImmutableDictionary<T>>
     readonly max: number;
     constructor({ items, one, many, placeholder, min, max, title, value, ...options }: DictionarySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableDictionary<T>;
+    format(dict: ImmutableDictionary<T>): string;
 }
 /** Valid dictionary object with specifed items. */
 export declare const DICTIONARY: <T>(items: Schema<T>) => DictionarySchema<T>;

package/schema/DictionarySchema.js

@@ -1,4 +1,5 @@
 import { isDictionary } from "../util/dictionary.js";
+import { formatArray } from "../util/format.js";
 import { validateDictionary } from "../util/validate.js";
 import { Schema } from "./Schema.js";
 /** Validate a dictionary object (whose props are all the same with string keys). */
@@ -23,6 +24,9 @@ export class DictionarySchema extends Schema {
             throw `Maximum ${this.max} ${this.many}`;
         return validDictionary;
     }
+    format(dict) {
+        return formatArray(Object.values(dict).map(v => this.items.format(v)), undefined, this.format);
+    }
 }
 /** Valid dictionary object with specifed items. */
 export const DICTIONARY = (items) => new DictionarySchema({ items });

package/schema/EntitySchema.d.ts

@@ -14,4 +14,4 @@ export declare class EntitySchema<T extends string> extends StringSchema {
 /** Valid file, e.g. `challenge:a1b2c3` */
 export declare const ENTITY: EntitySchema<string>;
 /** Valid optional file, e.g. `file.txt`, or `null` */
-export declare const NULLABLE_ENTITY: import("./NullableSchema.js").NullableSchema<`${string}:${string}`>;
+export declare const NULLABLE_ENTITY: import("./NullableSchema.js").NullableSchema<string>;

package/schema/KeySchema.d.ts

@@ -8,7 +8,7 @@ import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
  * - 32 characters is enough for UUIDs, as the 4 `-` hyphens are removed.
  */
 export declare class KeySchema extends StringSchema {
-    constructor({ one, min, max, ...options }: StringSchemaOptions);
+    constructor({ one, title, min, max, ...options }: StringSchemaOptions);
     sanitize(str: string): string;
 }
 /** Valid database key. */

package/schema/KeySchema.js

@@ -10,8 +10,8 @@ const R_NOT_CHAR = /[^a-zA-Z0-9]/g;
  * - 32 characters is enough for UUIDs, as the 4 `-` hyphens are removed.
  */
 export class KeySchema extends StringSchema {
-    constructor({ one = "key", min = 1, max = 32, ...options }) {
-        super({ one, min, max, ...options });
+    constructor({ one = "key", title = "Key", min = 1, max = 32, ...options }) {
+        super({ one, title, min, max, ...options });
     }
     sanitize(str) {
         return str.replace(R_NOT_CHAR, "");

package/schema/NullableSchema.d.ts

@@ -10,6 +10,7 @@ export declare class NullableSchema<T> extends ThroughSchema<T | null> {
     readonly value: T | null;
     constructor({ value, ...options }: NullableSchemaOptions<T>);
     validate(unsafeValue?: unknown): T | null;
+    format(value: T | null): string;
 }
 /** Create a new nullable schema from a source schema. */
 export declare const NULLABLE: <T>(source: Schema<T>) => NullableSchema<T>;

package/schema/NullableSchema.js

@@ -9,6 +9,9 @@ export class NullableSchema extends ThroughSchema {
             return null;
         return super.validate(unsafeValue);
     }
+    format(value) {
+        return value === null ? `No ${this.source.one}` : super.format(value);
+    }
 }
 /** Create a new nullable schema from a source schema. */
 export const NULLABLE = (source) => new NullableSchema({ source });

package/schema/NumberSchema.d.ts

@@ -16,9 +16,9 @@ export declare class NumberSchema extends Schema<number> {
     readonly min: number;
     readonly max: number;
     readonly step: number | undefined;
-    format: typeof formatNumber;
     constructor({ one, title, min, max, step, format, value, ...options }: NumberSchemaOptions);
     validate(value?: unknown): number;
+    format(value: number): string;
 }
 /** Valid number, e.g. `2048.12345` or `0` zero and a default value of zero. */
 export declare const NUMBER: NumberSchema;

package/schema/NumberSchema.js

@@ -7,13 +7,11 @@ export class NumberSchema extends Schema {
     min;
     max;
     step;
-    format;
     constructor({ one = "number", title = "Number", min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY, step, format = formatNumber, value, ...options }) {
         super({ one, title, value, ...options });
         this.min = min;
         this.max = max;
         this.step = step;
-        this.format = format;
     }
     validate(value = this.value) {
         const number = getNumber(value);
@@ -26,6 +24,9 @@ export class NumberSchema extends Schema {
             throw `Maximum ${this.format(this.max)}`;
         return stepped;
     }
+    format(value) {
+        return formatNumber(value);
+    }
 }
 /** Valid number, e.g. `2048.12345` or `0` zero and a default value of zero. */
 export const NUMBER = new NumberSchema({ title: "Number" });

package/schema/OptionalSchema.d.ts

@@ -14,6 +14,7 @@ export declare class OptionalSchema<T> extends ThroughSchema<T | undefined> {
     readonly value: undefined;
     constructor(options: OptionalSchemaOptions<T>);
     validate(unsafeValue: unknown): T | undefined;
+    format(value: T | undefined): string;
 }
 /** Make a property of a set of data optional, i.e. it can be the value or `undefined` */
 export declare const OPTIONAL: <T>(source: Schema<T>) => OptionalSchema<T>;

package/schema/OptionalSchema.js

@@ -13,6 +13,9 @@ export class OptionalSchema extends ThroughSchema {
             return undefined;
         return super.validate(unsafeValue);
     }
+    format(value) {
+        return value === undefined ? `No ${this.source.one}` : super.format(value);
+    }
 }
 /** Make a property of a set of data optional, i.e. it can be the value or `undefined` */
 export const OPTIONAL = (source) => new OptionalSchema({ source });

package/schema/PasswordSchema.d.ts

@@ -0,0 +1,9 @@
+import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
+export interface PasswordSchemaOptions extends Omit<StringSchemaOptions, "input"> {
+}
+export declare class PasswordSchema extends StringSchema {
+    constructor({ one, title, min, ...options }?: PasswordSchemaOptions);
+    format(): string;
+}
+/** Password string. */
+export declare const PASSWORD: StringSchema;

package/schema/PasswordSchema.js

@@ -0,0 +1,11 @@
+import { StringSchema } from "./StringSchema.js";
+export class PasswordSchema extends StringSchema {
+    constructor({ one = "password", title = "Password", min = 6, ...options } = {}) {
+        super({ one, title, min, ...options, input: "password" });
+    }
+    format() {
+        return ""; // Never format a password for display.
+    }
+}
+/** Password string. */
+export const PASSWORD = new StringSchema({});