shelving 1.159.2 → 1.159.4

package/package.json

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

package/schema/ArraySchema.d.ts

@@ -3,8 +3,6 @@ import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `ArraySchema` */
 export interface ArraySchemaOptions<T> extends SchemaOptions {
-    readonly one?: string;
-    readonly many?: string;
     readonly value?: ImmutableArray;
     readonly items: Schema<T>;
     readonly min?: number;
@@ -40,8 +38,6 @@ export interface ArraySchemaOptions<T> extends SchemaOptions {
  */
 export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     readonly value: ImmutableArray<T>;
-    readonly one: string;
-    readonly many: string;
     readonly items: Schema<T>;
     readonly unique: boolean;
     readonly min: number;

package/schema/ArraySchema.js

@@ -30,16 +30,12 @@ import { Schema } from "./Schema.js";
  *  schema.validate(["a", null], schema); // Throws Invalids({ "1": Invalid('Must be a string') });
  */
 export class ArraySchema extends Schema {
-    one;
-    many;
     items;
     unique;
     min;
     max;
-    constructor({ items, one = "item", many = `${one}s`, title = "Items", placeholder = `No ${many}`, unique = false, min = 0, max = Number.POSITIVE_INFINITY, value = [], ...options }) {
-        super({ title, placeholder, value, ...options });
-        this.one = one;
-        this.many = many;
+    constructor({ items, one = items.one, many = items.many, title = "Items", placeholder = `No ${many}`, unique = false, min = 0, max = Number.POSITIVE_INFINITY, value = [], ...options }) {
+        super({ one, many, title, placeholder, value, ...options });
         this.items = items;
         this.unique = unique;
         this.min = min;

package/schema/ChoiceSchema.d.ts

@@ -22,7 +22,7 @@ export interface ChoiceSchemaOptions<K extends string> extends Omit<SchemaOption
 export declare class ChoiceSchema<K extends string> extends Schema<K> implements Iterable<ChoiceOption<K>> {
     readonly value: K;
     readonly options: ChoiceOptions<K>;
-    constructor({ options, placeholder, value, ...rest }: ChoiceSchemaOptions<K>);
+    constructor({ one, title, placeholder, options, value, ...rest }: ChoiceSchemaOptions<K>);
     validate(unsafeValue?: unknown): K;
     [Symbol.iterator](): Iterator<ChoiceOption<K>>;
     keys(): ImmutableArray<K>;

package/schema/ChoiceSchema.js

@@ -20,8 +20,8 @@ export function isOption(options, option) {
 /** Choose from an allowed set of values. */
 export class ChoiceSchema extends Schema {
     options;
-    constructor({ options, placeholder = "Empty", value = requireFirst(isArray(options) ? options : getKeys(options)), ...rest }) {
-        super({ value, placeholder, ...rest });
+    constructor({ one = "choice", title = "Choice", placeholder = `No ${one}`, options, value = requireFirst(isArray(options) ? options : getKeys(options)), ...rest }) {
+        super({ one, title, value, placeholder, ...rest });
         this.options = options;
     }
     validate(unsafeValue = this.value) {

package/schema/ColorSchema.d.ts

@@ -9,7 +9,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({ title, value, ...options }: Omit<StringSchemaOptions, "type" | "min" | "max" | "multiline" | "match">);
+    constructor({ one, title, value, ...options }: Omit<StringSchemaOptions, "type" | "min" | "max" | "match" | "multiline">);
     sanitize(insaneString: string): string;
 }
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */

package/schema/ColorSchema.js

@@ -12,8 +12,9 @@ const NOT_HEX_REGEXP = /[^0-9A-F]/g;
  * 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 class ColorSchema extends StringSchema {
-    constructor({ title = "Color", value = "#000000", ...options }) {
+    constructor({ one = "color", title = "Color", value = "#000000", ...options }) {
         super({
+            one,
             title,
             value,
             ...options,

package/schema/DataSchema.d.ts

@@ -13,7 +13,7 @@ export interface DataSchemaOptions<T extends Data> extends SchemaOptions {
 export declare class DataSchema<T extends Data> extends Schema<unknown> {
     readonly value: T;
     readonly props: Schemas<T>;
-    constructor({ props, title, value: partialValue, ...options }: DataSchemaOptions<T>);
+    constructor({ one, title, props, value: partialValue, ...options }: DataSchemaOptions<T>);
     validate(unsafeValue?: unknown): T;
 }
 /** Set of named data schemas. */

package/schema/DataSchema.js

@@ -8,10 +8,10 @@ import { Schema } from "./Schema.js";
 /** Validate a data object. */
 export class DataSchema extends Schema {
     props;
-    constructor({ props, title = "Data", value: partialValue, ...options }) {
+    constructor({ one = "item", title = "Item", props, value: partialValue, ...options }) {
         // Build default value from props and partial value.
         const value = { ...mapProps(props, _getSchemaValue), ...partialValue };
-        super({ title, value, ...options });
+        super({ one, title, value, ...options });
         this.props = props;
     }
     validate(unsafeValue = this.value) {

package/schema/DateSchema.d.ts

@@ -23,7 +23,7 @@ export declare class DateSchema extends Schema<string> {
     readonly max: Date | undefined;
     readonly input: DateInputType;
     readonly step: number | undefined;
-    constructor({ min, max, value, input, step, ...options }: DateSchemaOptions);
+    constructor({ one, min, max, value, input, step, ...options }: DateSchemaOptions);
     validate(value?: unknown): string;
     stringify(value: Date): string;
     format(value: Date): string;

package/schema/DateSchema.js

@@ -9,8 +9,8 @@ export class DateSchema extends Schema {
     max;
     input;
     step;
-    constructor({ min, max, value = "now", input = "date", step, ...options }) {
-        super({ title: "Date", value, ...options });
+    constructor({ one = "date", min, max, value = "now", input = "date", step, ...options }) {
+        super({ one, title: "Date", value, ...options });
         this.min = getDate(min);
         this.max = getDate(max);
         this.input = input;

package/schema/DateTimeSchema.d.ts

@@ -6,7 +6,7 @@ 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({ title, input, ...options }: DateSchemaOptions);
+    constructor({ one, title, input, ...options }: DateSchemaOptions);
     format(value: Date): string;
     stringify(value: Date): string;
 }

package/schema/DateTimeSchema.js

@@ -8,8 +8,8 @@ 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({ title = "Time", input = "datetime-local", ...options }) {
-        super({ title, input, ...options });
+    constructor({ one = "time", title = "Time", input = "datetime-local", ...options }) {
+        super({ one, title, input, ...options });
     }
     format(value) {
         return formatDateTime(value);

package/schema/DictionarySchema.d.ts

@@ -3,8 +3,6 @@ import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `DictionarySchema` */
 export interface DictionarySchemaOptions<T> extends SchemaOptions {
-    readonly one?: string;
-    readonly many?: string;
     readonly items: Schema<T>;
     readonly value?: ImmutableDictionary | undefined;
     readonly min?: number | undefined;
@@ -13,8 +11,6 @@ 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<T>;
-    readonly one: string;
-    readonly many: string;
     readonly items: Schema<T>;
     readonly min: number;
     readonly max: number;

package/schema/DictionarySchema.js

@@ -4,15 +4,11 @@ import { validateDictionary } from "../util/validate.js";
 import { Schema } from "./Schema.js";
 /** Validate a dictionary object (whose props are all the same with string keys). */
 export class DictionarySchema extends Schema {
-    one;
-    many;
     items;
     min;
     max;
-    constructor({ items, one = "item", many = `${one}s`, placeholder = `No ${many}`, min = 0, max = Number.POSITIVE_INFINITY, title = "Items", value = {}, ...options }) {
-        super({ title, placeholder, value, ...options });
-        this.one = one;
-        this.many = many;
+    constructor({ items, one = items.one, many = items.many, placeholder = `No ${many}`, min = 0, max = Number.POSITIVE_INFINITY, title = "Items", value = {}, ...options }) {
+        super({ one, many, title, placeholder, value, ...options });
         this.items = items;
         this.min = min;
         this.max = max;

package/schema/EmailSchema.d.ts

@@ -18,7 +18,7 @@ import { StringSchema } from "./StringSchema.js";
  *     - TLD is a segment of 2-63 characters, possibly in `xn--` international format.
  */
 export declare class EmailSchema extends StringSchema {
-    constructor({ title, ...options }: Omit<StringSchemaOptions, "type" | "min" | "max" | "match" | "multiline">);
+    constructor({ one, title, ...options }: Omit<StringSchemaOptions, "type" | "min" | "max" | "match" | "multiline">);
     sanitize(str: string): string;
 }
 /** Valid email, e.g. `test@test.com` */

package/schema/EmailSchema.js

@@ -19,8 +19,9 @@ const R_MATCH = /^[a-z0-9](?:[a-zA-Z0-9._+-]{0,62}[a-zA-Z0-9])?@(?:[a-z0-9](?:[a
  *     - TLD is a segment of 2-63 characters, possibly in `xn--` international format.
  */
 export class EmailSchema extends StringSchema {
-    constructor({ title = "Email", ...options }) {
+    constructor({ one = "email address", title = "Email", ...options }) {
         super({
+            one,
             title,
             ...options,
             input: "email",

package/schema/EntitySchema.d.ts

@@ -8,7 +8,7 @@ export interface EntitySchemaOptions<T extends string> extends StringSchemaOptio
 /** Validate a file name matching one or more extensions. */
 export declare class EntitySchema<T extends string> extends StringSchema {
     readonly types: ImmutableArray<T> | undefined;
-    constructor({ types, title, ...options }: EntitySchemaOptions<T>);
+    constructor({ one, title, types, ...options }: EntitySchemaOptions<T>);
     validate(unsafeValue?: unknown): Entity<T>;
 }
 /** Valid file, e.g. `challenge:a1b2c3` */

package/schema/EntitySchema.js

@@ -6,8 +6,8 @@ import { StringSchema } from "./StringSchema.js";
 /** Validate a file name matching one or more extensions. */
 export class EntitySchema extends StringSchema {
     types;
-    constructor({ types, title = "Entity", ...options }) {
-        super({ title, ...options });
+    constructor({ one = "entity", title = "Entity", types, ...options }) {
+        super({ one, title, ...options });
         this.types = types;
     }
     validate(unsafeValue = this.value) {

package/schema/FileSchema.d.ts

@@ -7,7 +7,7 @@ export interface FileSchemaOptions extends StringSchemaOptions {
 /** Validate a file name matching one or more extensions. */
 export declare class FileSchema extends StringSchema {
     readonly types: FileTypes | undefined;
-    constructor({ types, title, ...options }: FileSchemaOptions);
+    constructor({ one, title, types, ...options }: FileSchemaOptions);
     validate(unsafeValue?: unknown): string;
 }
 /** Valid file, e.g. `file.txt` */

package/schema/FileSchema.js

@@ -6,8 +6,8 @@ import { StringSchema } from "./StringSchema.js";
 /** Validate a file name matching one or more extensions. */
 export class FileSchema extends StringSchema {
     types;
-    constructor({ types, title = "File", ...options }) {
-        super({ title, ...options });
+    constructor({ one = "file", title = "File", types, ...options }) {
+        super({ one, title, ...options });
         this.types = types;
     }
     validate(unsafeValue = this.value) {

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({ min, max, ...options }: StringSchemaOptions);
+    constructor({ one, 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({ min = 1, max = 32, ...options }) {
-        super({ min, max, ...options });
+    constructor({ one = "key", min = 1, max = 32, ...options }) {
+        super({ one, min, max, ...options });
     }
     sanitize(str) {
         return str.replace(R_NOT_CHAR, "");

package/schema/LinkSchema.d.ts

@@ -3,7 +3,7 @@ import { type AbsoluteLink } from "../util/link.js";
 import type { StringSchemaOptions } from "./StringSchema.js";
 import { StringSchema } from "./StringSchema.js";
 /** Allowed options for `LinkSchema` */
-export interface LinkSchemaOptions extends Omit<StringSchemaOptions, "type" | "min" | "max" | "multiline"> {
+export interface LinkSchemaOptions extends Omit<StringSchemaOptions, "input" | "min" | "max" | "multiline"> {
     readonly base?: AbsoluteLink | undefined;
     readonly schemes?: ImmutableArray<string> | undefined;
     readonly hosts?: ImmutableArray<string> | undefined;
@@ -18,7 +18,7 @@ export declare class LinkSchema extends StringSchema {
     readonly base: AbsoluteLink | undefined;
     readonly schemes: ImmutableArray<string> | undefined;
     readonly hosts: ImmutableArray<string> | undefined;
-    constructor({ base, schemes, hosts, title, ...options }: LinkSchemaOptions);
+    constructor({ one, title, base, schemes, hosts, ...options }: LinkSchemaOptions);
     validate(unsafeValue: unknown): AbsoluteLink;
 }
 /** Valid link, e.g. `https://www.google.com` */

package/schema/LinkSchema.js

@@ -12,8 +12,9 @@ export class LinkSchema extends StringSchema {
     base;
     schemes;
     hosts;
-    constructor({ base, schemes, hosts, title = "Link", ...options }) {
+    constructor({ one = "link", title = "Link", base, schemes, hosts, ...options }) {
         super({
+            one,
             title,
             ...options,
             input: "url",

package/schema/NumberSchema.d.ts

@@ -13,7 +13,7 @@ export declare class NumberSchema extends Schema<number> {
     readonly min: number;
     readonly max: number;
     readonly step: number | undefined;
-    constructor({ min, max, step, title, value, ...options }: NumberSchemaOptions);
+    constructor({ one, title, min, max, step, value, ...options }: NumberSchemaOptions);
     validate(unsafeValue?: unknown): number;
 }
 /** Valid number, e.g. `2048.12345` or `0` zero. */

package/schema/NumberSchema.js

@@ -8,8 +8,8 @@ export class NumberSchema extends Schema {
     min;
     max;
     step;
-    constructor({ min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY, step, title = "Number", value = 0, ...options }) {
-        super({ title, value, ...options });
+    constructor({ one = "number", title = "Number", min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY, step, value = 0, ...options }) {
+        super({ one, title, value, ...options });
         this.min = min;
         this.max = max;
         this.step = step;
@@ -19,10 +19,10 @@ export class NumberSchema extends Schema {
         if (typeof optionalNumber !== "number")
             throw new ValueFeedback("Must be number", unsafeValue);
         const roundedNumber = typeof this.step === "number" ? roundStep(optionalNumber, this.step) : optionalNumber;
+        if (roundedNumber < this.min)
+            throw new ValueFeedback(!optionalNumber ? "Required" : `Minimum ${formatNumber(this.min)}`, roundedNumber);
         if (roundedNumber > this.max)
             throw new ValueFeedback(`Maximum ${formatNumber(this.max)}`, roundedNumber);
-        if (roundedNumber < this.min)
-            throw new ValueFeedback(`Minimum ${formatNumber(this.min)}`, roundedNumber);
         return roundedNumber;
     }
 }

package/schema/PhoneSchema.d.ts

@@ -6,7 +6,7 @@ import { StringSchema } from "./StringSchema.js";
  * - Falsy values are converted to `""` empty string.
  */
 export declare class PhoneSchema extends StringSchema {
-    constructor({ title, ...options }: StringSchemaOptions);
+    constructor({ one, title, ...options }: Omit<StringSchemaOptions, "input" | "min" | "max" | "match" | "multiline">);
     sanitize(insaneString: string): string;
 }
 /** Valid phone number, e.g. `+441234567890` */

package/schema/PhoneSchema.js

@@ -10,8 +10,9 @@ const PHONE_REGEXP = /^\+[1-9][0-9]{0,2}[0-9]{5,12}$/;
  * - Falsy values are converted to `""` empty string.
  */
 export class PhoneSchema extends StringSchema {
-    constructor({ title = "Phone", ...options }) {
+    constructor({ one = "phone number", title = "Phone", ...options }) {
         super({
+            one,
             title,
             ...options,
             input: "tel",

package/schema/Schema.d.ts

@@ -2,6 +2,10 @@ import type { Data } from "../util/data.js";
 import type { Validator } from "../util/validate.js";
 /** Options allowed by a `Schema` instance. */
 export type SchemaOptions = {
+    /** String for one of this thing, e.g. `product` or `item` or `sheep` */
+    readonly one?: string;
+    /** String for several of this thing, e.g. `products` or `items` or `sheep` (defaults to `one` + "s") */
+    readonly many?: string;
     /** Title of the schema, e.g. for using as the title of a corresponding field. */
     readonly title?: string | undefined;
     /** Description of the schema, e.g. for using as a description in a corresponding field. */
@@ -17,15 +21,19 @@ export type SchemaOptions = {
  * - `validate()` returns `Invalid` if value was not valid.
  */
 export declare abstract class Schema<T = unknown> implements Validator<T> {
+    /** String for one of this thing, e.g. `product` or `item` or `sheep` */
+    readonly one: string;
+    /** String for several of this thing, e.g. `products` or `items` or `sheep` (defaults to `one` + "s") */
+    readonly many: string;
     /** Title of the schema, e.g. for using as the title of a corresponding field. */
-    readonly title: string | undefined;
+    readonly title: string;
     /** Description of the schema, e.g. for using as a description in a corresponding field. */
-    readonly description: string | undefined;
+    readonly description: string;
     /** Placeholder of the schema, e.g. for using as a placeholder in a corresponding field. */
-    readonly placeholder: string | undefined;
+    readonly placeholder: string;
     /** Default value for the schema if `validate()` is called with an `undefined` value. */
     readonly value: unknown;
-    constructor({ title, description, placeholder, value }: SchemaOptions);
+    constructor({ one, many, title, description, placeholder, value }: SchemaOptions);
     /** Every schema must implement a `validate()` method. */
     abstract validate(unsafeValue: unknown): T;
 }

package/schema/Schema.js

@@ -7,6 +7,10 @@ import { getUndefined } from "../util/undefined.js";
  * - `validate()` returns `Invalid` if value was not valid.
  */
 export class Schema {
+    /** String for one of this thing, e.g. `product` or `item` or `sheep` */
+    one;
+    /** String for several of this thing, e.g. `products` or `items` or `sheep` (defaults to `one` + "s") */
+    many;
     /** Title of the schema, e.g. for using as the title of a corresponding field. */
     title;
     /** Description of the schema, e.g. for using as a description in a corresponding field. */
@@ -15,7 +19,9 @@ export class Schema {
     placeholder;
     /** Default value for the schema if `validate()` is called with an `undefined` value. */
     value;
-    constructor({ title, description, placeholder, value }) {
+    constructor({ one = "value", many = `${one}s`, title = "", description = "", placeholder = "", value }) {
+        this.one = one;
+        this.many = many;
         this.title = title;
         this.description = description;
         this.placeholder = placeholder;
@@ -23,7 +29,15 @@ export class Schema {
     }
 }
 // Unknown validator always passes through its input value as `unknown`
-export const UNKNOWN = { title: "", description: "", placeholder: "", value: undefined, validate: PASSTHROUGH };
+export const UNKNOWN = {
+    one: "none",
+    many: "none",
+    title: "",
+    description: "",
+    placeholder: "",
+    value: undefined,
+    validate: PASSTHROUGH,
+};
 // Undefined validator always returns `undefined`
 export const UNDEFINED = { ...UNKNOWN, validate: getUndefined };
 // Null validator always returns `null`

package/schema/TimeSchema.d.ts

@@ -1,7 +1,7 @@
 import { DateSchema, type DateSchemaOptions } from "./DateSchema.js";
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
 export declare class TimeSchema extends DateSchema {
-    constructor({ title, input, ...options }: DateSchemaOptions);
+    constructor({ one, title, input, ...options }: DateSchemaOptions);
     stringify(value: Date): string;
     format(value: Date): string;
 }

package/schema/TimeSchema.js

@@ -4,8 +4,8 @@ import { DateSchema } from "./DateSchema.js";
 import { NULLABLE } from "./NullableSchema.js";
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
 export class TimeSchema extends DateSchema {
-    constructor({ title = "Time", input = "time", ...options }) {
-        super({ title, input, ...options });
+    constructor({ one = "time", title = "Time", input = "time", ...options }) {
+        super({ one, title, input, ...options });
     }
     stringify(value) {
         return requireTimeString(value);

package/schema/UUIDSchema.d.ts

@@ -5,7 +5,7 @@ import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
  * - Falsy values are converted to empty string.
  */
 export declare class UUIDSchema extends StringSchema {
-    constructor(options?: StringSchemaOptions);
+    constructor({ one, title, ...rest }?: Omit<StringSchemaOptions, "input" | "min" | "max" | "match" | "multiline">);
     sanitize(str: string): string;
 }
 /** Any valid UUID (versions 1-5) */

package/schema/UUIDSchema.js

@@ -7,9 +7,9 @@ import { StringSchema } from "./StringSchema.js";
  * - Falsy values are converted to empty string.
  */
 export class UUIDSchema extends StringSchema {
-    constructor(options = {}) {
-        const { title = "UUID", ...rest } = options;
+    constructor({ one = "UUID", title = "UUID", ...rest } = {}) {
         super({
+            one,
             title,
             ...rest,
             min: 32,