shelving 1.86.2 → 1.86.4

package/constraint/FilterConstraint.d.ts

@@ -16,7 +16,7 @@ export type FilterProps<T extends Data> = {
     [K in DataKey<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
 };
 /** List of filters in a flexible format. */
-export type FilterList<T extends Data> = Nullish<FilterProps<T> | FilterConstraint<T>> | Iterable<FilterList<T>>;
+export type FilterList<T extends Data> = FilterProps<T> | FilterConstraint<T> | Iterable<Nullish<FilterProps<T> | FilterConstraint<T>>>;
 /**
  * Filter: filters a list of data.
  *
@@ -34,5 +34,5 @@ export declare class FilterConstraint<T extends Data = Data> implements Constrai
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;
 }
-/** Get the separate filters generated from a list of filters. */
-export declare function getFilters<T extends Data>(filters: FilterList<T>): Iterable<FilterConstraint<T>>;
+/** Turn `FilterList` into a list of `FilterConstraint` instances. */
+export declare function getFilters<T extends Data>(list: FilterList<T> | FilterList<T>[]): Iterable<FilterConstraint<T>>;

package/constraint/FilterConstraint.js

@@ -79,17 +79,18 @@ export class FilterConstraint {
         return `"${this.filterKey}":${JSON.stringify(this.value)}`;
     }
 }
-/** Get the separate filters generated from a list of filters. */
-export function* getFilters(filters) {
-    if (filters instanceof FilterConstraint) {
-        yield filters;
+/** Turn `FilterList` into a list of `FilterConstraint` instances. */
+export function* getFilters(list) {
+    if (list instanceof FilterConstraint) {
+        yield list;
     }
-    else if (isIterable(filters)) {
-        for (const filter of filters)
-            yield* getFilters(filter);
+    else if (isIterable(list)) {
+        for (const filter of list)
+            if (filter)
+                yield* getFilters(filter);
     }
-    else if (filters) {
-        for (const [key, value] of Object.entries(filters))
+    else {
+        for (const [key, value] of Object.entries(list))
             yield new FilterConstraint(key, value);
     }
 }

package/constraint/FilterConstraints.d.ts

@@ -8,14 +8,14 @@ import { Constraints } from "./Constraints.js";
  */
 export interface Filterable<T extends Data> extends Matchable<[T]> {
     /** Add a filter to this filterable. */
-    filter(...filters: FilterList<Partial<T>>[]): this;
+    filter(...filters: FilterList<T>[]): this;
     /** Match an item against the filters specified for this object. */
     match(item: T): boolean;
 }
 /** A set of filters. */
-export declare class FilterConstraints<T extends Data = Data> extends Constraints<T, FilterConstraint<Partial<T>>> implements Filterable<T> {
-    constructor(...filters: FilterList<Partial<T>>[]);
-    filter(...filters: FilterList<Partial<T>>[]): this;
+export declare class FilterConstraints<T extends Data = Data> extends Constraints<T, FilterConstraint<T>> implements Filterable<T> {
+    constructor(...filters: FilterList<T>[]);
+    filter(...filters: FilterList<T>[]): this;
     match(item: T): boolean;
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;

package/constraint/QueryConstraints.d.ts

@@ -31,11 +31,11 @@ export declare class QueryConstraints<T extends Data = Data> extends Constraint<
     readonly filters: FilterConstraints<T>;
     readonly sorts: SortConstraints<T>;
     readonly limit: number | null;
-    constructor(filters?: FilterList<Partial<T>> | FilterConstraints<T>, sorts?: SortList<Partial<T>> | SortConstraints<T>, limit?: number | null);
-    filter(...filters: FilterList<Partial<T>>[]): this;
+    constructor(filters?: FilterList<T> | FilterConstraints<T>, sorts?: SortList<T> | SortConstraints<T>, limit?: number | null);
+    filter(...filters: FilterList<T>[]): this;
     get unfilter(): this;
     match(item: T): boolean;
-    sort(...sorts: SortList<Partial<T>>[]): this;
+    sort(...sorts: SortList<T>[]): this;
     get unsort(): this;
     rank(left: T, right: T): number;
     after(item: T): this;

package/constraint/SortConstraint.d.ts

@@ -10,7 +10,7 @@ export type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
 /** Possible operator references. */
 export type SortDirection = "ASC" | "DESC";
 /** List of sorts in a flexible format. */
-export type SortList<T extends Data> = Nullish<SortKeys<T> | SortConstraint<T> | Iterable<SortList<T>>>;
+export type SortList<T extends Data> = SortKey<T> | SortConstraint<T> | Iterable<Nullish<SortKey<T> | SortConstraint<T>>>;
 /** Sort a list of values. */
 export declare class SortConstraint<T extends Data = Data> implements Constraint<T>, Rankable<T> {
     readonly key: string;
@@ -21,5 +21,5 @@ export declare class SortConstraint<T extends Data = Data> implements Constraint
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;
 }
-/** Get the separate sorts generated from a list of sorts. */
-export declare function getSorts<T extends Data>(sorts: SortList<T>): Iterable<SortConstraint<T>>;
+/** Turn `SortList` into array of list of `SortConstraint` instances. */
+export declare function getSorts<T extends Data>(list: SortList<T> | SortList<T>[]): Iterable<SortConstraint<T>>;

package/constraint/SortConstraint.js

@@ -24,16 +24,17 @@ export class SortConstraint {
         return this.sortKey;
     }
 }
-/** Get the separate sorts generated from a list of sorts. */
-export function* getSorts(sorts) {
-    if (typeof sorts === "string") {
-        yield new SortConstraint(sorts);
-    }
-    else if (sorts instanceof SortConstraint) {
-        yield sorts;
-    }
-    else if (sorts) {
-        for (const sort of sorts)
-            yield* getSorts(sort);
+/** Turn `SortList` into array of list of `SortConstraint` instances. */
+export function* getSorts(list) {
+    if (typeof list === "string") {
+        yield new SortConstraint(list);
+    }
+    else if (list instanceof SortConstraint) {
+        yield list;
+    }
+    else {
+        for (const sort of list)
+            if (sort)
+                yield* getSorts(sort);
     }
 }

package/constraint/SortConstraints.d.ts

@@ -8,12 +8,12 @@ import { SortConstraint, SortList } from "./SortConstraint.js";
  */
 export interface Sortable<T extends Data> extends Rankable<T> {
     /** Add one or more sorts to this sortable. */
-    sort(...keys: SortList<Partial<T>>[]): this;
+    sort(...keys: SortList<T>[]): this;
 }
 /** A set of sorts. */
-export declare class SortConstraints<T extends Data = Data> extends Constraints<T, SortConstraint<Partial<T>>> implements Sortable<T> {
-    constructor(...sorts: SortList<Partial<T>>[]);
-    sort(...sorts: SortList<Partial<T>>[]): this;
+export declare class SortConstraints<T extends Data = Data> extends Constraints<T, SortConstraint<T>> implements Sortable<T> {
+    constructor(...sorts: SortList<T>[]);
+    sort(...sorts: SortList<T>[]): this;
     rank(left: T, right: T): number;
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;

package/db/Collection.d.ts

@@ -43,7 +43,7 @@ export declare class Collection<T extends Datas = Datas, K extends DataKey<T> =
     readonly db: Database<T>;
     readonly collection: K;
     constructor(db: Database<T>, collection: K);
-    query(filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K>;
+    query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K>;
     item(id: string): Item<T, K>;
     change(...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
     get(id: string): ItemValue<T[K]>;
@@ -57,7 +57,7 @@ export declare class AsyncCollection<T extends Datas = Datas, K extends DataKey<
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
     constructor(db: AsyncDatabase<T>, collection: K);
-    query(filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): AsyncQuery<T, K>;
+    query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T, K>;
     item(id: string): AsyncItem<T, K>;
     change(...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): Promise<ItemChanges<T, K>>;
     get(id: string): Promise<ItemValue<T[K]>>;

package/db/Database.d.ts

@@ -45,7 +45,7 @@ export declare class Database<T extends Datas = Datas> extends BaseDatabase<T> {
     readonly provider: Provider<T>;
     constructor(provider: Provider<T>);
     collection<K extends DataKey<T>>(collection: K): Collection<T, K>;
-    query<K extends DataKey<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K>;
+    query<K extends DataKey<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K>;
     item<K extends DataKey<T>>(collection: K, id: string): Item<T, K>;
     change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): ItemChanges<T>;
     get<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
@@ -59,7 +59,7 @@ export declare class AsyncDatabase<T extends Datas = Datas> extends BaseDatabase
     readonly provider: AsyncProvider<T>;
     constructor(provider: AsyncProvider<T>);
     collection<K extends DataKey<T>>(collection: K): AsyncCollection<T, K>;
-    query<K extends DataKey<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): AsyncQuery<T, K>;
+    query<K extends DataKey<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T, K>;
     item<K extends DataKey<T>>(collection: K, id: string): AsyncItem<T, K>;
     change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): Promise<ItemChanges<T>>;
     get<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;

package/db/Query.d.ts

@@ -73,7 +73,7 @@ declare abstract class BaseQuery<T extends Datas = Datas, K extends DataKey<T> =
 export declare class Query<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseQuery<T, K> {
     readonly db: Database<T>;
     readonly collection: K;
-    constructor(db: Database<T>, collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null);
+    constructor(db: Database<T>, collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null);
     get value(): ItemArray<T[K]>;
     get count(): number;
     get exists(): boolean;
@@ -89,7 +89,7 @@ export declare class Query<T extends Datas = Datas, K extends DataKey<T> = DataK
 export declare class AsyncQuery<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseQuery<T, K> {
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
-    constructor(db: AsyncDatabase<T>, collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null);
+    constructor(db: AsyncDatabase<T>, collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null);
     get value(): Promise<ItemArray<T[K]>>;
     get count(): Promise<number>;
     get exists(): Promise<boolean>;

package/firestore/client/FirestoreClientProvider.js

@@ -1,9 +1,8 @@
-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 { documentId as firestoreDocumentId, 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, 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.
+const ID = firestoreDocumentId();
 // Map `Filter.types` to `WhereFilterOp`
 const OPERATORS = {
     IS: "==",

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,9 +1,10 @@
-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 { documentId as firestoreDocumentId, 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, 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.
+// const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
+const ID = firestoreDocumentId();
 // Map `Filter.types` to `WhereFilterOp`
 const OPERATORS = {
     IS: "==",

package/firestore/server/FirestoreServerProvider.js

@@ -1,9 +1,8 @@
-import { Firestore, FieldValue as FirestoreFieldValue } from "@google-cloud/firestore";
+import { Firestore, FieldValue, FieldPath } from "@google-cloud/firestore";
 import { LazyDeferredSequence } from "../../sequence/LazyDeferredSequence.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.
+const ID = FieldPath.documentId();
 // Map `Filter.types` to `WhereFilterOp`
 const OPERATORS = {
     IS: "==",
@@ -53,11 +52,11 @@ function* _getFieldValues(updates, prefix = "") {
         else if (update instanceof ArrayUpdate) {
             if (update.adds.length) {
                 yield `${prefix}${key}`;
-                yield FirestoreFieldValue.arrayUnion(...update.adds);
+                yield FieldValue.arrayUnion(...update.adds);
             }
             if (update.deletes.length) {
                 yield `${prefix}${key}`;
-                yield FirestoreFieldValue.arrayRemove(...update.deletes);
+                yield FieldValue.arrayRemove(...update.deletes);
             }
         }
         else {
@@ -65,9 +64,9 @@ function* _getFieldValues(updates, prefix = "") {
             if (!(update instanceof Update))
                 yield update;
             else if (update instanceof Delete)
-                yield FirestoreFieldValue.delete();
+                yield FieldValue.delete();
             else if (update instanceof Increment)
-                yield FirestoreFieldValue.increment(update.amount);
+                yield FieldValue.increment(update.amount);
             else
                 yield update.transform();
         }

package/markup/regexp.d.ts

@@ -41,7 +41,7 @@ export declare function getLineRegExp(content?: PossibleRegExp, end?: PossibleRe
  * - If we could use a negative lookbehind for the start of the word we wouldn't need to create a function that offsets the start.
  */
 export declare class WordRegExp extends RegExp {
-    constructor(pattern: string);
+    constructor(pattern: string, flags?: string);
     exec(input: string): RegExpExecArray | null;
     test(input: string): boolean;
 }

package/markup/regexp.js

@@ -26,8 +26,8 @@ export function getLineRegExp(content = LINE_REGEXP, end = LINE_END_REGEXP, star
  * - If we could use a negative lookbehind for the start of the word we wouldn't need to create a function that offsets the start.
  */
 export class WordRegExp extends RegExp {
-    constructor(pattern) {
-        super(`(?<lookbehind>^|[^\\p{L}\\p{N}])${pattern}(?![\\p{L}\\p{N}])`);
+    constructor(pattern, flags) {
+        super(`(?<lookbehind>^|[^\\p{L}\\p{N}])${pattern}(?![\\p{L}\\p{N}])`, flags);
     }
     exec(input) {
         var _a;

package/markup/rule.d.ts

@@ -36,35 +36,33 @@ export declare abstract class MarkupRule {
     abstract render(props: Data | undefined, options: MarkupOptions): JSXElement;
 }
 export declare class RegExpMarkupRule extends MarkupRule {
-    private readonly _regexp;
-    private readonly _render;
-    constructor(_regexp: RegExp, //
-    _render: (props: Data, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
+    readonly regexp: RegExp;
+    readonly render: (props: Data, options: MarkupOptions) => JSXElement;
+    constructor(regexp: RegExp, //
+    render: (props: Data, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
     match(input: string): MarkupRuleMatch | null;
-    render(props: Data, options: MarkupOptions): JSXElement;
 }
 export declare class NamedRegExpMarkupRule<T extends NamedRegExpData> extends MarkupRule {
-    private readonly _regexp;
-    private readonly _render;
-    constructor(_regexp: NamedRegExp<T>, //
-    _render: (props: T, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
+    readonly regexp: NamedRegExp<T>;
+    readonly render: (props: T, options: MarkupOptions) => JSXElement;
+    constructor(regexp: NamedRegExp<T>, //
+    render: (props: T, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
     match(input: string): NamedRegExpArray<T> | null;
-    render(props: T, options: MarkupOptions): JSXElement;
 }
 export declare class LinkRegExpMarkupRule extends MarkupRule {
-    readonly _regexp: NamedRegExp<{
+    readonly regexp: NamedRegExp<{
         title?: string;
         href: string;
     }>;
-    readonly _render: (props: {
+    readonly render: (props: {
         title: string;
         href: string;
     }, options: MarkupOptions) => JSXElement;
-    constructor(_regexp: NamedRegExp<{
+    constructor(regexp: NamedRegExp<{
         title?: string;
         href: string;
     }>, //
-    _render: (props: {
+    render: (props: {
         title: string;
         href: string;
     }, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
@@ -72,9 +70,5 @@ export declare class LinkRegExpMarkupRule extends MarkupRule {
         title: string;
         href: string;
     }> | null;
-    render(props: {
-        title: string;
-        href: string;
-    }, options: MarkupOptions): JSXElement<import("../util/jsx.js").JSXProps>;
 }
 export type MarkupRules = MarkupRule[];

package/markup/rule.js

@@ -8,45 +8,39 @@ export class MarkupRule {
     }
 }
 export class RegExpMarkupRule extends MarkupRule {
-    constructor(_regexp, //
-    _render, contexts, subcontext, priority) {
+    constructor(regexp, //
+    render, contexts, subcontext, priority) {
         super(contexts, subcontext, priority);
-        this._regexp = _regexp;
-        this._render = _render;
+        this.regexp = regexp;
+        this.render = render;
     }
     match(input) {
-        return this._regexp.exec(input);
-    }
-    render(props, options) {
-        return this._render(props, options);
+        return this.regexp.exec(input);
     }
 }
 export class NamedRegExpMarkupRule extends MarkupRule {
-    constructor(_regexp, //
-    _render, contexts, subcontext, priority) {
+    constructor(regexp, //
+    render, contexts, subcontext, priority) {
         super(contexts, subcontext, priority);
-        this._regexp = _regexp;
-        this._render = _render;
+        this.regexp = regexp;
+        this.render = render;
     }
     match(input) {
-        return this._regexp.exec(input);
-    }
-    render(props, options) {
-        return this._render(props, options);
+        return this.regexp.exec(input);
     }
 }
 export class LinkRegExpMarkupRule extends MarkupRule {
-    constructor(_regexp, //
-    _render, contexts, subcontext, priority) {
+    constructor(regexp, //
+    render, contexts, subcontext, priority) {
         super(contexts, subcontext, priority);
-        this._regexp = _regexp;
-        this._render = _render;
+        this.regexp = regexp;
+        this.render = render;
     }
     // Validates that the link is a valid URL (using `getOptionalURL()` to resolve relative links relative to `options.url`).
     // Validates that the link's URL scheme is in the `options.schemes` whitelist (defaults to `http` and `https`).
     // Generates a default title for the link using `formatURL()` (e.g. `shax.com/my/dir`).
     match(input, { schemes, url: base }) {
-        const match = this._regexp.exec(input);
+        const match = this.regexp.exec(input);
         if (match) {
             const { 0: first, index, groups } = match;
             const { href, title } = groups;
@@ -57,7 +51,4 @@ export class LinkRegExpMarkupRule extends MarkupRule {
         }
         return null;
     }
-    render(props, options) {
-        return this._render(props, options);
-    }
 }

package/markup/rules.d.ts

@@ -1,5 +1,4 @@
 import type { JSXElement } from "../util/jsx.js";
-import { NamedRegExp } from "../util/regexp.js";
 import type { MarkupOptions } from "./options.js";
 import { LinkRegExpMarkupRule, MarkupRules, NamedRegExpMarkupRule, RegExpMarkupRule } from "./rule.js";
 /**
@@ -60,10 +59,6 @@ export declare function renderLinkRule({ href, title }: {
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
  * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
-export declare const URL_REGEXP: NamedRegExp<{
-    title?: string;
-    href: string;
-}>;
 export declare const URL_RULE: LinkRegExpMarkupRule;
 /**
  * Markdown-style link.
@@ -73,10 +68,6 @@ export declare const URL_RULE: LinkRegExpMarkupRule;
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
  * - For security only `http://` or `https://` links will work (if invalid the unparsed text will be returned).
  */
-export declare const LINK_REGEXP: NamedRegExp<{
-    title: string;
-    href: string;
-}>;
 export declare const LINK_RULE: LinkRegExpMarkupRule;
 /**
  * Inline code.

package/markup/rules.js

@@ -150,8 +150,8 @@ export function renderLinkRule({ href, title }, { rel }) {
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
  * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
-export const URL_REGEXP = getRegExp(/(?<href>[a-z]+:[-$_@.&!*,=;/#?:%a-zA-Z0-9]+)(?: +(?:\((?<title>[^)]*?)\)))?/);
-export const URL_RULE = new LinkRegExpMarkupRule(URL_REGEXP, renderLinkRule, ["inline", "list"], "link");
+export const URL_RULE = new LinkRegExpMarkupRule(getRegExp(/(?<href>[a-z]+:[-$_@.&!*,=;/#?:%a-zA-Z0-9]+)(?: +(?:\((?<title>[^)]*?)\)))?/), //
+renderLinkRule, ["inline", "list"], "link");
 /**
  * Markdown-style link.
  * - Link in standard Markdown format, e.g. `[Google Maps](http://google.com/maps)`
@@ -160,8 +160,8 @@ export const URL_RULE = new LinkRegExpMarkupRule(URL_REGEXP, renderLinkRule, ["i
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
  * - For security only `http://` or `https://` links will work (if invalid the unparsed text will be returned).
  */
-export const LINK_REGEXP = getRegExp(/\[(?<title>[^\]]*?)\]\((?<href>[^)]*?)\)/);
-export const LINK_RULE = new LinkRegExpMarkupRule(LINK_REGEXP, renderLinkRule, ["inline", "list"], "link");
+export const LINK_RULE = new LinkRegExpMarkupRule(getRegExp(/\[(?<title>[^\]]*?)\]\((?<href>[^)]*?)\)/), //
+renderLinkRule, ["inline", "list"], "link");
 /**
  * Inline code.
  * - Text surrounded by one or more "`" backtick tilde characters.

package/package.json

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

package/react/useQuery.js

@@ -70,7 +70,7 @@ export class QueryState extends State {
         this.busy.set(true);
         try {
             const items = await this.ref.value;
-            this._hasMore = items.length < this.limit;
+            this._hasMore = items.length >= this.limit; // If the query returned {limit} or more items, we can assume there are more items waiting to be queried.
             this.set(items);
         }
         catch (thrown) {
@@ -92,9 +92,11 @@ export class QueryState extends State {
     async _loadMore() {
         this.busy.set(true);
         try {
-            const items = await this.ref.after(this.lastData).value;
+            const last = this.lastValue;
+            const query = last ? this.ref.after(last) : this.ref;
+            const items = await query.value;
             this.set([...this.value, ...items]);
-            this._hasMore = items.length < this.limit;
+            this._hasMore = items.length >= this.limit; // If the query returned {limit} or more items, we can assume there are more items waiting to be queried.
         }
         catch (thrown) {
             this.next.reject(thrown);

package/state/State.d.ts

@@ -1,3 +1,4 @@
+import type { Validatable } from "../util/validate.js";
 import { Dispatch, Handler, Stop } from "../util/function.js";
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
 /** Any `State` instance. */
@@ -12,7 +13,7 @@ export type AnyState = State<any>;
  * - To set the state to be loading, use the `State.NOVALUE` constant or a `Promise` value.
  * - To set the state to an explicit value, use that value or another `State` instance with a value.
  * */
-export declare class State<T> implements AsyncIterable<T> {
+export declare class State<T> implements AsyncIterable<T>, Validatable<T> {
     /** The `NOVALUE` symbol indicates no value has been received by a `State` instance. */
     static readonly NOVALUE: unique symbol;
     /** Deferred sequence this state uses to issue values as they change. */
@@ -30,7 +31,7 @@ export declare class State<T> implements AsyncIterable<T> {
     /** Is there a current value, or is it still loading. */
     get loading(): boolean;
     /** Set the value of the state. */
-    set(value: T): void;
+    set(next: T): void;
     /** Set the value of the state as values are pulled from a sequence. */
     through(sequence: AsyncIterable<T>): AsyncIterable<T>;
     /** Pull values from a source sequence until the returned stop function is called. */
@@ -38,6 +39,8 @@ export declare class State<T> implements AsyncIterable<T> {
     /** Push values to another state or callback to this state until the returned stop function is called. */
     to(target: Dispatch<[T]>, onError?: Handler): Stop;
     [Symbol.asyncIterator](): AsyncIterator<T>;
+    /** Validate data set on this state. */
+    validate(value: T): T;
 }
 /** Is an unknown value a `State` instance. */
 export declare const isState: <T extends AnyState>(v: unknown) => v is T;

package/state/State.js

@@ -28,8 +28,12 @@ export class State {
     }
     /** State is initiated with an initial state. */
     constructor(initial = State.NOVALUE, next = new DeferredSequence()) {
-        this._value = initial;
-        this._time = initial !== State.NOVALUE ? Date.now() : null;
+        this._value = State.NOVALUE;
+        this._time = null;
+        if (initial !== State.NOVALUE) {
+            this._value = this.validate(initial);
+            this._time = Date.now();
+        }
         this.next = next;
     }
     /** Is there a current value, or is it still loading. */
@@ -37,7 +41,8 @@ export class State {
         return this._value === State.NOVALUE;
     }
     /** Set the value of the state. */
-    set(value) {
+    set(next) {
+        const value = this.validate(next);
         if (value !== this._value) {
             this._value = value;
             this._time = Date.now();
@@ -67,6 +72,10 @@ export class State {
             yield this.value;
         yield* this.next;
     }
+    /** Validate data set on this state. */
+    validate(value) {
+        return value;
+    }
 }
 /** The `NOVALUE` symbol indicates no value has been received by a `State` instance. */
 State.NOVALUE = Symbol("shelving/State.NOVALUE");

package/util/class.d.ts

@@ -4,9 +4,8 @@ export type Constructor<T, A extends Arguments> = new (...args: A) => T;
 /** Any function arguments (designed for use with `extends Arguments` guards). */
 export type AnyConstructor = new (...args: any) => any;
 /** Class prototype that can be used with `instanceof` (string name, as per `Function`, and a prototype field matching the object). */
-export type Class<T = unknown> = Omit<Function, "prototype"> & {
-    prototype: T;
-};
+export type Class<T> = new (...args: any) => T;
+export declare const abc: Class<String>;
 /** Is a given value a class constructor? */
 export declare const isConstructor: <T extends AnyConstructor>(v: unknown) => v is T;
 /** Is a value an instance of a class? */

package/util/class.js

@@ -2,6 +2,7 @@
 import { AssertionError } from "../error/AssertionError.js";
 import { assertFunction } from "./function.js";
 import { debug } from "./debug.js";
+export const abc = String;
 /** Is a given value a class constructor? */
 export const isConstructor = (v) => typeof v === "function" && v.toString().startsWith("class");
 /** Is a value an instance of a class? */

package/util/hydrate.d.ts

@@ -5,7 +5,7 @@ import { Transformable } from "./transform.js";
  * A set of hydrations describes a set of string keys and the class constructor to be dehydrated and rehydrated.
  * - We can't use `class.name` because we don't know that the name of the class will survive minification.
  */
-export type Hydrations = ImmutableDictionary<Class>;
+export type Hydrations = ImmutableDictionary<Class<unknown>>;
 /**
  * Deeply dehydrate a class instance based on a set of `Hydrations`
  * - Dehydration allows you to pass class instances from a server back to a client.

package/util/regexp.d.ts

@@ -6,16 +6,6 @@ export declare const ALWAYS_REGEXP: RegExp;
 export declare const NEVER_REGEXP: RegExp;
 /** Things that can be convert to a regular expression. */
 export type PossibleRegExp = string | RegExp;
-/** Is an unknown value a `RegExp` instance? */
-export declare const isRegExp: <T extends RegExp>(v: unknown) => v is T;
-/** Assert that an unknown value is a `RegExp` instance. */
-export declare function assertRegExp<T extends RegExp>(v: T | unknown): asserts v is T;
-/** Convert a string to a regular expression that matches that string. */
-export declare const getRegExp: (pattern: PossibleRegExp, flags?: string) => RegExp;
-/** Convert a regular expression to its string source. */
-export declare const getRegExpSource: (regexp: PossibleRegExp) => string;
-/** Escape special characters in a string regular expression. */
-export declare const escapeRegExp: (pattern: string) => string;
 /** Set of named match groups from a regular expression. */
 export type NamedRegExpData = {
     [named: string]: string;
@@ -28,6 +18,19 @@ export interface NamedRegExpArray<T extends NamedRegExpData = NamedRegExpData> e
 export interface NamedRegExp<T extends NamedRegExpData = NamedRegExpData> extends RegExp {
     exec(input: string): NamedRegExpArray<T> | null;
 }
+/** Is an unknown value a `RegExp` instance? */
+export declare const isRegExp: <T extends RegExp>(v: unknown) => v is T;
+/** Assert that an unknown value is a `RegExp` instance. */
+export declare function assertRegExp<T extends RegExp>(v: T | unknown): asserts v is T;
+/** Convert a string to a regular expression that matches that string. */
+export declare function getRegExp<T extends string>(pattern: `(?<${T}>${string})`, flags?: string): NamedRegExp<{
+    [K in T]: string;
+}>;
+export declare function getRegExp(pattern: PossibleRegExp, flags?: string): RegExp;
+/** Convert a regular expression to its string source. */
+export declare const getRegExpSource: (regexp: PossibleRegExp) => string;
+/** Escape special characters in a string regular expression. */
+export declare const escapeRegExp: (pattern: string) => string;
 /** Create regular expression that matches any of a list of other expressions. */
 export declare function getAnyRegExp(patterns: Iterable<PossibleRegExp> & NotString, flags?: string): RegExp;
 /** Create regular expression that matches all of a list of other expressions. */

package/util/regexp.js

@@ -11,8 +11,9 @@ export function assertRegExp(v) {
     if (!(v instanceof RegExp))
         throw new AssertionError("Must be regular expression", v);
 }
-/** Convert a string to a regular expression that matches that string. */
-export const getRegExp = (pattern, flags) => (typeof pattern === "string" ? new RegExp(pattern, flags) : pattern);
+export function getRegExp(pattern, flags) {
+    return typeof pattern === "string" ? new RegExp(pattern, flags) : pattern;
+}
 /** Convert a regular expression to its string source. */
 export const getRegExpSource = (regexp) => (typeof regexp === "string" ? regexp : regexp.source);
 /** Escape special characters in a string regular expression. */