shelving 1.86.5 → 1.86.7

package/package.json

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

package/schema/ArraySchema.d.ts

@@ -6,7 +6,7 @@ export type ArraySchemaOptions<T> = SchemaOptions & {
     readonly value?: ImmutableArray;
     readonly items: Validator<T>;
     readonly min?: number;
-    readonly max?: number | null;
+    readonly max?: number;
     readonly unique?: boolean;
 };
 /**
@@ -41,7 +41,7 @@ export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     readonly items: Validator<T>;
     readonly unique: boolean;
     readonly min: number;
-    readonly max: number | null;
+    readonly max: number;
     constructor({ value, items, unique, min, max, ...options }: ArraySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableArray<T>;
 }

package/schema/ArraySchema.js

@@ -30,7 +30,7 @@ import { Schema } from "./Schema.js";
  *  schema.validate(["a", null], schema); // Throws Invalids({ "1": Invalid('Must be a string') });
  */
 export class ArraySchema extends Schema {
-    constructor({ value = [], items, unique = false, min = 0, max = null, ...options }) {
+    constructor({ value = [], items, unique = false, min = 0, max = Infinity, ...options }) {
         super(options);
         this.value = value;
         this.items = items;
@@ -43,9 +43,9 @@ export class ArraySchema extends Schema {
             throw new InvalidFeedback("Must be array", { value: unsafeValue });
         const safeArray = validateArray(unsafeValue, this.items);
         const dedupedArray = this.unique ? uniqueArray(safeArray) : safeArray;
-        if (typeof this.min === "number" && dedupedArray.length < this.min)
+        if (dedupedArray.length < this.min)
             throw new InvalidFeedback(dedupedArray.length ? `Minimum ${this.min} items` : "Required", { value: dedupedArray });
-        if (typeof this.max === "number" && dedupedArray.length > this.max)
+        if (dedupedArray.length > this.max)
             throw new InvalidFeedback(`Maximum ${this.max} items`, { value: dedupedArray });
         return dedupedArray;
     }

package/schema/BooleanSchema.d.ts

@@ -1,7 +1,7 @@
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `BooleanSchema` */
 export type BooleanSchemaOptions = SchemaOptions & {
-    readonly value?: boolean;
+    readonly value?: boolean | undefined;
 };
 /** Define a valid boolean. */
 export declare class BooleanSchema extends Schema<boolean> {

package/schema/DataSchema.d.ts

@@ -5,7 +5,7 @@ import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `DataSchema` */
 export type DataSchemaOptions<T extends Data> = SchemaOptions & {
     readonly props: Validators<T>;
-    readonly value?: Partial<T>;
+    readonly value?: Partial<T> | undefined;
 };
 /** Validate a data object. */
 export declare class DataSchema<T extends Data> extends Schema<T> {

package/schema/DateSchema.d.ts

@@ -1,10 +1,10 @@
-import { PossibleDate } from "../util/date.js";
+import { PossibleDate, PossibleOptionalDate } from "../util/date.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `DateSchema` */
 export type DateSchemaOptions = SchemaOptions & {
-    readonly value?: PossibleDate;
-    readonly min?: PossibleDate | null;
-    readonly max?: PossibleDate | null;
+    readonly value?: PossibleDate | undefined;
+    readonly min?: PossibleOptionalDate | undefined;
+    readonly max?: PossibleOptionalDate | undefined;
 };
 /** Define a valid date in YMD format, e.g. `2005-09-12` */
 export declare class DateSchema extends Schema<string> {

package/schema/DateSchema.js

@@ -1,4 +1,4 @@
-import { formatDate, getDate, getOptionalDate, getYMD } from "../util/date.js";
+import { formatDate, getOptionalDate, getYMD } from "../util/date.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { Schema } from "./Schema.js";
 import { OPTIONAL } from "./OptionalSchema.js";
@@ -7,8 +7,8 @@ export class DateSchema extends Schema {
     constructor({ value = "now", min = null, max = null, ...options }) {
         super(options);
         this.value = value;
-        this.min = min !== null ? getDate(min) : null;
-        this.max = max !== null ? getDate(max) : null;
+        this.min = getOptionalDate(min);
+        this.max = getOptionalDate(max);
     }
     validate(unsafeValue = this.value) {
         const date = getOptionalDate(unsafeValue);

package/schema/DictionarySchema.d.ts

@@ -4,16 +4,16 @@ import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `DictionarySchema` */
 export type DictionarySchemaOptions<T> = SchemaOptions & {
     readonly items: Validator<T>;
-    readonly value?: ImmutableDictionary;
-    readonly min?: number | null;
-    readonly max?: number | null;
+    readonly value?: ImmutableDictionary | undefined;
+    readonly min?: number | undefined;
+    readonly max?: number | undefined;
 };
 /** 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;
     readonly items: Validator<T>;
-    readonly min: number | null;
-    readonly max: number | null;
+    readonly min: number;
+    readonly max: number;
     constructor({ value, items, min, max, ...rest }: DictionarySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableDictionary<T>;
 }

package/schema/DictionarySchema.js

@@ -4,10 +4,8 @@ import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { Schema } from "./Schema.js";
 /** Validate a dictionary object (whose props are all the same with string keys). */
 export class DictionarySchema extends Schema {
-    constructor({ value = {}, items, min = null, max = null, ...rest }) {
+    constructor({ value = {}, items, min = 0, max = Infinity, ...rest }) {
         super(rest);
-        this.min = null;
-        this.max = null;
         this.items = items;
         this.value = value;
         this.min = min;
@@ -18,9 +16,9 @@ export class DictionarySchema extends Schema {
             throw new InvalidFeedback("Must be object", { value: unsafeValue });
         const unsafeEntries = Object.entries(unsafeValue);
         const safeObject = Object.fromEntries(validateEntries(unsafeEntries, this.items));
-        if (typeof this.min === "number" && unsafeEntries.length < this.min)
+        if (unsafeEntries.length < this.min)
             throw new InvalidFeedback(unsafeEntries.length ? `Minimum ${this.min} items` : "Required", { value: safeObject });
-        if (typeof this.max === "number" && unsafeEntries.length > this.max)
+        if (unsafeEntries.length > this.max)
             throw new InvalidFeedback(`Maximum ${this.max} items`, { value: safeObject });
         return safeObject;
     }

package/schema/LinkSchema.d.ts

@@ -1,8 +1,8 @@
 import { StringSchema, StringSchemaOptions } from "./StringSchema.js";
 /** Allowed options for `LinkSchema` */
 export type LinkSchemaOptions = StringSchemaOptions & {
-    readonly schemes?: string[];
-    readonly hosts?: string[] | null;
+    readonly schemes?: string[] | undefined;
+    readonly hosts?: string[] | undefined;
 };
 /**
  * Type of `StringSchema` that defines a valid URL.
@@ -15,7 +15,7 @@ export declare class LinkSchema extends StringSchema {
     readonly min = 1;
     readonly max = 512;
     readonly schemes: string[];
-    readonly hosts: string[] | null;
+    readonly hosts: string[] | undefined;
     constructor({ schemes, hosts, ...rest }: LinkSchemaOptions);
     validate(unsafeValue: unknown): string;
 }

package/schema/LinkSchema.js

@@ -9,13 +9,11 @@ import { StringSchema } from "./StringSchema.js";
  * - Falsy values are converted to `""` empty string.
  */
 export class LinkSchema extends StringSchema {
-    constructor({ schemes = ["http:", "https:"], hosts = null, ...rest }) {
+    constructor({ schemes = ["http:", "https:"], hosts, ...rest }) {
         super(rest);
         this.type = "url";
         this.min = 1;
         this.max = 512;
-        this.schemes = ["http:", "https:"];
-        this.hosts = null;
         this.schemes = schemes;
         this.hosts = hosts;
     }

package/schema/NumberSchema.d.ts

@@ -1,16 +1,16 @@
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `NumberSchema` */
 export type NumberSchemaOptions = SchemaOptions & {
-    readonly value?: number | null;
-    readonly min?: number | null;
-    readonly max?: number | null;
-    readonly step?: number | null;
+    readonly value?: number | undefined;
+    readonly min?: number | undefined;
+    readonly max?: number | undefined;
+    readonly step?: number | null | undefined;
 };
 /** Schema that defines a valid number. */
 export declare class NumberSchema extends Schema<number> {
-    readonly value: number | null;
-    readonly min: number | null;
-    readonly max: number | null;
+    readonly value: number;
+    readonly min: number;
+    readonly max: number;
     readonly step: number | null;
     constructor({ value, min, max, step, ...rest }: NumberSchemaOptions);
     validate(unsafeValue?: unknown): number;

package/schema/NumberSchema.js

@@ -4,7 +4,7 @@ import { Schema } from "./Schema.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 /** Schema that defines a valid number. */
 export class NumberSchema extends Schema {
-    constructor({ value = 0, min = null, max = null, step = null, ...rest }) {
+    constructor({ value = 0, min = -Infinity, max = Infinity, step = null, ...rest }) {
         super(rest);
         this.value = value;
         this.min = min;
@@ -16,9 +16,9 @@ export class NumberSchema extends Schema {
         if (typeof unsafeNumber !== "number")
             throw new InvalidFeedback("Must be number", { value: unsafeValue });
         const safeNumber = typeof this.step === "number" ? roundStep(unsafeNumber, this.step) : unsafeNumber;
-        if (typeof this.max === "number" && safeNumber > this.max)
+        if (safeNumber > this.max)
             throw new InvalidFeedback(`Maximum ${formatNumber(this.max)}`, { value: safeNumber });
-        if (typeof this.min === "number" && safeNumber < this.min)
+        if (safeNumber < this.min)
             throw new InvalidFeedback(`Minimum ${formatNumber(this.min)}`, { value: safeNumber });
         return safeNumber;
     }

package/schema/Schema.d.ts

@@ -2,11 +2,11 @@ import type { Validatable } from "../util/validate.js";
 /** Options allowed by a `Schema` instance. */
 export type SchemaOptions = {
     /** Title of the schema, e.g. for using as the title of a corresponding field. */
-    readonly title?: string | null;
+    readonly title?: string | undefined;
     /** Description of the schema, e.g. for using as a description in a corresponding field. */
-    readonly description?: string | null;
+    readonly description?: string | undefined;
     /** Placeholder of the schema, e.g. for using as a placeholder in a corresponding field. */
-    readonly placeholder?: string | null;
+    readonly placeholder?: string | undefined;
     /** Default value for the schema if `validate()` is called with an `undefined` value. */
     readonly value?: unknown;
 };
@@ -17,14 +17,16 @@ export type SchemaOptions = {
  */
 export declare abstract class Schema<T extends unknown = unknown> implements Validatable<T> {
     /** Title of the schema, e.g. for using as the title of a corresponding field. */
-    readonly title: string | null;
+    readonly title: string | undefined;
     /** Description of the schema, e.g. for using as a description in a corresponding field. */
-    readonly description: string | null;
+    readonly description: string | undefined;
     /** Placeholder of the schema, e.g. for using as a placeholder in a corresponding field. */
-    readonly placeholder: string | null;
+    readonly placeholder: string | undefined;
     /** Default value for the schema if `validate()` is called with an `undefined` value. */
     readonly value: unknown;
     constructor({ title, description, placeholder, value }: SchemaOptions);
     /** Every schema must implement a `validate()` method. */
     abstract validate(unsafeValue: unknown): T;
 }
+/** Is an unknown value a `Schema` instance? */
+export declare const isSchema: <T extends Schema<unknown>>(v: unknown) => v is T;

package/schema/Schema.js

@@ -4,10 +4,12 @@
  * - `validate()` returns `Invalid` if value was not valid.
  */
 export class Schema {
-    constructor({ title = null, description = null, placeholder = null, value }) {
+    constructor({ title, description, placeholder, value }) {
         this.title = title;
         this.description = description;
         this.placeholder = placeholder;
         this.value = value;
     }
 }
+/** Is an unknown value a `Schema` instance? */
+export const isSchema = (v) => v instanceof Schema;

package/schema/StringSchema.d.ts

@@ -5,13 +5,13 @@ export type HtmlInputType = "text" | "password" | "color" | "date" | "email" | "
 export type Sanitizer = (str: string) => string;
 /** Options for `StringSchema` */
 export type StringSchemaOptions = SchemaOptions & {
-    readonly value?: string;
-    readonly type?: HtmlInputType;
-    readonly min?: number;
-    readonly max?: number | null;
-    readonly match?: RegExp | null;
-    readonly sanitizer?: Sanitizer | null;
-    readonly multiline?: boolean;
+    readonly value?: string | undefined;
+    readonly type?: HtmlInputType | undefined;
+    readonly min?: number | undefined;
+    readonly max?: number | undefined;
+    readonly match?: RegExp | undefined;
+    readonly sanitizer?: Sanitizer | undefined;
+    readonly multiline?: boolean | undefined;
 };
 /**
  * Schema that defines a valid string.
@@ -37,9 +37,9 @@ export declare class StringSchema extends Schema<string> {
     readonly value: string;
     readonly type: HtmlInputType;
     readonly min: number;
-    readonly max: number | null;
-    readonly match: RegExp | null;
-    readonly sanitizer: Sanitizer | null;
+    readonly max: number;
+    readonly match: RegExp | undefined;
+    readonly sanitizer: Sanitizer | undefined;
     readonly multiline: boolean;
     constructor({ value, type, min, max, match, sanitizer, multiline, ...rest }: StringSchemaOptions);
     validate(unsafeValue?: unknown): string;

package/schema/StringSchema.js

@@ -22,7 +22,7 @@ import { Schema } from "./Schema.js";
  *  schema.validate('j'); // Throws 'Minimum 3 chaacters'
  */
 export class StringSchema extends Schema {
-    constructor({ value = "", type = "text", min = 0, max = null, match = null, sanitizer = null, multiline = false, ...rest }) {
+    constructor({ value = "", type = "text", min = 0, max = Infinity, match, sanitizer, multiline = false, ...rest }) {
         super(rest);
         this.type = type;
         this.value = value;
@@ -39,7 +39,7 @@ export class StringSchema extends Schema {
         const safeString = this.sanitize(unsafeString);
         if (safeString.length < this.min)
             throw new InvalidFeedback(safeString ? `Minimum ${this.min} characters` : "Required", { value: safeString });
-        if (this.max && safeString.length > this.max)
+        if (safeString.length > this.max)
             throw new InvalidFeedback(`Maximum ${this.max} characters`, { value: safeString });
         if (this.match && !this.match.test(safeString))
             throw new InvalidFeedback(safeString ? "Invalid format" : "Required", { value: safeString });

package/schema/TimeSchema.d.ts

@@ -1,11 +1,11 @@
-import { PossibleTime, Time } from "../util/time.js";
+import { PossibleTime, Time, PossibleOptionalTime } from "../util/time.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `TimeSchama` */
 export type TimeSchemaOptions = SchemaOptions & {
-    readonly value?: PossibleTime;
-    readonly min?: PossibleTime | null;
-    readonly max?: PossibleTime | null;
-    readonly step?: number | null;
+    readonly value?: PossibleTime | undefined;
+    readonly min?: PossibleOptionalTime | undefined;
+    readonly max?: PossibleOptionalTime | undefined;
+    readonly step?: number | null | undefined;
 };
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
 export declare class TimeSchema extends Schema<string> {

package/schema/TimeSchema.js

@@ -1,6 +1,6 @@
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { roundStep } from "../util/number.js";
-import { getOptionalTime, Time, getTime } from "../util/time.js";
+import { getOptionalTime, Time } from "../util/time.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
@@ -8,8 +8,8 @@ export class TimeSchema extends Schema {
     constructor({ value = "now", min = null, max = null, step = 60, ...options }) {
         super(options);
         this.value = value;
-        this.min = min !== null ? getTime(min) : null;
-        this.max = max !== null ? getTime(max) : null;
+        this.min = getOptionalTime(min);
+        this.max = getOptionalTime(max);
         this.step = step;
     }
     validate(unsafeValue = this.value) {

package/util/data.d.ts

@@ -17,6 +17,8 @@ export type Datas = {
 };
 /** Is an unknown value a data object? */
 export declare const isData: <T extends Data>(value: unknown) => value is T;
+/** Assert that an unknown value is a data object. */
+export declare function assertData<T extends Data>(value: T | unknown): asserts value is T;
 /** Is an unknown value the key for an own prop of a data object. */
 export declare const isDataKey: <T extends Data>(obj: T, key: unknown) => key is DataKey<T>;
 /** Get the data of a result (returns data or throws `RequiredError` if value is `null` or `undefined`). */

package/util/data.js

@@ -1,7 +1,13 @@
+import { AssertionError } from "../error/AssertionError.js";
 import { RequiredError } from "../error/RequiredError.js";
 import { isPlainObject } from "./object.js";
 /** Is an unknown value a data object? */
 export const isData = (value) => isPlainObject(value);
+/** Assert that an unknown value is a data object. */
+export function assertData(value) {
+    if (!isPlainObject(value))
+        throw new AssertionError("Must be data", value);
+}
 /** Is an unknown value the key for an own prop of a data object. */
 export const isDataKey = (obj, key) => typeof key === "string" && Object.prototype.hasOwnProperty.call(obj, key);
 /** Get the data of a result (returns data or throws `RequiredError` if value is `null` or `undefined`). */

package/util/object.d.ts

@@ -16,7 +16,7 @@ export type ObjectValue<T extends ImmutableObject = ImmutableObject> = T[keyof T
 /** Is an unknown value an unknown object? */
 export declare const isObject: <T extends ImmutableObject<PropertyKey, unknown>>(value: unknown) => value is T;
 /** Assert that a value is an object */
-export declare function assertObject(value: ImmutableObject | unknown): asserts value is ImmutableObject;
+export declare function assertObject<T extends ImmutableObject>(value: T | unknown): asserts value is T;
 /** is an unknown value an unknown plain object? */
 export declare function isPlainObject(value: ImmutableObject | unknown): value is ImmutableObject;
 /** Assert that a value is an object */