shelving 1.86.3 → 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/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/package.json

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

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/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. */