shelving 1.131.0 → 1.133.0

package/api/Resource.js

@@ -1,6 +1,6 @@
 import { ValidationError } from "../error/ValidationError.js";
 import { Feedback } from "../feedback/Feedback.js";
-import { UNDEFINED_VALIDATOR } from "../util/validate.js";
+import { UNDEFINED } from "../util/validate.js";
 /**
  * An abstract API resource definition, used to specify types for e.g. serverless functions..
  *
@@ -15,7 +15,7 @@ export class Resource {
     payload;
     /** Result validator. */
     result;
-    constructor(name, payload = UNDEFINED_VALIDATOR, result = UNDEFINED_VALIDATOR) {
+    constructor(name, payload = UNDEFINED, result = UNDEFINED) {
         this.name = name;
         this.payload = payload;
         this.result = result;

package/db/ValidationProvider.d.ts

@@ -1,4 +1,4 @@
-import type { DataSchema, DatabaseSchemas } from "../schema/DataSchema.js";
+import type { DataSchema, DataSchemas } from "../schema/DataSchema.js";
 import type { DataKey, Database } from "../util/data.js";
 import type { ItemQuery, Items, OptionalItem } from "../util/item.js";
 import type { Sourceable } from "../util/source.js";
@@ -7,8 +7,8 @@ import type { AsyncProvider, Provider } from "./Provider.js";
 import { AsyncThroughProvider, ThroughProvider } from "./ThroughProvider.js";
 /** Validate a synchronous source provider (source can have any type because validation guarantees the type). */
 export declare class ValidationProvider<T extends Database> extends ThroughProvider<T> implements Provider<T>, Sourceable<Provider<T>> {
-    readonly schemas: DatabaseSchemas<T>;
-    constructor(schemas: DatabaseSchemas<T>, source: Provider<T>);
+    readonly schemas: DataSchemas<T>;
+    constructor(schemas: DataSchemas<T>, source: Provider<T>);
     /** Get a named schema. */
     getSchema<K extends DataKey<T>>(collection: K): DataSchema<T[K]>;
     getItem<K extends DataKey<T>>(collection: K, id: string): OptionalItem<T[K]>;
@@ -26,8 +26,9 @@ export declare class ValidationProvider<T extends Database> extends ThroughProvi
 }
 /** Validate an asynchronous source provider (source can have any type because validation guarantees the type). */
 export declare class AsyncValidationProvider<T extends Database> extends AsyncThroughProvider<T> implements AsyncProvider<T>, Sourceable<AsyncProvider<T>> {
-    readonly schemas: DatabaseSchemas<T>;
-    constructor(schemas: DatabaseSchemas<T>, source: AsyncProvider<T>);
+    readonly schemas: DataSchemas<T>;
+    constructor(schemas: DataSchemas<T>, source: AsyncProvider<T>);
+    /** Get a named data schema for this database. */
     getSchema<K extends DataKey<T>>(collection: K): DataSchema<T[K]>;
     getItem<K extends DataKey<T>>(collection: K, id: string): Promise<OptionalItem<T[K]>>;
     getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<OptionalItem<T[K]>>;

package/db/ValidationProvider.js

@@ -1,13 +1,9 @@
-import { ValidationError } from "../error/ValidationError.js";
+import { ValidationError as ConflictError } from "../error/ValidationError.js";
 import { Feedback } from "../feedback/Feedback.js";
+import { KEY } from "../schema/KeySchema.js";
 import { updateData } from "../util/update.js";
-import { validateWithContext } from "../util/validate.js";
+import { validateData } from "../util/validate.js";
 import { AsyncThroughProvider, ThroughProvider } from "./ThroughProvider.js";
-// Constants.
-const VALIDATION_CONTEXT_GET = { action: "get", id: true };
-const VALIDATION_CONTEXT_ADD = { action: "add" };
-const VALIDATION_CONTEXT_SET = { action: "set" };
-const VALIDATION_CONTEXT_UPDATE = { action: "update", partial: true };
 /** Validate a synchronous source provider (source can have any type because validation guarantees the type). */
 export class ValidationProvider extends ThroughProvider {
     schemas;
@@ -28,13 +24,13 @@ export class ValidationProvider extends ThroughProvider {
             yield _validateItem(collection, unsafeItem, schema);
     }
     addItem(collection, data) {
-        return super.addItem(collection, validateWithContext(data, this.getSchema(collection), VALIDATION_CONTEXT_ADD));
+        return super.addItem(collection, validateData(data, this.getSchema(collection).props));
     }
     setItem(collection, id, data) {
-        super.setItem(collection, id, validateWithContext(data, this.getSchema(collection), VALIDATION_CONTEXT_SET));
+        super.setItem(collection, id, validateData(data, this.getSchema(collection).props));
     }
     updateItem(collection, id, updates) {
-        validateWithContext(updateData({}, updates), this.getSchema(collection), VALIDATION_CONTEXT_UPDATE);
+        validateData(updateData({}, updates), this.getSchema(collection).props, true);
         super.updateItem(collection, id, updates);
     }
     deleteItem(collection, id) {
@@ -50,7 +46,7 @@ export class ValidationProvider extends ThroughProvider {
         super.setQuery(collection, query, this.getSchema(collection).validate(data));
     }
     updateQuery(collection, query, updates) {
-        validateWithContext(updateData({}, updates), this.getSchema(collection), VALIDATION_CONTEXT_UPDATE);
+        validateData(updateData({}, updates), this.getSchema(collection).props, true);
         super.updateQuery(collection, query, updates);
     }
     deleteQuery(collection, query) {
@@ -69,6 +65,7 @@ export class AsyncValidationProvider extends AsyncThroughProvider {
         super(source);
         this.schemas = schemas;
     }
+    /** Get a named data schema for this database. */
     getSchema(collection) {
         return this.schemas[collection];
     }
@@ -81,13 +78,13 @@ export class AsyncValidationProvider extends AsyncThroughProvider {
             yield _validateItem(collection, unsafeItem, schema);
     }
     addItem(collection, data) {
-        return super.addItem(collection, validateWithContext(data, this.getSchema(collection), VALIDATION_CONTEXT_ADD));
+        return super.addItem(collection, validateData(data, this.getSchema(collection).props));
     }
     setItem(collection, id, data) {
-        return super.setItem(collection, id, validateWithContext(data, this.getSchema(collection), VALIDATION_CONTEXT_SET));
+        return super.setItem(collection, id, validateData(data, this.getSchema(collection).props));
     }
     updateItem(collection, id, updates) {
-        validateWithContext(updateData({}, updates), this.getSchema(collection), VALIDATION_CONTEXT_UPDATE);
+        validateData(updateData({}, updates), this.getSchema(collection).props, true);
         return super.updateItem(collection, id, updates);
     }
     deleteItem(collection, id) {
@@ -105,46 +102,49 @@ export class AsyncValidationProvider extends AsyncThroughProvider {
             yield _validateItems(collection, unsafeItems, schema);
     }
     setQuery(collection, query, data) {
-        return super.setQuery(collection, query, validateWithContext(data, this.getSchema(collection), VALIDATION_CONTEXT_SET));
+        return super.setQuery(collection, query, validateData(data, this.getSchema(collection).props));
     }
     updateQuery(collection, query, updates) {
-        validateWithContext(updateData({}, updates), this.getSchema(collection), VALIDATION_CONTEXT_UPDATE);
+        validateData(updateData({}, updates), this.getSchema(collection).props, true);
         return super.updateQuery(collection, query, updates);
     }
     deleteQuery(collection, query) {
         return super.deleteQuery(collection, query);
     }
 }
-function _validateItem(collection, unsafeEntity, schema) {
-    if (!unsafeEntity)
+function _validateItem(collection, unsafeItem, schema) {
+    if (!unsafeItem)
         return undefined;
     try {
-        return validateWithContext(unsafeEntity, schema, VALIDATION_CONTEXT_GET);
+        return validateData(unsafeItem, { id: KEY, ...schema.props });
     }
     catch (thrown) {
         if (!(thrown instanceof Feedback))
             throw thrown;
-        throw new ValidationError(`Invalid data for "${collection}"`, thrown.message);
+        throw new ConflictError(`Invalid data for "${collection}"`, thrown.message);
     }
 }
-/** Validate a set of entities for this query reference. */
+/**
+ * Validate a set of entities for this query reference.
+ * @throws `ConflictError` if one or more items did not validate (conflict because the program is not in an expected state).
+ */
 function _validateItems(collection, unsafeEntities, schema) {
-    return Array.from(_yieldValidItems(collection, unsafeEntities, schema));
+    return Array.from(_yieldValidItems(collection, unsafeEntities, { id: KEY, ...schema.props }));
 }
-function* _yieldValidItems(collection, unsafeEntities, schema) {
+function* _yieldValidItems(collection, unsafeEntities, validators) {
     let invalid = false;
     const messages = {};
-    for (const unsafeEntity of unsafeEntities) {
+    for (const unsafeItem of unsafeEntities) {
         try {
-            yield validateWithContext(unsafeEntity, schema, VALIDATION_CONTEXT_GET);
+            yield validateData(unsafeItem, validators);
         }
         catch (thrown) {
             if (!(thrown instanceof Feedback))
                 throw thrown;
             invalid = true;
-            messages[unsafeEntity.id] = thrown.message;
+            messages[unsafeItem.id] = thrown.message;
         }
     }
     if (invalid)
-        throw new ValidationError(`Invalid data for "${collection}"`, messages);
+        throw new ConflictError(`Invalid data for "${collection}"`, messages);
 }

package/error/UnauthorizedError.d.ts

@@ -1,6 +1,6 @@
 import { EnhancedError } from "./EnhancedError.js";
 /** Thrown if an operation failed because the user is logged in but does not have sufficient privileges to access something. */
 export declare class UnauthorizedError extends EnhancedError {
-    readonly code = 403;
+    readonly code = 401;
     constructor(message?: string, context?: unknown);
 }

package/error/UnauthorizedError.js

@@ -1,7 +1,7 @@
 import { EnhancedError } from "./EnhancedError.js";
 /** Thrown if an operation failed because the user is logged in but does not have sufficient privileges to access something. */
 export class UnauthorizedError extends EnhancedError {
-    code = 403;
+    code = 401;
     constructor(message = "Unauthorized", context) {
         super(message, context);
     }

package/package.json

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

package/schema/ColorSchema.d.ts

@@ -1,5 +1,4 @@
-import type { StringSchemaOptions } from "./StringSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema, type TextSchemaOptions } from "./TextSchema.js";
 /**
  * Define a valid color hex string, e.g `#00CCFF`
  *
@@ -9,8 +8,8 @@ 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 {
-    constructor({ title, value, ...options }: Omit<StringSchemaOptions, "type" | "min" | "max" | "multiline" | "match">);
+export declare class ColorSchema extends TextSchema {
+    constructor({ title, value, ...options }: Omit<TextSchemaOptions, "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 { OPTIONAL } from "./OptionalSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.js";
 const COLOR_REGEXP = /^#[0-9A-F]{6}$/;
 const NOT_HEX_REGEXP = /[^0-9A-F]/g;
 /**
@@ -11,7 +11,7 @@ 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 StringSchema {
+export class ColorSchema extends TextSchema {
     constructor({ title = "Color", value = "#000000", ...options }) {
         super({
             title,

package/schema/DataSchema.d.ts

@@ -16,7 +16,7 @@ export declare class DataSchema<T extends Data> extends Schema<T> {
     validate(unsafeValue?: unknown): T;
 }
 /** Set of named data schemas. */
-export type DatabaseSchemas<T extends Database> = {
+export type DataSchemas<T extends Database> = {
     [K in keyof T]: DataSchema<T[K]>;
 };
 /** Valid data object with specifed properties. */

package/schema/EmailSchema.d.ts

@@ -1,5 +1,5 @@
 import type { StringSchemaOptions } from "./StringSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.js";
 /**
  * Define a valid email address.
  *
@@ -17,9 +17,9 @@ import { StringSchema } from "./StringSchema.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 StringSchema {
+export declare class EmailSchema extends TextSchema {
     constructor({ title, ...options }: Omit<StringSchemaOptions, "type" | "min" | "max" | "match" | "multiline">);
-    sanitize(uncleanString: string): string;
+    sanitize(str: string): string;
 }
 /** Valid email, e.g. `test@test.com` */
 export declare const EMAIL: EmailSchema;

package/schema/EmailSchema.js

@@ -1,5 +1,5 @@
 import { OPTIONAL } from "./OptionalSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.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,7 +18,7 @@ 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 StringSchema {
+export class EmailSchema extends TextSchema {
     constructor({ title = "Email", ...options }) {
         super({
             title,
@@ -30,9 +30,8 @@ export class EmailSchema extends StringSchema {
             multiline: false,
         });
     }
-    sanitize(uncleanString) {
-        const sanitizedString = super.sanitize(uncleanString);
-        return typeof sanitizedString === "string" ? sanitizedString.toLowerCase() : sanitizedString;
+    sanitize(str) {
+        return super.sanitize(str).toLowerCase();
     }
 }
 /** Valid email, e.g. `test@test.com` */

package/schema/ItemSchema.d.ts

@@ -0,0 +1,33 @@
+import type { Data, Database } from "../util/data.js";
+import type { Item } from "../util/item.js";
+import type { Validators } from "../util/validate.js";
+import { DataSchema } from "./DataSchema.js";
+import type { KeySchema } from "./KeySchema.js";
+import { type OptionalSchema } from "./OptionalSchema.js";
+import type { SchemaOptions } from "./Schema.js";
+/** Allowed options for `ItemSchema` */
+export interface ItemSchemaOptions<T extends Data> extends SchemaOptions {
+    readonly id?: KeySchema | undefined;
+    readonly props: Validators<T>;
+    readonly value?: Partial<Item<T>> | undefined;
+}
+/** Validate an item object. */
+export declare class ItemSchema<T extends Data> extends DataSchema<Item<T>> {
+    constructor({ id, props, ...options }: ItemSchemaOptions<T>);
+}
+/** Set of named item schemas. */
+export type ItemSchemas<T extends Database> = {
+    [K in keyof T]: DataSchema<Item<T[K]>>;
+};
+/**
+ * Valid item object with specifed properties.
+ * - An `Item` is a `Data` object with a string `.id` prop.
+ * - Optional validator for `.id` must be a `KeySchema` and defaults to `KEY`.
+ */
+export declare const ITEM: <T extends Data>(props: Validators<T> | DataSchema<T>, id?: KeySchema) => ItemSchema<Item<T>>;
+/**
+ * Valid item object or `null`.
+ * - An `Item` is a `Data` object with a string `.id` prop.
+ * - Optional validator for `.id` must be a `KeySchema` and defaults to `KEY`.
+ */
+export declare const OPTIONAL_ITEM: <T extends Data>(props: Validators<T> | DataSchema<T>, id?: KeySchema) => OptionalSchema<Item<T>>;

package/schema/ItemSchema.js

@@ -0,0 +1,21 @@
+import { DataSchema } from "./DataSchema.js";
+import { KEY } from "./KeySchema.js";
+import { OPTIONAL } from "./OptionalSchema.js";
+/** Validate an item object. */
+export class ItemSchema extends DataSchema {
+    constructor({ id = KEY, props, ...options }) {
+        super({ props: { id, ...props }, ...options });
+    }
+}
+/**
+ * Valid item object with specifed properties.
+ * - An `Item` is a `Data` object with a string `.id` prop.
+ * - Optional validator for `.id` must be a `KeySchema` and defaults to `KEY`.
+ */
+export const ITEM = (props, id) => props instanceof DataSchema ? new ItemSchema({ id, ...props }) : new ItemSchema({ props, id });
+/**
+ * Valid item object or `null`.
+ * - An `Item` is a `Data` object with a string `.id` prop.
+ * - Optional validator for `.id` must be a `KeySchema` and defaults to `KEY`.
+ */
+export const OPTIONAL_ITEM = (props, id) => OPTIONAL(ITEM(props, id));

package/schema/KeySchema.d.ts

@@ -2,11 +2,14 @@ import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
 /**
  * Define a valid database key.
  *
+ * - Characters that are not a-z, A-Z, 0-9 are removed.
  * - Default minimum key length is 1 character.
- * - Default maximum key length is 64 characters.
+ * - Default maximum key length is 32 characters.
+ * - 32 characters is enough for UUIDs, as the 4 `-` hyphens are removed.
  */
 export declare class KeySchema extends StringSchema {
     constructor({ min, max, ...options }: StringSchemaOptions);
+    sanitize(str: string): string;
 }
 /** Valid database key. */
 export declare const KEY: KeySchema;

package/schema/KeySchema.js

@@ -1,17 +1,23 @@
 import { OPTIONAL } from "./OptionalSchema.js";
 import { StringSchema } from "./StringSchema.js";
+const R_NOT_CHAR = /[^a-zA-Z0-9]/g;
 /**
  * Define a valid database key.
  *
+ * - Characters that are not a-z, A-Z, 0-9 are removed.
  * - Default minimum key length is 1 character.
- * - Default maximum key length is 64 characters.
+ * - Default maximum key length is 32 characters.
+ * - 32 characters is enough for UUIDs, as the 4 `-` hyphens are removed.
  */
 export class KeySchema extends StringSchema {
-    constructor({ min = 1, max = 64, ...options }) {
+    constructor({ min = 1, max = 32, ...options }) {
         super({ min, max, ...options });
     }
+    sanitize(str) {
+        return str.replace(R_NOT_CHAR, "");
+    }
 }
 /** Valid database key. */
-export const KEY = new KeySchema({});
+export const KEY = new KeySchema({ title: "ID" });
 /** Valid optional database key. */
 export const OPTIONAL_KEY = OPTIONAL(KEY);

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 { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.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 StringSchema {
+export declare class LinkSchema extends TextSchema {
     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 { getOptionalLinkURL } from "../util/link.js";
 import { OPTIONAL } from "./OptionalSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.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 StringSchema {
+export class LinkSchema extends TextSchema {
     base;
     schemes;
     hosts;
@@ -27,10 +27,10 @@ export class LinkSchema extends StringSchema {
     }
     // Override to clean the URL using builtin helper functions and check the schemes and hosts against the whitelists.
     validate(unsafeValue) {
-        const unsafeString = super.validate(unsafeValue);
-        const url = getOptionalLinkURL(super.sanitize(unsafeString), this.base, this.schemes, this.hosts);
+        const str = super.validate(unsafeValue);
+        const url = getOptionalLinkURL(str, this.base, this.schemes, this.hosts);
         if (!url)
-            throw new ValueFeedback(unsafeString ? "Invalid format" : "Required", unsafeString);
+            throw new ValueFeedback(str ? "Invalid format" : "Required", str);
         return url.href;
     }
 }

package/schema/NumberSchema.js

@@ -26,7 +26,7 @@ export class NumberSchema extends Schema {
     }
 }
 /** Valid number, e.g. `2048.12345` or `0` zero. */
-export const NUMBER = new NumberSchema({});
+export const NUMBER = new NumberSchema({ title: "Number" });
 /** Valid optional number, e.g. `2048.12345` or `0` zero, or `null` */
 export const OPTIONAL_NUMBER = OPTIONAL(NUMBER);
 /** Valid integer number, e.g. `2048` or `0` zero. */

package/schema/PhoneSchema.d.ts

@@ -1,11 +1,11 @@
 import type { StringSchemaOptions } from "./StringSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.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 StringSchema {
+export declare class PhoneSchema extends TextSchema {
     constructor({ title, ...options }: StringSchemaOptions);
     sanitize(insaneString: string): string;
 }

package/schema/PhoneSchema.js

@@ -1,5 +1,5 @@
 import { OPTIONAL } from "./OptionalSchema.js";
-import { StringSchema } from "./StringSchema.js";
+import { TextSchema } from "./TextSchema.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,7 +9,7 @@ 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 StringSchema {
+export class PhoneSchema extends TextSchema {
     constructor({ title = "Phone", ...options }) {
         super({
             title,

package/schema/SlugSchema.d.ts

@@ -8,7 +8,7 @@ import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
  */
 export declare class SlugSchema extends StringSchema {
     constructor(options: Omit<StringSchemaOptions, "min" | "max" | "multiline">);
-    sanitize(insaneString: string): string;
+    sanitize(str: string): string;
 }
 /** Valid slug, e.g. `this-is-a-slug` */
 export declare const SLUG: SlugSchema;

package/schema/SlugSchema.js

@@ -14,11 +14,10 @@ export class SlugSchema extends StringSchema {
             ...options,
             min: 2,
             max: 32,
-            multiline: false,
         });
     }
-    sanitize(insaneString) {
-        return getSlug(insaneString);
+    sanitize(str) {
+        return getSlug(str);
     }
 }
 /** Valid slug, e.g. `this-is-a-slug` */

package/schema/StringSchema.d.ts

@@ -1,27 +1,16 @@
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
-/** `type=""` prop for HTML `<input />` tags that are relevant for strings. */
-export type HtmlInputType = "text" | "password" | "color" | "date" | "email" | "number" | "tel" | "search" | "url";
 /** Function that sanitizes a string. */
 export type Sanitizer = (str: string) => string;
 /** Options for `StringSchema` */
 export interface StringSchemaOptions extends SchemaOptions {
     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.
  *
- * 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.
- *
  * @example
  *  const schema = new StringSchema({ default: 'abc', required: true, min: 2, max: 6, match: /^[a-z0-9]+$/, trim: true });
  *  schema.validate('def'); // Returns 'def'
@@ -36,32 +25,14 @@ export interface StringSchemaOptions extends SchemaOptions {
  */
 export declare class StringSchema extends Schema<string> {
     readonly value: string;
-    readonly type: HtmlInputType;
     readonly min: number;
     readonly max: number;
-    readonly match: RegExp | undefined;
-    readonly sanitizer: Sanitizer | undefined;
-    readonly multiline: boolean;
-    constructor({ type, min, max, match, sanitizer, multiline, value, ...options }: StringSchemaOptions);
+    constructor({ min, max, value, ...options }: StringSchemaOptions);
     validate(unsafeValue?: unknown): string;
-    /**
-     * Clean a string by removing characters that aren't digits.
-     * - Might be empty string if the string contained only invalid characters.
-     * - Applies `options.sanitizer` too (if it's set).
-     */
-    sanitize(insaneString: string): string;
+    /** Sanitize the string by removing unwanted characters. */
+    sanitize(str: string): 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;
-/** 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 OPTIONAL_TITLE: import("./OptionalSchema.js").OptionalSchema<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 OPTIONAL_NAME: import("./OptionalSchema.js").OptionalSchema<string>;
-/** Password string. */
-export declare const PASSWORD: StringSchema;

package/schema/StringSchema.js

@@ -1,15 +1,8 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
-import { sanitizeLines, sanitizeString } from "../util/string.js";
-import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /**
  * Schema that defines a valid 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.
- *
  * @example
  *  const schema = new StringSchema({ default: 'abc', required: true, min: 2, max: 6, match: /^[a-z0-9]+$/, trim: true });
  *  schema.validate('def'); // Returns 'def'
@@ -23,20 +16,12 @@ import { Schema } from "./Schema.js";
  *  schema.validate('j'); // Throws 'Minimum 3 chaacters'
  */
 export class StringSchema extends Schema {
-    type;
     min;
     max;
-    match;
-    sanitizer;
-    multiline;
-    constructor({ type = "text", min = 0, max = Number.POSITIVE_INFINITY, match, sanitizer, multiline = false, value = "", ...options }) {
+    constructor({ min = 0, max = Number.POSITIVE_INFINITY, value = "", ...options }) {
         super({ value, ...options });
-        this.type = type;
         this.min = min;
         this.max = max;
-        this.match = match;
-        this.sanitizer = sanitizer;
-        this.multiline = multiline;
     }
     validate(unsafeValue = this.value) {
         const possibleString = typeof unsafeValue === "number" ? unsafeValue.toString() : unsafeValue;
@@ -47,30 +32,14 @@ export class StringSchema extends Schema {
             throw new ValueFeedback(saneString ? `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;
     }
-    /**
-     * Clean a string by removing characters that aren't digits.
-     * - Might be empty string if the string contained only invalid characters.
-     * - Applies `options.sanitizer` too (if it's set).
-     */
-    sanitize(insaneString) {
-        return this.sanitizer ? this.sanitizer(insaneString) : this.multiline ? sanitizeLines(insaneString) : sanitizeString(insaneString);
+    /** Sanitize the string by removing unwanted characters. */
+    sanitize(str) {
+        return str;
     }
 }
 /** 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 });
-/** 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 OPTIONAL_TITLE = OPTIONAL(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 OPTIONAL_NAME = OPTIONAL(NAME);
-/** Password string. */
-export const PASSWORD = new StringSchema({ title: "Password", min: 6, type: "password" });

package/schema/TextSchema.d.ts

@@ -0,0 +1,40 @@
+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 OPTIONAL_TITLE: import("./OptionalSchema.js").OptionalSchema<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 OPTIONAL_NAME: import("./OptionalSchema.js").OptionalSchema<string>;
+/** Password string. */
+export declare const PASSWORD: TextSchema;

package/schema/TextSchema.js

@@ -0,0 +1,47 @@
+import { ValueFeedback } from "../feedback/Feedback.js";
+import { sanitizeMultilineText, sanitizeText } from "../util/string.js";
+import { OPTIONAL } from "./OptionalSchema.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 OPTIONAL_TITLE = OPTIONAL(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 OPTIONAL_NAME = OPTIONAL(NAME);
+/** Password string. */
+export const PASSWORD = new TextSchema({ title: "Password", min: 6, type: "password" });

package/schema/index.d.ts

@@ -9,12 +9,14 @@ export * from "./DictionarySchema.js";
 export * from "./EmailSchema.js";
 export * from "./EntitySchema.js";
 export * from "./FileSchema.js";
+export * from "./ItemSchema.js";
 export * from "./KeySchema.js";
 export * from "./LinkSchema.js";
 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 "./ThroughSchema.js";
 export * from "./OptionalSchema.js";

package/schema/index.js

@@ -9,12 +9,14 @@ export * from "./DictionarySchema.js";
 export * from "./EmailSchema.js";
 export * from "./EntitySchema.js";
 export * from "./FileSchema.js";
+export * from "./ItemSchema.js";
 export * from "./KeySchema.js";
 export * from "./LinkSchema.js";
 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 "./ThroughSchema.js";
 export * from "./OptionalSchema.js";

package/util/string.d.ts

@@ -36,7 +36,7 @@ export declare function getStringLength(str: string, min?: number, max?: number)
 /** Concatenate an iterable set of strings together. */
 export declare function joinStrings(strs: Iterable<string> & NotString, joiner?: string): string;
 /**
- * Sanitize a single-line string.
+ * Sanitize a single line of text.
  * - Used when you're sanitising a single-line input, e.g. a title for something.
  * - Remove allow control characters
  * - Normalise runs of whitespace to one ` ` space,
@@ -44,9 +44,9 @@ export declare function joinStrings(strs: Iterable<string> & NotString, joiner?:
  *
  * @example santizeString("\x00Nice!   "); // Returns `"Nice!"`
  */
-export declare function sanitizeString(str: string): string;
+export declare function sanitizeText(str: string): string;
 /**
- * Sanitize a multiline string.
+ * Sanitize multiple lines of text.
  * - Used when you're sanitising a multi-line input, e.g. a description for something.
  * - Remove all control characters except `\n` newline.
  * - Normalise weird characters like paragraph separator, line separator, `\t` tab, `\r` carriage return.
@@ -55,7 +55,7 @@ export declare function sanitizeString(str: string): string;
  * - Allow spaces at the start of each line (for indentation) but trim the end of each line.
  * - Trim excess newlines at the start and end of the string and runs of more than two newlines in a row.
  */
-export declare function sanitizeLines(str: string): string;
+export declare function sanitizeMultilineText(str: string): string;
 /**
  * Simplify a string by removing anything that isn't a number, letter, or space.
  * - Normalizes the string by

package/util/string.js

@@ -65,7 +65,7 @@ export function joinStrings(strs, joiner = "") {
     return getArray(strs).join(joiner);
 }
 /**
- * Sanitize a single-line string.
+ * Sanitize a single line of text.
  * - Used when you're sanitising a single-line input, e.g. a title for something.
  * - Remove allow control characters
  * - Normalise runs of whitespace to one ` ` space,
@@ -73,14 +73,14 @@ export function joinStrings(strs, joiner = "") {
  *
  * @example santizeString("\x00Nice!   "); // Returns `"Nice!"`
  */
-export function sanitizeString(str) {
+export function sanitizeText(str) {
     return str
         .replace(/[^\P{C}\s]/gu, "") // Strip control characters (except whitespace).
         .replace(/\s+/gu, " ") // Normalise runs of whitespace to one ` ` space.
         .trim(); // Trim whitespace from the start and end of the string.
 }
 /**
- * Sanitize a multiline string.
+ * Sanitize multiple lines of text.
  * - Used when you're sanitising a multi-line input, e.g. a description for something.
  * - Remove all control characters except `\n` newline.
  * - Normalise weird characters like paragraph separator, line separator, `\t` tab, `\r` carriage return.
@@ -89,7 +89,7 @@ export function sanitizeString(str) {
  * - Allow spaces at the start of each line (for indentation) but trim the end of each line.
  * - Trim excess newlines at the start and end of the string and runs of more than two newlines in a row.
  */
-export function sanitizeLines(str) {
+export function sanitizeMultilineText(str) {
     return str
         .replace(/[^\P{C}\s]/gu, "") // Strip control characters (except whitespace).
         .replace(/\r\n?|\v|\x85|\u2028/g, "\n") // Normalise line separators to `\n` newline

package/util/validate.d.ts

@@ -1,7 +1,7 @@
 import type { ImmutableArray, PossibleArray } from "./array.js";
 import type { Data } from "./data.js";
 import type { ImmutableDictionary, PossibleDictionary } from "./dictionary.js";
-import type { Item } from "./item.js";
+import type { DeepPartial } from "./object.js";
 /** Object that can validate an unknown value with its `validate()` method. */
 export interface Validator<T> {
     /**
@@ -58,19 +58,13 @@ export declare function validateDictionary<T>(unsafeDictionary: PossibleDictiona
  * - Defined props in the object will be validated against the corresponding validator.
  * - `undefined` props in the object will be set to the default value of that prop.
  *
+ * @param partial Whether we're validating a partial match, or not.
  * @return Valid object.
  * @throw Feedback if one or more props did not validate.
  * - `feedback.details` will contain an entry for each invalid item (keyed by their count in the input iterable).
  */
-export declare function validateData<T extends Data>(unsafeData: Data, validators: Validators<T>): T;
-/** Get the current validation context. */
-export declare function getValidationContext(): Data;
-/** Validate a unknown value with a validator, and supply a context that can be read during the validation process. */
-export declare function validateWithContext<T extends Data>(unsafeValue: Item<Data>, validator: Validator<T>, context: Data & {
-    readonly id: true;
-}): Item<T>;
-export declare function validateWithContext<T extends Data>(unsafeValue: unknown, validator: Validator<T>, context: Data & {
-    readonly partial: true;
-}): Partial<T>;
-export declare function validateWithContext<T>(unsafeValue: unknown, validator: Validator<T>, context: Data): T;
-export declare const UNDEFINED_VALIDATOR: Validator<undefined>;
+export declare function validateData<T extends Data>(unsafeData: Data, validators: Validators<T>, partial: true): DeepPartial<T>;
+export declare function validateData<T extends Data>(unsafeData: Data, validators: Validators<T>, partial?: false): T;
+export declare const UNDEFINED: Validator<undefined>;
+export declare const NULL: Validator<null>;
+export declare const UNKNOWN: Validator<unknown>;

package/util/validate.js

@@ -1,10 +1,12 @@
 import { ValidationError } from "../error/ValidationError.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { ValueFeedbacks } from "../feedback/Feedbacks.js";
-import { getLastItem, isArray } from "./array.js";
+import { isArray } from "./array.js";
 import { getDataProps } from "./data.js";
 import { getDictionaryItems } from "./dictionary.js";
+import { PASSTHROUGH } from "./function.js";
 import { isIterable } from "./iterate.js";
+import { getNull } from "./null.js";
 import { getUndefined } from "./undefined.js";
 /** Get value that validates against a given `Validator`, or throw `ValidationError` */
 export function getValid(unsafeValue, validator) {
@@ -108,53 +110,43 @@ export function validateDictionary(unsafeDictionary, validator) {
         throw new ValueFeedbacks(messages, unsafeDictionary);
     return changed || isIterable(unsafeDictionary) ? safeDictionary : unsafeDictionary;
 }
-/**
- * Validate a data object with a set of validators.
- * - Defined props in the object will be validated against the corresponding validator.
- * - `undefined` props in the object will be set to the default value of that prop.
- *
- * @return Valid object.
- * @throw Feedback if one or more props did not validate.
- * - `feedback.details` will contain an entry for each invalid item (keyed by their count in the input iterable).
- */
-export function validateData(unsafeData, validators) {
-    const { partial = false, id = false } = getValidationContext();
+/** Keep track of whether we're doing a deep-partial match or not. */
+let isDeeplyPartial = false;
+export function validateData(unsafeData, validators, partial = isDeeplyPartial) {
     let valid = true;
     let changed = true;
-    const safeData = id && typeof unsafeData.id === "string" ? { id: unsafeData.id } : {};
+    const safeData = {};
     const messages = {};
-    for (const [key, validator] of getDataProps(validators)) {
-        const unsafeValue = unsafeData[key];
-        if (unsafeValue === undefined && partial)
-            continue; // Silently skip `undefined` props if in partial mode.
-        try {
-            const safeValue = validator.validate(unsafeValue);
-            safeData[key] = safeValue;
-            if (!changed && safeValue !== unsafeValue)
-                changed = true;
-        }
-        catch (thrown) {
-            if (!(thrown instanceof Feedback))
-                throw thrown;
-            messages[key] = thrown.message;
-            valid = false;
+    try {
+        isDeeplyPartial = partial;
+        for (const [key, validator] of getDataProps(validators)) {
+            const unsafeValue = unsafeData[key];
+            if (unsafeValue === undefined && partial)
+                continue; // Silently skip `undefined` props if in partial mode.
+            try {
+                const safeValue = validator.validate(unsafeValue);
+                safeData[key] = safeValue;
+                if (!changed && safeValue !== unsafeValue)
+                    changed = true;
+            }
+            catch (thrown) {
+                if (!(thrown instanceof Feedback))
+                    throw thrown;
+                messages[key] = thrown.message;
+                valid = false;
+            }
         }
+        if (!valid)
+            throw new ValueFeedbacks(messages, unsafeData);
+        return changed ? safeData : unsafeData;
+    }
+    finally {
+        isDeeplyPartial = false;
     }
-    if (!valid)
-        throw new ValueFeedbacks(messages, unsafeData);
-    return changed ? safeData : unsafeData;
-}
-/** Store a list of current contexts. */
-const CONTEXTS = [{}];
-/** Get the current validation context. */
-export function getValidationContext() {
-    return getLastItem(CONTEXTS);
-}
-export function validateWithContext(unsafeValue, validator, context) {
-    CONTEXTS.push(context);
-    const validValue = validator.validate(unsafeValue);
-    CONTEXTS.pop();
-    return validValue;
 }
-// Undefined validator always returns undefined.
-export const UNDEFINED_VALIDATOR = { validate: getUndefined };
+// Undefined validator always returns `undefined`
+export const UNDEFINED = { validate: getUndefined };
+// Null validator always returns `null`
+export const NULL = { validate: getNull };
+// Unknown validator always passes through its input value as `unknown`
+export const UNKNOWN = { validate: PASSTHROUGH };