@dungarees/core 0.11.2 → 0.11.4

package/error.d.ts

@@ -4,3 +4,5 @@ export declare const createCausedError: ({ message, cause }: {
     cause: unknown;
 }) => Error;
 export declare const getThrownError: (run: () => unknown) => Error;
+export declare const isAbortError: (cause: unknown) => boolean;
+export declare const isNetworkError: (cause: unknown) => boolean;

package/error.js

@@ -12,3 +12,20 @@ export const getThrownError = (run) => {
     }
     throw new Error('Expected a throw, but nothing was thrown');
 };
+// Reads the property without asserting a shape, so a rejection carrying a plain object is treated
+// the same as one carrying an Error.
+const readStringProperty = (value, property) => {
+    if (typeof value !== 'object' || value === null || !(property in value)) {
+        return undefined;
+    }
+    const read = Reflect.get(value, property);
+    return typeof read === 'string' ? read : undefined;
+};
+// The message is checked as well as the name because a cancelled request is often re-thrown
+// wrapped, which keeps the reason in the message but resets the name to plain 'Error'.
+export const isAbortError = (cause) => readStringProperty(cause, 'name') === 'AbortError' ||
+    /AbortError/i.test(readStringProperty(cause, 'message') ?? '');
+// A fetch that never reached the network rejects with a TypeError whose message is the only thing
+// distinguishing it from a programming error, and each engine words it differently.
+const NETWORK_FAILURE_MESSAGE = /Load failed/i;
+export const isNetworkError = (cause) => cause instanceof TypeError && NETWORK_FAILURE_MESSAGE.test(cause.message);

package/error.test.js

@@ -1,4 +1,4 @@
-import { createCausedError, getErrorMessage, getThrownError } from './error.js';
+import { createCausedError, getErrorMessage, getThrownError, isAbortError, isNetworkError, } from './error.js';
 import { expect, test } from 'vitest';
 test('getErrorMessage reads the message off an Error', () => {
     expect(getErrorMessage(new Error('it broke'))).toBe('it broke');
@@ -42,3 +42,31 @@ test('getThrownError fails when the thrown value is not an Error', () => {
         throw notAnError;
     })).toThrow('Expected an Error to be thrown, got: a bare string');
 });
+test('isAbortError recognises the DOMException a real abort produces', () => {
+    const controller = new AbortController();
+    controller.abort();
+    expect(isAbortError(controller.signal.reason)).toBe(true);
+});
+test('isAbortError recognises an error that only names AbortError in its message', () => {
+    expect(isAbortError(new Error('Fetch failed: AbortError'))).toBe(true);
+});
+test('isAbortError rejects an ordinary error', () => {
+    expect(isAbortError(new Error('it broke'))).toBe(false);
+});
+test('isAbortError rejects values that carry no name or message at all', () => {
+    expect(isAbortError(null)).toBe(false);
+    expect(isAbortError(undefined)).toBe(false);
+    expect(isAbortError('AbortError')).toBe(false);
+});
+test('isNetworkError recognises the TypeError a failed fetch throws', () => {
+    expect(isNetworkError(new TypeError('Load failed'))).toBe(true);
+});
+test('isNetworkError rejects a TypeError thrown for any other reason', () => {
+    expect(isNetworkError(new TypeError('x is not a function'))).toBe(false);
+});
+test('isNetworkError rejects a matching message on an error that is not a TypeError', () => {
+    expect(isNetworkError(new Error('Load failed'))).toBe(false);
+});
+test('isNetworkError rejects a nullish value', () => {
+    expect(isNetworkError(null)).toBe(false);
+});

package/package.json

@@ -24,7 +24,7 @@
     "hotscript": "^1.0.13",
     "rxjs": "^7.8.1"
   },
-  "version": "0.11.2",
+  "version": "0.11.4",
   "exports": {
     "./application.ts": {
       "import": "./application.js",