shelving 1.85.0 → 1.86.1

package/api/Resource.d.ts

@@ -27,9 +27,9 @@ export declare class Resource<P = unknown, R = void> implements Validatable<R> {
     validate(unsafeResult: unknown): R;
 }
 /** Extract the payload type from a `Resource`. */
-export declare type PayloadType<X extends Resource> = X extends Resource<infer Y, unknown> ? Y : never;
+export type PayloadType<X extends Resource> = X extends Resource<infer Y, unknown> ? Y : never;
 /** Extract the result type from a `Resource`. */
-export declare type ResourceType<X extends Resource> = X extends Resource<unknown, infer Y> ? Y : never;
+export type ResourceType<X extends Resource> = X extends Resource<unknown, infer Y> ? Y : never;
 /**
  * Shortcut to create a new `Resource` (consistent with `Schema` shortcuts.
  * - Sets `undefined` as the default type for payload and result.

package/constraint/Constraints.js

@@ -2,10 +2,6 @@ import { withArrayItems, omitArrayItems } from "../util/array.js";
 import { Constraint } from "./Constraint.js";
 /** Type of Rule that is powered by several sub-constraints (e.g. `Filters` and `Sorts` and `Query` itself extend this). */
 export class Constraints extends Constraint {
-    constructor(...constraints) {
-        super();
-        this._constraints = constraints;
-    }
     /** Get the first constraint. */
     get first() {
         return this._constraints[0];
@@ -18,6 +14,10 @@ export class Constraints extends Constraint {
     get size() {
         return this._constraints.length;
     }
+    constructor(...constraints) {
+        super();
+        this._constraints = constraints;
+    }
     /** Clone this set of constraints but add additional constraints. */
     with(...constraints) {
         const _constraints = withArrayItems(this._constraints, ...constraints);

package/constraint/FilterConstraint.d.ts

@@ -4,11 +4,11 @@ import { ImmutableArray } from "../util/array.js";
 import { Matchable } from "../util/match.js";
 import type { Constraint } from "./Constraint.js";
 /** Possible operator references. */
-export declare type FilterOperator = "IS" | "NOT" | "IN" | "OUT" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
+export type FilterOperator = "IS" | "NOT" | "IN" | "OUT" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
 /** Format that allows filters to be specified as a string, e.g. `!name` means `name is not` and `age>` means `age is more than` and `tags[]` means `tags array contains` */
-export declare type FilterKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}` | `${DataKey<T>}[]` | `${DataKey<T>}<` | `${DataKey<T>}<=` | `${DataKey<T>}>` | `${DataKey<T>}>=`;
+export type FilterKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}` | `${DataKey<T>}[]` | `${DataKey<T>}<` | `${DataKey<T>}<=` | `${DataKey<T>}>` | `${DataKey<T>}>=`;
 /** Format that allows multiple filters to be specified as a plain object. */
-export declare type FilterProps<T extends Data> = {
+export type FilterProps<T extends Data> = {
     [K in DataKey<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
 } & {
     [K in DataKey<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
@@ -16,7 +16,7 @@ export declare type FilterProps<T extends Data> = {
     [K in DataKey<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
 };
 /** List of filters in a flexible format. */
-export declare type FilterList<T extends Data> = Nullish<FilterProps<T> | FilterConstraint<T>> | Iterable<FilterList<T>>;
+export type FilterList<T extends Data> = Nullish<FilterProps<T> | FilterConstraint<T>> | Iterable<FilterList<T>>;
 /**
  * Filter: filters a list of data.
  *

package/constraint/FilterConstraint.js

@@ -21,6 +21,23 @@ const MATCHERS = {
  * @param value Value the specified property should be matched against.
  */
 export class FilterConstraint {
+    get filterKey() {
+        const { operator, key } = this;
+        if (operator === "NOT" || operator === "OUT")
+            return `!${key}`;
+        else if (operator === "CONTAINS")
+            return `${key}[]`;
+        else if (operator === "LT")
+            return `${key}<`;
+        else if (operator === "LTE")
+            return `${key}<=`;
+        else if (operator === "GT")
+            return `${key}>`;
+        else if (operator === "GTE")
+            return `${key}>=`;
+        else
+            return key;
+    }
     constructor(filterKey, value) {
         if (filterKey.startsWith("!")) {
             this.key = filterKey.slice(1);
@@ -52,23 +69,6 @@ export class FilterConstraint {
         }
         this.value = value;
     }
-    get filterKey() {
-        const { operator, key } = this;
-        if (operator === "NOT" || operator === "OUT")
-            return `!${key}`;
-        else if (operator === "CONTAINS")
-            return `${key}[]`;
-        else if (operator === "LT")
-            return `${key}<`;
-        else if (operator === "LTE")
-            return `${key}<=`;
-        else if (operator === "GT")
-            return `${key}>`;
-        else if (operator === "GTE")
-            return `${key}>=`;
-        else
-            return key;
-    }
     match(item) {
         return MATCHERS[this.operator](item[this.key], this.value);
     }

package/constraint/SortConstraint.d.ts

@@ -4,13 +4,13 @@ import type { Nullish } from "../util/null.js";
 import { Rankable } from "../util/sort.js";
 import type { Constraint } from "./Constraint.js";
 /** Format that allows sorts to be set as a plain string, e.g. `name` sorts by name in ascending order and `!date` sorts by date in descending order. */
-export declare type SortKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}`;
+export type SortKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}`;
 /** One or more sort keys. */
-export declare type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
+export type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
 /** Possible operator references. */
-export declare type SortDirection = "ASC" | "DESC";
+export type SortDirection = "ASC" | "DESC";
 /** List of sorts in a flexible format. */
-export declare type SortList<T extends Data> = Nullish<SortKeys<T> | SortConstraint<T> | Iterable<SortList<T>>>;
+export type SortList<T extends Data> = Nullish<SortKeys<T> | SortConstraint<T> | Iterable<SortList<T>>>;
 /** Sort a list of values. */
 export declare class SortConstraint<T extends Data = Data> implements Constraint<T>, Rankable<T> {
     readonly key: string;

package/constraint/SortConstraint.js

@@ -1,6 +1,9 @@
 import { rank, rankAsc, rankDesc, sortItems } from "../util/sort.js";
 /** Sort a list of values. */
 export class SortConstraint {
+    get sortKey() {
+        return `"${this.direction === "DESC" ? "!" : ""}${this.key}"`;
+    }
     constructor(sortKey) {
         if (sortKey.startsWith("!")) {
             this.key = sortKey.slice(1);
@@ -11,9 +14,6 @@ export class SortConstraint {
             this.direction = "ASC";
         }
     }
-    get sortKey() {
-        return `"${this.direction === "DESC" ? "!" : ""}${this.key}"`;
-    }
     rank(left, right) {
         return rank(left[this.key], this.direction === "ASC" ? rankAsc : rankDesc, right[this.key]);
     }

package/db/Change.d.ts

@@ -33,13 +33,13 @@ export interface DeleteChange<T extends Datas, K extends DataKey<T> = DataKey<T>
     readonly id: string;
 }
 /** Set, update, or delete change on an item. */
-export declare type ItemChange<T extends Datas, K extends DataKey<T> = DataKey<T>> = SetChange<T, K> | UpdateChange<T, K> | DeleteChange<T, K>;
+export type ItemChange<T extends Datas, K extends DataKey<T> = DataKey<T>> = SetChange<T, K> | UpdateChange<T, K> | DeleteChange<T, K>;
 /** Array of item changes. */
-export declare type ItemChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = ImmutableArray<ItemChange<T, K>>;
+export type ItemChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = ImmutableArray<ItemChange<T, K>>;
 /** Write change on an item. */
-export declare type WriteChange<T extends Datas, K extends DataKey<T> = DataKey<T>> = ItemChange<T, K> | AddChange<T, K>;
+export type WriteChange<T extends Datas, K extends DataKey<T> = DataKey<T>> = ItemChange<T, K> | AddChange<T, K>;
 /** Array of write changes. */
-export declare type WriteChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = ImmutableArray<WriteChange<T, K>>;
+export type WriteChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = ImmutableArray<WriteChange<T, K>>;
 /** Apply a set of changes to a synchronous provider. */
 export declare function changeProvider<T extends Datas, K extends DataKey<T>>(provider: Provider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
 /** Apply a set of changes to an asynchronous provider. */

package/db/Item.d.ts

@@ -7,15 +7,15 @@ import type { DeleteChange, SetChange, UpdateChange } from "./Change.js";
 import type { AsyncQuery, Query } from "./Query.js";
 import type { AsyncDatabase, Database } from "./Database.js";
 /** Item data with a string ID that uniquely identifies it. */
-export declare type ItemData<T extends Data = Data> = T & {
+export type ItemData<T extends Data = Data> = T & {
     id: string;
 };
 /** Entity or `null` to indicate the item doesn't exist. */
-export declare type ItemValue<T extends Data = Data> = ItemData<T> | null;
+export type ItemValue<T extends Data = Data> = ItemData<T> | null;
 /** An array of item data. */
-export declare type ItemArray<T extends Data = Data> = ImmutableArray<ItemData<T>>;
+export type ItemArray<T extends Data = Data> = ImmutableArray<ItemData<T>>;
 /** A set of query constraints for item data. */
-export declare type ItemConstraints<T extends Data = Data> = QueryConstraints<ItemData<T>>;
+export type ItemConstraints<T extends Data = Data> = QueryConstraints<ItemData<T>>;
 /** Reference to an item in a synchronous or asynchronous database. */
 declare abstract class BaseItem<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> implements AsyncIterable<ItemValue<T[K]>> {
     abstract readonly db: Database<T> | AsyncDatabase<T>;

package/markup/options.d.ts

@@ -1,6 +1,6 @@
 import { MarkupRules } from "./rules.js";
 /** The current parsing options (represents the current state of the parsing). */
-export declare type MarkupOptions = {
+export type MarkupOptions = {
     /** The active list of parsing rules. */
     readonly rules: MarkupRules;
     /** The initial context to start parsing in (rules may render their children with a different context). */

package/markup/regexp.d.ts

@@ -2,13 +2,13 @@ import type { Data } from "../util/data.js";
 import { NamedRegExp, NamedRegExpData, PossibleRegExp } from "../util/regexp.js";
 import type { MarkupOptions } from "./options.js";
 /** Subset of `NamedRegExpArray<T>` that are the only things we're required return from a `MarkupMatcher` function. */
-export declare type MarkupMatch<T extends Data | undefined = Data | undefined> = {
+export type MarkupMatch<T extends Data | undefined = Data | undefined> = {
     0: string;
     index: number;
     groups: T;
 };
 /** Function that matches a string and returns a `MarkupMatch` or `null` or `void` */
-export declare type MarkupMatcher<T extends Data | undefined = Data | undefined> = (input: string, options: MarkupOptions) => MarkupMatch<T> | null | void;
+export type MarkupMatcher<T extends Data | undefined = Data | undefined> = (input: string, options: MarkupOptions) => MarkupMatch<T> | null | void;
 export declare const LINE_REGEXP: RegExp;
 export declare const LINE_START_REGEXP: RegExp;
 export declare const LINE_END_REGEXP: RegExp;

package/markup/rules.d.ts

@@ -34,9 +34,9 @@ export interface MarkupRule<T extends Data | undefined = Data | undefined> {
     readonly priority?: number;
 }
 /** Any markup rule. */
-export declare type AnyMarkupRule = MarkupRule<any>;
+export type AnyMarkupRule = MarkupRule<any>;
 /** A set of markup rules (as an object or array). */
-export declare type MarkupRules = AnyMarkupRule[];
+export type MarkupRules = AnyMarkupRule[];
 /**
  * Headings are single line only (don't allow multiline).
  * - 1-6 hashes then 1+ spaces, then the title.

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.85.0",
+	"version": "1.86.1",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -64,26 +64,26 @@
 		"build:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config=jest.config.build.cjs"
 	},
 	"devDependencies": {
-		"@google-cloud/firestore": "^5.0.2",
-		"@types/jest": "^28.1.8",
-		"@types/react": "^18.0.21",
-		"@types/react-dom": "^18.0.4",
-		"@typescript-eslint/eslint-plugin": "^5.39.0",
-		"@typescript-eslint/parser": "^5.39.0",
+		"@google-cloud/firestore": "^6.4.1",
+		"@types/jest": "^29.2.3",
+		"@types/react": "^18.0.25",
+		"@types/react-dom": "^18.0.9",
+		"@typescript-eslint/eslint-plugin": "^5.44.0",
+		"@typescript-eslint/parser": "^5.44.0",
 		"dpdm": "^3.9.0",
-		"esbuild": "^0.15.10",
+		"esbuild": "^0.15.14",
 		"esbuild-jest": "^0.5.0",
-		"eslint": "^8.25.0",
+		"eslint": "^8.28.0",
 		"eslint-config-prettier": "^8.5.0",
 		"eslint-plugin-import": "^2.26.0",
 		"eslint-plugin-prettier": "^4.0.0",
-		"firebase": "^9.11.0",
-		"jest": "^28.1.0",
+		"firebase": "^9.14.0",
+		"jest": "^29.3.1",
 		"jest-ts-webcompat-resolver": "^1.0.0",
-		"prettier": "^2.6.2",
+		"prettier": "^2.8.0",
 		"react": "^18.1.0",
 		"react-dom": "^18.1.0",
-		"typescript": "^4.8.4"
+		"typescript": "^4.9.3"
 	},
 	"peerDependencies": {
 		"@google-cloud/firestore": ">=4.0.0",

package/react/useItem.js

@@ -9,6 +9,14 @@ import { useState } from "./useState.js";
 import { useCache } from "./useCache.js";
 /** Hold the current state of a item. */
 export class ItemState extends State {
+    /** Get the data of the item (throws `RequiredError` if item doesn't exist). */
+    get data() {
+        return getData(this.value);
+    }
+    /** Does the item exist (i.e. its value isn't `null`)? */
+    get exists() {
+        return !!this.value;
+    }
     constructor(ref) {
         var _a;
         const { db, collection, id } = ref;
@@ -28,14 +36,6 @@ export class ItemState extends State {
         if (this.loading)
             this.refresh();
     }
-    /** Get the data of the item (throws `RequiredError` if item doesn't exist). */
-    get data() {
-        return getData(this.value);
-    }
-    /** Does the item exist (i.e. its value isn't `null`)? */
-    get exists() {
-        return !!this.value;
-    }
     async _refresh() {
         this.busy.set(true);
         try {

package/react/useQuery.js

@@ -9,6 +9,34 @@ import { useState } from "./useState.js";
 import { useCache } from "./useCache.js";
 /** Hold the current state of a query. */
 export class QueryState extends State {
+    /** Can more items be loaded after the current result. */
+    get hasMore() {
+        return this._hasMore;
+    }
+    /** Get the first document matched by this query or `null` if this query has no items. */
+    get firstValue() {
+        return getOptionalFirstItem(this.value);
+    }
+    /** Get the first document matched by this query. */
+    get firstData() {
+        return getFirstItem(this.value);
+    }
+    /** Get the last document matched by this query or `null` if this query has no items. */
+    get lastValue() {
+        return getOptionalLastItem(this.value);
+    }
+    /** Get the last document matched by this query. */
+    get lastData() {
+        return getLastItem(this.value);
+    }
+    /** Does the document have at least one result. */
+    get exists() {
+        return !!this.value.length;
+    }
+    /** Get the number of items matching this query. */
+    get count() {
+        return this.value.length;
+    }
     constructor(ref) {
         var _a;
         const { db, collection, limit } = ref;
@@ -38,34 +66,6 @@ export class QueryState extends State {
         if (this.loading)
             this.refresh();
     }
-    /** Can more items be loaded after the current result. */
-    get hasMore() {
-        return this._hasMore;
-    }
-    /** Get the first document matched by this query or `null` if this query has no items. */
-    get firstValue() {
-        return getOptionalFirstItem(this.value);
-    }
-    /** Get the first document matched by this query. */
-    get firstData() {
-        return getFirstItem(this.value);
-    }
-    /** Get the last document matched by this query or `null` if this query has no items. */
-    get lastValue() {
-        return getOptionalLastItem(this.value);
-    }
-    /** Get the last document matched by this query. */
-    get lastData() {
-        return getLastItem(this.value);
-    }
-    /** Does the document have at least one result. */
-    get exists() {
-        return !!this.value.length;
-    }
-    /** Get the number of items matching this query. */
-    get count() {
-        return this.value.length;
-    }
     async _refresh() {
         this.busy.set(true);
         try {

package/schema/AllowSchema.d.ts

@@ -1,21 +1,21 @@
 import type { Entry } from "../util/entry.js";
-import { ImmutableRequiredMap, PossibleMap, PossibleStringMap } from "../util/map.js";
+import { ImmutableMap, PossibleMap, PossibleStringMap } from "../util/map.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `AllowSchama` */
-export declare type AllowSchemaOptions<K, T> = Omit<SchemaOptions, "value"> & {
+export type AllowSchemaOptions<K, T> = Omit<SchemaOptions, "value"> & {
     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;
-    readonly allow: ImmutableRequiredMap<K, T>;
+    readonly allow: ImmutableMap<K, T>;
     constructor({ allow, ...options }: AllowSchemaOptions<K, T>);
     validate(value?: unknown): K;
     /** Iterate over the the allowed options in `[key, value]` format. */
     [Symbol.iterator](): Iterator<Entry<K, T>>;
 }
 /** Allowed options for `AllowStringSchama` */
-export declare type AllowStringSchemaOptions<K extends string, T> = Omit<SchemaOptions, "value"> & {
+export type AllowStringSchemaOptions<K extends string, T> = Omit<SchemaOptions, "value"> & {
     allow: PossibleStringMap<K, T>;
 };
 /** Define a valid string value from an allowed set of string values. */

package/schema/AllowSchema.js

@@ -1,5 +1,5 @@
 import { getString } from "../util/string.js";
-import { getRequiredMap, isMapKey } from "../util/map.js";
+import { getMap, isMapKey } from "../util/map.js";
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { getFirstItem } from "../util/array.js";
 import { Schema } from "./Schema.js";
@@ -7,7 +7,7 @@ import { Schema } from "./Schema.js";
 export class AllowSchema extends Schema {
     constructor({ allow, ...options }) {
         super(options);
-        this.allow = getRequiredMap(allow);
+        this.allow = getMap(allow);
         this.value = getFirstItem(this.allow.keys());
     }
     validate(value = this.value) {
@@ -23,7 +23,7 @@ export class AllowSchema extends Schema {
 /** Define a valid string value from an allowed set of string values. */
 export class AllowStringSchema extends AllowSchema {
     constructor({ allow, ...options }) {
-        super({ allow: getRequiredMap(allow), ...options });
+        super({ allow: getMap(allow), ...options });
     }
     validator(value = this.value) {
         return super.validate(getString(value));

package/schema/ArraySchema.d.ts

@@ -2,7 +2,7 @@ import { ImmutableArray } from "../util/array.js";
 import { Validator } from "../util/validate.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `ArraySchema` */
-export declare type ArraySchemaOptions<T> = SchemaOptions & {
+export type ArraySchemaOptions<T> = SchemaOptions & {
     readonly value?: ImmutableArray;
     readonly items: Validator<T>;
     readonly min?: number;

package/schema/BooleanSchema.d.ts

@@ -1,6 +1,6 @@
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `BooleanSchema` */
-export declare type BooleanSchemaOptions = SchemaOptions & {
+export type BooleanSchemaOptions = SchemaOptions & {
     readonly value?: boolean;
 };
 /** Define a valid boolean. */

package/schema/DataSchema.d.ts

@@ -3,7 +3,7 @@ import { Validators } from "../util/validate.js";
 import { OptionalSchema } from "./OptionalSchema.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `DataSchema` */
-export declare type DataSchemaOptions<T extends Data> = SchemaOptions & {
+export type DataSchemaOptions<T extends Data> = SchemaOptions & {
     readonly props: Validators<T>;
     readonly value?: Partial<T>;
 };
@@ -15,7 +15,7 @@ export declare class DataSchema<T extends Data> extends Schema<T> {
     validate(unsafeValue?: unknown): T;
 }
 /** Set of named data schemas. */
-export declare type DataSchemas<T extends Datas> = {
+export type DataSchemas<T extends Datas> = {
     [K in keyof T]: DataSchema<T[K]>;
 };
 /** Valid data object with specifed properties. */

package/schema/DateSchema.d.ts

@@ -1,7 +1,7 @@
 import { PossibleDate } from "../util/date.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `DateSchema` */
-export declare type DateSchemaOptions = SchemaOptions & {
+export type DateSchemaOptions = SchemaOptions & {
     readonly value?: PossibleDate;
     readonly min?: PossibleDate | null;
     readonly max?: PossibleDate | null;

package/schema/DictionarySchema.d.ts

@@ -2,7 +2,7 @@ import { ImmutableDictionary } from "../util/dictionary.js";
 import { Validator } from "../util/validate.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `DictionarySchema` */
-export declare type DictionarySchemaOptions<T> = SchemaOptions & {
+export type DictionarySchemaOptions<T> = SchemaOptions & {
     readonly items: Validator<T>;
     readonly value?: ImmutableDictionary;
     readonly min?: number | null;

package/schema/LinkSchema.d.ts

@@ -1,6 +1,6 @@
 import { StringSchema, StringSchemaOptions } from "./StringSchema.js";
 /** Allowed options for `LinkSchema` */
-export declare type LinkSchemaOptions = StringSchemaOptions & {
+export type LinkSchemaOptions = StringSchemaOptions & {
     readonly schemes?: string[];
     readonly hosts?: string[] | null;
 };

package/schema/NumberSchema.d.ts

@@ -1,6 +1,6 @@
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `NumberSchema` */
-export declare type NumberSchemaOptions = SchemaOptions & {
+export type NumberSchemaOptions = SchemaOptions & {
     readonly value?: number | null;
     readonly min?: number | null;
     readonly max?: number | null;

package/schema/Schema.d.ts

@@ -1,6 +1,6 @@
 import type { Validatable } from "../util/validate.js";
 /** Options allowed by a `Schema` instance. */
-export declare type SchemaOptions = {
+export type SchemaOptions = {
     /** Title of the schema, e.g. for using as the title of a corresponding field. */
     readonly title?: string | null;
     /** Description of the schema, e.g. for using as a description in a corresponding field. */

package/schema/StringSchema.d.ts

@@ -1,10 +1,10 @@
 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";
+export type HtmlInputType = "text" | "password" | "color" | "date" | "email" | "number" | "tel" | "search" | "url";
 /** Function that sanitizes a string. */
-export declare type Sanitizer = (str: string) => string;
+export type Sanitizer = (str: string) => string;
 /** Options for `StringSchema` */
-export declare type StringSchemaOptions = SchemaOptions & {
+export type StringSchemaOptions = SchemaOptions & {
     readonly value?: string;
     readonly type?: HtmlInputType;
     readonly min?: number;

package/schema/ThroughSchema.d.ts

@@ -1,7 +1,7 @@
 import type { Sourceable } from "../util/source.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `ThroughSchama` */
-export declare type ThroughSchemaOptions<T> = SchemaOptions & {
+export type ThroughSchemaOptions<T> = SchemaOptions & {
     source: Schema<T>;
 };
 /** Schema that passes through to a source schema. */

package/schema/TimeSchema.d.ts

@@ -1,7 +1,7 @@
 import { PossibleTime, Time } from "../util/time.js";
 import { Schema, SchemaOptions } from "./Schema.js";
 /** Allowed options for `TimeSchama` */
-export declare type TimeSchemaOptions = SchemaOptions & {
+export type TimeSchemaOptions = SchemaOptions & {
     readonly value?: PossibleTime;
     readonly min?: PossibleTime | null;
     readonly max?: PossibleTime | null;

package/sequence/DeferredSequence.d.ts

@@ -21,12 +21,14 @@ export declare class DeferredSequence<T = void, R = void> extends AbstractSequen
     private _nextReason;
     /** Fulfill the current deferred by resolving or rejecting it. */
     private readonly _fulfill;
-    /** Resolve the current deferred from a sequence of values. */
-    resolveSequence(sequence: AsyncIterable<T>): AsyncIterable<T>;
     next(): Promise<IteratorResult<T, R>>;
     then<X = T, Y = never>(onNext?: (v: T) => X | PromiseLike<X>, onError?: (r: unknown) => Y | PromiseLike<Y>): Promise<X | Y>;
     catch<Y>(onError: (r: unknown) => Y | PromiseLike<Y>): Promise<T | Y>;
     finally(onFinally: () => void): Promise<T>;
+    /** Resolve the current deferred from a sequence of values. */
+    through(sequence: AsyncIterable<T>): AsyncIterable<T>;
+    /** Pull values from a source sequence until the returned stop function is called. */
+    from(source: AsyncIterable<T>, onError?: Handler): Stop;
     /** Subscrbe to the value of the sequence with a callback until the returned stop function is called. */
-    subscribe(onNext: Dispatch<[T]>, onError?: Handler): Stop;
+    to(onNext: Dispatch<[T]>, onError?: Handler): Stop;
 }

package/sequence/DeferredSequence.js

@@ -28,10 +28,10 @@ export class DeferredSequence extends AbstractSequence {
         /** Fulfill the current deferred by resolving or rejecting it. */
         this._fulfill = () => {
             const { _deferred, _nextReason, _nextValue } = this;
+            this._deferred = undefined;
+            this._nextReason = _NOVALUE;
+            this._nextValue = _NOVALUE;
             if (_deferred) {
-                this._deferred = undefined;
-                this._nextReason = _NOVALUE;
-                this._nextValue = _NOVALUE;
                 if (_nextReason !== _NOVALUE)
                     _deferred.reject(_nextReason);
                 else if (_nextValue !== _NOVALUE)
@@ -43,13 +43,6 @@ export class DeferredSequence extends AbstractSequence {
     get value() {
         return (this._deferred || (this._deferred = new Deferred()));
     }
-    /** Resolve the current deferred from a sequence of values. */
-    async *resolveSequence(sequence) {
-        for await (const item of sequence) {
-            this.resolve(item);
-            yield item;
-        }
-    }
     // Implement `AsyncIterator`
     async next() {
         return { value: await this.value };
@@ -64,8 +57,19 @@ export class DeferredSequence extends AbstractSequence {
     finally(onFinally) {
         return this.value.finally(onFinally);
     }
+    /** Resolve the current deferred from a sequence of values. */
+    async *through(sequence) {
+        for await (const item of sequence) {
+            this.resolve(item);
+            yield item;
+        }
+    }
+    /** Pull values from a source sequence until the returned stop function is called. */
+    from(source, onError) {
+        return runSequence(this.through(source), undefined, onError);
+    }
     /** Subscrbe to the value of the sequence with a callback until the returned stop function is called. */
-    subscribe(onNext, onError) {
+    to(onNext, onError) {
         return runSequence(this, onNext, onError);
     }
 }