shelving 1.82.1 → 1.83.0

package/constraint/QueryConstraints.js

@@ -1,4 +1,4 @@
-import { getObjectProp } from "../util/object.js";
+import { getProp } from "../util/object.js";
 import { assert } from "../util/assert.js";
 import { limitItems } from "../util/iterate.js";
 import { FilterConstraints } from "./FilterConstraints.js";
@@ -96,7 +96,7 @@ function* _getAfterFilters(sorts, item) {
     for (const sort of sorts) {
         const { key, direction } = sort;
         const filterKey = direction === "ASC" ? (sort === lastSort ? `${key}>` : `${key}>=`) : sort === lastSort ? `${key}<` : `${key}<=`;
-        yield new FilterConstraint(filterKey, getObjectProp(item, key));
+        yield new FilterConstraint(filterKey, getProp(item, key));
     }
 }
 function* _getBeforeFilters(sorts, item) {
@@ -105,6 +105,6 @@ function* _getBeforeFilters(sorts, item) {
     for (const sort of sorts) {
         const { key, direction } = sort;
         const filterKey = direction === "ASC" ? (sort === lastSort ? `${key}<` : `${key}<=`) : sort === lastSort ? `${key}>` : `${key}>=`;
-        yield new FilterConstraint(filterKey, getObjectProp(item, key));
+        yield new FilterConstraint(filterKey, getProp(item, key));
     }
 }

package/feedback/Feedback.d.ts

@@ -1,4 +1,4 @@
-import { ImmutableObject } from "../util/object.js";
+import type { ImmutableDictionary } from "../util/dictionary.js";
 /**
  * The `Feedback` class represents a feedback message that should be shown to the user.
  * - Basic `Feedback` is neither good nor bad, `SuccessFeedback` indicates good news, and `ErrorFeedback` indicates bad news.
@@ -24,4 +24,4 @@ export declare const isFeedback: <T extends Feedback<unknown>>(v: unknown) => v
  * Get an object of sub-messages in `{ key: message }` format from a feedback's value.
  * - Takes the `.value` property from a `Feedback` instance and looks for keyed `Feedback` instances in either `{ key: Feedback }`. `Feedback[]`, or `Map<key, Feedback>` formats.
  */
-export declare const getFeedbackMessages: ({ value }: Feedback) => ImmutableObject<string>;
+export declare const getFeedbackMessages: ({ value }: Feedback) => ImmutableDictionary<string>;

package/feedback/Feedback.js

@@ -4,9 +4,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { isObject } from "../util/object.js";
 import { getEntries } from "../util/entry.js";
 import { setPrototype } from "../util/class.js";
+import { isObject } from "../util/object.js";
+import { getString } from "../util/string.js";
 /**
  * The `Feedback` class represents a feedback message that should be shown to the user.
  * - Basic `Feedback` is neither good nor bad, `SuccessFeedback` indicates good news, and `ErrorFeedback` indicates bad news.
@@ -38,5 +39,5 @@ function* _yieldFeedbackMessages(value) {
     if (isObject(value))
         for (const [k, v] of getEntries(value))
             if (isFeedback(v))
-                yield [k, v.message];
+                yield [getString(k), v.message];
 }

package/firestore/client/FirestoreClientProvider.js

@@ -1,6 +1,6 @@
 import { orderBy as firestoreOrderBy, where as firestoreWhere, limit as firestoreLimit, increment as firestoreIncrement, arrayUnion as firestoreArrayUnion, arrayRemove as firestoreArrayRemove, deleteField as firestoreDeleteField, collection as firestoreCollection, doc as firestoreDocument, query as firestoreQuery, onSnapshot, addDoc, setDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore";
 import { LazyDeferredSequence } from "../../sequence/LazyDeferredSequence.js";
-import { ArrayUpdate, DataUpdate, Increment, ObjectUpdate, Delete, Update } from "../../update/index.js";
+import { ArrayUpdate, DataUpdate, Increment, DictionaryUpdate, Delete, Update } from "../../update/index.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
 const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
@@ -47,7 +47,7 @@ function _getItemValue(snapshot) {
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
 function* _getFieldValues(updates, prefix = "") {
     for (const [key, update] of updates) {
-        if (update instanceof DataUpdate || update instanceof ObjectUpdate) {
+        if (update instanceof DataUpdate || update instanceof DictionaryUpdate) {
             yield* _getFieldValues(update, `${prefix}${key}.`);
         }
         else if (update instanceof ArrayUpdate) {

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,6 +1,6 @@
 import { orderBy as firestoreOrderBy, where as firestoreWhere, limit as firestoreLimit, increment as firestoreIncrement, arrayUnion as firestoreArrayUnion, arrayRemove as firestoreArrayRemove, deleteField as firestoreDeleteField, collection as firestoreCollection, doc as firestoreDocument, query as firestoreQuery, setDoc, addDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore/lite";
 import { UnsupportedError } from "../../error/UnsupportedError.js";
-import { ArrayUpdate, DataUpdate, Increment, ObjectUpdate, Delete, Update } from "../../update/index.js";
+import { ArrayUpdate, DataUpdate, Increment, DictionaryUpdate, Delete, Update } from "../../update/index.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
 const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
@@ -47,7 +47,7 @@ function _getItemValue(snapshot) {
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
 function* _getFieldValues(updates, prefix = "") {
     for (const [key, update] of updates) {
-        if (update instanceof DataUpdate || update instanceof ObjectUpdate) {
+        if (update instanceof DataUpdate || update instanceof DictionaryUpdate) {
             yield* _getFieldValues(update, `${prefix}${key}.`);
         }
         else if (update instanceof ArrayUpdate) {

package/firestore/server/FirestoreServerProvider.js

@@ -1,6 +1,6 @@
 import { Firestore, FieldValue as FirestoreFieldValue } from "@google-cloud/firestore";
 import { LazyDeferredSequence } from "../../sequence/LazyDeferredSequence.js";
-import { ArrayUpdate, DataUpdate, Increment, ObjectUpdate, Delete, Update } from "../../update/index.js";
+import { ArrayUpdate, DataUpdate, Increment, DictionaryUpdate, Delete, Update } from "../../update/index.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
 const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
@@ -47,7 +47,7 @@ function _getItemValue(snapshot) {
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
 function* _getFieldValues(updates, prefix = "") {
     for (const [key, update] of updates) {
-        if (update instanceof DataUpdate || update instanceof ObjectUpdate) {
+        if (update instanceof DataUpdate || update instanceof DictionaryUpdate) {
             yield* _getFieldValues(update, `${prefix}${key}.`);
         }
         else if (update instanceof ArrayUpdate) {

package/package.json

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

package/provider/MemoryProvider.d.ts

@@ -1,6 +1,6 @@
 import type { Data, Datas, DataKey } from "../util/data.js";
 import type { ItemArray, ItemValue, ItemData, ItemConstraints } from "../db/Item.js";
-import type { Updates } from "../update/DataUpdate.js";
+import { Updates } from "../update/DataUpdate.js";
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
 import type { Provider } from "./Provider.js";
 /**

package/provider/MemoryProvider.js

@@ -1,9 +1,9 @@
+import { updateData } from "../update/DataUpdate.js";
 import { QueryConstraints } from "../constraint/QueryConstraints.js";
 import { getRandomKey } from "../util/random.js";
 import { isArrayEqual } from "../util/equal.js";
 import { RequiredError } from "../error/RequiredError.js";
 import { getArray } from "../util/array.js";
-import { transformData } from "../util/transform.js";
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
 /**
  * Fast in-memory store for data.
@@ -135,7 +135,7 @@ export class MemoryTable {
         const item = this._data.get(id);
         if (!item)
             throw new RequiredError(`Document "${id}" does not exist`);
-        this._data.set(id, { ...transformData(item, updates), id });
+        this._data.set(id, { ...updateData(item, updates), id });
         this._times.set(id, Date.now());
         this._changed.resolve();
     }
@@ -231,7 +231,7 @@ export class MemoryTable {
         let count = 0;
         for (const item of _getWriteConstraints(constraints).transform(this._data.values())) {
             const id = item.id;
-            this._data.set(id, { ...transformData(item, updates), id });
+            this._data.set(id, { ...updateData(item, updates), id });
             this._times.set(id, now);
             count++;
         }

package/provider/ValidationProvider.js

@@ -103,9 +103,9 @@ function _validateItem(collection, unsafeEntity, schema) {
 }
 /** Validate a set of entities for this query reference. */
 function _validateItems(collection, unsafeEntities, schema) {
-    return Array.from(_yieldItems(collection, unsafeEntities, schema));
+    return Array.from(_yieldValidItems(collection, unsafeEntities, schema));
 }
-function* _yieldItems(collection, unsafeEntities, schema) {
+function* _yieldValidItems(collection, unsafeEntities, schema) {
     let invalid = false;
     const details = {};
     for (const unsafeEntity of unsafeEntities) {

package/schema/AllowSchema.d.ts

@@ -1,28 +1,29 @@
-import { Schema } from "./Schema.js";
-/** Specify a specific list of allowed values. */
-export declare type Allowed<T extends string | number> = ReadonlyArray<T> | {
-    readonly [K in T]: unknown;
+import type { Entry } from "../util/entry.js";
+import { ImmutableRequiredMap, PossibleMap, PossibleStringMap } from "../util/map.js";
+import { Schema, SchemaOptions } from "./Schema.js";
+/** Options for an `AllowSchema` instance. */
+declare type AllowSchemaOptions<K, T> = SchemaOptions & {
+    allow: PossibleMap<K, T>;
+    value?: K | null;
 };
-/** Validate a value against a specific set of allowed values. */
-export declare function validateAllowed<T extends string | number>(value: unknown, allowed: Allowed<T>): T;
 /** Define a valid value from an allowed set of values. */
-export declare abstract class AllowSchema<T extends string | number> extends Schema<T> {
-    readonly value: T | null;
-    readonly allow: Allowed<T>;
-    constructor({ allow, value, ...options }: ConstructorParameters<typeof Schema>[0] & {
-        allow: Allowed<T>;
-        value?: T | null;
-    });
-}
-/** Define a valid string from an allowed set of strings. */
-export declare class AllowStringSchema<T extends string> extends AllowSchema<T> {
-    validate(unsafeValue?: unknown): T;
+export declare class AllowSchema<K, T> extends Schema<K> implements Iterable<Entry<K, T>> {
+    readonly value: K | null;
+    readonly allow: ImmutableRequiredMap<K, T>;
+    constructor({ allow, value, ...options }: AllowSchemaOptions<K, T>);
+    validate(value?: unknown): K;
+    /** Iterate over the the allowed options in `[key, value]` format. */
+    [Symbol.iterator](): Iterator<Entry<K, T>>;
 }
-/** Define a valid number from an allowed set of numbers. */
-export declare class AllowNumberSchema<T extends number> extends AllowSchema<T> {
-    validate(unsafeValue?: unknown): T;
+/** Define a valid string value from an allowed set of values. */
+export declare class AllowStringSchema<K extends string, T> extends AllowSchema<K, T> {
+    constructor({ allow, ...options }: SchemaOptions & {
+        allow: PossibleStringMap<K, T>;
+    });
+    validator(value?: unknown): K;
 }
-/** Valid string from an allowed set of strings. */
-export declare const ALLOW_STRING: <T extends string>(allow: Allowed<T>) => AllowStringSchema<T>;
-/** Valid string from an allowed set of numbers. */
-export declare const ALLOW_NUMBER: <T extends number>(allow: Allowed<T>) => AllowNumberSchema<T>;
+/** Valid value from an allowed set of values. */
+export declare function ALLOW<K, T>(allow: PossibleMap<K, T>): AllowSchema<K, T>;
+/** Valid string from an allowed set of values. */
+export declare function ALLOW_STRING<K extends string, T>(allow: PossibleStringMap<K, T>): AllowSchema<K, T>;
+export {};

package/schema/AllowSchema.js

@@ -1,42 +1,38 @@
-import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { getString } from "../util/string.js";
-import { isArray, isArrayItem } from "../util/array.js";
-import { getOptionalNumber } from "../util/number.js";
-import { isObjectKey } from "../util/object.js";
+import { getRequiredMap, isMapKey } from "../util/map.js";
+import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { Schema } from "./Schema.js";
-/** Validate a value against a specific set of allowed values. */
-export function validateAllowed(value, allowed) {
-    if (isArray(allowed)) {
-        if (isArrayItem(allowed, value))
-            return value;
-    }
-    else {
-        if (isObjectKey(allowed, value))
-            return value;
-    }
-    throw new InvalidFeedback("Unknown value", { value });
-}
 /** Define a valid value from an allowed set of values. */
 export class AllowSchema extends Schema {
     constructor({ allow, value = null, ...options }) {
         super(options);
-        this.allow = allow;
+        this.allow = getRequiredMap(allow);
         this.value = value;
     }
+    validate(value = this.value) {
+        if (isMapKey(this.allow, value))
+            return value;
+        throw new InvalidFeedback("Unknown value", { value });
+    }
+    /** Iterate over the the allowed options in `[key, value]` format. */
+    [Symbol.iterator]() {
+        return this.allow[Symbol.iterator]();
+    }
 }
-/** Define a valid string from an allowed set of strings. */
+/** Define a valid string value from an allowed set of values. */
 export class AllowStringSchema extends AllowSchema {
-    validate(unsafeValue = this.value) {
-        return validateAllowed(getString(unsafeValue), this.allow);
+    constructor({ allow, ...options }) {
+        super({ allow: getRequiredMap(allow), ...options });
     }
-}
-/** Define a valid number from an allowed set of numbers. */
-export class AllowNumberSchema extends AllowSchema {
-    validate(unsafeValue = this.value) {
-        return validateAllowed(getOptionalNumber(unsafeValue), this.allow);
+    validator(value = this.value) {
+        return super.validate(getString(value));
     }
 }
-/** Valid string from an allowed set of strings. */
-export const ALLOW_STRING = (allow) => new AllowStringSchema({ allow });
-/** Valid string from an allowed set of numbers. */
-export const ALLOW_NUMBER = (allow) => new AllowNumberSchema({ allow });
+/** Valid value from an allowed set of values. */
+export function ALLOW(allow) {
+    return new AllowSchema({ allow });
+}
+/** Valid string from an allowed set of values. */
+export function ALLOW_STRING(allow) {
+    return new AllowStringSchema({ allow });
+}

package/schema/ArraySchema.d.ts

@@ -1,6 +1,6 @@
 import { ImmutableArray } from "../util/array.js";
 import { Validator } from "../util/validate.js";
-import { Schema } from "./Schema.js";
+import { Schema, SchemaOptions } from "./Schema.js";
 /**
  * Define a valid array.
  *
@@ -34,7 +34,7 @@ export declare class ArraySchema<T> extends Schema<ImmutableArray<T>> {
     readonly unique: boolean;
     readonly min: number;
     readonly max: number | null;
-    constructor({ value, items, unique, min, max, ...options }: ConstructorParameters<typeof Schema>[0] & {
+    constructor({ value, items, unique, min, max, ...options }: SchemaOptions & {
         readonly value?: ImmutableArray;
         readonly items: Validator<T>;
         readonly min?: number;

package/schema/BooleanSchema.d.ts

@@ -1,8 +1,8 @@
-import { Schema } from "./Schema.js";
+import { Schema, SchemaOptions } from "./Schema.js";
 /** Define a valid boolean. */
 export declare class BooleanSchema extends Schema<boolean> {
     readonly value: boolean;
-    constructor({ value, ...options }: ConstructorParameters<typeof Schema>[0] & {
+    constructor({ value, ...options }: SchemaOptions & {
         readonly value?: boolean;
     });
     validate(unsafeValue?: unknown): boolean;

package/schema/DataSchema.d.ts

@@ -1,12 +1,12 @@
 import type { Data, Datas } from "../util/data.js";
 import { Validators } from "../util/validate.js";
 import { OptionalSchema } from "./OptionalSchema.js";
-import { Schema } from "./Schema.js";
+import { Schema, SchemaOptions } from "./Schema.js";
 /** Validate a data object. */
 export declare class DataSchema<T extends Data> extends Schema<T> {
     readonly value: Partial<T>;
     readonly props: Validators<T>;
-    constructor({ value, props, ...options }: ConstructorParameters<typeof Schema>[0] & {
+    constructor({ value, props, ...options }: SchemaOptions & {
         readonly props: Validators<T>;
         readonly value?: Partial<T>;
     });

package/schema/DataSchema.js

@@ -1,6 +1,6 @@
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { validateData } from "../util/validate.js";
-import { isObject } from "../util/object.js";
+import { isData } from "../util/data.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
 /** Validate a data object. */
@@ -11,7 +11,7 @@ export class DataSchema extends Schema {
         this.value = value;
     }
     validate(unsafeValue = this.value) {
-        if (!isObject(unsafeValue))
+        if (!isData(unsafeValue))
             throw new InvalidFeedback("Must be object", { value: unsafeValue });
         return validateData(unsafeValue, this.props);
     }

package/schema/DateSchema.d.ts

@@ -1,11 +1,11 @@
 import { PossibleDate } from "../util/date.js";
-import { Schema } from "./Schema.js";
+import { Schema, SchemaOptions } from "./Schema.js";
 /** Define a valid date, e.g. `2005-09-12` */
 export declare class DateSchema extends Schema<string> {
     readonly value: PossibleDate;
     readonly min: PossibleDate | null;
     readonly max: PossibleDate | null;
-    constructor({ value, min, max, ...options }: ConstructorParameters<typeof Schema>[0] & {
+    constructor({ value, min, max, ...options }: SchemaOptions & {
         readonly value?: PossibleDate;
         readonly min?: PossibleDate | null;
         readonly max?: PossibleDate | null;

package/schema/DictionarySchema.d.ts

@@ -0,0 +1,19 @@
+import { ImmutableDictionary } from "../util/dictionary.js";
+import { Validator } from "../util/validate.js";
+import { Schema, SchemaOptions } from "./Schema.js";
+/** 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 | null;
+    readonly max: number | null;
+    constructor({ value, items, min, max, ...rest }: SchemaOptions & {
+        readonly items: Validator<T>;
+        readonly value?: ImmutableDictionary;
+        readonly min?: number | null;
+        readonly max?: number | null;
+    });
+    validate(unsafeValue?: unknown): ImmutableDictionary<T>;
+}
+/** Valid dictionary object with specifed items. */
+export declare const DICTIONARY: <T>(items: Validator<T>) => DictionarySchema<T>;

package/schema/{ObjectSchema.js → DictionarySchema.js}

@@ -1,9 +1,9 @@
-import { isObject } from "../util/object.js";
+import { isDictionary } from "../util/dictionary.js";
 import { validateEntries } from "../util/validate.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { Schema } from "./Schema.js";
-/** Validate a map-like object (whose props are all the same). */
-export class ObjectSchema extends Schema {
+/** Validate a dictionary object (whose props are all the same with string keys). */
+export class DictionarySchema extends Schema {
     constructor({ value = {}, items, min = null, max = null, ...rest }) {
         super(rest);
         this.min = null;
@@ -14,7 +14,7 @@ export class ObjectSchema extends Schema {
         this.max = max;
     }
     validate(unsafeValue = this.value) {
-        if (!isObject(unsafeValue))
+        if (!isDictionary(unsafeValue))
             throw new InvalidFeedback("Must be object", { value: unsafeValue });
         const unsafeEntries = Object.entries(unsafeValue);
         const safeObject = Object.fromEntries(validateEntries(unsafeEntries, this.items));
@@ -25,5 +25,5 @@ export class ObjectSchema extends Schema {
         return safeObject;
     }
 }
-/** Valid map-like object with specifed items. */
-export const OBJECT = (items) => new ObjectSchema({ items });
+/** Valid dictionary object with specifed items. */
+export const DICTIONARY = (items) => new DictionarySchema({ items });

package/schema/LinkSchema.d.ts

@@ -1,4 +1,4 @@
-import { StringSchema } from "./StringSchema.js";
+import { StringSchema, StringSchemaOptions } from "./StringSchema.js";
 /**
  * Type of `StringSchema` that defines a valid URL.
  * - Checks URL scheme against a whitelist (always), and checks URL domain against a whitelist (optional).
@@ -11,7 +11,7 @@ export declare class LinkSchema extends StringSchema {
     readonly max = 512;
     readonly schemes: string[];
     readonly hosts: string[] | null;
-    constructor({ schemes, hosts, ...rest }: ConstructorParameters<typeof StringSchema>[0] & {
+    constructor({ schemes, hosts, ...rest }: StringSchemaOptions & {
         readonly schemes?: string[];
         readonly hosts?: string[] | null;
     });

package/schema/NumberSchema.d.ts

@@ -1,11 +1,11 @@
-import { Schema } from "./Schema.js";
+import { Schema, SchemaOptions } from "./Schema.js";
 /** Schema that defines a valid number. */
 export declare class NumberSchema extends Schema<number> {
     readonly value: number | null;
     readonly min: number | null;
     readonly max: number | null;
     readonly step: number | null;
-    constructor({ value, min, max, step, ...rest }: ConstructorParameters<typeof Schema>[0] & {
+    constructor({ value, min, max, step, ...rest }: SchemaOptions & {
         readonly value?: number | null;
         readonly min?: number | null;
         readonly max?: number | null;

package/schema/Schema.d.ts

@@ -1,4 +1,13 @@
 import type { Validatable } from "../util/validate.js";
+/** Options allowed by a `Schema` instance. */
+export declare type SchemaOptions = {
+    /** Title of the schema, e.g. for using as the title of a corresponding field. */
+    readonly title?: string;
+    /** Description of the schema, e.g. for using as a description in a corresponding field. */
+    readonly description?: string;
+    /** Placeholder of the schema, e.g. for using as a placeholder in a corresponding field. */
+    readonly placeholder?: string;
+};
 /**
  * Schema is an object instance with a `validate()` method.
  * - Type `T` represents the type of value `validate()` returns.
@@ -13,14 +22,7 @@ export declare abstract class Schema<T extends unknown = unknown> implements Val
     readonly placeholder: string;
     /** Default value. */
     readonly value: unknown;
-    constructor({ title, description, placeholder, }: {
-        /** Title of the schema, e.g. for using as the title of a corresponding field. */
-        readonly title?: string;
-        /** Description of the schema, e.g. for using as a description in a corresponding field. */
-        readonly description?: string;
-        /** Placeholder of the schema, e.g. for using as a placeholder in a corresponding field. */
-        readonly placeholder?: string;
-    });
+    constructor({ title, description, placeholder }: SchemaOptions);
     /** Every schema must implement a `validate()` method. */
     abstract validate(unsafeValue: unknown): T;
 }

package/schema/Schema.js

@@ -4,7 +4,7 @@
  * - `validate()` returns `Invalid` if value was not valid.
  */
 export class Schema {
-    constructor({ title = "", description = "", placeholder = "", }) {
+    constructor({ title = "", description = "", placeholder = "" }) {
         this.title = title;
         this.description = description;
         this.placeholder = placeholder;

package/schema/StringSchema.d.ts

@@ -1,8 +1,18 @@
-import { Schema } from "./Schema.js";
+import { Schema, SchemaOptions } from "./Schema.js";
 /** `type=""` prop for HTML `<input />` tags that are relevant for strings. */
 export declare type HtmlInputType = "text" | "password" | "color" | "date" | "email" | "number" | "tel" | "search" | "url";
 /** Function that sanitizes a string. */
 export declare type Sanitizer = (str: string) => string;
+/** Options for `StringSchema` */
+export declare type StringSchemaOptions = SchemaOptions & {
+    readonly value?: string;
+    readonly type?: HtmlInputType;
+    readonly min?: number;
+    readonly max?: number | null;
+    readonly match?: RegExp | null;
+    readonly sanitizer?: Sanitizer | null;
+    readonly multiline?: boolean;
+};
 /**
  * Schema that defines a valid string.
  *
@@ -31,15 +41,7 @@ export declare class StringSchema extends Schema<string> {
     readonly match: RegExp | null;
     readonly sanitizer: Sanitizer | null;
     readonly multiline: boolean;
-    constructor({ value, type, min, max, match, sanitizer, multiline, ...rest }: ConstructorParameters<typeof Schema>[0] & {
-        readonly value?: string;
-        readonly type?: HtmlInputType;
-        readonly min?: number;
-        readonly max?: number | null;
-        readonly match?: RegExp | null;
-        readonly sanitizer?: Sanitizer | null;
-        readonly multiline?: boolean;
-    });
+    constructor({ value, type, min, max, match, sanitizer, multiline, ...rest }: StringSchemaOptions);
     validate(unsafeValue?: unknown): string;
     /**
      * Clean a string by removing characters that aren't digits.

package/schema/index.d.ts

@@ -5,11 +5,11 @@ export * from "./BooleanSchema.js";
 export * from "./ColorSchema.js";
 export * from "./DataSchema.js";
 export * from "./DateSchema.js";
+export * from "./DictionarySchema.js";
 export * from "./EmailSchema.js";
 export * from "./KeySchema.js";
 export * from "./LinkSchema.js";
 export * from "./NumberSchema.js";
-export * from "./ObjectSchema.js";
 export * from "./OptionalSchema.js";
 export * from "./PhoneSchema.js";
 export * from "./RequiredSchema.js";

package/schema/index.js

@@ -5,11 +5,11 @@ export * from "./BooleanSchema.js";
 export * from "./ColorSchema.js";
 export * from "./DataSchema.js";
 export * from "./DateSchema.js";
+export * from "./DictionarySchema.js";
 export * from "./EmailSchema.js";
 export * from "./KeySchema.js";
 export * from "./LinkSchema.js";
 export * from "./NumberSchema.js";
-export * from "./ObjectSchema.js";
 export * from "./OptionalSchema.js";
 export * from "./PhoneSchema.js";
 export * from "./RequiredSchema.js";

package/state/DataState.js

@@ -1,5 +1,5 @@
 import { getData } from "../util/data.js";
-import { transformData } from "../util/transform.js";
+import { transformObject } from "../util/transform.js";
 import { State } from "./State.js";
 /** State that stores a data object and has additional methods to help with that. */
 export class DataState extends State {
@@ -9,7 +9,7 @@ export class DataState extends State {
     }
     /** Update several props in this data. */
     update(updates) {
-        this.set(transformData(this.data, updates));
+        this.set(transformObject(this.data, updates));
     }
 }
 /** State that stores an optional data object and has additional methods to help with that. */
@@ -24,7 +24,7 @@ export class OptionalDataState extends State {
     }
     /** Update several props in this data. */
     update(updates) {
-        this.set(transformData(this.data, updates));
+        this.set(transformObject(this.data, updates));
     }
     /** Set the data to `null`. */
     unset() {

package/state/DictionaryState.d.ts

@@ -0,0 +1,15 @@
+import { DictionaryItem, ImmutableDictionary } from "../util/dictionary.js";
+import { Transformers } from "../util/transform.js";
+import { State } from "./State.js";
+/** State that stores a dictionary object and has additional methods to help with that. */
+export declare class DictionaryState<T> extends State<ImmutableDictionary<T>> implements Iterable<DictionaryItem<T>> {
+    constructor(initial?: ImmutableDictionary<T>);
+    /** Get the length of the current value of this state. */
+    get count(): number;
+    /** Set a named entry in this object with a different value. */
+    update(updates: Transformers<ImmutableDictionary<T>>): void;
+    /** Remove a named entry from this object. */
+    delete(...keys: string[]): void;
+    /** Iterate over the entries of the object. */
+    [Symbol.iterator](): Iterator<DictionaryItem<T>>;
+}

package/state/{ObjectState.js → DictionaryState.js}

@@ -1,8 +1,8 @@
-import { withoutObjectProps } from "../util/object.js";
-import { transformData } from "../util/transform.js";
+import { withoutDictionaryItems } from "../util/dictionary.js";
+import { transformDictionary } from "../util/transform.js";
 import { State } from "./State.js";
-/** State that stores a map-like object and has additional methods to help with that. */
-export class ObjectState extends State {
+/** State that stores a dictionary object and has additional methods to help with that. */
+export class DictionaryState extends State {
     constructor(initial = {}) {
         super(initial);
     }
@@ -12,11 +12,11 @@ export class ObjectState extends State {
     }
     /** Set a named entry in this object with a different value. */
     update(updates) {
-        this.set(transformData(this.value, updates));
+        this.set(transformDictionary(this.value, updates));
     }
     /** Remove a named entry from this object. */
     delete(...keys) {
-        this.set(withoutObjectProps(this.value, ...keys));
+        this.set(withoutDictionaryItems(this.value, ...keys));
     }
     /** Iterate over the entries of the object. */
     [Symbol.iterator]() {