shelving 1.147.0 → 1.148.0

package/package.json

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

package/schema/ColorSchema.d.ts

@@ -15,4 +15,4 @@ export declare class ColorSchema extends TextSchema {
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */
 export declare const COLOR: ColorSchema;
 /** Valid color hex string, e.g. `#00CCFF`, or `null` */
-export declare const OPTIONAL_COLOR: import("./OptionalSchema.js").OptionalSchema<string>;
+export declare const NULLABLE_COLOR: import("./NullableSchema.js").NullableSchema<string>;

package/schema/ColorSchema.js

@@ -1,4 +1,4 @@
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { TextSchema } from "./TextSchema.js";
 const COLOR_REGEXP = /^#[0-9A-F]{6}$/;
 const NOT_HEX_REGEXP = /[^0-9A-F]/g;
@@ -32,4 +32,4 @@ export class ColorSchema extends TextSchema {
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */
 export const COLOR = new ColorSchema({});
 /** Valid color hex string, e.g. `#00CCFF`, or `null` */
-export const OPTIONAL_COLOR = OPTIONAL(COLOR);
+export const NULLABLE_COLOR = NULLABLE(COLOR);

package/schema/DataSchema.d.ts

@@ -1,15 +1,17 @@
 import type { Data, Database } from "../util/data.js";
-import type { Validators } from "../util/validate.js";
-import type { OptionalSchema } from "./OptionalSchema.js";
+import type { Item } from "../util/item.js";
+import type { Validator, Validators } from "../util/validate.js";
+import type { NullableSchema } from "./NullableSchema.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
-/** Allowed options for `DataSchema` */
+/** Allowed options for `PropsSchema` (a schema that has props). */
 export interface DataSchemaOptions<T extends Data> extends SchemaOptions {
+    readonly id?: Validator<string>;
     readonly props: Validators<T>;
     readonly value?: Partial<T> | undefined;
 }
 /** Validate a data object. */
-export declare class DataSchema<T extends Data> extends Schema<T> {
+export declare class DataSchema<T extends Data> extends Schema<unknown> {
     readonly value: Partial<T>;
     readonly props: Validators<T>;
     constructor({ props, title, value, ...options }: DataSchemaOptions<T>);
@@ -19,7 +21,11 @@ export declare class DataSchema<T extends Data> extends Schema<T> {
 export type DataSchemas<T extends Database> = {
     [K in keyof T]: DataSchema<T[K]>;
 };
-/** Valid data object with specifed properties. */
+/** Create a `DataSchema` for a set of 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>) => OptionalSchema<T>;
+export declare const NULLABLE_DATA: <T extends Data>(props: Validators<T>) => NullableSchema<T>;
+/** Create a `DataSchema` that validates partially, i.e. properties can be their value, or `undefined` */
+export declare function PARTIAL<T extends Data>(source: Validators<T> | DataSchema<T>): DataSchema<Partial<T>>;
+/** Create a `DataSchema` that validates a data item, i.e. it has a string `.id` property. */
+export declare function ITEM<T extends Data>(validators: Validators<T> | DataSchema<T>, id?: Validator<string>): DataSchema<Item<T>>;

package/schema/DataSchema.js

@@ -1,6 +1,9 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { isData } from "../util/data.js";
+import { mapObject } from "../util/transform.js";
 import { validateData } from "../util/validate.js";
+import { KEY } from "./KeySchema.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /** Validate a data object. */
@@ -16,7 +19,21 @@ export class DataSchema extends Schema {
         return validateData(unsafeValue, this.props);
     }
 }
-/** Valid data object with specifed properties. */
+/** Create a `DataSchema` for a set of properties. */
 export const DATA = (props) => new DataSchema({ props });
 /** Valid data object with specifed properties, or `null` */
-export const OPTIONAL_DATA = (props) => OPTIONAL(new DataSchema({ props }));
+export const NULLABLE_DATA = (props) => NULLABLE(new DataSchema({ props }));
+/** Create a `DataSchema` that validates partially, i.e. properties can be their value, or `undefined` */
+export function PARTIAL(source) {
+    const props = source instanceof DataSchema ? source.props : source;
+    return new DataSchema({
+        props: mapObject(props, OPTIONAL),
+    });
+}
+/** Create a `DataSchema` that validates a data item, i.e. it has a string `.id` property. */
+export function ITEM(validators, id = KEY) {
+    const props = validators instanceof DataSchema ? validators.props : validators;
+    return new DataSchema({
+        props: { id, ...props },
+    });
+}

package/schema/DateSchema.d.ts

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

package/schema/DateSchema.js

@@ -1,7 +1,7 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { getDate, requireYMD } from "../util/date.js";
 import { formatDate } from "../util/format.js";
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { Schema } from "./Schema.js";
 /** Define a valid date in YMD format, e.g. `2005-09-12` */
 export class DateSchema extends Schema {
@@ -26,4 +26,4 @@ export class DateSchema extends Schema {
 /** Valid date, e.g. `2005-09-12` (required because falsy values are invalid). */
 export const DATE = new DateSchema({});
 /** Valid date, e.g. `2005-09-12`, or `null` */
-export const OPTIONAL_DATE = OPTIONAL(DATE);
+export const NULLABLE_DATE = NULLABLE(DATE);

package/schema/EmailSchema.d.ts

@@ -24,4 +24,4 @@ export declare class EmailSchema extends TextSchema {
 /** Valid email, e.g. `test@test.com` */
 export declare const EMAIL: EmailSchema;
 /** Valid optional email, e.g. `test@test.com`, or `null` */
-export declare const OPTIONAL_EMAIL: import("./OptionalSchema.js").OptionalSchema<string>;
+export declare const NULLABLE_EMAIL: import("./NullableSchema.js").NullableSchema<string>;

package/schema/EmailSchema.js

@@ -1,4 +1,4 @@
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.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])$/;
 /**
@@ -37,4 +37,4 @@ export class EmailSchema extends TextSchema {
 /** Valid email, e.g. `test@test.com` */
 export const EMAIL = new EmailSchema({});
 /** Valid optional email, e.g. `test@test.com`, or `null` */
-export const OPTIONAL_EMAIL = OPTIONAL(EMAIL);
+export const NULLABLE_EMAIL = NULLABLE(EMAIL);

package/schema/EntitySchema.d.ts

@@ -14,4 +14,4 @@ export declare class EntitySchema<T extends string> extends StringSchema {
 /** Valid file, e.g. `challenge:a1b2c3` */
 export declare const ENTITY: EntitySchema<string>;
 /** Valid optional file, e.g. `file.txt`, or `null` */
-export declare const OPTIONAL_ENTITY: import("./OptionalSchema.js").OptionalSchema<`${string}:${string}`>;
+export declare const NULLABLE_ENTITY: import("./NullableSchema.js").NullableSchema<`${string}:${string}`>;

package/schema/EntitySchema.js

@@ -1,7 +1,7 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { isItem } from "../util/array.js";
 import { getEntity } from "../util/entity.js";
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { StringSchema } from "./StringSchema.js";
 /** Validate a file name matching one or more extensions. */
 export class EntitySchema extends StringSchema {
@@ -23,4 +23,4 @@ export class EntitySchema extends StringSchema {
 /** Valid file, e.g. `challenge:a1b2c3` */
 export const ENTITY = new EntitySchema({});
 /** Valid optional file, e.g. `file.txt`, or `null` */
-export const OPTIONAL_ENTITY = OPTIONAL(ENTITY);
+export const NULLABLE_ENTITY = NULLABLE(ENTITY);

package/schema/FileSchema.d.ts

@@ -13,4 +13,4 @@ export declare class FileSchema extends StringSchema {
 /** Valid file, e.g. `file.txt` */
 export declare const FILE: FileSchema;
 /** Valid optional file, e.g. `file.txt`, or `null` */
-export declare const OPTIONAL_FILE: import("./OptionalSchema.js").OptionalSchema<string>;
+export declare const NULLABLE_FILE: import("./NullableSchema.js").NullableSchema<string>;

package/schema/FileSchema.js

@@ -1,7 +1,7 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { getFileExtension } from "../util/file.js";
 import { isProp } from "../util/object.js";
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { StringSchema } from "./StringSchema.js";
 /** Validate a file name matching one or more extensions. */
 export class FileSchema extends StringSchema {
@@ -23,4 +23,4 @@ export class FileSchema extends StringSchema {
 /** Valid file, e.g. `file.txt` */
 export const FILE = new FileSchema({});
 /** Valid optional file, e.g. `file.txt`, or `null` */
-export const OPTIONAL_FILE = OPTIONAL(FILE);
+export const NULLABLE_FILE = NULLABLE(FILE);

package/schema/KeySchema.d.ts

@@ -14,4 +14,4 @@ export declare class KeySchema extends StringSchema {
 /** Valid database key. */
 export declare const KEY: KeySchema;
 /** Valid optional database key. */
-export declare const OPTIONAL_KEY: import("./OptionalSchema.js").OptionalSchema<string>;
+export declare const NULLABLE_KEY: import("./NullableSchema.js").NullableSchema<string>;

package/schema/KeySchema.js

@@ -1,4 +1,4 @@
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { StringSchema } from "./StringSchema.js";
 const R_NOT_CHAR = /[^a-zA-Z0-9]/g;
 /**
@@ -20,4 +20,4 @@ export class KeySchema extends StringSchema {
 /** Valid database key. */
 export const KEY = new KeySchema({ title: "ID" });
 /** Valid optional database key. */
-export const OPTIONAL_KEY = OPTIONAL(KEY);
+export const NULLABLE_KEY = NULLABLE(KEY);

package/schema/LinkSchema.d.ts

@@ -24,4 +24,4 @@ export declare class LinkSchema extends TextSchema {
 /** 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}:${string}`>;
+export declare const NULLABLE_LINK: import("./NullableSchema.js").NullableSchema<`${string}:${string}`>;

package/schema/LinkSchema.js

@@ -1,6 +1,6 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { getLinkURL } from "../util/link.js";
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { TextSchema } from "./TextSchema.js";
 /**
  * Type of `StringSchema` that defines a valid URL link.
@@ -37,4 +37,4 @@ export class LinkSchema extends TextSchema {
 /** 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);
+export const NULLABLE_LINK = NULLABLE(LINK);

package/schema/NullableSchema.d.ts

@@ -0,0 +1,15 @@
+import type { Schema, SchemaOptions } from "./Schema.js";
+import { ThroughSchema } from "./ThroughSchema.js";
+/** Allowed options for `NullableSchema` */
+export interface NullableSchemaOptions<T> extends SchemaOptions {
+    readonly source: Schema<T>;
+    readonly value?: T | null;
+}
+/** Validate a value of a specific type or `null`. */
+export declare class NullableSchema<T> extends ThroughSchema<T | null> {
+    readonly value: T | null;
+    constructor({ value, ...options }: NullableSchemaOptions<T>);
+    validate(unsafeValue?: unknown): T | null;
+}
+/** Create a new nullable schema from a source schema. */
+export declare const NULLABLE: <T>(source: Schema<T>) => NullableSchema<T>;

package/schema/NullableSchema.js

@@ -0,0 +1,14 @@
+import { ThroughSchema } from "./ThroughSchema.js";
+/** Validate a value of a specific type or `null`. */
+export class NullableSchema extends ThroughSchema {
+    constructor({ value = null, ...options }) {
+        super({ value, ...options });
+    }
+    validate(unsafeValue = this.value) {
+        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 });

package/schema/NumberSchema.d.ts

@@ -19,7 +19,7 @@ export declare class NumberSchema extends Schema<number> {
 /** Valid number, e.g. `2048.12345` or `0` zero. */
 export declare const NUMBER: NumberSchema;
 /** Valid optional number, e.g. `2048.12345` or `0` zero, or `null` */
-export declare const OPTIONAL_NUMBER: import("./OptionalSchema.js").OptionalSchema<number>;
+export declare const NULLABLE_NUMBER: import("./NullableSchema.js").NullableSchema<number>;
 /** Valid integer number, e.g. `2048` or `0` zero. */
 export declare const INTEGER: NumberSchema;
 /** Valid positive integer number, e.g. `1,2,3` (not including zero). */
@@ -31,8 +31,8 @@ export declare const NEGATIVE_INTEGER: NumberSchema;
 /** Valid non-positive integer number, e.g. `0,-1,-2,-3` (including zero). */
 export declare const NON_POSITIVE_INTEGER: NumberSchema;
 /** Valid optional integer number, e.g. `2048` or `0` zero, or `null` */
-export declare const OPTIONAL_INTEGER: import("./OptionalSchema.js").OptionalSchema<number>;
+export declare const NULLABLE_INTEGER: import("./NullableSchema.js").NullableSchema<number>;
 /** Valid Unix timestamp (including milliseconds). */
 export declare const TIMESTAMP: NumberSchema;
 /** Valid Unix timestamp (including milliseconds). */
-export declare const OPTIONAL_TIMESTAMP: import("./OptionalSchema.js").OptionalSchema<number>;
+export declare const NULLABLE_TIMESTAMP: import("./NullableSchema.js").NullableSchema<number>;

package/schema/NumberSchema.js

@@ -1,7 +1,7 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { formatNumber } from "../util/format.js";
 import { getNumber, roundStep } from "../util/number.js";
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { Schema } from "./Schema.js";
 /** Schema that defines a valid number. */
 export class NumberSchema extends Schema {
@@ -29,7 +29,7 @@ export class NumberSchema extends Schema {
 /** Valid number, e.g. `2048.12345` or `0` zero. */
 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);
+export const NULLABLE_NUMBER = NULLABLE(NUMBER);
 /** Valid integer number, e.g. `2048` or `0` zero. */
 export const INTEGER = new NumberSchema({ step: 1, min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER, value: 0 });
 /** Valid positive integer number, e.g. `1,2,3` (not including zero). */
@@ -41,7 +41,7 @@ export const NEGATIVE_INTEGER = new NumberSchema({ step: 1, min: Number.MIN_SAFE
 /** Valid non-positive integer number, e.g. `0,-1,-2,-3` (including zero). */
 export const NON_POSITIVE_INTEGER = new NumberSchema({ step: 1, min: Number.MIN_SAFE_INTEGER, max: 0, value: 0 });
 /** Valid optional integer number, e.g. `2048` or `0` zero, or `null` */
-export const OPTIONAL_INTEGER = OPTIONAL(INTEGER);
+export const NULLABLE_INTEGER = NULLABLE(INTEGER);
 /** Valid Unix timestamp (including milliseconds). */
 export const TIMESTAMP = new NumberSchema({
     title: "Timestamp",
@@ -51,4 +51,4 @@ export const TIMESTAMP = new NumberSchema({
     value: 0,
 });
 /** Valid Unix timestamp (including milliseconds). */
-export const OPTIONAL_TIMESTAMP = OPTIONAL_INTEGER;
+export const NULLABLE_TIMESTAMP = NULLABLE_INTEGER;

package/schema/OptionalSchema.d.ts

@@ -1,15 +1,12 @@
-import type { Schema, SchemaOptions } from "./Schema.js";
+import type { Schema } from "./Schema.js";
 import { ThroughSchema } from "./ThroughSchema.js";
-/** Allowed options for `OptionalSchema` */
-export interface OptionalSchemaOptions<T> extends SchemaOptions {
-    readonly source: Schema<T>;
-    readonly value?: T | null;
+/**
+ * Validate a property in an optional way, i.e. it can be the value, or `undefined`
+ * - If the prop is `undefined`, then `undefined` is returned.
+ * - When used with `validateData()` this means the prop can be silently skipped.
+ */
+export declare class OptionalSchema<T> extends ThroughSchema<T | undefined> {
+    validate(unsafeValue: unknown): T | undefined;
 }
-/** Validate a value of a specific type or `null`. */
-export declare class OptionalSchema<T> extends ThroughSchema<T | null> {
-    readonly value: T | null;
-    constructor({ value, ...options }: OptionalSchemaOptions<T>);
-    validate(unsafeValue?: unknown): T | null;
-}
-/** Create a new optional schema from a source schema. */
+/** Make a property of a set of data optional, i.e. it can be the value or `undefined` */
 export declare const OPTIONAL: <T>(source: Schema<T>) => OptionalSchema<T>;

package/schema/OptionalSchema.js

@@ -1,14 +1,15 @@
 import { ThroughSchema } from "./ThroughSchema.js";
-/** Validate a value of a specific type or `null`. */
+/**
+ * Validate a property in an optional way, i.e. it can be the value, or `undefined`
+ * - If the prop is `undefined`, then `undefined` is returned.
+ * - When used with `validateData()` this means the prop can be silently skipped.
+ */
 export class OptionalSchema extends ThroughSchema {
-    constructor({ value = null, ...options }) {
-        super({ value, ...options });
-    }
-    validate(unsafeValue = this.value) {
-        if (unsafeValue === null || unsafeValue === undefined || unsafeValue === "" || Number.isNaN(unsafeValue))
-            return null;
+    validate(unsafeValue) {
+        if (unsafeValue === undefined)
+            return undefined;
         return super.validate(unsafeValue);
     }
 }
-/** Create a new optional schema from a source schema. */
+/** Make a property of a set of data optional, i.e. it can be the value or `undefined` */
 export const OPTIONAL = (source) => new OptionalSchema({ source });

package/schema/PhoneSchema.d.ts

@@ -12,4 +12,4 @@ export declare class PhoneSchema extends TextSchema {
 /** Valid phone number, e.g. `+441234567890` */
 export declare const PHONE: PhoneSchema;
 /** Valid phone number, e.g. `+441234567890`, or `null` */
-export declare const OPTIONAL_PHONE: import("./OptionalSchema.js").OptionalSchema<string>;
+export declare const NULLABLE_PHONE: import("./NullableSchema.js").NullableSchema<string>;

package/schema/PhoneSchema.js

@@ -1,4 +1,4 @@
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.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`).
@@ -31,4 +31,4 @@ export class PhoneSchema extends TextSchema {
 /** Valid phone number, e.g. `+441234567890` */
 export const PHONE = new PhoneSchema({});
 /** Valid phone number, e.g. `+441234567890`, or `null` */
-export const OPTIONAL_PHONE = OPTIONAL(PHONE);
+export const NULLABLE_PHONE = NULLABLE(PHONE);

package/schema/SlugSchema.d.ts

@@ -13,4 +13,4 @@ export declare class SlugSchema extends StringSchema {
 /** Valid slug, e.g. `this-is-a-slug` */
 export declare const SLUG: SlugSchema;
 /** Valid slug, e.g. `this-is-a-slug`, or `null` */
-export declare const OPTIONAL_SLUG: import("./OptionalSchema.js").OptionalSchema<string>;
+export declare const NULLABLE_SLUG: import("./NullableSchema.js").NullableSchema<string>;

package/schema/SlugSchema.js

@@ -1,5 +1,5 @@
 import { getSlug } from "../util/string.js";
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { StringSchema } from "./StringSchema.js";
 /**
  * Define a valid slug, e.g. `this-is-a-slug`
@@ -23,4 +23,4 @@ export class SlugSchema extends StringSchema {
 /** Valid slug, e.g. `this-is-a-slug` */
 export const SLUG = new SlugSchema({});
 /** Valid slug, e.g. `this-is-a-slug`, or `null` */
-export const OPTIONAL_SLUG = OPTIONAL(SLUG);
+export const NULLABLE_SLUG = NULLABLE(SLUG);

package/schema/TextSchema.d.ts

@@ -31,10 +31,10 @@ 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>;
+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 OPTIONAL_NAME: import("./OptionalSchema.js").OptionalSchema<string>;
+export declare const NULLABLE_NAME: import("./NullableSchema.js").NullableSchema<string>;
 /** Password string. */
 export declare const PASSWORD: TextSchema;

package/schema/TextSchema.js

@@ -1,6 +1,6 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { sanitizeMultilineText, sanitizeText } from "../util/string.js";
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { StringSchema } from "./StringSchema.js";
 /**
  * Schema that defines a valid text string.
@@ -38,10 +38,10 @@ 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);
+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 OPTIONAL_NAME = OPTIONAL(NAME);
+export const NULLABLE_NAME = NULLABLE(NAME);
 /** Password string. */
 export const PASSWORD = new TextSchema({ title: "Password", min: 6, type: "password" });

package/schema/ThroughSchema.d.ts

@@ -1,13 +1,14 @@
 import type { Sourceable } from "../util/source.js";
+import type { Validator } from "../util/validate.js";
 import type { SchemaOptions } from "./Schema.js";
 import { Schema } from "./Schema.js";
-/** Allowed options for `ThroughSchama` */
+/** Allowed options for `ThroughSchema` */
 export interface ThroughSchemaOptions<T> extends SchemaOptions {
-    source: Schema<T>;
+    source: Validator<T>;
 }
 /** Schema that passes through to a source schema. */
-export declare abstract class ThroughSchema<T> extends Schema<T> implements Sourceable<Schema<T>> {
-    readonly source: Schema<T>;
+export declare abstract class ThroughSchema<T> extends Schema<T> implements Sourceable<Validator<T>> {
+    readonly source: Validator<T>;
     constructor({ source, ...options }: ThroughSchemaOptions<T>);
     validate(unsafeValue: unknown): T;
 }

package/schema/ThroughSchema.js

@@ -3,7 +3,7 @@ import { Schema } from "./Schema.js";
 export class ThroughSchema extends Schema {
     source;
     constructor({ source, ...options }) {
-        super({ ...source, ...options });
+        super(source instanceof Schema ? { ...source, ...options } : options);
         this.source = source;
     }
     validate(unsafeValue) {

package/schema/TimeSchema.d.ts

@@ -26,4 +26,4 @@ export declare class TimeSchema extends Schema<string> {
 /** Valid time, e.g. `2005-09-12` (required because falsy values are invalid). */
 export declare const TIME: TimeSchema;
 /** Valid time, e.g. `2005-09-12`, or `null` */
-export declare const OPTIONAL_TIME: import("./OptionalSchema.js").OptionalSchema<string>;
+export declare const NULLABLE_TIME: import("./NullableSchema.js").NullableSchema<string>;

package/schema/TimeSchema.js

@@ -1,7 +1,7 @@
 import { ValueFeedback } from "../feedback/Feedback.js";
 import { roundStep } from "../util/number.js";
 import { Time, getTime } from "../util/time.js";
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { Schema } from "./Schema.js";
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
 export class TimeSchema extends Schema {
@@ -33,4 +33,4 @@ export class TimeSchema extends Schema {
 /** Valid time, e.g. `2005-09-12` (required because falsy values are invalid). */
 export const TIME = new TimeSchema({});
 /** Valid time, e.g. `2005-09-12`, or `null` */
-export const OPTIONAL_TIME = OPTIONAL(TIME);
+export const NULLABLE_TIME = NULLABLE(TIME);

package/schema/UUIDSchema.d.ts

@@ -11,4 +11,4 @@ export declare class UUIDSchema extends StringSchema {
 /** Any valid UUID (versions 1-5) */
 export declare const UUID: UUIDSchema;
 /** Any valid UUID (versions 1-5) or null */
-export declare const OPTIONAL_UUID: import("./OptionalSchema.js").OptionalSchema<string>;
+export declare const NULLABLE_UUID: import("./NullableSchema.js").NullableSchema<string>;

package/schema/UUIDSchema.js

@@ -1,5 +1,5 @@
 import { getUUID } from "../util/uuid.js";
-import { OPTIONAL } from "./OptionalSchema.js";
+import { NULLABLE } from "./NullableSchema.js";
 import { StringSchema } from "./StringSchema.js";
 /**
  * Type of `StringSchema` that defines a valid UUID (versions 1-5). Defaults to any-version validation.
@@ -23,4 +23,4 @@ export class UUIDSchema extends StringSchema {
 /** Any valid UUID (versions 1-5) */
 export const UUID = new UUIDSchema({ title: "ID" });
 /** Any valid UUID (versions 1-5) or null */
-export const OPTIONAL_UUID = OPTIONAL(UUID);
+export const NULLABLE_UUID = NULLABLE(UUID);

package/schema/index.d.ts

@@ -1,8 +1,8 @@
 export * from "./Schema.js";
 export * from "./ThroughSchema.js";
+export * from "./NullableSchema.js";
 export * from "./OptionalSchema.js";
 export * from "./RequiredSchema.js";
-export * from "./PartialSchema.js";
 export * from "./AllowSchema.js";
 export * from "./ArraySchema.js";
 export * from "./BooleanSchema.js";
@@ -13,7 +13,6 @@ 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";

package/schema/index.js

@@ -1,9 +1,9 @@
 export * from "./Schema.js";
 // Utility schemas.
 export * from "./ThroughSchema.js";
+export * from "./NullableSchema.js";
 export * from "./OptionalSchema.js";
 export * from "./RequiredSchema.js";
-export * from "./PartialSchema.js";
 // Field schemas.
 export * from "./AllowSchema.js";
 export * from "./ArraySchema.js";
@@ -15,7 +15,6 @@ 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";

package/test/people.js

@@ -1,9 +1,9 @@
 import { DATA } from "../schema/DataSchema.js";
-import { OPTIONAL_DATE } from "../schema/DateSchema.js";
+import { NULLABLE_DATE } from "../schema/DateSchema.js";
 import { REQUIRED_STRING } from "../schema/StringSchema.js";
 export const PERSON_SCHEMA = DATA({
     name: DATA({ first: REQUIRED_STRING, last: REQUIRED_STRING }),
-    birthday: OPTIONAL_DATE,
+    birthday: NULLABLE_DATE,
 });
 export const person1 = { id: "person1", name: { first: "Dave", last: "Brook" }, birthday: "1985-12-06" };
 export const person2 = { id: "person2", name: { first: "Sally", last: "Callister" }, birthday: "1973-11-19" };

package/util/validate.d.ts

@@ -58,8 +58,10 @@ export declare function validateDictionary<T>(unsafeDictionary: ImmutableDiction
  * 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.
+ * - `undefined` props after validation will not be set in the output object.
+ *
+ * @param partial Whether we're validating a partial match or not. This allows props to be missing without error.
  *
- * @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).

package/util/validate.js

@@ -2,7 +2,7 @@ import { ValueError } from "../error/ValueError.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { ValueFeedbacks } from "../feedback/Feedbacks.js";
 import { isArray } from "./array.js";
-import { getDataProps } from "./data.js";
+import { getDataKeys, getDataProps } from "./data.js";
 import { getDictionaryItems } from "./dictionary.js";
 import { PASSTHROUGH } from "./function.js";
 import { isIterable } from "./iterate.js";
@@ -55,7 +55,7 @@ export function* validateItems(unsafeItems, validator) {
 export function validateArray(unsafeArray, validator) {
     let index = 0;
     let valid = true;
-    let changed = true;
+    let changed = false; // start false so we can reuse original if nothing changes
     const safeArray = [];
     const messages = {};
     for (const unsafeItem of unsafeArray) {
@@ -110,18 +110,20 @@ export function validateDictionary(unsafeDictionary, validator) {
 let isDeeplyPartial = false;
 export function validateData(unsafeData, validators, partial = isDeeplyPartial) {
     let valid = true;
-    let changed = true;
+    let changed = false;
     const safeData = {};
     const messages = {};
     try {
         isDeeplyPartial = partial;
-        for (const [key, validator] of getDataProps(validators)) {
+        const props = getDataProps(validators);
+        for (const [key, validator] of props) {
             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 (safeValue !== undefined)
+                    safeData[key] = safeValue;
                 if (!changed && safeValue !== unsafeValue)
                     changed = true;
             }
@@ -134,7 +136,9 @@ export function validateData(unsafeData, validators, partial = isDeeplyPartial)
         }
         if (!valid)
             throw new ValueFeedbacks(messages, unsafeData);
-        return changed ? safeData : unsafeData;
+        if (changed || getDataKeys(unsafeData).length > props.length)
+            return safeData;
+        return unsafeData;
     }
     finally {
         isDeeplyPartial = false;

package/schema/ItemSchema.d.ts

@@ -1,33 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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/PartialSchema.d.ts

@@ -1,18 +0,0 @@
-import type { Data } from "../util/data.js";
-import type { DataSchema } from "./DataSchema.js";
-import type { SchemaOptions } from "./Schema.js";
-import { ThroughSchema } from "./ThroughSchema.js";
-/** Allowed options for `PartialSchema` */
-export interface PartialSchemaOptions<T extends Data> extends SchemaOptions {
-    readonly source: DataSchema<T>;
-    readonly value?: Partial<T> | undefined;
-}
-/** Validate a partial value for a given `DataSchema` source. */
-export declare class PartialSchema<T extends Data> extends ThroughSchema<Partial<T>> {
-    readonly source: DataSchema<T>;
-    readonly value: Partial<T>;
-    constructor({ value, ...options }: PartialSchemaOptions<T>);
-    validate(unsafeValue?: unknown): Partial<T>;
-}
-/** Create a new partial schema from a `DataSchema` source. */
-export declare const PARTIAL: <T extends Data>(source: DataSchema<T>) => PartialSchema<T>;

package/schema/PartialSchema.js

@@ -1,17 +0,0 @@
-import { ValueFeedback } from "../feedback/Feedback.js";
-import { isData } from "../util/data.js";
-import { validateData } from "../util/validate.js";
-import { ThroughSchema } from "./ThroughSchema.js";
-/** Validate a partial value for a given `DataSchema` source. */
-export class PartialSchema extends ThroughSchema {
-    constructor({ value = {}, ...options }) {
-        super({ value, ...options });
-    }
-    validate(unsafeValue = this.value) {
-        if (!isData(unsafeValue))
-            throw new ValueFeedback("Must be object", unsafeValue);
-        return validateData(unsafeValue, this.source.props, true);
-    }
-}
-/** Create a new partial schema from a `DataSchema` source. */
-export const PARTIAL = (source) => new PartialSchema({ source });