shelving 1.20.2 → 1.20.3

package/package.json

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

package/react/useDocument.d.ts

@@ -30,5 +30,5 @@ export declare function useAsyncDocument<T extends Data>(ref: DataDocument<T> |
  * @trhows `Error` if a `CacheProvider` is not part of the database's provider chain.
  * @throws `Error` if there was a problem retrieving the result.
  */
-export declare function useResult<T extends Data>(ref: DataDocument<T>, maxAge?: number | true): Result<T>;
-export declare function useResult<T extends Data>(ref: DataDocument<T> | undefined, maxAge?: number | true): Result<T> | undefined;
+export declare function useDocument<T extends Data>(ref: DataDocument<T>, maxAge?: number | true): Result<T>;
+export declare function useDocument<T extends Data>(ref: DataDocument<T> | undefined, maxAge?: number | true): Result<T> | undefined;

package/react/useDocument.js

@@ -54,6 +54,6 @@ function subscribeEffect(ref, maxAge, next, error) {
         return stopCache;
     }
 }
-export function useResult(ref, maxAge) {
+export function useDocument(ref, maxAge) {
     return throwAsync(useAsyncDocument(ref, maxAge));
 }

package/schema/ColorSchema.d.ts

@@ -9,13 +9,14 @@ import { StringSchema } 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 {
-    readonly max = 7;
     readonly type = "color";
+    readonly min = 1;
+    readonly max = 7;
     readonly multiline = false;
     readonly match: RegExp;
     sanitize(uncleanString: string): string;
 }
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */
-export declare const REQUIRED_COLOR: ColorSchema;
+export declare const COLOR: ColorSchema;
 /** Valid color hex string, e.g. `#00CCFF`, or `null` */
-export declare const OPTIONAL_COLOR: import("./NullableSchema.js").NullableSchema<string>;
+export declare const OPTIONAL_COLOR: import("./OptionalSchema.js").OptionalSchema<string>;

package/schema/ColorSchema.js

@@ -1,4 +1,4 @@
-import { NULLABLE } from "./NullableSchema.js";
+import { OPTIONAL } from "./OptionalSchema.js";
 import { StringSchema } from "./StringSchema.js";
 const R_MATCH = /^#[0-9A-F]{6}$/;
 const R_STRIP = /[^0-9A-F]/g;
@@ -14,8 +14,9 @@ const R_STRIP = /[^0-9A-F]/g;
 export class ColorSchema extends StringSchema {
     constructor() {
         super(...arguments);
-        this.max = 7;
         this.type = "color";
+        this.min = 1;
+        this.max = 7;
         this.multiline = false;
         this.match = R_MATCH;
     }
@@ -25,6 +26,6 @@ export class ColorSchema extends StringSchema {
     }
 }
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */
-export const REQUIRED_COLOR = new ColorSchema({});
+export const COLOR = new ColorSchema({});
 /** Valid color hex string, e.g. `#00CCFF`, or `null` */
-export const OPTIONAL_COLOR = NULLABLE(REQUIRED_COLOR);
+export const OPTIONAL_COLOR = OPTIONAL(COLOR);

package/schema/DataSchema.d.ts

@@ -1,6 +1,6 @@
 import { Validators, Data } from "../util/index.js";
 import { Schema } from "./Schema.js";
-import { NullableSchema } from "./NullableSchema.js";
+import { OptionalSchema } from "./OptionalSchema.js";
 /** Validate a data object. */
 export declare class DataSchema<T extends Data> extends Schema<T> {
     readonly props: Validators<T>;
@@ -14,4 +14,4 @@ export declare class DataSchema<T extends Data> extends Schema<T> {
 /** Valid data object with specifed properties. */
 export declare const DATA: <T extends Data>(props: Validators<T>) => DataSchema<T>;
 /** Valid data object with specifed properties, or `null` */
-export declare const OPTIONAL_DATA: <T extends Data>(props: Validators<T>) => NullableSchema<T>;
+export declare const OPTIONAL_DATA: <T extends Data>(props: Validators<T>) => OptionalSchema<T>;

package/schema/DataSchema.js

@@ -1,7 +1,7 @@
 import { isObject, validateData } from "../util/index.js";
 import { InvalidFeedback } from "../feedback/index.js";
 import { Schema } from "./Schema.js";
-import { NULLABLE } from "./NullableSchema.js";
+import { OPTIONAL } from "./OptionalSchema.js";
 /** Validate a data object. */
 export class DataSchema extends Schema {
     constructor({ value = {}, props, ...options }) {
@@ -18,4 +18,4 @@ export class DataSchema extends Schema {
 /** Valid data object with specifed properties. */
 export const DATA = (props) => new DataSchema({ props });
 /** Valid data object with specifed properties, or `null` */
-export const OPTIONAL_DATA = (props) => NULLABLE(new DataSchema({ props }));
+export const OPTIONAL_DATA = (props) => OPTIONAL(new DataSchema({ props }));

package/schema/DateSchema.d.ts

@@ -13,6 +13,6 @@ export declare class DateSchema extends Schema<string> {
     validate(unsafeValue?: unknown): string;
 }
 /** Valid date, e.g. `2005-09-12` (required because falsy values are invalid). */
-export declare const REQUIRED_DATE: DateSchema;
+export declare const DATE: DateSchema;
 /** Valid date, e.g. `2005-09-12`, or `null` */
-export declare const OPTIONAL_DATE: import("./NullableSchema.js").NullableSchema<string>;
+export declare const OPTIONAL_DATE: import("./OptionalSchema.js").OptionalSchema<string>;

package/schema/DateSchema.js

@@ -1,7 +1,7 @@
 import { toDate, getYmd } from "../util/index.js";
 import { InvalidFeedback } from "../feedback/index.js";
 import { Schema } from "./Schema.js";
-import { NULLABLE } from "./NullableSchema.js";
+import { OPTIONAL } from "./OptionalSchema.js";
 /** Define a valid date, e.g. `2005-09-12` */
 export class DateSchema extends Schema {
     constructor({ value = "now", min = null, max = null, ...options }) {
@@ -24,6 +24,6 @@ export class DateSchema extends Schema {
     }
 }
 /** Valid date, e.g. `2005-09-12` (required because falsy values are invalid). */
-export const REQUIRED_DATE = new DateSchema({});
+export const DATE = new DateSchema({});
 /** Valid date, e.g. `2005-09-12`, or `null` */
-export const OPTIONAL_DATE = NULLABLE(REQUIRED_DATE);
+export const OPTIONAL_DATE = OPTIONAL(DATE);

package/schema/EmailSchema.d.ts

@@ -18,12 +18,13 @@ import { StringSchema } from "./StringSchema.js";
  */
 export declare class EmailSchema extends StringSchema {
     readonly type = "email";
+    readonly min = 1;
     readonly max = 254;
     readonly match: RegExp;
     readonly multiline = false;
     sanitize(uncleanString: string): string;
 }
-/** Valid email, e.g. `test@test.com` (required because empty string is invalid). */
-export declare const REQUIRED_EMAIL: EmailSchema;
+/** Valid email, e.g. `test@test.com` */
+export declare const EMAIL: EmailSchema;
 /** Valid email, e.g. `test@test.com`, or `null` */
-export declare const OPTIONAL_EMAIL: import("./NullableSchema.js").NullableSchema<string>;
+export declare const OPTIONAL_EMAIL: import("./OptionalSchema.js").OptionalSchema<string>;

package/schema/EmailSchema.js

@@ -1,4 +1,4 @@
-import { NULLABLE } from "./NullableSchema.js";
+import { OPTIONAL } from "./OptionalSchema.js";
 import { StringSchema } from "./StringSchema.js";
 const R_MATCH = /^[a-z0-9](?:[a-zA-Z0-9._+-]{0,62}[a-zA-Z0-9])?@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.){1,3}(?:[a-z]{2,63}|xn--[a-z0-9-]{0,58}[a-z0-9])$/;
 /**
@@ -22,6 +22,7 @@ export class EmailSchema extends StringSchema {
     constructor() {
         super(...arguments);
         this.type = "email";
+        this.min = 1;
         this.max = 254;
         this.match = R_MATCH;
         this.multiline = false;
@@ -31,7 +32,7 @@ export class EmailSchema extends StringSchema {
         return typeof cleanString === "string" ? cleanString.toLowerCase() : cleanString;
     }
 }
-/** Valid email, e.g. `test@test.com` (required because empty string is invalid). */
-export const REQUIRED_EMAIL = new EmailSchema({});
+/** Valid email, e.g. `test@test.com` */
+export const EMAIL = new EmailSchema({});
 /** Valid email, e.g. `test@test.com`, or `null` */
-export const OPTIONAL_EMAIL = NULLABLE(REQUIRED_EMAIL);
+export const OPTIONAL_EMAIL = OPTIONAL(EMAIL);

package/schema/KeySchema.d.ts

@@ -11,6 +11,6 @@ export declare class KeySchema extends StringSchema {
     readonly max = 64;
 }
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */
-export declare const REQUIRED_KEY: KeySchema;
+export declare const KEY: KeySchema;
 /** Valid color hex string, e.g. `#00CCFF`, or `null` */
-export declare const OPTIONAL_KEY: import("./NullableSchema.js").NullableSchema<string>;
+export declare const OPTIONAL_KEY: import("./OptionalSchema.js").OptionalSchema<string>;

package/schema/KeySchema.js

@@ -1,5 +1,5 @@
 import { StringSchema } from "./StringSchema.js";
-import { NULLABLE } from "./NullableSchema.js";
+import { OPTIONAL } from "./OptionalSchema.js";
 /**
  * Define a valid database key.
  *
@@ -15,6 +15,6 @@ export class KeySchema extends StringSchema {
     }
 }
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */
-export const REQUIRED_KEY = new KeySchema({});
+export const KEY = new KeySchema({});
 /** Valid color hex string, e.g. `#00CCFF`, or `null` */
-export const OPTIONAL_KEY = NULLABLE(REQUIRED_KEY);
+export const OPTIONAL_KEY = OPTIONAL(KEY);

package/schema/{UrlSchema.d.ts → LinkSchema.d.ts}

@@ -5,8 +5,9 @@ import { StringSchema } from "./StringSchema.js";
  * - URLs are limited to 512 characters, but generally these won't be data: URIs so this is a reasonable limit.
  * - Falsy values are converted to `""` empty string.
  */
-export declare class UrlSchema extends StringSchema {
+export declare class LinkSchema extends StringSchema {
     readonly type = "url";
+    readonly min = 1;
     readonly max = 512;
     readonly schemes: string[];
     readonly hosts: string[] | null;
@@ -16,7 +17,7 @@ export declare class UrlSchema extends StringSchema {
     });
     validate(unsafeValue: unknown): string;
 }
-/** Valid URL, e.g. `#00CCFF` (required because empty string won't validate). */
-export declare const REQUIRED_URL: UrlSchema;
-/** Valid URL, e.g. `#00CCFF`, or `null` */
-export declare const OPTIONAL_URL: import("./NullableSchema.js").NullableSchema<string>;
+/** Valid link, e.g. `https://www.google.com` */
+export declare const LINK: LinkSchema;
+/** Valid link, e.g. `https://www.google.com`, or `null` */
+export declare const OPTIONAL_LINK: import("./OptionalSchema.js").OptionalSchema<string>;

package/schema/{UrlSchema.js → LinkSchema.js}

@@ -1,6 +1,6 @@
 import { InvalidFeedback } from "../feedback/index.js";
 import { toURL } from "../util/index.js";
-import { NULLABLE } from "./NullableSchema.js";
+import { OPTIONAL } from "./OptionalSchema.js";
 import { StringSchema } from "./StringSchema.js";
 /**
  * Type of `StringSchema` that defines a valid URL.
@@ -8,10 +8,11 @@ import { StringSchema } from "./StringSchema.js";
  * - URLs are limited to 512 characters, but generally these won't be data: URIs so this is a reasonable limit.
  * - Falsy values are converted to `""` empty string.
  */
-export class UrlSchema extends StringSchema {
+export class LinkSchema extends StringSchema {
     constructor({ schemes = ["http:", "https:"], hosts = null, ...rest }) {
         super(rest);
         this.type = "url";
+        this.min = 1;
         this.max = 512;
         this.schemes = ["http:", "https:"];
         this.hosts = null;
@@ -31,7 +32,7 @@ export class UrlSchema extends StringSchema {
         return url.href;
     }
 }
-/** Valid URL, e.g. `#00CCFF` (required because empty string won't validate). */
-export const REQUIRED_URL = new UrlSchema({});
-/** Valid URL, e.g. `#00CCFF`, or `null` */
-export const OPTIONAL_URL = NULLABLE(REQUIRED_URL);
+/** Valid link, e.g. `https://www.google.com` */
+export const LINK = new LinkSchema({});
+/** Valid link, e.g. `https://www.google.com`, or `null` */
+export const OPTIONAL_LINK = OPTIONAL(LINK);

package/schema/MapSchema.d.ts

@@ -2,7 +2,6 @@ import { ImmutableMap, Validator } from "../util/index.js";
 import { Schema } from "./Schema.js";
 /** Validate a `Map` instance. */
 export declare class MapSchema<T> extends Schema<ImmutableMap<T>> {
-    static from<X>(items: Validator<X>): MapSchema<X>;
     readonly value: ImmutableMap;
     readonly items: Validator<T>;
     readonly min: number | null;

package/schema/MapSchema.js

@@ -12,9 +12,6 @@ export class MapSchema extends Schema {
         this.min = min;
         this.max = max;
     }
-    static from(items) {
-        return new MapSchema({ items });
-    }
     validate(unsafeValue = this.value) {
         if (!isObject(unsafeValue))
             throw new InvalidFeedback("Must be map");

package/schema/NumberSchema.d.ts

@@ -16,4 +16,4 @@ export declare class NumberSchema extends Schema<number> {
 /** Valid number, e.g. `2048` or `0` zero. */
 export declare const NUMBER: NumberSchema;
 /** Valid number, e.g. `#2048` or `0` zero, or `null` */
-export declare const OPTIONAL_NUMBER: import("./NullableSchema.js").NullableSchema<number>;
+export declare const OPTIONAL_NUMBER: import("./OptionalSchema.js").OptionalSchema<number>;

package/schema/NumberSchema.js

@@ -1,7 +1,7 @@
 import { toNumber, roundNumber } from "../util/index.js";
 import { InvalidFeedback } from "../feedback/index.js";
 import { Schema } from "./Schema.js";
-import { NULLABLE } from "./NullableSchema.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 }) {
@@ -26,4 +26,4 @@ export class NumberSchema extends Schema {
 /** Valid number, e.g. `2048` or `0` zero. */
 export const NUMBER = new NumberSchema({});
 /** Valid number, e.g. `#2048` or `0` zero, or `null` */
-export const OPTIONAL_NUMBER = NULLABLE(NUMBER);
+export const OPTIONAL_NUMBER = OPTIONAL(NUMBER);

package/schema/{NullableSchema.d.ts → OptionalSchema.d.ts}

@@ -1,7 +1,7 @@
 import { Schema } from "./Schema.js";
 import { ThroughSchema } from "./ThroughSchema.js";
 /** Validate a value of a specific type or `null`. */
-export declare class NullableSchema<T> extends ThroughSchema<T | null> {
+export declare class OptionalSchema<T> extends ThroughSchema<T | null> {
     readonly value: T | null;
     constructor({ value, ...rest }: ConstructorParameters<typeof Schema>[0] & {
         source: Schema<T>;
@@ -9,5 +9,5 @@ export declare class NullableSchema<T> extends ThroughSchema<T | null> {
     });
     validate(unsafeValue?: unknown): T | null;
 }
-/** Create a new nullable schema from a source schema. */
-export declare const NULLABLE: <T>(source: Schema<T>) => NullableSchema<T>;
+/** Create a new optional schema from a source schema. */
+export declare const OPTIONAL: <T>(source: Schema<T>) => OptionalSchema<T>;

package/schema/{NullableSchema.js → OptionalSchema.js}

@@ -1,16 +1,16 @@
 import { ThroughSchema } from "./ThroughSchema.js";
 /** Validate a value of a specific type or `null`. */
-export class NullableSchema extends ThroughSchema {
+export class OptionalSchema extends ThroughSchema {
     constructor({ value = null, ...rest }) {
         super(rest);
         this.value = null;
         this.value = value;
     }
     validate(unsafeValue = this.value) {
-        if (unsafeValue === null)
+        if (unsafeValue === null || unsafeValue === undefined || unsafeValue === "" || Number.isNaN(unsafeValue))
             return null;
         return super.validate(unsafeValue);
     }
 }
-/** Create a new nullable schema from a source schema. */
-export const NULLABLE = (source) => new NullableSchema({ source });
+/** Create a new optional schema from a source schema. */
+export const OPTIONAL = (source) => new OptionalSchema({ source });

package/schema/PhoneSchema.d.ts

@@ -5,12 +5,13 @@ import { StringSchema } from "./StringSchema.js";
  * - Falsy values are converted to `""` empty string.
  */
 export declare class PhoneSchema extends StringSchema {
-    readonly type = "phone";
+    readonly type = "tel";
     readonly match: RegExp;
+    readonly min = 1;
     readonly max: number;
     sanitize(str: string): string;
 }
 /** Valid phone number, e.g. `+441234567890` */
-export declare const REQUIRED_PHONE: PhoneSchema;
+export declare const PHONE: PhoneSchema;
 /** Valid phone number, e.g. `+441234567890`, or `null` */
-export declare const OPTIONAL_PHONE: import("./NullableSchema.js").NullableSchema<string>;
+export declare const OPTIONAL_PHONE: import("./OptionalSchema.js").OptionalSchema<string>;

package/schema/PhoneSchema.js

@@ -1,5 +1,5 @@
 import { StringSchema } from "./StringSchema.js";
-import { NULLABLE } from "./NullableSchema.js";
+import { OPTIONAL } from "./OptionalSchema.js";
 // Valid phone number is max 16 digits made up of:
 // - Country code (`+` plus character and 1-3 digits, e.g. `+44` or `+1`).
 // - Subscriber number (5-12 digits — the Solomon Islands have five-digit phone numbers apparently).
@@ -12,8 +12,9 @@ const R_MATCH = /^\+[1-9][0-9]{0,2}[0-9]{5,12}$/;
 export class PhoneSchema extends StringSchema {
     constructor() {
         super(...arguments);
-        this.type = "phone";
+        this.type = "tel";
         this.match = R_MATCH;
+        this.min = 1;
         this.max = 16; // Valid phone number is 16 digits or fewer (15 numerals with a leading `+` plus).
     }
     sanitize(str) {
@@ -24,6 +25,6 @@ export class PhoneSchema extends StringSchema {
     }
 }
 /** Valid phone number, e.g. `+441234567890` */
-export const REQUIRED_PHONE = new PhoneSchema({});
+export const PHONE = new PhoneSchema({});
 /** Valid phone number, e.g. `+441234567890`, or `null` */
-export const OPTIONAL_PHONE = NULLABLE(REQUIRED_PHONE);
+export const OPTIONAL_PHONE = OPTIONAL(PHONE);

package/schema/StringSchema.d.ts

@@ -1,4 +1,6 @@
 import { Schema } from "./Schema.js";
+/** `type=""` prop for HTML `<input />` tags that are relevant for strings. */
+export declare type HtmlInputType = "text" | "password" | "color" | "date" | "email" | "number" | "tel" | "search" | "url";
 /**
  * Schema that defines a valid string.
  *
@@ -21,7 +23,7 @@ import { Schema } from "./Schema.js";
  */
 export declare class StringSchema extends Schema<string> {
     readonly value: string;
-    readonly type: string;
+    readonly type: HtmlInputType;
     readonly min: number;
     readonly max: number | null;
     readonly match: RegExp | null;
@@ -29,7 +31,7 @@ export declare class StringSchema extends Schema<string> {
     readonly trim: boolean;
     constructor({ value, type, min, max, match, multiline, trim, ...rest }: ConstructorParameters<typeof Schema>[0] & {
         readonly value?: string;
-        readonly type?: string;
+        readonly type?: HtmlInputType;
         readonly min?: number;
         readonly max?: number | null;
         readonly match?: RegExp | null;

package/schema/ThroughSchema.d.ts

@@ -2,7 +2,7 @@ import type { Class } from "../util/index.js";
 import { Schema } from "./Schema.js";
 export declare abstract class ThroughSchema<T> extends Schema<T> {
     readonly source: Schema<T>;
-    constructor({ source, ...options }: ConstructorParameters<typeof Schema>[0] & {
+    constructor({ source, title, description, placeholder, }: ConstructorParameters<typeof Schema>[0] & {
         source: Schema<T>;
     });
     validate(unsafeValue: unknown): T;

package/schema/ThroughSchema.js

@@ -1,8 +1,8 @@
 import { AssertionError } from "../error/index.js";
 import { Schema } from "./Schema.js";
 export class ThroughSchema extends Schema {
-    constructor({ source, ...options }) {
-        super(options);
+    constructor({ source, title = source.title, description = source.description, placeholder = source.placeholder, }) {
+        super({ title, description, placeholder });
         this.source = source;
     }
     validate(unsafeValue) {

package/schema/index.d.ts

@@ -8,11 +8,11 @@ export * from "./DateSchema.js";
 export * from "./EmailSchema.js";
 export * from "./KeySchema.js";
 export * from "./MapSchema.js";
-export * from "./NullableSchema.js";
+export * from "./OptionalSchema.js";
 export * from "./NumberSchema.js";
 export * from "./ObjectSchema.js";
 export * from "./PhoneSchema.js";
 export * from "./RequiredSchema.js";
 export * from "./StringSchema.js";
 export * from "./ThroughSchema.js";
-export * from "./UrlSchema.js";
+export * from "./LinkSchema.js";

package/schema/index.js

@@ -8,11 +8,11 @@ export * from "./DateSchema.js";
 export * from "./EmailSchema.js";
 export * from "./KeySchema.js";
 export * from "./MapSchema.js";
-export * from "./NullableSchema.js";
+export * from "./OptionalSchema.js";
 export * from "./NumberSchema.js";
 export * from "./ObjectSchema.js";
 export * from "./PhoneSchema.js";
 export * from "./RequiredSchema.js";
 export * from "./StringSchema.js";
 export * from "./ThroughSchema.js";
-export * from "./UrlSchema.js";
+export * from "./LinkSchema.js";

package/util/entry.d.ts

@@ -1,3 +1,4 @@
+import type { ImmutableArray, MutableArray } from "./array.js";
 import type { PossibleOptionalDate } from "./date.js";
 /**
  * Single entry from a map-like object.
@@ -9,6 +10,10 @@ export declare type Entry<T = unknown> = readonly [string, T];
 export declare type AnyEntry = readonly [string, any];
 /** Extract the type for an entry. */
 export declare type EntryType<X extends AnyEntry> = X extends Entry<infer Y> ? Y : never;
+/** Readonly list of entries with string keys. */
+export declare type ImmutableEntries<T = unknown> = ImmutableArray<Entry<T>>;
+/** Writable object with string keys. */
+export declare type MutableEntries<T = unknown> = MutableArray<Entry<T>>;
 /** Extract the key from an object entry. */
 export declare const ENTRY_KEY: ([k]: Entry<unknown>) => string;
 /** Extract the value from an object entry. */