shelving 1.154.2 → 1.156.0

package/package.json

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

package/schema/ChoiceSchema.d.ts

@@ -7,12 +7,14 @@ export type ChoiceOptions<K extends string> = {
 export interface ChoiceSchemaOptions<K extends string> extends Omit<SchemaOptions, "value"> {
     /** Specify correct options using a dictionary of entries. */
     options: ChoiceOptions<K>;
+    /** Default option for the value. */
+    value?: K;
 }
 /** Choose from an allowed set of values. */
 export declare class ChoiceSchema<K extends string> extends Schema<K> {
     readonly value: string;
     readonly options: ChoiceOptions<K>;
-    constructor({ options, ...rest }: ChoiceSchemaOptions<K>);
+    constructor({ options, value, ...rest }: ChoiceSchemaOptions<K>);
     validate(unsafeValue?: unknown): K;
 }
 /** Choose from an allowed set of values. */

package/schema/ChoiceSchema.js

@@ -5,8 +5,8 @@ import { Schema } from "./Schema.js";
 /** Choose from an allowed set of values. */
 export class ChoiceSchema extends Schema {
     options;
-    constructor({ options, ...rest }) {
-        super({ value: requireFirst(getKeys(options)), ...rest });
+    constructor({ options, value = requireFirst(getKeys(options)), ...rest }) {
+        super({ value, ...rest });
         this.options = options;
     }
     validate(unsafeValue = this.value) {

package/schema/DateSchema.d.ts

@@ -10,13 +10,20 @@ export interface DateSchemaOptions extends SchemaOptions {
     readonly min?: Nullish<PossibleDate>;
     readonly max?: Nullish<PossibleDate>;
     readonly input?: DateInputType | undefined;
+    /**
+     * Rounding step (in milliseconds, because that's the base unit for time).
+     * - E.g. `1000 * 60` will round to the nearest minute.
+     * - Note: HTML `<input>` `step` attributes are in _seconds_, so you may need to convert units.
+     */
+    readonly step?: number | undefined;
 }
 export declare class DateSchema extends Schema<string> {
     readonly value: PossibleDate;
     readonly min: Date | undefined;
     readonly max: Date | undefined;
     readonly input: DateInputType;
-    constructor({ min, max, value, input, ...options }: DateSchemaOptions);
+    readonly step: number | undefined;
+    constructor({ min, max, value, input, step, ...options }: DateSchemaOptions);
     validate(value?: unknown): string;
     stringify(value: Date): string;
     format(value: Date): string;

package/schema/DateSchema.js

@@ -1,27 +1,31 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { getDate, requireDateString } from "../util/date.js";
 import { formatDate } from "../util/format.js";
+import { roundStep } from "../util/number.js";
 import { NULLABLE } from "./NullableSchema.js";
 import { Schema } from "./Schema.js";
 export class DateSchema extends Schema {
     min;
     max;
     input;
-    constructor({ min, max, value = "now", input = "date", ...options }) {
+    step;
+    constructor({ min, max, value = "now", input = "date", step, ...options }) {
         super({ title: "Date", value, ...options });
         this.min = getDate(min);
         this.max = getDate(max);
         this.input = input;
+        this.step = step;
     }
     validate(value = this.value) {
         const date = getDate(value);
         if (!date)
             throw new ValueFeedback(value ? "Invalid date" : "Required", value);
-        if (this.min && date < this.min)
-            throw new ValueFeedback(`Minimum ${this.format(this.min)}`, date);
-        if (this.max && date > this.max)
-            throw new ValueFeedback(`Maximum ${this.format(this.max)}`, date);
-        return this.stringify(date);
+        const rounded = typeof this.step === "number" ? new Date(roundStep(date.getTime(), this.step)) : date;
+        if (this.min && rounded < this.min)
+            throw new ValueFeedback(`Minimum ${this.format(this.min)}`, rounded);
+        if (this.max && rounded > this.max)
+            throw new ValueFeedback(`Maximum ${this.format(this.max)}`, rounded);
+        return this.stringify(rounded);
     }
     stringify(value) {
         return requireDateString(value);

package/schema/TimeSchema.d.ts

@@ -1,19 +1,9 @@
-import { type PossibleDate } from "../util/date.js";
 import { DateSchema, type DateSchemaOptions } from "./DateSchema.js";
-/** Allowed options for `TimeSchama` */
-export interface TimeSchemaOptions extends DateSchemaOptions {
-    step?: number | undefined;
-}
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
 export declare class TimeSchema extends DateSchema {
-    readonly value: PossibleDate;
-    /**
-     * Rounding step (in milliseconds, because that's the base unit for time), e.g. `60000` will round to the nearest second.
-     * - Note: `<input type="time">` elements expect `step=""` to be  in _seconds_ so you need to multiply this by `1000`
-     */
-    readonly step: number | undefined;
-    constructor({ title, input, step, ...options }: TimeSchemaOptions);
-    validate(unsafeValue?: unknown): string;
+    constructor({ title, input, ...options }: DateSchemaOptions);
+    stringify(value: Date): string;
+    format(value: Date): string;
 }
 /** Valid time, e.g. `2005-09-12` (required because falsy values are invalid). */
 export declare const TIME: TimeSchema;

package/schema/TimeSchema.js

@@ -1,30 +1,17 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
-import { getDate, requireTimeString } from "../util/date.js";
+import { requireTimeString } from "../util/date.js";
 import { formatTime } from "../util/format.js";
-import { roundStep } from "../util/number.js";
 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 {
-    /**
-     * Rounding step (in milliseconds, because that's the base unit for time), e.g. `60000` will round to the nearest second.
-     * - Note: `<input type="time">` elements expect `step=""` to be  in _seconds_ so you need to multiply this by `1000`
-     */
-    step;
-    constructor({ title = "Time", input = "time", step, ...options }) {
+    constructor({ title = "Time", input = "time", ...options }) {
         super({ title, input, ...options });
-        this.step = step;
     }
-    validate(unsafeValue = this.value) {
-        const date = getDate(unsafeValue);
-        if (!date)
-            throw new ValueFeedback(unsafeValue ? "Invalid time" : "Required", unsafeValue);
-        const rounded = typeof this.step === "number" ? new Date(roundStep(date.getTime(), this.step)) : date;
-        if (this.max && rounded > this.max)
-            throw new ValueFeedback(`Maximum ${formatTime(this.max)}`, rounded);
-        if (this.min && rounded < this.min)
-            throw new ValueFeedback(`Minimum ${formatTime(this.min)}`, rounded);
-        return requireTimeString(rounded);
+    stringify(value) {
+        return requireTimeString(value);
+    }
+    format(value) {
+        return formatTime(value);
     }
 }
 /** Valid time, e.g. `2005-09-12` (required because falsy values are invalid). */