shelving 1.121.1 → 1.123.0

package/package.json

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

package/schema/AllowSchema.d.ts

@@ -3,9 +3,10 @@ import type { Entry } from "../util/entry.js";
 import type { ImmutableMap, PossibleMap, PossibleStringMap } from "../util/map.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `AllowSchama` */
-export type AllowSchemaOptions<K, T> = Omit<SchemaOptions, "value"> & {
+export interface AllowSchemaOptions<K, T> extends Omit<SchemaOptions, "value"> {
+    /** Specify correct options using a `Map` or iterable set of entries. */
     allow: PossibleMap<K, T>;
-};
+}
 /** Define a valid value from an allowed set of values. */
 export declare class AllowSchema<K, T> extends Schema<K> implements Iterable<Entry<K, T>> {
     readonly value: K;
@@ -17,6 +18,7 @@ export declare class AllowSchema<K, T> extends Schema<K> implements Iterable<Ent
 }
 /** Allowed options for `AllowStringSchama` */
 export type AllowStringSchemaOptions<K extends string, T> = Omit<SchemaOptions, "value"> & {
+    /** Specify correct options using a `Map`, iterable set of entries, or an object with string keys. */
     allow: PossibleStringMap<K, T>;
 };
 /** Define a valid string value from an allowed set of string values. */

package/schema/AllowSchema.js

@@ -8,7 +8,8 @@ export class AllowSchema extends Schema {
     allow;
     constructor(options) {
         const allow = getMap(options.allow);
-        super({ value: getFirstItem(allow.keys()), ...options });
+        const value = getFirstItem(allow.keys());
+        super({ value, ...options });
         this.allow = allow;
     }
     validate(unsafeValue = this.value) {

package/schema/ArraySchema.d.ts

@@ -3,13 +3,13 @@ import type { ImmutableArray } from "../util/array.js";
 import type { Validator } from "../util/validate.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `ArraySchema` */
-export type ArraySchemaOptions<T> = SchemaOptions & {
+export interface ArraySchemaOptions<T> extends SchemaOptions {
     readonly value?: ImmutableArray;
     readonly items: Validator<T>;
     readonly min?: number;
     readonly max?: number;
     readonly unique?: boolean;
-};
+}
 /**
  * Define a valid array.
  *
@@ -43,7 +43,7 @@ export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     readonly unique: boolean;
     readonly min: number;
     readonly max: number;
-    constructor(options: ArraySchemaOptions<T>);
+    constructor({ items, unique, min, max, title, value, ...options }: ArraySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableArray<T>;
 }
 /** Valid array with specifed items. */

package/schema/ArraySchema.js

@@ -34,9 +34,8 @@ export class ArraySchema extends Schema {
     unique;
     min;
     max;
-    constructor(options) {
-        super({ value: [], ...options });
-        const { items, unique = false, min = 0, max = Infinity } = options;
+    constructor({ items, unique = false, min = 0, max = Infinity, title = "Items", value = [], ...options }) {
+        super({ title, value, ...options });
         this.items = items;
         this.unique = unique;
         this.min = min;

package/schema/BooleanSchema.d.ts

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

package/schema/BooleanSchema.js

@@ -1,8 +1,8 @@
 import { Schema } from "./Schema.js";
 /** Define a valid boolean. */
 export class BooleanSchema extends Schema {
-    constructor(options) {
-        super({ value: false, ...options });
+    constructor({ value = false, ...options }) {
+        super({ value, ...options });
     }
     validate(unsafeValue = this.value) {
         return !!unsafeValue;

package/schema/ColorSchema.d.ts

@@ -10,7 +10,7 @@ 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(options: Omit<StringSchemaOptions, "type" | "min" | "max" | "multiline" | "match">);
+    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

@@ -12,10 +12,10 @@ 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 {
-    constructor(options) {
+    constructor({ title = "Color", value = "#000000", ...options }) {
         super({
-            title: "Color",
-            value: "#000000",
+            title,
+            value,
             ...options,
             type: "color",
             min: 1,

package/schema/DataSchema.d.ts

@@ -4,15 +4,15 @@ import type { Data, Database } from "../util/data.js";
 import type { Validators } from "../util/validate.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `DataSchema` */
-export type DataSchemaOptions<T extends Data> = SchemaOptions & {
+export interface DataSchemaOptions<T extends Data> extends SchemaOptions {
     readonly props: Validators<T>;
     readonly value?: Partial<T> | undefined;
-};
+}
 /** Validate a data object. */
 export declare class DataSchema<T extends Data> extends Schema<T> {
     readonly value: Partial<T>;
     readonly props: Validators<T>;
-    constructor(options: DataSchemaOptions<T>);
+    constructor({ props, title, value, ...options }: DataSchemaOptions<T>);
     validate(unsafeValue?: unknown): T;
 }
 /** Set of named data schemas. */

package/schema/DataSchema.js

@@ -6,9 +6,9 @@ import { Schema } from "./Schema.js";
 /** Validate a data object. */
 export class DataSchema extends Schema {
     props;
-    constructor(options) {
-        super({ value: {}, ...options });
-        this.props = options.props;
+    constructor({ props, title = "Data", value = {}, ...options }) {
+        super({ title, value, ...options });
+        this.props = props;
     }
     validate(unsafeValue = this.value) {
         if (!isData(unsafeValue))

package/schema/DateSchema.d.ts

@@ -3,17 +3,17 @@ import type { PossibleDate } from "../util/date.js";
 import type { Optional } from "../util/optional.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `DateSchema` */
-export type DateSchemaOptions = SchemaOptions & {
+export interface DateSchemaOptions extends SchemaOptions {
     readonly value?: PossibleDate | undefined;
     readonly min?: Optional<PossibleDate> | undefined;
     readonly max?: Optional<PossibleDate> | undefined;
-};
+}
 /** Define a valid date in YMD format, e.g. `2005-09-12` */
 export declare class DateSchema extends Schema<string> {
     readonly value: PossibleDate;
     readonly min: Date | undefined;
     readonly max: Date | undefined;
-    constructor(options: DateSchemaOptions);
+    constructor({ min, max, title, value, ...options }: DateSchemaOptions);
     validate(unsafeValue?: unknown): string;
 }
 /** Valid date, e.g. `2005-09-12` (required because falsy values are invalid). */

package/schema/DateSchema.js

@@ -6,9 +6,8 @@ import { Schema } from "./Schema.js";
 export class DateSchema extends Schema {
     min;
     max;
-    constructor(options) {
-        super({ title: "Date", value: "now", ...options });
-        const { min = null, max = null } = options;
+    constructor({ min = null, max = null, title = "Date", value = "now", ...options }) {
+        super({ title, value, ...options });
         this.min = getOptionalDate(min);
         this.max = getOptionalDate(max);
     }

package/schema/DictionarySchema.d.ts

@@ -3,19 +3,19 @@ import type { ImmutableDictionary } from "../util/dictionary.js";
 import type { Validator } from "../util/validate.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `DictionarySchema` */
-export type DictionarySchemaOptions<T> = SchemaOptions & {
+export interface DictionarySchemaOptions<T> extends SchemaOptions {
     readonly items: Validator<T>;
     readonly value?: ImmutableDictionary | undefined;
     readonly min?: number | undefined;
     readonly max?: number | undefined;
-};
+}
 /** Validate a dictionary object (whose props are all the same with string keys). */
 export declare class DictionarySchema<T> extends Schema<ImmutableDictionary<T>> {
     readonly value: ImmutableDictionary;
     readonly items: Validator<T>;
     readonly min: number;
     readonly max: number;
-    constructor(options: DictionarySchemaOptions<T>);
+    constructor({ items, min, max, title, value, ...options }: DictionarySchemaOptions<T>);
     validate(unsafeValue?: unknown): ImmutableDictionary<T>;
 }
 /** Valid dictionary object with specifed items. */

package/schema/DictionarySchema.js

@@ -7,9 +7,8 @@ export class DictionarySchema extends Schema {
     items;
     min;
     max;
-    constructor(options) {
-        super({ value: {}, ...options });
-        const { items, min = 0, max = Infinity } = options;
+    constructor({ items, min = 0, max = Infinity, title = "Items", value = {}, ...options }) {
+        super({ title, value, ...options });
         this.items = items;
         this.min = min;
         this.max = max;

package/schema/EmailSchema.d.ts

@@ -18,10 +18,10 @@ import { StringSchema } from "./StringSchema.js";
  *     - TLD is a segment of 2-63 characters, possibly in `xn--` international format.
  */
 export declare class EmailSchema extends StringSchema {
-    constructor(options: Omit<StringSchemaOptions, "type" | "min" | "max" | "match" | "multiline">);
+    constructor({ title, ...options }: Omit<StringSchemaOptions, "type" | "min" | "max" | "match" | "multiline">);
     sanitize(uncleanString: string): string;
 }
 /** Valid email, e.g. `test@test.com` */
 export declare const EMAIL: EmailSchema;
-/** Valid email, e.g. `test@test.com`, or `null` */
+/** Valid optional email, e.g. `test@test.com`, or `null` */
 export declare const OPTIONAL_EMAIL: import("./OptionalSchema.js").OptionalSchema<string>;

package/schema/EmailSchema.js

@@ -19,9 +19,9 @@ const R_MATCH = /^[a-z0-9](?:[a-zA-Z0-9._+-]{0,62}[a-zA-Z0-9])?@(?:[a-z0-9](?:[a
  *     - TLD is a segment of 2-63 characters, possibly in `xn--` international format.
  */
 export class EmailSchema extends StringSchema {
-    constructor(options) {
+    constructor({ title = "Email", ...options }) {
         super({
-            title: "Email",
+            title,
             ...options,
             type: "email",
             min: 1,
@@ -37,5 +37,5 @@ export class EmailSchema extends StringSchema {
 }
 /** Valid email, e.g. `test@test.com` */
 export const EMAIL = new EmailSchema({});
-/** Valid email, e.g. `test@test.com`, or `null` */
+/** Valid optional email, e.g. `test@test.com`, or `null` */
 export const OPTIONAL_EMAIL = OPTIONAL(EMAIL);

package/schema/EntitySchema.d.ts

@@ -0,0 +1,17 @@
+import { type ImmutableArray } from "../util/array.js";
+import { type Entity } from "../util/entity.js";
+import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
+/** Allowed options for `EntitySchema` with specific types */
+export interface EntitySchemaOptions<T extends string> extends StringSchemaOptions {
+    readonly types?: ImmutableArray<T> | undefined;
+}
+/** Validate a file name matching one or more extensions. */
+export declare class EntitySchema<T extends string> extends StringSchema {
+    readonly types: ImmutableArray<T> | undefined;
+    constructor({ types, title, ...options }: EntitySchemaOptions<T>);
+    validate(unsafeValue?: unknown): Entity<T>;
+}
+/** 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}`>;

package/schema/EntitySchema.js

@@ -0,0 +1,26 @@
+import { Feedback } from "../feedback/Feedback.js";
+import { isArrayItem } from "../util/array.js";
+import { splitOptionalEntity } from "../util/entity.js";
+import { OPTIONAL } from "./OptionalSchema.js";
+import { StringSchema } from "./StringSchema.js";
+/** Validate a file name matching one or more extensions. */
+export class EntitySchema extends StringSchema {
+    types;
+    constructor({ types, title = "Entity", ...options }) {
+        super({ title, ...options });
+        this.types = types;
+    }
+    validate(unsafeValue = this.value) {
+        const entity = super.validate(unsafeValue);
+        const [type] = splitOptionalEntity(entity);
+        if (!type)
+            throw new Feedback("Must be entity", unsafeValue);
+        if (this.types && !isArrayItem(this.types, type))
+            throw new Feedback("Invalid entity type", type);
+        return entity;
+    }
+}
+/** 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);

package/schema/FileSchema.d.ts

@@ -0,0 +1,16 @@
+import type { FileTypes } from "../util/file.js";
+import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
+/** Allowed options for `FileSchema` */
+export interface FileSchemaOptions extends StringSchemaOptions {
+    readonly types?: FileTypes | undefined;
+}
+/** Validate a file name matching one or more extensions. */
+export declare class FileSchema extends StringSchema {
+    readonly types: FileTypes | undefined;
+    constructor({ types, title, ...options }: FileSchemaOptions);
+    validate(unsafeValue?: unknown): string;
+}
+/** 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>;

package/schema/FileSchema.js

@@ -0,0 +1,26 @@
+import { Feedback } from "../feedback/Feedback.js";
+import { getOptionalFileExtension } from "../util/file.js";
+import { isProp } from "../util/object.js";
+import { OPTIONAL } from "./OptionalSchema.js";
+import { StringSchema } from "./StringSchema.js";
+/** Validate a file name matching one or more extensions. */
+export class FileSchema extends StringSchema {
+    types;
+    constructor({ types, title = "File", ...options }) {
+        super({ title, ...options });
+        this.types = types;
+    }
+    validate(unsafeValue = this.value) {
+        const path = super.validate(unsafeValue);
+        const extension = getOptionalFileExtension(path);
+        if (!extension)
+            throw new Feedback("Must be file name with extension", unsafeValue);
+        if (this.types && !isProp(this.types, extension))
+            throw new Feedback("Invalid file type", extension);
+        return path;
+    }
+}
+/** 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);

package/schema/KeySchema.d.ts

@@ -6,7 +6,7 @@ import { StringSchema, type StringSchemaOptions } from "./StringSchema.js";
  * - Default maximum key length is 64 characters.
  */
 export declare class KeySchema extends StringSchema {
-    constructor(options: StringSchemaOptions);
+    constructor({ min, max, ...options }: StringSchemaOptions);
 }
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */
 export declare const KEY: KeySchema;

package/schema/KeySchema.js

@@ -7,8 +7,8 @@ import { StringSchema } from "./StringSchema.js";
  * - Default maximum key length is 64 characters.
  */
 export class KeySchema extends StringSchema {
-    constructor(options) {
-        super({ min: 1, max: 64, ...options });
+    constructor({ min = 1, max = 64, ...options }) {
+        super({ min, max, ...options });
     }
 }
 /** Valid color hex string, e.g. `#00CCFF` (required because empty string is invalid). */

package/schema/LinkSchema.d.ts

@@ -2,10 +2,10 @@ import type { StringSchemaOptions } from "./StringSchema.js";
 import type { ImmutableArray } from "../util/array.js";
 import { StringSchema } from "./StringSchema.js";
 /** Allowed options for `LinkSchema` */
-export type LinkSchemaOptions = Omit<StringSchemaOptions, "type" | "min" | "max" | "multiline"> & {
+export interface LinkSchemaOptions extends Omit<StringSchemaOptions, "type" | "min" | "max" | "multiline"> {
     readonly schemes?: ImmutableArray<string> | undefined;
     readonly hosts?: ImmutableArray<string> | undefined;
-};
+}
 /**
  * Type of `StringSchema` that defines a valid URL.
  * - Checks URL scheme against a whitelist (always), and checks URL domain against a whitelist (optional).
@@ -15,7 +15,7 @@ export type LinkSchemaOptions = Omit<StringSchemaOptions, "type" | "min" | "max"
 export declare class LinkSchema extends StringSchema {
     readonly schemes: ImmutableArray<string>;
     readonly hosts: ImmutableArray<string> | undefined;
-    constructor(options: LinkSchemaOptions);
+    constructor({ schemes, hosts, title, ...options }: LinkSchemaOptions);
     validate(unsafeValue: unknown): string;
 }
 /** Valid link, e.g. `https://www.google.com` */

package/schema/LinkSchema.js

@@ -11,17 +11,17 @@ import { StringSchema } from "./StringSchema.js";
 export class LinkSchema extends StringSchema {
     schemes;
     hosts;
-    constructor(options) {
+    constructor({ schemes = ["http:", "https:"], hosts, title = "Link", ...options }) {
         super({
-            title: "Link",
+            title,
             ...options,
             type: "url",
             min: 1,
             max: 512,
             multiline: false,
         });
-        this.schemes = options.schemes || ["http:", "https:"];
-        this.hosts = options.hosts;
+        this.schemes = schemes;
+        this.hosts = hosts;
     }
     // Override to clean the URL using the builtin `URL` class and check the schemes and hosts against the whitelists.
     validate(unsafeValue) {

package/schema/NumberSchema.d.ts

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

package/schema/NumberSchema.js

@@ -7,9 +7,8 @@ export class NumberSchema extends Schema {
     min;
     max;
     step;
-    constructor(options) {
-        super({ title: "Number", value: 0, ...options });
-        const { min = -Infinity, max = Infinity, step } = options;
+    constructor({ min = -Infinity, max = Infinity, step, title = "Number", value = 0, ...options }) {
+        super({ title, value, ...options });
         this.min = min;
         this.max = max;
         this.step = step;

package/schema/OptionalSchema.d.ts

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

package/schema/OptionalSchema.js

@@ -1,8 +1,8 @@
 import { ThroughSchema } from "./ThroughSchema.js";
 /** Validate a value of a specific type or `null`. */
 export class OptionalSchema extends ThroughSchema {
-    constructor(options) {
-        super({ value: null, ...options });
+    constructor({ value = null, ...options }) {
+        super({ value, ...options });
     }
     validate(unsafeValue = this.value) {
         if (unsafeValue === null || unsafeValue === undefined || unsafeValue === "" || Number.isNaN(unsafeValue))

package/schema/PhoneSchema.d.ts

@@ -6,7 +6,7 @@ import { StringSchema } from "./StringSchema.js";
  * - Falsy values are converted to `""` empty string.
  */
 export declare class PhoneSchema extends StringSchema {
-    constructor(options: StringSchemaOptions);
+    constructor({ title, ...options }: StringSchemaOptions);
     sanitize(insaneString: string): string;
 }
 /** Valid phone number, e.g. `+441234567890` */

package/schema/PhoneSchema.js

@@ -10,9 +10,9 @@ const PHONE_REGEXP = /^\+[1-9][0-9]{0,2}[0-9]{5,12}$/;
  * - Falsy values are converted to `""` empty string.
  */
 export class PhoneSchema extends StringSchema {
-    constructor(options) {
+    constructor({ title = "Phone", ...options }) {
         super({
-            title: "Phone",
+            title,
             ...options,
             type: "tel",
             min: 1,

package/schema/StringSchema.d.ts

@@ -5,7 +5,7 @@ export type HtmlInputType = "text" | "password" | "color" | "date" | "email" | "
 /** Function that sanitizes a string. */
 export type Sanitizer = (str: string) => string;
 /** Options for `StringSchema` */
-export type StringSchemaOptions = SchemaOptions & {
+export interface StringSchemaOptions extends SchemaOptions {
     readonly value?: string | undefined;
     readonly type?: HtmlInputType | undefined;
     readonly min?: number | undefined;
@@ -13,7 +13,7 @@ export type StringSchemaOptions = SchemaOptions & {
     readonly match?: RegExp | undefined;
     readonly sanitizer?: Sanitizer | undefined;
     readonly multiline?: boolean | undefined;
-};
+}
 /**
  * Schema that defines a valid string.
  *
@@ -42,7 +42,7 @@ export declare class StringSchema extends Schema<string> {
     readonly match: RegExp | undefined;
     readonly sanitizer: Sanitizer | undefined;
     readonly multiline: boolean;
-    constructor(options: StringSchemaOptions);
+    constructor({ type, min, max, match, sanitizer, multiline, value, ...options }: StringSchemaOptions);
     validate(unsafeValue?: unknown): string;
     /**
      * Clean a string by removing characters that aren't digits.

package/schema/StringSchema.js

@@ -29,9 +29,8 @@ export class StringSchema extends Schema {
     match;
     sanitizer;
     multiline;
-    constructor(options) {
-        super({ value: "", ...options });
-        const { type = "text", min = 0, max = Infinity, match, sanitizer, multiline = false } = options;
+    constructor({ type = "text", min = 0, max = Infinity, match, sanitizer, multiline = false, value = "", ...options }) {
+        super({ value, ...options });
         this.type = type;
         this.min = min;
         this.max = max;

package/schema/ThroughSchema.d.ts

@@ -2,12 +2,12 @@ import type { SchemaOptions } from "./Schema.js";
 import type { Sourceable } from "../util/source.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `ThroughSchama` */
-export type ThroughSchemaOptions<T> = SchemaOptions & {
+export interface ThroughSchemaOptions<T> extends SchemaOptions {
     source: Schema<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>;
-    constructor(options: ThroughSchemaOptions<T>);
+    constructor({ source, ...options }: ThroughSchemaOptions<T>);
     validate(unsafeValue: unknown): T;
 }

package/schema/ThroughSchema.js

@@ -2,8 +2,7 @@ import { Schema } from "./Schema.js";
 /** Schema that passes through to a source schema. */
 export class ThroughSchema extends Schema {
     source;
-    constructor(options) {
-        const source = options.source;
+    constructor({ source, ...options }) {
         super({ ...source, ...options });
         this.source = source;
     }

package/schema/TimeSchema.d.ts

@@ -4,12 +4,12 @@ import type { PossibleTime } from "../util/time.js";
 import { Time } from "../util/time.js";
 import { Schema } from "./Schema.js";
 /** Allowed options for `TimeSchama` */
-export type TimeSchemaOptions = SchemaOptions & {
+export interface TimeSchemaOptions extends SchemaOptions {
     readonly value?: PossibleTime | undefined;
     readonly min?: Optional<PossibleTime> | undefined;
     readonly max?: Optional<PossibleTime> | undefined;
     readonly step?: number | undefined;
-};
+}
 /** Define a valid time in 24h hh:mm:ss.fff format, e.g. `23:59` or `24:00 */
 export declare class TimeSchema extends Schema<string> {
     readonly value: PossibleTime;
@@ -20,7 +20,7 @@ export declare class TimeSchema extends Schema<string> {
      * - Note: `<input type="time">` elements expect `step=""` to be  in _seconds_ so you need to multiply this by `1000`
      */
     readonly step: number | undefined;
-    constructor(options: TimeSchemaOptions);
+    constructor({ min, max, step, title, value, ...options }: TimeSchemaOptions);
     validate(unsafeValue?: unknown): string;
 }
 /** Valid time, e.g. `2005-09-12` (required because falsy values are invalid). */

package/schema/TimeSchema.js

@@ -12,9 +12,8 @@ export class TimeSchema extends Schema {
      * - Note: `<input type="time">` elements expect `step=""` to be  in _seconds_ so you need to multiply this by `1000`
      */
     step;
-    constructor(options) {
-        super({ title: "Time", value: "now", ...options });
-        const { min = null, max = null, step = 60 } = options;
+    constructor({ min = null, max = null, step = 60, title = "Time", value = "now", ...options }) {
+        super({ title, value, ...options });
         this.min = getOptionalTime(min);
         this.max = getOptionalTime(max);
         this.step = step;

package/schema/index.d.ts

@@ -7,6 +7,8 @@ export * from "./DataSchema.js";
 export * from "./DateSchema.js";
 export * from "./DictionarySchema.js";
 export * from "./EmailSchema.js";
+export * from "./EntitySchema.js";
+export * from "./FileSchema.js";
 export * from "./KeySchema.js";
 export * from "./LinkSchema.js";
 export * from "./NumberSchema.js";

package/schema/index.js

@@ -7,6 +7,8 @@ export * from "./DataSchema.js";
 export * from "./DateSchema.js";
 export * from "./DictionarySchema.js";
 export * from "./EmailSchema.js";
+export * from "./EntitySchema.js";
+export * from "./FileSchema.js";
 export * from "./KeySchema.js";
 export * from "./LinkSchema.js";
 export * from "./NumberSchema.js";

package/util/entity.d.ts

@@ -0,0 +1,16 @@
+import type { Optional } from "./optional.js";
+/** Entity strings combine a type and ID, e.g. `challenge:a1b2c3` */
+export type Entity<T extends string = string> = `${T}:${string}`;
+/** Extract the type from an `Entity` string. */
+export type EntityType<E extends Entity> = E extends Entity<infer T> ? T : never;
+/** Empty entity has undefined type and ID. */
+export type EmptyEntity = [type: undefined, id: undefined];
+/** Empty entity. */
+export declare const EMPTY_ENTITY: EmptyEntity;
+/** Split an entity tag like `challenge:a1b2c3` into `type` and `id` */
+export declare function splitEntity<T extends string>(entity: Entity<T>): [type: T, id: string];
+export declare function splitEntity(entity: string): [type: string, id: string];
+/** Split an optional entity tag like `challenge:a1b2c3` into `["challenge", "a1b2c3"]`, or `undefined` or `null` */
+export declare function splitOptionalEntity<T extends string>(entity: Entity<T>): [type: T, id: string];
+export declare function splitOptionalEntity<T extends string>(entity: Optional<Entity<T>>): [type: T, id: string] | EmptyEntity;
+export declare function splitOptionalEntity(entity: Optional<string>): [type: string, id: string] | EmptyEntity;

package/util/entity.js

@@ -0,0 +1,17 @@
+import { ValueError } from "../error/ValueError.js";
+/** Empty entity. */
+export const EMPTY_ENTITY = [undefined, undefined];
+export function splitEntity(entity) {
+    const bits = entity.split(":", 2);
+    if (bits[0] && bits[1])
+        return bits;
+    throw new ValueError("Invalid entity");
+}
+export function splitOptionalEntity(entity) {
+    if (entity) {
+        const bits = entity.split(":", 2);
+        if (bits[0] && bits[1])
+            return bits;
+    }
+    return EMPTY_ENTITY;
+}

package/util/file.d.ts

@@ -0,0 +1,8 @@
+/** List of file types in `extension: mime` format. */
+export type FileTypes = {
+    [extension: string]: string;
+};
+/** Get the file extension from a file path, or return `undefined` if the input has no extension. */
+export declare function getOptionalFileExtension(file: string): string | undefined;
+/** Get the file extension from a file path, or throw `ValueError` if the input has no extension. */
+export declare function getFileExtension(path: string): string;

package/util/file.js

@@ -0,0 +1,13 @@
+import { ValueError } from "../error/ValueError.js";
+/** Get the file extension from a file path, or return `undefined` if the input has no extension. */
+export function getOptionalFileExtension(file) {
+    const i = file.lastIndexOf(".");
+    return (i >= 0 && file.slice(i + 1)) || undefined;
+}
+/** Get the file extension from a file path, or throw `ValueError` if the input has no extension. */
+export function getFileExtension(path) {
+    const extension = getOptionalFileExtension(path);
+    if (!extension)
+        throw new ValueError("File extension is required", path);
+    return extension;
+}

package/util/index.d.ts

@@ -13,9 +13,11 @@ export * from "./dictionary.js";
 export * from "./diff.js";
 export * from "./dispose.js";
 export * from "./duration.js";
+export * from "./entity.js";
 export * from "./entry.js";
 export * from "./equal.js";
 export * from "./error.js";
+export * from "./file.js";
 export * from "./focus.js";
 export * from "./function.js";
 export * from "./hash.js";

package/util/index.js

@@ -13,9 +13,11 @@ export * from "./dictionary.js";
 export * from "./diff.js";
 export * from "./dispose.js";
 export * from "./duration.js";
+export * from "./entity.js";
 export * from "./entry.js";
 export * from "./equal.js";
 export * from "./error.js";
+export * from "./file.js";
 export * from "./focus.js";
 export * from "./function.js";
 export * from "./hash.js";