shelving 1.145.2 → 1.145.3

package/db/ItemStore.d.ts

@@ -2,7 +2,7 @@ import { BooleanStore } from "../store/BooleanStore.js";
 import { OptionalDataStore } from "../store/DataStore.js";
 import type { DataKey, Database } from "../util/data.js";
 import type { Item } from "../util/item.js";
-import type { Stop } from "../util/start.js";
+import type { StopCallback } from "../util/start.js";
 import type { MemoryProvider } from "./MemoryProvider.js";
 import type { AbstractProvider } from "./Provider.js";
 /** Store a single item. */
@@ -22,5 +22,5 @@ export declare class ItemStore<T extends Database, K extends DataKey<T>> extends
     /** Refresh this store if data in the cache is older than `maxAge` (in milliseconds). */
     refreshStale(maxAge: number, provider?: AbstractProvider<T>): void;
     /** Subscribe this store to a provider. */
-    connect(provider?: AbstractProvider<T>): Stop;
+    connect(provider?: AbstractProvider<T>): StopCallback;
 }

package/db/QueryStore.d.ts

@@ -2,7 +2,7 @@ import { ArrayStore } from "../store/ArrayStore.js";
 import { BooleanStore } from "../store/BooleanStore.js";
 import type { DataKey, Database } from "../util/data.js";
 import type { Item, ItemQuery } from "../util/item.js";
-import type { Stop } from "../util/start.js";
+import type { StopCallback } from "../util/start.js";
 import type { MemoryProvider } from "./MemoryProvider.js";
 import type { AbstractProvider } from "./Provider.js";
 /** Store a set of multiple items. */
@@ -26,7 +26,7 @@ export declare class QueryStore<T extends Database, K extends DataKey<T>> extend
     /** Refresh this store if data in the cache is older than `maxAge` (in milliseconds). */
     refreshStale(maxAge: number): void;
     /** Subscribe this store to a provider. */
-    connect(provider?: AbstractProvider<T>): Stop;
+    connect(provider?: AbstractProvider<T>): StopCallback;
     /**
      * Load more items after the last once.
      * - Promise that needs to be handled.

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.145.2",
+	"version": "1.145.3",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -59,13 +59,13 @@
 	"devDependencies": {
 		"@biomejs/biome": "^1.9.4",
 		"@google-cloud/firestore": "^7.11.3",
-		"@types/bun": "^1.2.18",
-		"@types/react": "^19.1.8",
-		"@types/react-dom": "^19.1.6",
+		"@types/bun": "^1.2.20",
+		"@types/react": "^19.1.11",
+		"@types/react-dom": "^19.1.7",
 		"firebase": "^11.10.0",
-		"react": "^19.1.0",
-		"react-dom": "^19.1.0",
-		"typescript": "^5.8.3"
+		"react": "^19.1.1",
+		"react-dom": "^19.1.1",
+		"typescript": "^5.9.2"
 	},
 	"peerDependencies": {
 		"@google-cloud/firestore": ">=7.0.0",

package/sequence/LazyDeferredSequence.d.ts

@@ -1,10 +1,10 @@
-import { type Start } from "../util/start.js";
+import { type StartCallback } from "../util/start.js";
 import { DeferredSequence } from "./DeferredSequence.js";
 /** Deferred sequence of values that calls a `StartCallback` when it has iterators that are iterating, and calls the corresponding `StopCallback` when all iterators have finished. */
 export declare class LazyDeferredSequence<T = void> extends DeferredSequence<T> implements Disposable {
     private _iterating;
     private _starter;
-    constructor(start: Start<[DeferredSequence<T>]>);
+    constructor(start: StartCallback<[DeferredSequence<T>]>);
     [Symbol.asyncIterator](): AsyncIterator<T, void, void>;
     [Symbol.dispose](): void;
 }

package/util/base64.d.ts

@@ -1,13 +1,13 @@
-import { type PossibleBytes } from "./bytes.js";
+import { type Bytes, type PossibleBytes } from "./bytes.js";
 /** Encode a string or binary data to Base64 string. */
 export declare function encodeBase64(input: PossibleBytes, pad?: boolean): string;
 /** Decode Base64 string to string (decodes Base64URL too). */
 export declare function decodeBase64String(base64: string): string;
 /** Decode URL-safe Base64 string to byte sequence (decodes Base64URL too). */
-export declare function decodeBase64Bytes(base64: string): Uint8Array;
+export declare function decodeBase64Bytes(base64: string): Bytes;
 /** Encode a string or binary data to URL-safe Base64 */
 export declare function encodeBase64URL(input: PossibleBytes, pad?: boolean): string;
 /** Decode a string from URL-safe Base64 (decodes Base64 too). */
 export declare function decodeBase64URLString(base64: string): string;
 /** Decode URL-safe Base64 string to byte sequence (decodes Base64 too). */
-export declare function decodeBase64URLBytes(base64: string): Uint8Array;
+export declare function decodeBase64URLBytes(base64: string): Bytes;

package/util/bytes.d.ts

@@ -1,15 +1,22 @@
 import type { AnyCaller } from "./function.js";
+/** We store a sets of bytes as a `Uint8Array` byte sequence. */
+export type Bytes = Uint8Array<ArrayBuffer>;
 /** Types that can be converted to a `Uint8Array` byte sequence. */
-export type PossibleBytes = Uint8Array | ArrayBuffer | string;
+export type PossibleBytes = Bytes | ArrayBuffer | string;
+/** Is an unknown value a set of bytes? */
+export declare function isBytes(value: unknown): value is Bytes;
 /** Assert that an unknown value is a `Uint8Array` byte sequence. */
-export declare function assertBytes(value: unknown, min?: number, max?: number, caller?: AnyCaller): asserts value is Uint8Array;
+export declare function assertBytes(value: unknown, min?: number, max?: number, caller?: AnyCaller): asserts value is Bytes;
 /**
- * Convert an unknown value to a `Uint8Array` byte sequence, or `undefined` if the value cannot be converted.
+ * Convert an unknown value to a `Uint8Array<ArrayBuffer>` byte sequence, or `undefined` if the value cannot be converted.
  *
- * - ArrayBuffers and TypedArrays are converted to `Uint8Array`
- * - Strings are encoded as UTF-8.
+ * - `Uint8Array` values are returned as-is (if backed by an `ArrayBuffer`) or copied to a new `Uint8Array` (if not).
+ * - `ArrayBuffer` instances are converted to `Uint8Array`
+ * - Strings are encoded as UTF-8 characters in a `Uint8Array`
  * - Everything else returns `undefined`
  */
-export declare function getBytes(value: unknown): Uint8Array | undefined;
-/** Convert an unknown value to a `Uint8Array` byte sequence, or throw `RequiredError` if the value cannot be converted. */
-export declare function requireBytes(value: PossibleBytes, min?: number, max?: number, caller?: AnyCaller): Uint8Array;
+export declare function getBytes(value: unknown): Uint8Array<ArrayBuffer> | undefined;
+/**
+ * Convert a possible set of bytes to a `Uint8Array` byte sequence, or throw `RequiredError` if the value cannot be converted.
+ */
+export declare function requireBytes(value: PossibleBytes, min?: number, max?: number, caller?: AnyCaller): Uint8Array<ArrayBuffer>;

package/util/bytes.js

@@ -1,18 +1,23 @@
 import { RequiredError } from "../error/RequiredError.js";
+/** Is an unknown value a set of bytes? */
+export function isBytes(value) {
+    return value instanceof Uint8Array && value.buffer instanceof ArrayBuffer;
+}
 /** Assert that an unknown value is a `Uint8Array` byte sequence. */
 export function assertBytes(value, min = 0, max = Number.POSITIVE_INFINITY, caller = assertBytes) {
-    if (!(value instanceof Uint8Array) || value.length < min || value.length > max)
+    if (!isBytes(value) || value.length < min || value.length > max)
         throw new RequiredError(`Value must be byte sequence${min > 0 || max < Number.POSITIVE_INFINITY ? ` with length between ${min} and ${max}` : ""}`, { received: value, caller });
 }
 /**
- * Convert an unknown value to a `Uint8Array` byte sequence, or `undefined` if the value cannot be converted.
+ * Convert an unknown value to a `Uint8Array<ArrayBuffer>` byte sequence, or `undefined` if the value cannot be converted.
  *
- * - ArrayBuffers and TypedArrays are converted to `Uint8Array`
- * - Strings are encoded as UTF-8.
+ * - `Uint8Array` values are returned as-is (if backed by an `ArrayBuffer`) or copied to a new `Uint8Array` (if not).
+ * - `ArrayBuffer` instances are converted to `Uint8Array`
+ * - Strings are encoded as UTF-8 characters in a `Uint8Array`
  * - Everything else returns `undefined`
  */
 export function getBytes(value) {
-    if (value instanceof Uint8Array)
+    if (isBytes(value))
         return value;
     if (value instanceof ArrayBuffer)
         return new Uint8Array(value);
@@ -20,7 +25,9 @@ export function getBytes(value) {
         return new TextEncoder().encode(value);
     return undefined;
 }
-/** Convert an unknown value to a `Uint8Array` byte sequence, or throw `RequiredError` if the value cannot be converted. */
+/**
+ * Convert a possible set of bytes to a `Uint8Array` byte sequence, or throw `RequiredError` if the value cannot be converted.
+ */
 export function requireBytes(value, min = 0, max = Number.POSITIVE_INFINITY, caller = requireBytes) {
     const bytes = getBytes(value);
     assertBytes(bytes, min, max, caller);

package/util/crypto.d.ts

@@ -1,5 +1,6 @@
+import { type Bytes } from "./bytes.js";
 /** Get random bytes from the crypto API. */
-export declare function getRandomBytes(length: number): Uint8Array;
+export declare function getRandomBytes(length: number): Bytes;
 /**
  * Hash a password using PBKDF2, generating a new salt, and return the combined salt$iterations$hash string.
  *

package/util/jwt.d.ts

@@ -1,4 +1,4 @@
-import { type PossibleBytes } from "./bytes.js";
+import { type Bytes, type PossibleBytes } from "./bytes.js";
 import type { Data } from "./data.js";
 import type { AnyCaller } from "./function.js";
 /**
@@ -15,7 +15,7 @@ export type TokenData = {
     signature: string;
     headerData: Data;
     payloadData: Data;
-    signatureBytes: Uint8Array;
+    signatureBytes: Bytes;
 };
 /**
  * Split a JSON Web Token into its header, payload, and signature, and decode and parse the JSON.

package/util/sequence.d.ts

@@ -1,7 +1,7 @@
 import type { AsyncValueCallback, ValueCallback } from "./callback.js";
 import type { ErrorCallback } from "./callback.js";
 import { STOP } from "./constants.js";
-import type { Stop } from "./start.js";
+import type { StopCallback } from "./start.js";
 /**
  * Is a value an async iterable object?
  * - Any object with a `Symbol.iterator` property is iterable.
@@ -15,4 +15,4 @@ export declare function repeatDelay(ms: number): AsyncIterable<number>;
 /** Dispatch items in a sequence to a (possibly async) callback. */
 export declare function callSequence<T>(sequence: AsyncIterable<T>, callback: AsyncValueCallback<T>): AsyncIterable<T>;
 /** Pull values from a sequence until the returned function is called. */
-export declare function runSequence<T>(sequence: AsyncIterable<T>, onNext?: ValueCallback<T>, onError?: ErrorCallback): Stop;
+export declare function runSequence<T>(sequence: AsyncIterable<T>, onNext?: ValueCallback<T>, onError?: ErrorCallback): StopCallback;

package/util/start.d.ts

@@ -1,8 +1,8 @@
 import type { Arguments } from "./function.js";
 /** Callback function that starts something with multiple values and returns an optional stop callback. */
-export type Start<T extends Arguments = []> = (...values: T) => Stop | void;
+export type StartCallback<T extends Arguments = []> = (...values: T) => StopCallback | void;
 /** Callback function that stops something. */
-export type Stop = () => void;
+export type StopCallback = () => void;
 /**
  * Wrapper class to handle state on start/stop callback process.
  * - If process has already started, `starter.start()` won't be called twice (including if `start()` didn't return a `stop()` callback).
@@ -10,12 +10,12 @@ export type Stop = () => void;
 export declare class Starter<T extends Arguments> implements Disposable {
     private readonly _start;
     private _stop;
-    constructor(start: Start<T>);
+    constructor(start: StartCallback<T>);
     start(...values: T): void;
     stop(): void;
     [Symbol.dispose](): void;
 }
 /** Something that can be made into a `Starter` */
-export type PossibleStarter<T extends Arguments> = Start<T> | Starter<T>;
+export type PossibleStarter<T extends Arguments> = StartCallback<T> | Starter<T>;
 /** Get a `Starter` from a `PossibleStarter` */
-export declare function getStarter<T extends Arguments>(start: Start<T> | Starter<T>): Starter<T>;
+export declare function getStarter<T extends Arguments>(start: StartCallback<T> | Starter<T>): Starter<T>;