shelving 1.109.2 → 1.109.4

package/change/Change.d.ts

@@ -11,8 +11,6 @@ export interface Change {
 /** A change to a database collection. */
 export interface CollectionChange<T extends Database, K extends DataKey<T>> extends Change {
     readonly collection: K;
-    readonly id?: string | never;
-    readonly query?: ItemQuery<T[K]> | never;
 }
 /** Add an item to a database collection. */
 export interface ItemAddChange<T extends Database, K extends DataKey<T>> extends CollectionChange<T, K> {

package/db/ItemStore.js

@@ -27,13 +27,14 @@ export class ItemStore extends Store {
     }
     constructor(provider, collection, id) {
         const memory = getOptionalSource(CacheProvider, provider)?.memory;
-        const time = memory ? memory.getItemTime(collection, id) : undefined;
-        super(memory && typeof time === "number" ? memory.getItem(collection, id) : NONE, time);
+        const time = memory?.getItemTime(collection, id);
+        const value = memory && typeof time === "number" ? memory.getItem(collection, id) : NONE; // Use the value in the memory provider if it's cached, or use mark this store as loading otherwise (which will trigger `refresh()` below.
+        super(value, time);
         this.provider = provider;
         this.collection = collection;
         this.id = id;
         // Queue a request to refresh the value if it doesn't exist.
-        if (this.loading)
+        if (typeof time !== "number")
             this.refresh();
     }
     /** Refresh this store from the source provider. */

package/db/QueryStore.js

@@ -45,13 +45,15 @@ export class QueryStore extends Store {
     }
     constructor(provider, collection, query) {
         const memory = getOptionalSource(CacheProvider, provider)?.memory;
-        super(memory?.getQuery(collection, query) || NONE, memory?.getQueryTime(collection, query));
+        const time = memory?.getQueryTime(collection, query);
+        const value = memory?.getQuery(collection, query) || NONE; // Always use any matching items currently in the memory store (this might update when we call `refresh()` below).
+        super(value, time);
         this.provider = provider;
         this.collection = collection;
         this.query = query;
         this.limit = getLimit(query) ?? Infinity;
         // Queue a request to refresh the value if it doesn't exist.
-        if (this.loading)
+        if (typeof time !== "number")
             this.refresh();
     }
     /** Refresh this store from the source provider. */

package/error/ThroughError.d.ts

@@ -3,5 +3,5 @@
  * - Merges the message and stack of the previous message.
  */
 export declare class ThroughError extends Error {
-    constructor(message: string, cause: Error | unknown);
+    constructor(message: string, cause: unknown);
 }

package/iterate/AbstractGenerator.d.ts

@@ -2,7 +2,7 @@
 export declare abstract class AbstractGenerator<T, R, N> implements Generator<T, R, N> {
     readonly [Symbol.toStringTag] = "Generator";
     abstract next(value: N): IteratorResult<T, R>;
-    throw(thrown: Error | unknown): IteratorResult<T, R>;
+    throw(thrown: unknown): IteratorResult<T, R>;
     return(value: R): IteratorResult<T, R>;
     [Symbol.iterator](): Generator<T, R, N>;
 }

package/iterate/InspectGenerator.d.ts

@@ -24,7 +24,7 @@ export declare class InspectGenerator<T, R, N> extends ThroughGenerator<T, R, N>
     get returned(): R;
     private _returned;
     next(value: N): IteratorResult<T, R>;
-    throw(thrown: Error | unknown): IteratorResult<T, R>;
+    throw(thrown: unknown): IteratorResult<T, R>;
     return(value: R): IteratorResult<T, R>;
     /** Capture a result. */
     private _inspect;

package/iterate/ThroughGenerator.d.ts

@@ -4,6 +4,6 @@ export declare class ThroughGenerator<T, R, N> extends AbstractGenerator<T, R, N
     private readonly _source;
     constructor(iterator: Iterator<T, R, N>);
     next(value: N): IteratorResult<T, R>;
-    throw(thrown: Error | unknown): IteratorResult<T, R>;
+    throw(thrown: unknown): IteratorResult<T, R>;
     return(value: R): IteratorResult<T, R>;
 }

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.109.2",
+	"version": "1.109.4",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -66,19 +66,19 @@
 		"@types/jest": "^29.4.0",
 		"@types/react": "^18.0.27",
 		"@types/react-dom": "^18.0.10",
-		"@typescript-eslint/eslint-plugin": "^5.49.0",
-		"@typescript-eslint/parser": "^5.49.0",
-		"esbuild": "^0.17.12",
+		"@typescript-eslint/eslint-plugin": "^6.7.0",
+		"@typescript-eslint/parser": "^6.7.0",
+		"esbuild": "^0.19.2",
 		"esbuild-jest": "^0.5.0",
 		"eslint": "^8.33.0",
-		"eslint-config-prettier": "^8.6.0",
+		"eslint-config-prettier": "^9.0.0",
 		"eslint-import-resolver-typescript": "^3.5.5",
 		"eslint-plugin-import": "^2.27.5",
-		"eslint-plugin-prettier": "^4.0.0",
-		"firebase": "^9.16.0",
+		"eslint-plugin-prettier": "^5.0.0",
+		"firebase": "^10.3.1",
 		"jest": "^29.4.1",
 		"jest-ts-webcompat-resolver": "^1.0.0",
-		"prettier": "^2.8.3",
+		"prettier": "^3.0.3",
 		"react": "^18.1.0",
 		"react-dom": "^18.1.0",
 		"typescript": "^5.0.2"

package/sequence/AbstractSequence.d.ts

@@ -3,6 +3,6 @@ export declare abstract class AbstractSequence<T, R, N> implements AsyncGenerato
     readonly [Symbol.toStringTag] = "Sequence";
     abstract next(value: N): Promise<IteratorResult<T, R>>;
     return(returnValue: R | PromiseLike<R>): Promise<IteratorResult<T, R>>;
-    throw(reason: Error | unknown): Promise<IteratorResult<T, R>>;
+    throw(reason: unknown): Promise<IteratorResult<T, R>>;
     [Symbol.asyncIterator](): AsyncGenerator<T, R>;
 }

package/sequence/InspectSequence.d.ts

@@ -24,7 +24,7 @@ export declare class InspectSequence<T, R, N> extends ThroughSequence<T, R, N> {
     get returned(): R;
     private _returned;
     next(): Promise<IteratorResult<T, R>>;
-    throw(thrown: Error | unknown): Promise<IteratorResult<T, R>>;
+    throw(thrown: unknown): Promise<IteratorResult<T, R>>;
     return(value: R): Promise<IteratorResult<T, R>>;
     /** Capture a result. */
     private _inspect;

package/sequence/ThroughSequence.d.ts

@@ -4,6 +4,6 @@ export declare class ThroughSequence<T, R, N> extends AbstractSequence<T, R, N>
     private readonly _source;
     constructor(source: AsyncIterator<T, R, N>);
     next(next: N): Promise<IteratorResult<T, R>>;
-    throw(thrown: Error | unknown): Promise<IteratorResult<T, R>>;
+    throw(thrown: unknown): Promise<IteratorResult<T, R>>;
     return(value: R | PromiseLike<R>): Promise<IteratorResult<T, R>>;
 }

package/store/Store.d.ts

@@ -28,7 +28,7 @@ export declare class Store<T> implements AsyncIterable<T> {
     get age(): number;
     /** Current error of this store (or `undefined` if there is no reason). */
     get reason(): unknown;
-    set reason(reason: Error | unknown);
+    set reason(reason: unknown);
     private _reason;
     /** Store is initiated with an initial store. */
     constructor(value: T | typeof NONE, time?: number);

package/util/array.d.ts

@@ -13,13 +13,13 @@ export type ArrayItem<T extends ImmutableArray> = T[number];
 /** Things that can be converted to arrays. */
 export type PossibleArray<T> = ImmutableArray<T> | Iterable<T>;
 /** Is an unknown value an array? */
-export declare const isArray: <T extends ImmutableArray<unknown>>(value: unknown) => value is T;
+export declare const isArray: (value: unknown) => value is ImmutableArray<unknown>;
 /** Assert that an unknown value is an array. */
-export declare function assertArray<T>(arr: ImmutableArray<T> | unknown): asserts arr is ImmutableArray<T>;
+export declare function assertArray<T>(arr: unknown): asserts arr is ImmutableArray<T>;
 /** Is an unknown value an item in a specified array? */
 export declare const isArrayItem: <T>(arr: ImmutableArray<T>, item: unknown) => item is T;
 /** Assert that an unknown value is an item in a specified array. */
-export declare function assertArrayItem<T>(arr: ImmutableArray<T>, item: T | unknown): asserts item is T;
+export declare function assertArrayItem<T>(arr: ImmutableArray<T>, item: unknown): asserts item is T;
 /** Convert an iterable to an array (if its not already an array). */
 export declare function getArray<T>(items: PossibleArray<T>): ImmutableArray<T>;
 /** Add multiple items to an array (immutably) and return a new array with those items (or the same array if no changes were made). */
@@ -77,25 +77,25 @@ export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 2, max?: n
 export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 3, max?: number): arr is readonly [T, T, T, ...T[]];
 export declare function isArrayLength<T>(arr: ImmutableArray<T>, min: 4, max?: number): arr is readonly [T, T, T, T, ...T[]];
 export declare function isArrayLength<T>(arr: ImmutableArray<T>, min?: number, max?: number): boolean;
-/** Assert that a value has a specific length (or length is in a specific range). */
+/** Assert that an array has a specific length (or length is in a specific range). */
 export declare function assertArrayLength<T>(arr: MutableArray<T>, min: 1, max: 1): asserts arr is [T];
 export declare function assertArrayLength<T>(arr: MutableArray<T>, min: 2, max: 2): asserts arr is [T, T];
 export declare function assertArrayLength<T>(arr: MutableArray<T>, min: 3, max: 3): asserts arr is [T, T, T];
 export declare function assertArrayLength<T>(arr: MutableArray<T>, min: 4, max: 4): asserts arr is [T, T, T, T];
-export declare function assertArrayLength<T>(arr: MutableArray<T> | unknown, min?: 1, max?: number): asserts arr is [T, ...T[]];
-export declare function assertArrayLength<T>(arr: MutableArray<T> | unknown, min: 2, max?: number): asserts arr is [T, T, ...T[]];
-export declare function assertArrayLength<T>(arr: MutableArray<T> | unknown, min: 3, max?: number): asserts arr is [T, T, T, ...T[]];
-export declare function assertArrayLength<T>(arr: MutableArray<T> | unknown, min: 4, max?: number): asserts arr is [T, T, T, T, ...T[]];
-export declare function assertArrayLength<T>(arr: MutableArray<T> | unknown, min: number, max?: number): asserts arr is MutableArray<T>;
+export declare function assertArrayLength<T>(arr: MutableArray<T>, min?: 1, max?: number): asserts arr is [T, ...T[]];
+export declare function assertArrayLength<T>(arr: MutableArray<T>, min: 2, max?: number): asserts arr is [T, T, ...T[]];
+export declare function assertArrayLength<T>(arr: MutableArray<T>, min: 3, max?: number): asserts arr is [T, T, T, ...T[]];
+export declare function assertArrayLength<T>(arr: MutableArray<T>, min: 4, max?: number): asserts arr is [T, T, T, T, ...T[]];
+export declare function assertArrayLength<T>(arr: MutableArray<T>, min: number, max?: number): asserts arr is MutableArray<T>;
 export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 1, max: 1): asserts arr is readonly [T];
 export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 2, max: 2): asserts arr is readonly [T, T];
 export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 3, max: 3): asserts arr is readonly [T, T, T];
 export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 4, max: 4): asserts arr is readonly [T, T, T, T];
-export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min?: 1, max?: number): asserts arr is readonly [T, ...T[]];
-export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min: 2, max?: number): asserts arr is readonly [T, T, ...T[]];
-export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min: 3, max?: number): asserts arr is readonly [T, T, T, ...T[]];
-export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min: 4, max?: number): asserts arr is readonly [T, T, T, T, ...T[]];
-export declare function assertArrayLength<T>(arr: ImmutableArray<T> | unknown, min: number, max?: number): asserts arr is ImmutableArray<T>;
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min?: 1, max?: number): asserts arr is readonly [T, ...T[]];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 2, max?: number): asserts arr is readonly [T, T, ...T[]];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 3, max?: number): asserts arr is readonly [T, T, T, ...T[]];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: 4, max?: number): asserts arr is readonly [T, T, T, T, ...T[]];
+export declare function assertArrayLength<T>(arr: ImmutableArray<T>, min: number, max?: number): asserts arr is ImmutableArray<T>;
 /** Get an array if it has the specified minimum length.  */
 export declare function getArrayLength<T>(arr: MutableArray<T>, min: 1, max: 1): [T];
 export declare function getArrayLength<T>(arr: MutableArray<T>, min: 2, max: 2): [T, T];

package/util/assert.d.ts

@@ -1,6 +1,6 @@
 /** Assert a boolean condition is true. */
 export declare function assert(condition: unknown, ...receivedExpected: [received?: unknown, expected?: unknown]): asserts condition;
 /** Assert two values are equal. */
-export declare function assertEqual<T>(left: T | unknown, right: T): asserts left is T;
+export declare function assertEqual<T>(left: unknown, right: T): asserts left is T;
 /** Assert two values are equal. */
 export declare function assertNot<T, N>(left: T | N, right: N): asserts left is T;

package/util/callback.d.ts

@@ -12,7 +12,7 @@ export type ValuesCallback<T extends Arguments = []> = (...values: T) => void;
 /** Callback function that receives multiple values and possibly returns a promise that must be handled. */
 export type AsyncValuesCallback<T extends Arguments = []> = (...values: T) => void | PromiseLike<void>;
 /** Callback function that handles an error. */
-export type ErrorCallback = (reason: Error | unknown) => void;
+export type ErrorCallback = (reason: unknown) => void;
 /** Callback function that starts something (and returns an optional stop callback). */
 export type StartCallback<T> = (value: T) => StopCallback;
 /** Callback function that stops something. */

package/util/class.d.ts

@@ -3,11 +3,11 @@ import type { Arguments } from "./function.js";
 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). */
+/** Class prototype that can be used with `instanceof`. */
 export type Class<T> = new (...args: any) => T;
 /** Is a given value a class constructor? */
-export declare const isConstructor: <T extends AnyConstructor>(value: unknown) => value is T;
+export declare const isConstructor: (value: unknown) => value is AnyConstructor;
 /** Is a value an instance of a class? */
 export declare const isInstance: <T>(value: unknown, type: Class<T>) => value is T;
 /** Assert that a value is an instance of something. */
-export declare function assertInstance<T>(value: T | unknown, type: Class<T>): asserts value is T;
+export declare function assertInstance<T>(value: unknown, type: Class<T>): asserts value is T;

package/util/color.d.ts

@@ -27,9 +27,9 @@ export declare class Color {
     toString(): string;
 }
 /** Is an unknown value a `Color` instance. */
-export declare const isColor: (value: Color | unknown) => value is Color;
+export declare const isColor: (value: unknown) => value is Color;
 /** Assert that an unknown value is a `Color` instance. */
-export declare function assertColor(value: Color | unknown): asserts value is Color;
+export declare function assertColor(value: unknown): asserts value is Color;
 /** Convert a possible color to a `Color` instance or `null` */
 export declare function getOptionalColor(possible: unknown): Color | null;
 /** Convert a possible color to a `Color` instance */

package/util/data.d.ts

@@ -44,9 +44,9 @@ export type LeafProp<T extends Data> = {
     readonly [K in DataKey<T>]: (T[K] extends Data ? LeafProp<T[K]> : readonly [null, T[K]]) extends infer E ? E extends readonly [infer KK, infer VV] ? readonly [KK extends string ? `${K}.${KK}` : K, VV] : never : never;
 }[DataKey<T>];
 /** Is an unknown value a data object? */
-export declare const isData: <T extends Data>(value: unknown) => value is T;
+export declare const isData: (value: unknown) => value is Data;
 /** Assert that an unknown value is a data object. */
-export declare function assertData<T extends Data>(value: T | unknown): asserts value is T;
+export declare function assertData(value: unknown): asserts value is Data;
 /** Is an unknown value the key for an own prop of a data object. */
 export declare const isDataProp: <T extends Data>(data: T, key: unknown) => key is DataKey<T>;
 /** Assert that an unknown value is the key for an own prop of a data object. */

package/util/date.d.ts

@@ -3,9 +3,9 @@ export type PossibleDate = Date | number | string;
 /** Things that converted to dates or `null` */
 export type PossibleOptionalDate = Date | number | string | null;
 /** Is a value a date? */
-export declare function isDate(value: Date | unknown): value is Date;
+export declare function isDate(value: unknown): value is Date;
 /** Assert that a value is a `Date` instance. */
-export declare function assertDate(value: Date | unknown): asserts value is Date;
+export declare function assertDate(value: unknown): asserts value is Date;
 /**
  * Convert an unknown value to a valid `Date` instance, or `null` if it couldn't be converted.
  * - Note: `Date` instances can be invalid (e.g. `new Date("blah blah").getTime()` returns `NaN`). These are detected and will always return `null`

package/util/dictionary.d.ts

@@ -13,9 +13,9 @@ export type DictionaryValue<T extends ImmutableDictionary> = T[string];
 /** Something that can be converted to a dictionary object. */
 export type PossibleDictionary<T> = ImmutableDictionary<T> | Iterable<DictionaryItem<T>>;
 /** Is an unknown value a dictionary object? */
-export declare const isDictionary: <T extends ImmutableDictionary<T>>(value: unknown) => value is T;
+export declare const isDictionary: (value: unknown) => value is ImmutableDictionary<unknown>;
 /** Assert that an unknown value is a dictionary object */
-export declare function assertDictionary<T>(value: ImmutableDictionary<T> | unknown): asserts value is ImmutableDictionary<T>;
+export declare function assertDictionary(value: unknown): asserts value is ImmutableDictionary;
 /** Is an unknown value the key for an own prop of a dictionary. */
 export declare const isDictionaryItem: <T>(obj: ImmutableDictionary<T>, key: unknown) => key is string;
 /** Assert that an unknown value is the key for an own prop of a dictionary. */

package/util/function.d.ts

@@ -1,11 +1,11 @@
 /** Unknown function. */
 export type UnknownFunction = (...args: unknown[]) => unknown;
-/** Any function (designed for use with `extends AnyFunction` guards). */
+/** Any function (purposefully as wide as possible for use with `extends X` or `is X` statements). */
 export type AnyFunction = (...args: any) => any;
 /** Is a value a function? */
-export declare const isFunction: <T extends AnyFunction>(value: unknown) => value is T;
+export declare const isFunction: (value: unknown) => value is AnyFunction;
 /** Assert that a value is a function. */
-export declare function assertFunction<T extends AnyFunction>(value: T | unknown): asserts value is T;
+export declare function assertFunction(value: unknown): asserts value is AnyFunction;
 /** Readonly unknown array that is being used as a set of arguments to a function. */
 export type Arguments = readonly unknown[];
 /** Function that just passes through the first argument. */

package/util/iterate.d.ts

@@ -1,10 +1,5 @@
-/**
- * Is a value an iterable object?
- * - Any object with a `Symbol.iterator` property is iterable.
- * - Note: Array and Map instances etc will return true because they implement `Symbol.iterator`
- */
 /** Is an unknown value an iterable? */
-export declare const isIterable: <T extends Iterable<unknown>>(value: unknown) => value is T;
+export declare const isIterable: (value: unknown) => value is Iterable<unknown>;
 /** An iterable containing items or nested iterables of items. */
 export type DeepIterable<T> = T | Iterable<DeepIterable<T>>;
 /** Flatten one or more iterables. */
@@ -15,7 +10,7 @@ export declare function flattenItems<T>(items: DeepIterable<T>): Iterable<T>;
  */
 export declare function hasItems(items: Iterable<unknown>): boolean;
 /** Is an unknown value one of the values of an iterable? */
-export declare function isItem<T>(items: Iterable<T>, value: T | unknown): value is T;
+export declare function isItem<T>(items: Iterable<T>, value: unknown): value is T;
 /** Count the number of items in an iterable. */
 export declare function countItems(items: Iterable<unknown>): number;
 /**

package/util/iterate.js

@@ -1,8 +1,3 @@
-/**
- * Is a value an iterable object?
- * - Any object with a `Symbol.iterator` property is iterable.
- * - Note: Array and Map instances etc will return true because they implement `Symbol.iterator`
- */
 /** Is an unknown value an iterable? */
 export const isIterable = (value) => typeof value === "object" && !!value && Symbol.iterator in value;
 /** Flatten one or more iterables. */

package/util/jsx.d.ts

@@ -14,9 +14,9 @@ export type JSXElement<P extends JSXProps = JSXProps> = {
 /** JSX node (similar to `React.ReactNode`) */
 export type JSXNode = undefined | null | string | JSXElement | JSXNode[];
 /** Is an unknown value a JSX element? */
-export declare const isJSXElement: <T extends JSXElement<JSXProps>>(value: unknown) => value is T;
+export declare const isJSXElement: (value: unknown) => value is JSXElement<JSXProps>;
 /** Is an unknown value a JSX node? */
-export declare const isJSXNode: <T extends JSXNode>(value: unknown) => value is T;
+export declare const isJSXNode: (value: unknown) => value is JSXNode;
 /**
  * Take a Markup JSX node and strip all tags from it to produce a plain text string.
  *

package/util/map.d.ts

@@ -20,13 +20,13 @@ export type PossibleStringMap<K extends string, T> = PossibleMap<K, T> | {
     readonly [KK in K]: T;
 };
 /** Is an unknown value a map? */
-export declare const isMap: <T extends ImmutableMap<unknown, unknown>>(value: unknown) => value is T;
+export declare const isMap: (value: unknown) => value is ImmutableMap<unknown, unknown>;
 /** Assert that a value is a `Map` instance. */
-export declare function assertMap<T extends ImmutableMap>(value: T | unknown): asserts value is T;
+export declare function assertMap(value: unknown): asserts value is ImmutableMap;
 /** Is an unknown value a key for an item in a map? */
 export declare const isMapItem: <K, V>(map: ImmutableMap<K, V>, key: unknown) => key is K;
 /** Assert that an unknown value is a key for an item in a map. */
-export declare function assertMapItem<K, V>(map: ImmutableMap<K, V>, key: K | unknown): asserts key is K;
+export declare function assertMapItem<K, V>(map: ImmutableMap<K, V>, key: unknown): asserts key is K;
 /** Convert an iterable to a `Map` (if it's already a `Map` it passes through unchanged). */
 export declare function getMap<K extends string, T>(input: PossibleStringMap<K, T>): ImmutableMap<K, T>;
 export declare function getMap<K, T>(input: PossibleMap<K, T>): ImmutableMap<K, T>;

package/util/number.d.ts

@@ -1,9 +1,9 @@
 /** Is a value a number? */
 export declare const isNumber: (value: unknown) => value is number;
 /** Assert that a value is a number. */
-export declare function assertNumber(value: number | unknown): asserts value is number;
+export declare function assertNumber(value: unknown): asserts value is number;
 /** Assert that a value is a number greater than. */
-export declare function assertFinite(value: number | unknown): asserts value is number;
+export declare function assertFinite(value: unknown): asserts value is number;
 /**
  * Is a finite number within a specified range?
  *
@@ -13,11 +13,11 @@ export declare function assertFinite(value: number | unknown): asserts value is
  */
 export declare const isBetween: (num: number, min: number, max: number) => boolean;
 /** Assert that a value is a number greater than. */
-export declare function assertBetween(value: number | unknown, min: number, max: number): asserts value is number;
+export declare function assertBetween(value: unknown, min: number, max: number): asserts value is number;
 /** Assert that a value is a number greater than. */
-export declare function assertMax(value: number | unknown, max: number): asserts value is number;
+export declare function assertMax(value: unknown, max: number): asserts value is number;
 /** Assert that a value is a number less than. */
-export declare function assertMin(value: number | unknown, min: number): asserts value is number;
+export declare function assertMin(value: unknown, min: number): asserts value is number;
 /**
  * Convert an unknown value to a finite number or `null`
  * - Note: numbers can be non-finite numbers like `NaN` or `Infinity`. These are detected and will always return `null`

package/util/object.d.ts

@@ -16,13 +16,13 @@ export type Value<T> = T[keyof T];
 /** Something that can be converted to an object. */
 export type PossibleObject<T> = T | Iterable<Prop<T>>;
 /** Is an unknown value an unknown object? */
-export declare const isObject: <T extends ImmutableObject<PropertyKey, unknown>>(value: unknown) => value is T;
+export declare const isObject: (value: unknown) => value is ImmutableObject<PropertyKey, unknown>;
 /** Assert that a value is an object */
-export declare function assertObject<T extends ImmutableObject>(value: T | unknown): asserts value is T;
+export declare function assertObject(value: unknown): asserts value is ImmutableObject;
 /** Is an unknown value a plain object? */
-export declare function isPlainObject<T extends ImmutableObject>(value: T | unknown): value is T;
+export declare function isPlainObject(value: unknown): value is ImmutableObject;
 /** Assert that an unknown value is a plain object */
-export declare function assertPlainObject<T extends ImmutableObject>(value: T | unknown): asserts value is T;
+export declare function assertPlainObject(value: unknown): asserts value is ImmutableObject;
 /** Is an unknown value the key for an own prop of an object. */
 export declare const isProp: <T extends ImmutableObject<PropertyKey, unknown>>(obj: T, key: PropertyKey) => key is keyof T;
 /** Assert that an unknown value is the key for an own prop of an object. */

package/util/object.js

@@ -93,7 +93,7 @@ export function deleteProps(obj, ...keys) {
  */
 export function formatObject(obj) {
     if (typeof obj.toString === "function" && obj.toString !== Object.prototype.toString)
-        return obj.toString();
+        return obj.toString(); // eslint-disable-line @typescript-eslint/no-base-to-string
     const name = obj.name;
     if (typeof name === "string")
         return name;

package/util/regexp.d.ts

@@ -19,9 +19,9 @@ export interface NamedRegExp<T extends NamedRegExpData = NamedRegExpData> extend
     exec(input: string): NamedRegExpArray<T> | null;
 }
 /** Is an unknown value a `RegExp` instance? */
-export declare const isRegExp: <T extends RegExp>(value: unknown) => value is T;
+export declare const isRegExp: (value: unknown) => value is RegExp;
 /** Assert that an unknown value is a `RegExp` instance. */
-export declare function assertRegExp<T extends RegExp>(value: T | unknown): asserts value is T;
+export declare function assertRegExp(value: unknown): asserts value is RegExp;
 /** 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;

package/util/sequence.d.ts

@@ -5,7 +5,7 @@ import { STOP } from "./constants.js";
  * - Any object with a `Symbol.iterator` property is iterable.
  * - Note: Array and Map instances etc will return true because they implement `Symbol.iterator`
  */
-export declare const isSequence: <T extends AsyncIterable<unknown>>(value: unknown) => value is T;
+export declare const isSequence: (value: unknown) => value is AsyncIterable<unknown>;
 /** Infinite sequence that yields until a `SIGNAL` is received. */
 export declare function repeatUntil<T>(source: AsyncIterable<T>, ...signals: [Promise<typeof STOP>, ...Promise<typeof STOP>[]]): AsyncIterable<T>;
 /** Infinite sequence that yields every X milliseconds (yields a count of the number of iterations). */

package/util/serialise.js

@@ -34,7 +34,7 @@ export function serialise(value) {
         const type = prototype !== Object.prototype && prototype !== null ? prototype?.constructor?.name : undefined;
         // Use custom `toString()` function if it's defined.
         if (type && value.toString !== Object.prototype.toString)
-            return `{"$type":${escapeString(type)},"value":${escapeString(value.toString())}}`;
+            return `{"$type":${escapeString(type)},"value":${escapeString(value.toString())}}`; // eslint-disable-line @typescript-eslint/no-base-to-string
         // Otherwise crawl the object and sort the props ascendingly.
         const props = Object.entries(value).map(serialiseEntry).sort();
         return `{${type ? `"$type":${escapeString(type)}${props.length ? "," : ""}` : ""}${props.join(",")}}`;

package/util/set.d.ts

@@ -7,13 +7,13 @@ export type PossibleSet<T> = ImmutableSet<T> | Iterable<T>;
 /** Get the type of the _items_ in a set. */
 export type SetItem<X> = X extends ReadonlySet<infer Y> ? Y : never;
 /** Is an unknown value a set? */
-export declare const isSet: <T extends ImmutableSet<unknown>>(value: unknown) => value is T;
+export declare const isSet: (value: unknown) => value is ImmutableSet<unknown>;
 /** Assert that a value is a `Set` instance. */
-export declare function assertSet<T extends ImmutableSet>(value: T | unknown): asserts value is T;
+export declare function assertSet(value: unknown): asserts value is ImmutableSet;
 /** Is an unknown value an item in a set? */
 export declare const isSetItem: <T>(set: ImmutableSet<T>, item: unknown) => item is T;
 /** Assert that an unknown value is an item in a set. */
-export declare function assertSetItem<T>(set: ImmutableSet<T>, item: T | unknown): asserts item is T;
+export declare function assertSetItem<T>(set: ImmutableSet<T>, item: unknown): asserts item is T;
 /** Convert an iterable to a `Set` (if it's already a `Set` it passes through unchanged). */
 export declare function getSet<T>(iterable: PossibleSet<T>): ImmutableSet<T>;
 /** Add an item to a set (by reference) and return the set item. */

package/util/string.d.ts

@@ -30,7 +30,7 @@ export declare function getString(value: unknown): string;
 /** Does a string have the specified minimum length.  */
 export declare const isStringLength: (str: string, min?: number, max?: number) => boolean;
 /** Assert that a value has a specific length (or length is in a specific range). */
-export declare function assertStringLength(str: string | unknown, min?: number, max?: number): asserts str is string;
+export declare function assertStringLength(str: unknown, min?: number, max?: number): asserts str is string;
 /** Get a string if it has the specified minimum length.  */
 export declare function getStringLength(str: string, min?: number, max?: number): string;
 /** Concatenate an iterable set of strings together. */

package/util/time.d.ts

@@ -37,7 +37,7 @@ export type PossibleTime = Time | Date | number | string;
 /** Things that converted to times or `null` */
 export type PossibleOptionalTime = Time | Date | number | string | null;
 /** Is an unknown value a `Time` instance. */
-export declare const isTime: (value: Time | unknown) => value is Time;
+export declare const isTime: (value: unknown) => value is Time;
 /**
  * Convert a value to a `Time` instance or `null`
  * - Works with possible dates, e.g. `now` or `Date` or `2022-09-12 18:32` or `19827263567`

package/util/url.d.ts

@@ -2,9 +2,9 @@
 export type PossibleURL = string | URL;
 export type PossibleOptionalURL = PossibleURL | null;
 /** Is an unknown value a URL? */
-export declare const isURL: (value: URL | unknown) => value is URL;
+export declare const isURL: (value: unknown) => value is URL;
 /** Assert that an unknown value is a URL. */
-export declare function assertURL(value: URL | unknown): asserts value is URL;
+export declare function assertURL(value: unknown): asserts value is URL;
 /** Convert a possible URL to a URL or return `null` if conversion fails. */
 export declare function getOptionalURL(url: PossibleOptionalURL, base?: PossibleOptionalURL): URL | null;
 /** Convert a possible URL to a URL but throw `AssertionError` if conversion fails. */