shelving 1.185.1 → 1.185.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shelving",
-	"version": "1.185.1",
+	"version": "1.185.3",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"repository": {
 		"type": "git",

package/schema/ChoiceSchema.d.ts

@@ -20,7 +20,7 @@ export interface ChoiceSchemaOptions<K extends string> extends Omit<SchemaOption
 }
 /** Choose from an allowed set of values. */
 export declare class ChoiceSchema<K extends string> extends Schema<K> implements Iterable<ChoiceOption<K>> {
-    readonly value: K;
+    readonly value: K | undefined;
     readonly options: ChoiceOptions<K>;
     constructor({ one, title, placeholder, options, value, ...rest }: ChoiceSchemaOptions<K>);
     validate(unsafeValue?: unknown): K;

package/schema/ChoiceSchema.js

@@ -1,4 +1,4 @@
-import { isArray, requireFirst } from "../util/array.js";
+import { isArray } from "../util/array.js";
 import { getKeys, getProps, isProp } from "../util/object.js";
 import { Schema } from "./Schema.js";
 /** Get the options for a choice field as an array. */
@@ -19,14 +19,14 @@ export function isOption(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 = requireFirst(isArray(options) ? options : getKeys(options)), ...rest }) {
+    constructor({ one = "choice", title = "Choice", placeholder = `No ${one}`, options, value, ...rest }) {
         super({ one, title, value, placeholder, ...rest });
         this.options = options;
     }
     validate(unsafeValue = this.value) {
         if (typeof unsafeValue === "string" && isOption(this.options, unsafeValue))
             return unsafeValue;
-        throw "Unknown value";
+        throw unsafeValue ? `Unknown ${this.one}` : "Required";
     }
     // Implement iterable.
     *[Symbol.iterator]() {

package/schema/DateSchema.d.ts

@@ -18,7 +18,7 @@ export interface DateSchemaOptions extends SchemaOptions {
     readonly step?: number | undefined;
 }
 export declare class DateSchema extends Schema<string> {
-    readonly value: PossibleDate;
+    readonly value: PossibleDate | undefined;
     readonly min: Date | undefined;
     readonly max: Date | undefined;
     readonly input: DateInputType;

package/schema/DateSchema.js

@@ -8,7 +8,7 @@ export class DateSchema extends Schema {
     max;
     input;
     step;
-    constructor({ one = "date", min, max, value = "now", input = "date", step, ...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);
@@ -18,13 +18,13 @@ export class DateSchema extends Schema {
     validate(value = this.value) {
         const date = getDate(value);
         if (!date)
-            throw value ? "Invalid date" : "Required";
-        const rounded = typeof this.step === "number" ? new Date(roundStep(date.getTime(), this.step)) : date;
-        if (this.min && rounded < this.min)
+            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)}`;
-        if (this.max && rounded > this.max)
+        if (this.max && stepped > this.max)
             throw `Maximum ${this.format(this.max)}`;
-        return this.stringify(rounded);
+        return this.stringify(stepped);
     }
     stringify(value) {
         return requireDateString(value);

package/schema/FileSchema.js

@@ -13,9 +13,9 @@ export class FileSchema extends StringSchema {
         const path = super.validate(unsafeValue);
         const extension = getFileExtension(path);
         if (!extension)
-            throw "Must be file name with extension";
+            throw `Must have extension`;
         if (this.types && !isProp(this.types, extension))
-            throw "Invalid file type";
+            throw `Invalid extension`;
         return path;
     }
 }

package/schema/NumberSchema.d.ts

@@ -9,14 +9,14 @@ export interface NumberSchemaOptions extends SchemaOptions {
 }
 /** Schema that defines a valid number. */
 export declare class NumberSchema extends Schema<number> {
-    readonly value: number;
+    readonly value: number | undefined;
     readonly min: number;
     readonly max: number;
     readonly step: number | undefined;
     constructor({ one, title, min, max, step, value, ...options }: NumberSchemaOptions);
-    validate(unsafeValue?: unknown): number;
+    validate(value?: unknown): number;
 }
-/** Valid number, e.g. `2048.12345` or `0` zero. */
+/** Valid number, e.g. `2048.12345` or `0` zero and a default value of zero. */
 export declare const NUMBER: NumberSchema;
 /** Valid optional number, e.g. `2048.12345` or `0` zero, or `null` */
 export declare const NULLABLE_NUMBER: import("./NullableSchema.js").NullableSchema<number>;

package/schema/NumberSchema.js

@@ -7,38 +7,38 @@ export class NumberSchema extends Schema {
     min;
     max;
     step;
-    constructor({ one = "number", title = "Number", min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY, step, value = 0, ...options }) {
+    constructor({ one = "number", title = "Number", min = Number.NEGATIVE_INFINITY, max = Number.POSITIVE_INFINITY, step, value, ...options }) {
         super({ one, title, value, ...options });
         this.min = min;
         this.max = max;
         this.step = step;
     }
-    validate(unsafeValue = this.value) {
-        const optionalNumber = getNumber(unsafeValue);
-        if (typeof optionalNumber !== "number")
-            throw "Must be number";
-        const roundedNumber = typeof this.step === "number" ? roundStep(optionalNumber, this.step) : optionalNumber;
-        if (roundedNumber < this.min)
-            throw !optionalNumber ? "Required" : `Minimum ${formatNumber(this.min)}`;
-        if (roundedNumber > this.max)
+    validate(value = this.value) {
+        const number = getNumber(value);
+        if (typeof number !== "number")
+            throw value ? `Must be ${this.one}` : "Required";
+        const stepped = typeof this.step === "number" ? roundStep(number, this.step) : number;
+        if (stepped < this.min)
+            throw !number ? "Required" : `Minimum ${formatNumber(this.min)}`;
+        if (stepped > this.max)
             throw `Maximum ${formatNumber(this.max)}`;
-        return roundedNumber;
+        return stepped;
     }
 }
-/** Valid number, e.g. `2048.12345` or `0` zero. */
+/** Valid number, e.g. `2048.12345` or `0` zero and a default value of zero. */
 export const NUMBER = new NumberSchema({ title: "Number" });
 /** Valid optional number, e.g. `2048.12345` or `0` zero, or `null` */
 export const NULLABLE_NUMBER = NULLABLE(NUMBER);
 /** Valid integer number, e.g. `2048` or `0` zero. */
-export const INTEGER = new NumberSchema({ step: 1, min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER, value: 0 });
+export const INTEGER = new NumberSchema({ step: 1, min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER });
 /** Valid positive integer number, e.g. `1,2,3` (not including zero). */
-export const POSITIVE_INTEGER = new NumberSchema({ step: 1, min: 1, max: Number.MAX_SAFE_INTEGER, value: 1 });
+export const POSITIVE_INTEGER = new NumberSchema({ step: 1, min: 1, max: Number.MAX_SAFE_INTEGER });
 /** Valid non-negative integer number, e.g. `0,1,2,3` (including zero). */
-export const NON_NEGATIVE_INTEGER = new NumberSchema({ step: 1, min: 0, max: Number.MAX_SAFE_INTEGER, value: 0 });
+export const NON_NEGATIVE_INTEGER = new NumberSchema({ step: 1, min: 0, max: Number.MAX_SAFE_INTEGER });
 /** Valid negative integer number, e.g. `-1,-2,-3` (not including zero). */
-export const NEGATIVE_INTEGER = new NumberSchema({ step: 1, min: Number.MIN_SAFE_INTEGER, max: -1, value: -1 });
+export const NEGATIVE_INTEGER = new NumberSchema({ step: 1, min: Number.MIN_SAFE_INTEGER, max: -1 });
 /** Valid non-positive integer number, e.g. `0,-1,-2,-3` (including zero). */
-export const NON_POSITIVE_INTEGER = new NumberSchema({ step: 1, min: Number.MIN_SAFE_INTEGER, max: 0, value: 0 });
+export const NON_POSITIVE_INTEGER = new NumberSchema({ step: 1, min: Number.MIN_SAFE_INTEGER, max: 0 });
 /** Valid optional integer number, e.g. `2048` or `0` zero, or `null` */
 export const NULLABLE_INTEGER = NULLABLE(INTEGER);
 /** Valid Unix timestamp (including milliseconds). */
@@ -47,7 +47,6 @@ export const TIMESTAMP = new NumberSchema({
     step: 1,
     min: Number.MIN_SAFE_INTEGER,
     max: Number.MAX_SAFE_INTEGER,
-    value: 0,
 });
 /** Valid Unix timestamp (including milliseconds). */
 export const NULLABLE_TIMESTAMP = NULLABLE_INTEGER;

package/schema/StringSchema.d.ts

@@ -35,8 +35,8 @@ export declare class StringSchema extends Schema<string> {
     readonly multiline: boolean;
     readonly match: RegExp | undefined;
     readonly case: "upper" | "lower" | undefined;
-    constructor({ min, max, value, multiline, match, case: _case, input, ...options }: StringSchemaOptions);
-    validate(unsafeValue?: unknown): string;
+    constructor({ one, min, max, value, multiline, match, case: _case, input, ...options }: StringSchemaOptions);
+    validate(value?: unknown): string;
     /** Sanitize the string by removing unwanted characters. */
     sanitize(str: string): string;
 }

package/schema/StringSchema.js

@@ -23,8 +23,8 @@ export class StringSchema extends Schema {
     multiline;
     match;
     case;
-    constructor({ min = 0, max = Number.POSITIVE_INFINITY, value = "", multiline = false, match, case: _case, input = "text", ...options }) {
-        super({ value, ...options });
+    constructor({ one = "string", min = 0, max = Number.POSITIVE_INFINITY, value = "", multiline = false, match, case: _case, input = "text", ...options }) {
+        super({ one, value, ...options });
         this.min = min;
         this.max = max;
         this.multiline = multiline;
@@ -32,18 +32,18 @@ export class StringSchema extends Schema {
         this.case = _case;
         this.input = input;
     }
-    validate(unsafeValue = this.value) {
-        const possibleString = typeof unsafeValue === "number" ? unsafeValue.toString() : unsafeValue;
-        if (typeof possibleString !== "string")
-            throw "Must be string";
-        const saneString = this.sanitize(possibleString);
-        if (saneString.length < this.min)
-            throw possibleString.length ? `Minimum ${this.min} characters` : "Required";
-        if (saneString.length > this.max)
+    validate(value = this.value) {
+        const str = typeof value === "number" ? value.toString() : value;
+        if (typeof str !== "string")
+            throw value ? `Must be ${this.one}` : "Required";
+        const sane = this.sanitize(str);
+        if (this.match && !this.match.test(sane))
+            throw str.length ? `Invalid ${this.one}` : "Required";
+        if (sane.length < this.min)
+            throw str.length ? `Minimum ${this.min} characters` : "Required";
+        if (sane.length > this.max)
             throw `Maximum ${this.max} characters`;
-        if (this.match && !this.match.test(saneString))
-            throw saneString ? "Invalid format" : "Required";
-        return saneString;
+        return sane;
     }
     /** Sanitize the string by removing unwanted characters. */
     sanitize(str) {

package/schema/URISchema.js

@@ -25,9 +25,9 @@ export class URISchema extends StringSchema {
         const str = super.validate(unsafeValue);
         const uri = getURI(str);
         if (!uri)
-            throw str ? "Invalid format" : "Required";
+            throw str ? `Invalid ${this.one} format` : "Required";
         if (this.schemes && !this.schemes.includes(uri.protocol))
-            throw "Invalid URI scheme";
+            throw `Invalid ${this.one} scheme`;
         return uri.href;
     }
 }

package/schema/URLSchema.js

@@ -28,9 +28,9 @@ export class URLSchema extends StringSchema {
         const str = super.validate(unsafeValue);
         const url = getURL(str, this.base);
         if (!url)
-            throw str ? "Invalid format" : "Required";
+            throw str ? `Invalid ${this.one} format` : "Required";
         if (this.schemes && !this.schemes.includes(url.protocol))
-            throw "Invalid URL scheme";
+            throw `Invalid ${this.one} scheme`;
         return url.href;
     }
 }