shelving 1.151.0 → 1.152.0

package/package.json

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

package/schema/ColorSchema.d.ts

@@ -1,4 +1,4 @@
-import { TextSchema, type TextSchemaOptions } from "./TextSchema.js";
+import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
 /**
  * Define a valid color hex string, e.g `#00CCFF`
  *
@@ -8,8 +8,8 @@ import { TextSchema, type TextSchemaOptions } from "./TextSchema.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 TextSchema {
-    constructor({ title, value, ...options }: Omit<TextSchemaOptions, "type" | "min" | "max" | "multiline" | "match">);
+export declare class ColorSchema extends StringSchema {
+    constructor({ title, value, ...options }: Omit<StringSchemaOptions, "type" | "min" | "max" | "multiline" | "match">);
     sanitize(insaneString: string): string;
 }
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */

package/schema/ColorSchema.js

@@ -1,5 +1,5 @@
 import { NULLABLE } from "./NullableSchema.js";
-import { TextSchema } from "./TextSchema.js";
+import { StringSchema } from "./StringSchema.js";
 const COLOR_REGEXP = /^#[0-9A-F]{6}$/;
 const NOT_HEX_REGEXP = /[^0-9A-F]/g;
 /**
@@ -11,16 +11,15 @@ const NOT_HEX_REGEXP = /[^0-9A-F]/g;
  *
  * 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 class ColorSchema extends TextSchema {
+export class ColorSchema extends StringSchema {
     constructor({ title = "Color", value = "#000000", ...options }) {
         super({
             title,
             value,
             ...options,
-            type: "color",
+            input: "color",
             min: 1,
             max: 7,
-            multiline: false,
             match: COLOR_REGEXP,
         });
     }

package/schema/EmailSchema.d.ts

@@ -1,5 +1,5 @@
 import type { StringSchemaOptions } from "./StringSchema.js";
-import { TextSchema } from "./TextSchema.js";
+import { StringSchema } from "./StringSchema.js";
 /**
  * Define a valid email address.
  *
@@ -17,7 +17,7 @@ import { TextSchema } from "./TextSchema.js";
  *     - Up to 10 segments of up to 63 characters each, separated by `.`
  *     - TLD is a segment of 2-63 characters, possibly in `xn--` international format.
  */
-export declare class EmailSchema extends TextSchema {
+export declare class EmailSchema extends StringSchema {
     constructor({ title, ...options }: Omit<StringSchemaOptions, "type" | "min" | "max" | "match" | "multiline">);
     sanitize(str: string): string;
 }

package/schema/EmailSchema.js

@@ -1,5 +1,5 @@
 import { NULLABLE } from "./NullableSchema.js";
-import { TextSchema } from "./TextSchema.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])$/;
 /**
  * Define a valid email address.
@@ -18,16 +18,15 @@ const R_MATCH = /^[a-z0-9](?:[a-zA-Z0-9._+-]{0,62}[a-zA-Z0-9])?@(?:[a-z0-9](?:[a
  *     - Up to 10 segments of up to 63 characters each, separated by `.`
  *     - TLD is a segment of 2-63 characters, possibly in `xn--` international format.
  */
-export class EmailSchema extends TextSchema {
+export class EmailSchema extends StringSchema {
     constructor({ title = "Email", ...options }) {
         super({
             title,
             ...options,
-            type: "email",
+            input: "email",
             min: 1,
             max: 254,
             match: R_MATCH,
-            multiline: false,
         });
     }
     sanitize(str) {

package/schema/LinkSchema.d.ts

@@ -1,7 +1,7 @@
 import type { ImmutableArray } from "../util/array.js";
 import { type AbsoluteLink } from "../util/link.js";
 import type { StringSchemaOptions } from "./StringSchema.js";
-import { TextSchema } from "./TextSchema.js";
+import { StringSchema } from "./StringSchema.js";
 /** Allowed options for `LinkSchema` */
 export interface LinkSchemaOptions extends Omit<StringSchemaOptions, "type" | "min" | "max" | "multiline"> {
     readonly base?: AbsoluteLink | undefined;
@@ -14,7 +14,7 @@ export interface LinkSchemaOptions extends Omit<StringSchemaOptions, "type" | "m
  * - 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 LinkSchema extends TextSchema {
+export declare class LinkSchema extends StringSchema {
     readonly base: AbsoluteLink | undefined;
     readonly schemes: ImmutableArray<string> | undefined;
     readonly hosts: ImmutableArray<string> | undefined;

package/schema/LinkSchema.js

@@ -1,14 +1,14 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { getLinkURL } from "../util/link.js";
 import { NULLABLE } from "./NullableSchema.js";
-import { TextSchema } from "./TextSchema.js";
+import { StringSchema } from "./StringSchema.js";
 /**
  * Type of `StringSchema` that defines a valid URL link.
  * - Checks URL scheme against a whitelist (always), and checks URL domain against a whitelist (optional).
  * - 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 LinkSchema extends TextSchema {
+export class LinkSchema extends StringSchema {
     base;
     schemes;
     hosts;
@@ -16,7 +16,7 @@ export class LinkSchema extends TextSchema {
         super({
             title,
             ...options,
-            type: "url",
+            input: "url",
             min: 1,
             max: 512,
             multiline: false,

package/schema/PhoneSchema.d.ts

@@ -1,11 +1,11 @@
 import type { StringSchemaOptions } from "./StringSchema.js";
-import { TextSchema } from "./TextSchema.js";
+import { StringSchema } from "./StringSchema.js";
 /**
  * Type of `StringSchema` that defines a valid phone number.
  * - Multiple string formats are automatically converted to E.164 format (starting with `+` plus).
  * - Falsy values are converted to `""` empty string.
  */
-export declare class PhoneSchema extends TextSchema {
+export declare class PhoneSchema extends StringSchema {
     constructor({ title, ...options }: StringSchemaOptions);
     sanitize(insaneString: string): string;
 }

package/schema/PhoneSchema.js

@@ -1,5 +1,5 @@
 import { NULLABLE } from "./NullableSchema.js";
-import { TextSchema } from "./TextSchema.js";
+import { StringSchema } from "./StringSchema.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).
@@ -9,16 +9,15 @@ const PHONE_REGEXP = /^\+[1-9][0-9]{0,2}[0-9]{5,12}$/;
  * - Multiple string formats are automatically converted to E.164 format (starting with `+` plus).
  * - Falsy values are converted to `""` empty string.
  */
-export class PhoneSchema extends TextSchema {
+export class PhoneSchema extends StringSchema {
     constructor({ title = "Phone", ...options }) {
         super({
             title,
             ...options,
-            type: "tel",
+            input: "tel",
             min: 1,
             max: 16, // Valid phone number is 16 digits or fewer (15 numerals with a leading `+` plus).
             match: PHONE_REGEXP,
-            multiline: false,
         });
     }
     sanitize(insaneString) {

package/schema/SlugSchema.js

@@ -12,7 +12,7 @@ export class SlugSchema extends StringSchema {
     constructor(options) {
         super({
             ...options,
-            min: 2,
+            min: 1,
             max: 32,
         });
     }

package/schema/StringSchema.d.ts

@@ -1,12 +1,16 @@
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
-/** Function that sanitizes a string. */
-export type Sanitizer = (str: string) => string;
+/** `type=""` prop for HTML `<input />` tags that are relevant for strings. */
+export type HTMLInputType = "text" | "password" | "color" | "date" | "email" | "number" | "tel" | "search" | "url";
 /** Options for `StringSchema` */
 export interface StringSchemaOptions extends SchemaOptions {
     readonly value?: string | undefined;
     readonly min?: number | undefined;
     readonly max?: number | undefined;
+    readonly multiline?: boolean | undefined;
+    readonly match?: RegExp | undefined;
+    readonly case?: "upper" | "lower" | undefined;
+    readonly input?: HTMLInputType | undefined;
 }
 /**
  * Schema that defines a valid string.
@@ -25,9 +29,13 @@ export interface StringSchemaOptions extends SchemaOptions {
  */
 export declare class StringSchema extends Schema<string> {
     readonly value: string;
+    readonly input: HTMLInputType;
     readonly min: number;
     readonly max: number;
-    constructor({ min, max, value, ...options }: StringSchemaOptions);
+    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;
     /** Sanitize the string by removing unwanted characters. */
     sanitize(str: string): string;
@@ -35,4 +43,17 @@ export declare class StringSchema extends Schema<string> {
 /** Valid string, e.g. `Hello there!` */
 export declare const STRING: StringSchema;
 /** Valid string, `Hello there!`, with more than one character. */
-export declare const REQUIRED_STRING: StringSchema;
+export declare const REQUIRED_STRING: StringSchema; /** Valid text, e.g. `Hello there!` */
+export declare const TEXT: StringSchema;
+/** Valid text, `Hello there!`, with more than one character. */
+export declare const REQUIRED_TEXT: StringSchema;
+/** Title string, e.g. `Title of something` */
+export declare const TITLE: StringSchema;
+/** Optional name string, e.g. `Title of something` or `null` */
+export declare const NULLABLE_TITLE: import("./NullableSchema.js").NullableSchema<string>;
+/** Name string, e.g. `Name of Something` */
+export declare const NAME: StringSchema;
+/** Optional name string, e.g. `Name of Something` or `null` */
+export declare const NULLABLE_NAME: import("./NullableSchema.js").NullableSchema<string>;
+/** Password string. */
+export declare const PASSWORD: StringSchema;

package/schema/StringSchema.js

@@ -1,4 +1,6 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
+import { sanitizeMultilineText, sanitizeText } from "../util/string.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { Schema } from "./Schema.js";
 /**
  * Schema that defines a valid string.
@@ -16,12 +18,20 @@ import { Schema } from "./Schema.js";
  *  schema.validate('j'); // Throws 'Minimum 3 chaacters'
  */
 export class StringSchema extends Schema {
+    input;
     min;
     max;
-    constructor({ min = 0, max = Number.POSITIVE_INFINITY, value = "", ...options }) {
+    multiline;
+    match;
+    case;
+    constructor({ min = 0, max = Number.POSITIVE_INFINITY, value = "", multiline = false, match, case: _case, input = "text", ...options }) {
         super({ value, ...options });
         this.min = min;
         this.max = max;
+        this.multiline = multiline;
+        this.match = match;
+        this.case = _case;
+        this.input = input;
     }
     validate(unsafeValue = this.value) {
         const possibleString = typeof unsafeValue === "number" ? unsafeValue.toString() : unsafeValue;
@@ -32,14 +42,34 @@ export class StringSchema extends Schema {
             throw new ValueFeedback(possibleString.length ? `Minimum ${this.min} characters` : "Required", saneString);
         if (saneString.length > this.max)
             throw new ValueFeedback(`Maximum ${this.max} characters`, saneString);
+        if (this.match && !this.match.test(saneString))
+            throw new ValueFeedback(saneString ? "Invalid format" : "Required", saneString);
         return saneString;
     }
     /** Sanitize the string by removing unwanted characters. */
     sanitize(str) {
-        return str;
+        const sane = this.multiline ? sanitizeMultilineText(str) : sanitizeText(str);
+        if (this.case === "upper")
+            return sane.toUpperCase();
+        if (this.case === "lower")
+            return sane.toLowerCase();
+        return sane;
     }
 }
 /** Valid string, e.g. `Hello there!` */
 export const STRING = new StringSchema({});
 /** Valid string, `Hello there!`, with more than one character. */
-export const REQUIRED_STRING = new StringSchema({ min: 1 });
+export const REQUIRED_STRING = new StringSchema({ min: 1 }); /** Valid text, e.g. `Hello there!` */
+export const TEXT = new StringSchema({ title: "Text" });
+/** Valid text, `Hello there!`, with more than one character. */
+export const REQUIRED_TEXT = new StringSchema({ min: 1 });
+/** Title string, e.g. `Title of something` */
+export const TITLE = new StringSchema({ title: "Title", min: 1, max: 100 });
+/** Optional name string, e.g. `Title of something` or `null` */
+export const NULLABLE_TITLE = NULLABLE(TITLE);
+/** Name string, e.g. `Name of Something` */
+export const NAME = new StringSchema({ title: "Name", min: 1, max: 100 });
+/** Optional name string, e.g. `Name of Something` or `null` */
+export const NULLABLE_NAME = NULLABLE(NAME);
+/** Password string. */
+export const PASSWORD = new StringSchema({ title: "Password", min: 6, input: "password" });

package/schema/index.d.ts

@@ -19,6 +19,5 @@ export * from "./NumberSchema.js";
 export * from "./PhoneSchema.js";
 export * from "./SlugSchema.js";
 export * from "./StringSchema.js";
-export * from "./TextSchema.js";
 export * from "./TimeSchema.js";
 export * from "./UUIDSchema.js";

package/schema/index.js

@@ -21,6 +21,5 @@ export * from "./NumberSchema.js";
 export * from "./PhoneSchema.js";
 export * from "./SlugSchema.js";
 export * from "./StringSchema.js";
-export * from "./TextSchema.js";
 export * from "./TimeSchema.js";
 export * from "./UUIDSchema.js";

package/schema/TextSchema.d.ts

@@ -1,40 +0,0 @@
-import { type Sanitizer, StringSchema, type StringSchemaOptions } from "./StringSchema.js";
-/** `type=""` prop for HTML `<input />` tags that are relevant for strings. */
-export type TextSchemaType = "text" | "password" | "color" | "date" | "email" | "number" | "tel" | "search" | "url";
-/** Options for `TextSchema` */
-export interface TextSchemaOptions extends StringSchemaOptions {
-    readonly type?: TextSchemaType | undefined;
-    readonly match?: RegExp | undefined;
-    readonly multiline?: boolean | undefined;
-}
-/**
- * Schema that defines a valid text string.
- *
- * Ensures value is string and optionally enforces min/max length, whether to trim whitespace, and regex match format.
- * Doesn't allow `null` to mean no value — empty string is the equivalent for StringSchema (because it means we'll never accidentally get `"null"` by converting the `null` to string).
- *
- * Defaults to a single line text string (newlines are stripped). Use `multiline=true` to allow newlines.
- */
-export declare class TextSchema extends StringSchema {
-    readonly type: TextSchemaType;
-    readonly match: RegExp | undefined;
-    readonly sanitizer: Sanitizer | undefined;
-    readonly multiline: boolean;
-    constructor({ type, match, multiline, ...options }: TextSchemaOptions);
-    validate(unsafeValue?: unknown): string;
-    sanitize(str: string): string;
-}
-/** Valid text, e.g. `Hello there!` */
-export declare const TEXT: TextSchema;
-/** Valid text, `Hello there!`, with more than one character. */
-export declare const REQUIRED_TEXT: TextSchema;
-/** Title string, e.g. `Title of something` */
-export declare const TITLE: TextSchema;
-/** Optional name string, e.g. `Title of something` or `null` */
-export declare const NULLABLE_TITLE: import("./NullableSchema.js").NullableSchema<string>;
-/** Name string, e.g. `Name of Something` */
-export declare const NAME: TextSchema;
-/** Optional name string, e.g. `Name of Something` or `null` */
-export declare const NULLABLE_NAME: import("./NullableSchema.js").NullableSchema<string>;
-/** Password string. */
-export declare const PASSWORD: TextSchema;

package/schema/TextSchema.js

@@ -1,47 +0,0 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
-import { sanitizeMultilineText, sanitizeText } from "../util/string.js";
-import { NULLABLE } from "./NullableSchema.js";
-import { StringSchema } from "./StringSchema.js";
-/**
- * Schema that defines a valid text string.
- *
- * Ensures value is string and optionally enforces min/max length, whether to trim whitespace, and regex match format.
- * Doesn't allow `null` to mean no value — empty string is the equivalent for StringSchema (because it means we'll never accidentally get `"null"` by converting the `null` to string).
- *
- * Defaults to a single line text string (newlines are stripped). Use `multiline=true` to allow newlines.
- */
-export class TextSchema extends StringSchema {
-    type;
-    match;
-    sanitizer;
-    multiline;
-    constructor({ type = "text", match, multiline = false, ...options }) {
-        super(options);
-        this.type = type;
-        this.match = match;
-        this.multiline = multiline;
-    }
-    validate(unsafeValue = this.value) {
-        const str = super.validate(unsafeValue);
-        if (this.match && !this.match.test(str))
-            throw new ValueFeedback(str ? "Invalid format" : "Required", str);
-        return str;
-    }
-    sanitize(str) {
-        return this.multiline ? sanitizeMultilineText(str) : sanitizeText(str);
-    }
-}
-/** Valid text, e.g. `Hello there!` */
-export const TEXT = new TextSchema({ title: "Text" });
-/** Valid text, `Hello there!`, with more than one character. */
-export const REQUIRED_TEXT = new TextSchema({ min: 1 });
-/** Title string, e.g. `Title of something` */
-export const TITLE = new TextSchema({ title: "Title", min: 1, max: 100 });
-/** Optional name string, e.g. `Title of something` or `null` */
-export const NULLABLE_TITLE = NULLABLE(TITLE);
-/** Name string, e.g. `Name of Something` */
-export const NAME = new TextSchema({ title: "Name", min: 1, max: 100 });
-/** Optional name string, e.g. `Name of Something` or `null` */
-export const NULLABLE_NAME = NULLABLE(NAME);
-/** Password string. */
-export const PASSWORD = new TextSchema({ title: "Password", min: 6, type: "password" });