shelving 1.154.1 → 1.155.0

package/package.json

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

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 = "datetime-local", ...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/DateTimeSchema.d.ts

@@ -1,7 +1,4 @@
 import { DateSchema, type DateSchemaOptions } from "./DateSchema.js";
-/** Allowed options for `DateSchema` */
-export interface DateTimeSchemaOptions extends DateSchemaOptions {
-}
 /**
  * Define a valid UTC date in ISO 8601 format, e.g. `2005-09-12T18:15:00.000Z`
  * - The date includes the `Z` suffix to indicate UTC time, this ensures consistent transfer of the date between client and server.
@@ -9,6 +6,7 @@ export interface DateTimeSchemaOptions extends DateSchemaOptions {
  * - 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);
     format(value: Date): string;
     stringify(value: Date): string;
 }

package/schema/DateTimeSchema.js

@@ -8,6 +8,9 @@ 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 });
+    }
     format(value) {
         return formatDateTime(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, 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", step, ...options }) {
-        super({ title, ...options });
-        this.step = step;
+    constructor({ title = "Time", input = "time", ...options }) {
+        super({ title, input, ...options });
     }
-    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). */

package/util/array.d.ts

@@ -66,7 +66,7 @@ export declare function isArrayItem<T>(list: PossibleArray<T>, item: unknown): i
 export declare function assertArrayItem<T>(arr: PossibleArray<T>, item: unknown, caller?: AnyCaller): asserts item is T;
 /** Add multiple items to an array (immutably) and return a new array with those items (or the same array if no changes were made). */
 export declare function withArrayItems<T>(list: PossibleArray<T>, ...add: T[]): ImmutableArray<T>;
-/** Pick multiple items from an array (immutably) and return a new array without those items (or the same array if no changes were made). */
+/** Pick multiple items from an array (immutably) and return a new array with those items (or the same array if no changes were made). */
 export declare function pickArrayItems<T>(items: PossibleArray<T>, ...pick: T[]): ImmutableArray<T>;
 /** Remove multiple items from an array (immutably) and return a new array without those items (or the same array if no changes were made). */
 export declare function omitArrayItems<T>(items: PossibleArray<T>, ...omit: T[]): ImmutableArray<T>;

package/util/array.js

@@ -42,7 +42,7 @@ export function withArrayItems(list, ...add) {
 function _doesNotInclude(value) {
     return !this.includes(value);
 }
-/** Pick multiple items from an array (immutably) and return a new array without those items (or the same array if no changes were made). */
+/** Pick multiple items from an array (immutably) and return a new array with those items (or the same array if no changes were made). */
 export function pickArrayItems(items, ...pick) {
     const arr = Array.from(pickItems(items, ...pick));
     return isArray(items) && arr.length === items.length ? items : arr;