shelving 1.116.2 → 1.117.0

package/api/Resource.js

@@ -1,4 +1,4 @@
-import { ValidationError } from "../error/ValidationError.js";
+import { ValueError } from "../error/ValueError.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { UNDEFINED_VALIDATOR } from "../util/validate.js";
 /**
@@ -41,7 +41,7 @@ export class Resource {
         }
         catch (thrown) {
             if (thrown instanceof Feedback)
-                throw new ValidationError(`Invalid result for resource`, thrown);
+                throw new ValueError(`Invalid result for resource`, thrown);
             throw thrown;
         }
     }

package/db/ValidationProvider.js

@@ -1,4 +1,4 @@
-import { ValidationError } from "../error/ValidationError.js";
+import { ValueError } from "../error/ValueError.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { updateData } from "../util/update.js";
 import { validateWithContext } from "../util/validate.js";
@@ -116,7 +116,7 @@ function _validateItem(collection, unsafeEntity, schema) {
     catch (thrown) {
         if (!(thrown instanceof Feedback))
             throw thrown;
-        throw new ValidationError(`Invalid data for "${collection}"`, thrown.message);
+        throw new ValueError(`Invalid data for "${collection}"`, thrown.message);
     }
 }
 /** Validate a set of entities for this query reference. */
@@ -138,5 +138,5 @@ function* _yieldValidItems(collection, unsafeEntities, schema) {
         }
     }
     if (invalid)
-        throw new ValidationError(`Invalid data for "${collection}"`, messages);
+        throw new ValueError(`Invalid data for "${collection}"`, messages);
 }

package/error/AssertionError.d.ts

@@ -1,12 +1,7 @@
-/**
- * Thrown if the program receives a value it didn't expect.
- *
- * @param message Message that explains why the thing happened.
- * @param received The value that made the assertion fail.
- * @param expected The value that made the assertion fail.
- */
-export declare class AssertionError extends Error {
-    readonly received: unknown;
-    readonly expected: unknown;
-    constructor(message?: string, ...receivedExpected: readonly [received?: unknown, expected?: unknown]);
+import type { ErrorCode } from "../util/error.js";
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if the is in a state . */
+export declare class AssertionError extends EnhancedError {
+    readonly code: ErrorCode;
+    constructor(message?: string, context?: unknown);
 }

package/error/AssertionError.js

@@ -1,22 +1,9 @@
-import { debug, indent } from "../util/debug.js";
-/**
- * Thrown if the program receives a value it didn't expect.
- *
- * @param message Message that explains why the thing happened.
- * @param received The value that made the assertion fail.
- * @param expected The value that made the assertion fail.
- */
-export class AssertionError extends Error {
-    received;
-    expected;
-    constructor(message = "Failed assertion", ...receivedExpected) {
-        super(receivedExpected.length >= 2 //
-            ? `${message}\nReceived:${indent(debug(receivedExpected[0]))}\nExpected:${indent(debug(receivedExpected[0]))}`
-            : receivedExpected.length >= 1
-                ? `${message}\nReceived:${indent(debug(receivedExpected[0]))}`
-                : message);
-        this.received = receivedExpected[0];
-        this.expected = receivedExpected[1];
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if the is in a state . */
+export class AssertionError extends EnhancedError {
+    code = "failed-precondition";
+    constructor(message = "Failed precondition", context) {
+        super(message, context);
     }
 }
 AssertionError.prototype.name = "AssertionError";

package/error/ConnectionError.d.ts

@@ -1,4 +1,7 @@
-import { AssertionError } from "./AssertionError.js";
-/** Thrown if a user's internet connection fails. */
-export declare class ConnectionError extends AssertionError {
+import type { ErrorCode } from "../util/error.js";
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if e.g. a user's internet connection fails. */
+export declare class ConnectionError extends EnhancedError {
+    readonly code: ErrorCode;
+    constructor(message?: string, context?: unknown);
 }

package/error/ConnectionError.js

@@ -1,5 +1,9 @@
-import { AssertionError } from "./AssertionError.js";
-/** Thrown if a user's internet connection fails. */
-export class ConnectionError extends AssertionError {
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if e.g. a user's internet connection fails. */
+export class ConnectionError extends EnhancedError {
+    code = "unavailable";
+    constructor(message = "Connection error", context) {
+        super(message, context);
+    }
 }
 ConnectionError.prototype.name = "ConnectionError";

package/error/EnhancedError.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Error with a `.context` field to provide information about what went wrong.
+ * - Context is appended to `.message` in the format `message: debuggedContext`
+ * - Context is converted to a string using `debug()`
+ */
+export declare class EnhancedError extends global.Error {
+    readonly context: unknown;
+    constructor(message: string, context?: unknown);
+}

package/error/EnhancedError.js

@@ -0,0 +1,15 @@
+import { debug } from "../util/debug.js";
+/**
+ * Error with a `.context` field to provide information about what went wrong.
+ * - Context is appended to `.message` in the format `message: debuggedContext`
+ * - Context is converted to a string using `debug()`
+ */
+export class EnhancedError extends global.Error {
+    context;
+    constructor(message, context) {
+        const debugged = context !== undefined ? debug(context, 2) : "";
+        super(debugged.length ? `${message}: ${debugged}` : message);
+        this.context = context;
+    }
+}
+EnhancedError.prototype.name = "EnhancedError";

package/error/PermissionError.d.ts

@@ -1,3 +1,6 @@
+import { EnhancedError } from "./EnhancedError.js";
 /** Thrown if an operation failed due to permissions. */
-export declare class PermissionError extends Error {
+export declare class PermissionError extends EnhancedError {
+    readonly code = "permission-denied";
+    constructor(message?: string, context?: unknown);
 }

package/error/PermissionError.js

@@ -1,4 +1,9 @@
+import { EnhancedError } from "./EnhancedError.js";
 /** Thrown if an operation failed due to permissions. */
-export class PermissionError extends Error {
+export class PermissionError extends EnhancedError {
+    code = "permission-denied";
+    constructor(message = "Permission denied", context) {
+        super(message, context);
+    }
 }
 PermissionError.prototype.name = "PermissionError";

package/error/RequiredError.d.ts

@@ -1,4 +1,6 @@
-import { AssertionError } from "./AssertionError.js";
-/** Thrown if a value is required but wasn't provided. */
-export declare class RequiredError extends AssertionError {
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if e.g. a value is required but wasn't provided. */
+export declare class RequiredError extends EnhancedError {
+    readonly code = "not-found";
+    constructor(message?: string, context?: unknown);
 }

package/error/RequiredError.js

@@ -1,5 +1,9 @@
-import { AssertionError } from "./AssertionError.js";
-/** Thrown if a value is required but wasn't provided. */
-export class RequiredError extends AssertionError {
+import { EnhancedError } from "./EnhancedError.js";
+/** Thrown if e.g. a value is required but wasn't provided. */
+export class RequiredError extends EnhancedError {
+    code = "not-found";
+    constructor(message = "Value is required", context) {
+        super(message, context);
+    }
 }
 RequiredError.prototype.name = "RequiredError";

package/error/UnimplementedError.d.ts

@@ -0,0 +1,6 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Error thrown when functionality is called but is not implemented by an interface. */
+export declare class UnimplementedError extends EnhancedError {
+    readonly code = "unimplemented";
+    constructor(message?: string, value?: unknown);
+}

package/error/UnimplementedError.js

@@ -0,0 +1,9 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Error thrown when functionality is called but is not implemented by an interface. */
+export class UnimplementedError extends EnhancedError {
+    code = "unimplemented";
+    constructor(message = "Not implemented", value) {
+        super(message, value);
+    }
+}
+UnimplementedError.prototype.name = "UnimplementedError";

package/error/ValueError.d.ts

@@ -0,0 +1,6 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Error thrown when a value isn't valid. */
+export declare class ValueError extends EnhancedError {
+    readonly code = "invalid-argument";
+    constructor(message?: string, context?: unknown);
+}

package/error/ValueError.js

@@ -0,0 +1,9 @@
+import { EnhancedError } from "./EnhancedError.js";
+/** Error thrown when a value isn't valid. */
+export class ValueError extends EnhancedError {
+    code = "invalid-argument";
+    constructor(message = "Invalid value", context) {
+        super(message, context);
+    }
+}
+ValueError.prototype.name = "ValidationError";

package/error/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./AssertionError.js";
-export * from "./ConditionError.js";
 export * from "./ConnectionError.js";
 export * from "./PermissionError.js";
 export * from "./RequiredError.js";
-export * from "./UnsupportedError.js";
-export * from "./ValidationError.js";
+export * from "./UnimplementedError.js";
+export * from "./ValueError.js";

package/error/index.js

@@ -1,7 +1,6 @@
 export * from "./AssertionError.js";
-export * from "./ConditionError.js";
 export * from "./ConnectionError.js";
 export * from "./PermissionError.js";
 export * from "./RequiredError.js";
-export * from "./UnsupportedError.js";
-export * from "./ValidationError.js";
+export * from "./UnimplementedError.js";
+export * from "./ValueError.js";

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,5 +1,5 @@
 import { addDoc, arrayRemove, arrayUnion, collection, deleteDoc, doc, documentId, getCount, getDoc, getDocs, increment, limit, orderBy, query, setDoc, updateDoc, where } from "firebase/firestore/lite";
-import { UnsupportedError } from "../../error/UnsupportedError.js";
+import { UnimplementedError } from "../../error/UnimplementedError.js";
 import { getItem } from "../../util/item.js";
 import { getObject } from "../../util/object.js";
 import { getFilters, getLimit, getOrders } from "../../util/query.js";
@@ -72,7 +72,7 @@ export class FirestoreLiteProvider {
         return _getOptionalItem(snapshot);
     }
     getItemSequence() {
-        throw new UnsupportedError("FirestoreLiteProvider does not support realtime subscriptions");
+        throw new UnimplementedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async addItem(c, data) {
         const reference = await addDoc(collection(this._firestore, c), data);
@@ -96,7 +96,7 @@ export class FirestoreLiteProvider {
         return snapshot.docs.map(_getItem);
     }
     getQuerySequence() {
-        throw new UnsupportedError("FirestoreLiteProvider does not support realtime subscriptions");
+        throw new UnimplementedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async setQuery(c, q, data) {
         const snapshot = await getDocs(_getQuery(this._firestore, c, q));

package/iterate/InspectGenerator.js

@@ -1,4 +1,4 @@
-import { ConditionError } from "../error/ConditionError.js";
+import { AssertionError } from "../error/AssertionError.js";
 import { ThroughGenerator } from "./ThroughGenerator.js";
 /** Used when the sequence hasn't inspected anything yet. */
 const _NOVALUE = Symbol("shelving/InspectGenerator.NOVALUE");
@@ -20,21 +20,21 @@ export class InspectGenerator extends ThroughGenerator {
     /** The first yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get first() {
         if (this._first === _NOVALUE)
-            throw new ConditionError("Iteration not started");
+            throw new AssertionError("Iteration not started");
         return this._first;
     }
     _first = _NOVALUE;
     /** The last yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get last() {
         if (this._last === _NOVALUE)
-            throw new ConditionError("Iteration not started");
+            throw new AssertionError("Iteration not started");
         return this._last;
     }
     _last = _NOVALUE;
     /** The returned value (throws if the iteration is not done, i.e. `this.done === false`). */
     get returned() {
         if (this._returned === _NOVALUE)
-            throw new ConditionError("Iteration not done");
+            throw new AssertionError("Iteration not done");
         return this._returned;
     }
     _returned = _NOVALUE;

package/package.json

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

package/react/createCacheContext.js

@@ -1,5 +1,5 @@
 import { createContext, createElement, useContext, useRef } from "react";
-import { ConditionError } from "../error/ConditionError.js";
+import { AssertionError } from "../error/AssertionError.js";
 /**
  * Create a cache context that can be provided to React elements and allows them to call `useCache()`
  * - Cache is a `Map` indexed by strings that can be used to store any value.
@@ -10,7 +10,7 @@ export function createCacheContext() {
         useCache() {
             const cache = useContext(context);
             if (!cache)
-                throw new ConditionError("useCache() must be used inside <Cache>");
+                throw new AssertionError("useCache() must be used inside <Cache>");
             return cache;
         },
         CacheContext({ children }) {

package/sequence/InspectSequence.js

@@ -1,4 +1,4 @@
-import { ConditionError } from "../error/ConditionError.js";
+import { AssertionError } from "../error/AssertionError.js";
 import { ThroughSequence } from "./ThroughSequence.js";
 /** Used when the sequence hasn't inspected anything yet. */
 const _NOVALUE = Symbol("shelving/InspectSequence.NOVALUE");
@@ -20,21 +20,21 @@ export class InspectSequence extends ThroughSequence {
     /** The first yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get first() {
         if (this._first === _NOVALUE)
-            throw new ConditionError("Iteration not started");
+            throw new AssertionError("Iteration not started");
         return this._first;
     }
     _first = _NOVALUE;
     /** The last yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get last() {
         if (this._last === _NOVALUE)
-            throw new ConditionError("Iteration not started");
+            throw new AssertionError("Iteration not started");
         return this._last;
     }
     _last = _NOVALUE;
     /** The returned value (throws if the iteration is not done, i.e. `this.done === false`). */
     get returned() {
         if (this._returned === _NOVALUE)
-            throw new ConditionError("Iteration not done");
+            throw new AssertionError("Iteration not done");
         return this._returned;
     }
     _returned = _NOVALUE;

package/util/assert.d.ts

@@ -1,5 +1,3 @@
-/** 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: unknown, right: T): asserts left is T;
 /** Assert two values are equal. */

package/util/assert.js

@@ -1,16 +1,11 @@
 import { AssertionError } from "../error/AssertionError.js";
-/** Assert a boolean condition is true. */
-export function assert(condition, ...receivedExpected) {
-    if (!condition)
-        throw new AssertionError(`Must assert`, ...receivedExpected);
-}
 /** Assert two values are equal. */
 export function assertEqual(left, right) {
     if (left !== right)
-        throw new AssertionError(`Must be equal`, left, right);
+        throw new AssertionError(`Must be equal`, { left, right });
 }
 /** Assert two values are equal. */
 export function assertNot(left, right) {
     if (left === right)
-        throw new AssertionError(`Must not be equal`, left, right);
+        throw new AssertionError(`Must not be equal`, { left, right });
 }

package/util/boolean.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 /** Is a value a boolean? */
 export const isBoolean = (value) => typeof value === "boolean";
 /** Is a value true? */
@@ -12,25 +12,25 @@ export const isFalsey = (value) => !value;
 /** Assert that a value is a boolean. */
 export function assertBoolean(value) {
     if (typeof value !== "boolean")
-        throw new AssertionError(`Must be boolean`, value);
+        throw new ValueError(`Must be boolean`, value);
 }
 /** Assert that a value is true. */
 export function assertTrue(value) {
     if (value !== true)
-        throw new AssertionError(`Must be true`, value);
+        throw new ValueError(`Must be true`, value);
 }
 /** Assert that a value is false. */
 export function assertFalse(value) {
     if (value !== false)
-        throw new AssertionError(`Must be false`, value);
+        throw new ValueError(`Must be false`, value);
 }
 /** Assert that a value is truthy. */
 export function assertTruthy(value) {
     if (!value)
-        throw new AssertionError(`Must be truthy`, value);
+        throw new ValueError(`Must be truthy`, value);
 }
 /** Assert that a value is falsy. */
 export function assertFalsy(value) {
     if (value)
-        throw new AssertionError(`Must be falsy`, value);
+        throw new ValueError(`Must be falsy`, value);
 }

package/util/color.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { boundNumber, roundNumber } from "./number.js";
 // Constants.
 const DARK = 140; // Anything with a luminance > 140 is considered light.
@@ -65,7 +65,7 @@ export const isColor = (value) => value instanceof Color;
 /** Assert that an unknown value is a `Color` instance. */
 export function assertColor(value) {
     if (!isColor(value))
-        throw new AssertionError("Invalid color", value);
+        throw new ValueError("Invalid color", value);
 }
 /** Convert a possible color to a `Color` instance or `undefined` */
 export function getOptionalColor(possible) {
@@ -75,6 +75,6 @@ export function getOptionalColor(possible) {
 export function getColor(possible) {
     const color = getOptionalColor(possible);
     if (!color)
-        throw new AssertionError("Invalid color", possible);
+        throw new ValueError("Invalid color", possible);
     return color;
 }

package/util/date.d.ts

@@ -24,15 +24,15 @@ export declare function assertDate(value: unknown): asserts value is Date;
  * @returns `Date` instance if the value could be converted to a valid date, and `null` if not.
  */
 export declare function getOptionalDate(possible?: unknown): Date | undefined;
-/** Convert a possible date to a `Date` instance, or throw `AssertionError` if it couldn't be converted. */
+/** Convert a possible date to a `Date` instance, or throw `ValueError` if it couldn't be converted. */
 export declare function getDate(possible?: PossibleDate): Date;
 /** Convert an unknown value to a timestamp (milliseconds past Unix epoch), or `undefined` if it couldn't be converted. */
 export declare function getOptionalTimestamp(possible: unknown): number | undefined;
-/** Convert a possible date to a timestamp (milliseconds past Unix epoch), or throw `AssertionError` if it couldn't be converted. */
+/** Convert a possible date to a timestamp (milliseconds past Unix epoch), or throw `ValueError` if it couldn't be converted. */
 export declare function getTimestamp(possible?: PossibleDate): number;
 /** Convert an unknown value to a YMD date string like "2015-09-12", or `undefined` if it couldn't be converted. */
 export declare function getOptionalYMD(possible: unknown): string | undefined;
-/** Convert a `Date` instance to a YMD string like "2015-09-12", or throw `AssertionError` if it couldn't be converted.  */
+/** Convert a `Date` instance to a YMD string like "2015-09-12", or throw `ValueError` if it couldn't be converted.  */
 export declare function getYMD(possible?: PossibleDate): string;
 /** List of day-of-week strings. */
 export declare const DAYS: readonly ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];

package/util/date.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 /** Is a value a date? */
 export function isDate(value) {
     return value instanceof Date && Number.isFinite(value.getTime());
@@ -6,7 +6,7 @@ export function isDate(value) {
 /** Assert that a value is a `Date` instance. */
 export function assertDate(value) {
     if (!isDate(value))
-        throw new AssertionError(`Must be date`, value);
+        throw new ValueError(`Must be date`, value);
 }
 /**
  * Convert an unknown value to a valid `Date` instance, or `null` if it couldn't be converted.
@@ -46,18 +46,18 @@ export function getOptionalDate(possible = "now") {
             return date;
     }
 }
-/** Convert a possible date to a `Date` instance, or throw `AssertionError` if it couldn't be converted. */
+/** Convert a possible date to a `Date` instance, or throw `ValueError` if it couldn't be converted. */
 export function getDate(possible) {
     const date = getOptionalDate(possible);
     if (!date)
-        throw new AssertionError(`Must be date`, possible);
+        throw new ValueError(`Must be date`, possible);
     return date;
 }
 /** Convert an unknown value to a timestamp (milliseconds past Unix epoch), or `undefined` if it couldn't be converted. */
 export function getOptionalTimestamp(possible) {
     return getOptionalDate(possible)?.getTime();
 }
-/** Convert a possible date to a timestamp (milliseconds past Unix epoch), or throw `AssertionError` if it couldn't be converted. */
+/** Convert a possible date to a timestamp (milliseconds past Unix epoch), or throw `ValueError` if it couldn't be converted. */
 export function getTimestamp(possible) {
     return getDate(possible).getTime();
 }
@@ -67,7 +67,7 @@ export function getOptionalYMD(possible) {
     if (date)
         return _ymd(date);
 }
-/** Convert a `Date` instance to a YMD string like "2015-09-12", or throw `AssertionError` if it couldn't be converted.  */
+/** Convert a `Date` instance to a YMD string like "2015-09-12", or throw `ValueError` if it couldn't be converted.  */
 export function getYMD(possible) {
     return _ymd(getDate(possible));
 }

package/util/dictionary.d.ts

@@ -16,15 +16,19 @@ export type PossibleDictionary<T> = ImmutableDictionary<T> | Iterable<Dictionary
 export declare const isDictionary: (value: unknown) => value is ImmutableDictionary<unknown>;
 /** Assert that an unknown value is a dictionary object */
 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. */
-export declare function assertDictionaryItem<T>(obj: ImmutableDictionary<T>, key: unknown): asserts key is string;
 /** turn a possible dictionary into a dictionary. */
 export declare function getDictionary<T>(obj: PossibleDictionary<T>): ImmutableDictionary<T>;
 /** Turn a dictionary object into a set of props. */
 export declare function getDictionaryItems<T>(obj: ImmutableDictionary<T>): readonly DictionaryItem<T>[];
 export declare function getDictionaryItems<T>(obj: PossibleDictionary<T>): Iterable<DictionaryItem<T>>;
+/** 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. */
+export declare function assertDictionaryItem<T>(obj: ImmutableDictionary<T>, key: unknown): asserts key is string;
+/** Get an item in a map or throw an error if it doesn't exist. */
+export declare function getDictionaryItem<T>(obj: ImmutableDictionary<T>, key: string): T;
+/** Get an item in a map or `undefined` if it doesn't exist. */
+export declare function getOptionalDictionaryItem<T>(obj: ImmutableDictionary<T>, key: string): T | undefined;
 /** Set a prop on a dictionary object (immutably) and return a new object including that prop. */
 export declare const withDictionaryItem: <T>(input: ImmutableDictionary<T>, key: string, value: T) => ImmutableDictionary<T>;
 /** Set several props on a dictionary object (immutably) and return a new object including those props. */

package/util/dictionary.js

@@ -1,4 +1,6 @@
 import { AssertionError } from "../error/AssertionError.js";
+import { RequiredError } from "../error/RequiredError.js";
+import { ValueError } from "../error/ValueError.js";
 import { isIterable } from "./iterate.js";
 import { deleteProps, isPlainObject, omitProps, pickProps, setProp, setProps, withProp, withProps } from "./object.js";
 /** Is an unknown value a dictionary object? */
@@ -6,7 +8,14 @@ export const isDictionary = (value) => isPlainObject(value);
 /** Assert that an unknown value is a dictionary object */
 export function assertDictionary(value) {
     if (!isDictionary(value))
-        throw new AssertionError("Must be dictionary", value);
+        throw new ValueError("Must be dictionary", value);
+}
+/** turn a possible dictionary into a dictionary. */
+export function getDictionary(obj) {
+    return isIterable(obj) ? Object.fromEntries(obj) : obj;
+}
+export function getDictionaryItems(obj) {
+    return isIterable(obj) ? obj : Object.entries(obj);
 }
 /** Is an unknown value the key for an own prop of a dictionary. */
 export const isDictionaryItem = (obj, key) => typeof key === "string" && Object.hasOwn(obj, key);
@@ -15,12 +24,15 @@ export function assertDictionaryItem(obj, key) {
     if (!isDictionaryItem(obj, key))
         throw new AssertionError("Must be dictionary item", key);
 }
-/** turn a possible dictionary into a dictionary. */
-export function getDictionary(obj) {
-    return isIterable(obj) ? Object.fromEntries(obj) : obj;
+/** Get an item in a map or throw an error if it doesn't exist. */
+export function getDictionaryItem(obj, key) {
+    if (!Object.hasOwn(obj, key))
+        throw new RequiredError(`Dictionary item is required`);
+    return obj[key];
 }
-export function getDictionaryItems(obj) {
-    return isIterable(obj) ? obj : Object.entries(obj);
+/** Get an item in a map or `undefined` if it doesn't exist. */
+export function getOptionalDictionaryItem(obj, key) {
+    return obj[key];
 }
 /** Set a prop on a dictionary object (immutably) and return a new object including that prop. */
 export const withDictionaryItem = withProp;

package/util/duration.d.ts

@@ -1,17 +1,10 @@
-import type { PossibleDate } from "./date.js";
-/** Format a full format of a duration of time using the most reasonable units e.g. `5 years` or `1 week` or `4 minutes` or `12 milliseconds`. */
-export declare function pluralizeDuration(ms: number): string;
+import { type PossibleDate } from "./date.js";
+import { type NumberOptions } from "./number.js";
 /** Format a description of a duration of time using the most reasonable units e.g. `5y` or `4m` or `12ms`. */
-export declare function formatDuration(ms: number): string;
-/** Full when a date happens/happened, e.g. `in 10 days` or `2 hours ago` */
-export declare const pluralizeWhen: (target: PossibleDate, current?: PossibleDate) => string;
-/** Compact when a date happens/happened, e.g. `in 10d` or `2h ago` or `in 1w` */
-export declare const formatWhen: (target: PossibleDate, current?: PossibleDate) => string;
-/** Full when a date happens, e.g. `10 days` or `2 hours` or `-1 week` */
-export declare const pluralizeUntil: (target: PossibleDate, current?: PossibleDate) => string;
+export declare function formatDuration(ms: number, options?: NumberOptions): string;
+/** Compact when a date happens/happened, e.g. `in 10d` or `2h ago` or `in 1w` or `just now` */
+export declare function formatWhen(target: PossibleDate, current?: PossibleDate, options?: NumberOptions): string;
 /** Compact when a date happens, e.g. `10d` or `2h` or `-1w` */
-export declare const formatUntil: (target: PossibleDate, current?: PossibleDate) => string;
-/** Full when a date happened, e.g. `10 days` or `2 hours` or `-1 week` */
-export declare const pluralizeAgo: (target: PossibleDate, current?: PossibleDate) => string;
+export declare function formatUntil(target: PossibleDate, current?: PossibleDate, options?: NumberOptions): string;
 /** Compact when a date will happen, e.g. `10d` or `2h` or `-1w` */
-export declare const formatAgo: (target: PossibleDate, current?: PossibleDate) => string;
+export declare function formatAgo(target: PossibleDate, current?: PossibleDate, options?: NumberOptions): string;

package/util/duration.js

@@ -1,5 +1,6 @@
 import { DAY, HOUR, MONTH, SECOND, WEEK } from "./constants.js";
 import { getDuration } from "./date.js";
+import { formatNumber } from "./number.js";
 import { TIME_UNITS } from "./units.js";
 /** Get an appropriate time unit based on an amount in milliseconds. */
 function _getTimeUnit(ms) {
@@ -21,33 +22,29 @@ function _getTimeUnit(ms) {
     return TIME_UNITS.getUnit("millisecond");
 }
 /** Default number options for duration (no decimal places and rounding down). */
-const NUMBER_OPTIONS = { maximumFractionDigits: 0, roundingMode: "trunc" };
-/** Format a full format of a duration of time using the most reasonable units e.g. `5 years` or `1 week` or `4 minutes` or `12 milliseconds`. */
-export function pluralizeDuration(ms) {
-    const unit = _getTimeUnit(ms);
-    return unit.pluralize(unit.from(ms), NUMBER_OPTIONS);
-}
+const DURATION_OPTIONS = {
+    style: "unit",
+    unitDisplay: "narrow",
+    maximumFractionDigits: 0,
+    roundingMode: "trunc",
+    roundingPriority: "lessPrecision",
+};
 /** Format a description of a duration of time using the most reasonable units e.g. `5y` or `4m` or `12ms`. */
-export function formatDuration(ms) {
+export function formatDuration(ms, options) {
     const unit = _getTimeUnit(ms);
-    return unit.format(unit.from(ms), NUMBER_OPTIONS);
+    return formatNumber(unit.from(ms), { ...DURATION_OPTIONS, ...options, unit: unit.key });
 }
-/** format when a data happens/happened. */
-function _formatWhen(formatter, target, current) {
+/** Compact when a date happens/happened, e.g. `in 10d` or `2h ago` or `in 1w` or `just now` */
+export function formatWhen(target, current, options) {
     const ms = getDuration(target, current);
     const abs = Math.abs(ms);
-    const duration = formatter(ms);
-    return abs < 10 * SECOND ? "just now" : ms > 0 ? `in ${duration}` : `${duration} ago`;
+    return abs < 30 * SECOND ? "just now" : ms > 0 ? `in ${formatDuration(abs, options)}` : `${formatDuration(abs, options)} ago`;
 }
-/** Full when a date happens/happened, e.g. `in 10 days` or `2 hours ago` */
-export const pluralizeWhen = (target, current) => _formatWhen(pluralizeDuration, target, current);
-/** Compact when a date happens/happened, e.g. `in 10d` or `2h ago` or `in 1w` */
-export const formatWhen = (target, current) => _formatWhen(formatDuration, target, current);
-/** Full when a date happens, e.g. `10 days` or `2 hours` or `-1 week` */
-export const pluralizeUntil = (target, current) => pluralizeDuration(getDuration(target, current));
 /** Compact when a date happens, e.g. `10d` or `2h` or `-1w` */
-export const formatUntil = (target, current) => formatDuration(getDuration(target, current));
-/** Full when a date happened, e.g. `10 days` or `2 hours` or `-1 week` */
-export const pluralizeAgo = (target, current) => pluralizeDuration(getDuration(current, target));
+export function formatUntil(target, current, options) {
+    return formatDuration(getDuration(target, current), options);
+}
 /** Compact when a date will happen, e.g. `10d` or `2h` or `-1w` */
-export const formatAgo = (target, current) => formatDuration(getDuration(current, target));
+export function formatAgo(target, current, options) {
+    return formatDuration(getDuration(current, target), options);
+}

package/util/error.d.ts

@@ -1,4 +1,17 @@
+/**
+ * Valid error codes in gRPC.
+ * See also: https://firebase.google.com/docs/reference/node/firebase.firestore#firestoreerrorcode
+ */
+export type ErrorCode = "cancelled" | "unknown" | "invalid-argument" | "deadline-exceeded" | "not-found" | "already-exists" | "permission-denied" | "resource-exhausted" | "failed-precondition" | "aborted" | "out-of-range" | "unimplemented" | "internal" | "unavailable" | "data-loss" | "unauthenticated";
 /** Callback function that reports an error. */
 export type Report = (reason: unknown) => void;
 /** Log an error to the console. */
 export declare const logError: Report;
+/** Is an unknown value an `Error` instance? */
+export declare function isError(v: unknown): v is Error & {
+    readonly code?: string | undefined;
+};
+/** Get the string `.code` property from an object or error, or `undefined` if it doesn't exist. */
+export declare function getOptionalErrorCode(v: unknown): string | undefined;
+/** Get the string `.code` property from an object or error, or throw `ValueError` if it doesn't exist. */
+export declare function getErrorCode(v: unknown): string | undefined;

package/util/error.js

@@ -1,3 +1,22 @@
+import { ValueError } from "../error/ValueError.js";
+import { isObject } from "./object.js";
+import { isString } from "./string.js";
 /** Log an error to the console. */
 // eslint-disable-next-line no-console
 export const logError = reason => console.error(reason);
+/** Is an unknown value an `Error` instance? */
+export function isError(v) {
+    return v instanceof Error;
+}
+/** Get the string `.code` property from an object or error, or `undefined` if it doesn't exist. */
+export function getOptionalErrorCode(v) {
+    if (isObject(v) && isString(v.code))
+        return v.code;
+}
+/** Get the string `.code` property from an object or error, or throw `ValueError` if it doesn't exist. */
+export function getErrorCode(v) {
+    const code = getOptionalErrorCode(v);
+    if (typeof code !== "string")
+        throw new ValueError("Error code must be string", v);
+    return code;
+}

package/util/function.js

@@ -1,10 +1,10 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 /** Is a value a function? */
 export const isFunction = (value) => typeof value === "function";
 /** Assert that a value is a function. */
 export function assertFunction(value) {
     if (typeof value !== "function")
-        throw new AssertionError("Must be function", value);
+        throw new ValueError("Must be function", value);
 }
 /** Function that just passes through the first argument. */
 export const PASSTHROUGH = (value) => value;

package/util/number.d.ts

@@ -31,7 +31,7 @@ export declare function assertMin(value: unknown, min: number): asserts value is
 export declare function getOptionalNumber(value: unknown): number | undefined;
 /**
  * Assertively convert an unknown value to a finite number.
- * @throws `AssertionError` if the value cannot be converted.
+ * @throws `ValueError` if the value cannot be converted.
  */
 export declare function getNumber(value: unknown): number;
 /**
@@ -86,7 +86,7 @@ export declare function formatNumber(num: number, options?: NumberOptions): stri
 /** Format a number range (based on the user's browser language settings). */
 export declare function formatRange(min: number, max: number, options?: NumberOptions): string;
 /** Format a number with a short suffix, e.g. `1,000 kg` */
-export declare const formatQuantity: (num: number, abbr: string, options?: NumberOptions) => string;
+export declare function formatQuantity(num: number, abbr: string, options?: NumberOptions): string;
 /** Format a number with a longer full-word suffix. */
 export declare function pluralizeQuantity(num: number, singular: string, plural: string, options?: NumberOptions): string;
 /**

package/util/number.js

@@ -1,16 +1,16 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { NNBSP } from "./constants.js";
 /** Is a value a number? */
 export const isNumber = (value) => typeof value === "number";
 /** Assert that a value is a number. */
 export function assertNumber(value) {
     if (typeof value !== "number")
-        throw new AssertionError(`Must be number`, value);
+        throw new ValueError(`Must be number`, value);
 }
 /** Assert that a value is a number greater than. */
 export function assertFinite(value) {
     if (typeof value !== "number" || !Number.isFinite(value))
-        throw new AssertionError(`Must be finite number`, value);
+        throw new ValueError(`Must be finite number`, value);
 }
 /**
  * Is a finite number within a specified range?
@@ -23,17 +23,17 @@ export const isBetween = (num, min, max) => num >= min && num <= max;
 /** Assert that a value is a number greater than. */
 export function assertBetween(value, min, max) {
     if (typeof value !== "number" || isBetween(value, min, max))
-        throw new AssertionError(`Must be number between ${min} and ${max}`, value);
+        throw new ValueError(`Must be number between ${min} and ${max}`, value);
 }
 /** Assert that a value is a number greater than. */
 export function assertMax(value, max) {
     if (typeof value !== "number" || value > max)
-        throw new AssertionError(`Must be number with maximum ${max}`, value);
+        throw new ValueError(`Must be number with maximum ${max}`, value);
 }
 /** Assert that a value is a number less than. */
 export function assertMin(value, min) {
     if (typeof value !== "number" || value < min)
-        throw new AssertionError(`Must be number with minimum ${min}`, value);
+        throw new ValueError(`Must be number with minimum ${min}`, value);
 }
 /**
  * Convert an unknown value to a finite number or `undefined`
@@ -56,7 +56,7 @@ export function getOptionalNumber(value) {
 const NOT_NUMERIC_REGEXP = /[^0-9-.]/g;
 /**
  * Assertively convert an unknown value to a finite number.
- * @throws `AssertionError` if the value cannot be converted.
+ * @throws `ValueError` if the value cannot be converted.
  */
 export function getNumber(value) {
     const num = getOptionalNumber(value);
@@ -128,7 +128,10 @@ export function formatRange(min, max, options) {
     return `${formatNumber(min, options)}–${formatNumber(max, options)}`;
 }
 /** Format a number with a short suffix, e.g. `1,000 kg` */
-export const formatQuantity = (num, abbr, options) => `${formatNumber(num, options)}${NNBSP}${abbr}`;
+export function formatQuantity(num, abbr, options) {
+    const str = formatNumber(num, options);
+    return `${str}${str.length > 2 || abbr.length > 2 ? NNBSP : ""}${abbr}`;
+}
 /** Format a number with a longer full-word suffix. */
 export function pluralizeQuantity(num, singular, plural, options) {
     const qty = formatNumber(num, options);

package/util/object.d.ts

@@ -27,7 +27,7 @@ export declare function assertPlainObject(value: unknown): asserts value is Immu
 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. */
 export declare function assertProp<T extends ImmutableObject>(obj: T, key: PropertyKey): asserts key is keyof T;
-/** turn a possible object into an object. */
+/** Turn a possible object into an object. */
 export declare function getObject<T extends ImmutableObject>(obj: PossibleObject<T>): T;
 /**
  * Mutable type is the opposite of `Readonly<T>` helper type.

package/util/object.js

@@ -27,7 +27,7 @@ export function assertProp(obj, key) {
     if (!isProp(obj, key))
         throw new AssertionError("Must be object prop", key);
 }
-/** turn a possible object into an object. */
+/** Turn a possible object into an object. */
 export function getObject(obj) {
     return isIterable(obj) ? Object.fromEntries(obj) : obj;
 }

package/util/optional.js

@@ -2,7 +2,7 @@ import { RequiredError } from "../error/RequiredError.js";
 /** Get a required value. */
 export function getRequired(value) {
     if (value === null || value === undefined)
-        throw new RequiredError("Value is required");
+        throw new RequiredError();
     return value;
 }
 /** Is a value not optional? */

package/util/regexp.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { getArray } from "./array.js";
 /** Regular expression that always matches everything. */
 export const ALWAYS_REGEXP = /^.*$/;
@@ -9,7 +9,7 @@ export const isRegExp = (value) => value instanceof RegExp;
 /** Assert that an unknown value is a `RegExp` instance. */
 export function assertRegExp(value) {
     if (!(value instanceof RegExp))
-        throw new AssertionError("Must be regular expression", value);
+        throw new ValueError("Must be regular expression", value);
 }
 export function getRegExp(pattern, flags) {
     return typeof pattern === "string" ? new RegExp(pattern, flags) : pattern;

package/util/string.js

@@ -1,5 +1,6 @@
 /* eslint-disable no-control-regex */
 import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { getArray, isArray } from "./array.js";
 import { formatDate, isDate } from "./date.js";
 import { formatNumber, formatRange, isBetween } from "./number.js";
@@ -9,7 +10,7 @@ export const isString = (value) => typeof value === "string";
 /** Assert that a value is a string. */
 export function assertString(value) {
     if (typeof value !== "string")
-        throw new AssertionError(`Must be string`, value);
+        throw new ValueError(`Must be string`, value);
 }
 /**
  * Convert an unknown value into a title string for user-facing use.

package/util/time.d.ts

@@ -40,7 +40,7 @@ export declare const isTime: (value: unknown) => value is Time;
  * - Works with time strings, e.g. `18:32` or `23:59:59.999`
  */
 export declare function getOptionalTime(possible: unknown): Time | undefined;
-/** Convert a possible time to a `Time` instance, or throw `AssertionError` if it couldn't be converted. */
+/** Convert a possible time to a `Time` instance, or throw `ValueError` if it couldn't be converted. */
 export declare function getTime(possible?: PossibleTime): Time;
 /** Get the time as in `hh:mm` format (hours, minutes), e.g. `13.59` */
 export declare const getShortTime: (time?: PossibleTime) => string;

package/util/time.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { DAY, HOUR, MINUTE, SECOND } from "./constants.js";
 import { getOptionalDate } from "./date.js";
 import { wrapNumber } from "./number.js";
@@ -94,11 +94,11 @@ export const isTime = (value) => value instanceof Time;
 export function getOptionalTime(possible) {
     return Time.from(possible);
 }
-/** Convert a possible time to a `Time` instance, or throw `AssertionError` if it couldn't be converted. */
+/** Convert a possible time to a `Time` instance, or throw `ValueError` if it couldn't be converted. */
 export function getTime(possible) {
     const time = getOptionalTime(possible);
     if (!time)
-        throw new AssertionError(`Must be time`, possible);
+        throw new ValueError(`Must be time`, possible);
     return time;
 }
 /** Get the time as in `hh:mm` format (hours, minutes), e.g. `13.59` */

package/util/undefined.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 /** Function that always returns undefined. */
 export const getUndefined = () => undefined;
 /** Is a value undefined? */
@@ -10,7 +10,7 @@ export const notUndefined = isDefined;
 /** Assert that a value is not `undefined` */
 export function assertDefined(value) {
     if (value === undefined)
-        throw new AssertionError("Must be defined", value);
+        throw new ValueError("Must be defined", value);
 }
 /** Get a defined value. */
 export function getDefined(value) {

package/util/units.js

@@ -1,4 +1,4 @@
-import { ConditionError } from "../error/ConditionError.js";
+import { AssertionError } from "../error/AssertionError.js";
 import { RequiredError } from "../error/RequiredError.js";
 import { DAY, HOUR, MILLION, MINUTE, MONTH, NNBSP, SECOND, WEEK, YEAR } from "./constants.js";
 import { ImmutableMap } from "./map.js";
@@ -63,7 +63,7 @@ export class Unit {
         if (thisToBase)
             return base._toUnit(_convert(amount, thisToBase), unit);
         // Cannot convert.
-        throw new ConditionError(`Cannot convert "${this.key}" to "${unit.key}"`);
+        throw new AssertionError(`Cannot convert "${this.key}" to "${unit.key}"`);
     }
     /** Format an amount with a given unit of measure, e.g. `12 kg` or `29.5 l` */
     format(amount, options) {
@@ -102,7 +102,7 @@ export class UnitList extends ImmutableMap {
     getUnit(units) {
         if (this.has(units))
             return this.get(units);
-        throw new RequiredError(`Unit "${units}" not found`);
+        throw new RequiredError(`Unknown unit`, units);
     }
 }
 // Distance constants.

package/util/url.d.ts

@@ -7,7 +7,7 @@ export declare const isURL: (value: unknown) => 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: Optional<PossibleURL>, base?: PossibleURL | Location | undefined): URL | undefined;
-/** Convert a possible URL to a URL but throw `AssertionError` if conversion fails. */
+/** Convert a possible URL to a URL but throw `ValueError` if conversion fails. */
 export declare function getURL(possibleURL: PossibleURL, base?: PossibleURL): URL;
 /** Just get important part of a URL, e.g. `http://shax.com/test?uid=129483` → `shax.com/test` */
 export declare function formatURL(possibleURL: PossibleURL, base?: PossibleURL): string;

package/util/url.js

@@ -1,11 +1,11 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { notOptional } from "./optional.js";
 /** Is an unknown value a URL? */
 export const isURL = (value) => value instanceof URL;
 /** Assert that an unknown value is a URL. */
 export function assertURL(value) {
     if (!isURL(value))
-        throw new AssertionError("Invalid URL", value);
+        throw new ValueError("Invalid URL", value);
 }
 /** Convert a possible URL to a URL or return `null` if conversion fails. */
 export function getOptionalURL(url, base = _LOCATION) {
@@ -21,11 +21,11 @@ export function getOptionalURL(url, base = _LOCATION) {
     }
 }
 const _LOCATION = typeof window === "object" ? window.location : undefined;
-/** Convert a possible URL to a URL but throw `AssertionError` if conversion fails. */
+/** Convert a possible URL to a URL but throw `ValueError` if conversion fails. */
 export function getURL(possibleURL, base) {
     const url = getOptionalURL(possibleURL, base);
     if (!url)
-        throw new AssertionError("Invalid URL", possibleURL);
+        throw new ValueError("Invalid URL", possibleURL);
     return url;
 }
 /** Just get important part of a URL, e.g. `http://shax.com/test?uid=129483` → `shax.com/test` */

package/util/validate.js

@@ -1,4 +1,4 @@
-import { ValidationError } from "../error/ValidationError.js";
+import { ValueError } from "../error/ValueError.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { Feedbacks } from "../feedback/Feedbacks.js";
 import { getLastItem, isArray } from "./array.js";
@@ -13,7 +13,7 @@ export function getValid(unsafeValue, validator) {
     }
     catch (thrown) {
         if (thrown instanceof Feedback)
-            throw new ValidationError("Must validate", thrown);
+            throw new ValueError("Must validate", thrown);
         throw thrown;
     }
 }

package/error/ConditionError.d.ts

@@ -1,7 +0,0 @@
-import { AssertionError } from "./AssertionError.js";
-/**
- * Thrown if the program is in a condition it shouldn't have reached.
- * e.g. writing to a stream that's already closed
- */
-export declare class ConditionError extends AssertionError {
-}

package/error/ConditionError.js

@@ -1,8 +0,0 @@
-import { AssertionError } from "./AssertionError.js";
-/**
- * Thrown if the program is in a condition it shouldn't have reached.
- * e.g. writing to a stream that's already closed
- */
-export class ConditionError extends AssertionError {
-}
-ConditionError.prototype.name = "ConditionError";

package/error/UnsupportedError.d.ts

@@ -1,4 +0,0 @@
-import { AssertionError } from "./AssertionError.js";
-/** Thrown if a method isn't supported. */
-export declare class UnsupportedError extends AssertionError {
-}

package/error/UnsupportedError.js

@@ -1,5 +0,0 @@
-import { AssertionError } from "./AssertionError.js";
-/** Thrown if a method isn't supported. */
-export class UnsupportedError extends AssertionError {
-}
-UnsupportedError.prototype.name = "UnsupportedError";

package/error/ValidationError.d.ts

@@ -1,4 +0,0 @@
-import { AssertionError } from "./AssertionError.js";
-/** Thrown if a value isn't valid. */
-export declare class ValidationError extends AssertionError {
-}

package/error/ValidationError.js

@@ -1,5 +0,0 @@
-import { AssertionError } from "./AssertionError.js";
-/** Thrown if a value isn't valid. */
-export class ValidationError extends AssertionError {
-}
-ValidationError.prototype.name = "ValidationError";

package/firestore/util/error.d.ts

@@ -1,2 +0,0 @@
-/** Convert a Firestore error (which use gRPC error codes) into a corresponding Shelving error. */
-export declare function convertFirestoreError(thrown: unknown): never;

package/firestore/util/error.js

@@ -1,19 +0,0 @@
-import { ConnectionError } from "../../error/ConnectionError.js";
-import { PermissionError } from "../../error/PermissionError.js";
-import { RequiredError } from "../../error/RequiredError.js";
-import { isObject } from "../../util/object.js";
-/** Convert a Firestore error (which use gRPC error codes) into a corresponding Shelving error. */
-export function convertFirestoreError(thrown) {
-    if (isObject(thrown)) {
-        const code = thrown.code;
-        if (typeof code === "string") {
-            if (code === "unavailable")
-                throw new ConnectionError();
-            if (code === "not-found")
-                throw new RequiredError();
-            if (code === "permission-denied")
-                throw new PermissionError();
-        }
-    }
-    throw thrown;
-}