@dungarees/core 0.11.6 → 0.12.0

package/package.json

@@ -24,72 +24,44 @@
     "hotscript": "^1.0.13",
     "rxjs": "^7.8.1"
   },
-  "version": "0.11.6",
+  "peerDependencies": {
+    "rxjs-marbles": "^7.0.1",
+    "vitest": "^3.0.2"
+  },
+  "version": "0.12.0",
   "exports": {
     "./application.ts": {
       "import": "./application.js",
       "types": "./application.d.ts"
     },
-    "./error.test.ts": {
-      "import": "./error.test.js",
-      "types": "./error.test.d.ts"
-    },
     "./error.ts": {
       "import": "./error.js",
       "types": "./error.d.ts"
     },
-    "./event.test.ts": {
-      "import": "./event.test.js",
-      "types": "./event.test.d.ts"
-    },
     "./event.ts": {
       "import": "./event.js",
       "types": "./event.d.ts"
     },
-    "./fake.test.ts": {
-      "import": "./fake.test.js",
-      "types": "./fake.test.d.ts"
-    },
     "./fake.ts": {
       "import": "./fake.js",
       "types": "./fake.d.ts"
     },
-    "./marbles-vitest.test.ts": {
-      "import": "./marbles-vitest.test.js",
-      "types": "./marbles-vitest.test.d.ts"
-    },
     "./marbles-vitest.ts": {
       "import": "./marbles-vitest.js",
       "types": "./marbles-vitest.d.ts"
     },
-    "./marbles.test.ts": {
-      "import": "./marbles.test.js",
-      "types": "./marbles.test.d.ts"
-    },
     "./marbles.ts": {
       "import": "./marbles.js",
       "types": "./marbles.d.ts"
     },
-    "./type-util.test.ts": {
-      "import": "./type-util.test.js",
-      "types": "./type-util.test.d.ts"
-    },
     "./type-util.ts": {
       "import": "./type-util.js",
       "types": "./type-util.d.ts"
     },
-    "./url.test.ts": {
-      "import": "./url.test.js",
-      "types": "./url.test.d.ts"
-    },
     "./url.ts": {
       "import": "./url.js",
       "types": "./url.d.ts"
     },
-    "./util.test.ts": {
-      "import": "./util.test.js",
-      "types": "./util.test.d.ts"
-    },
     "./util.ts": {
       "import": "./util.js",
       "types": "./util.d.ts"

package/url.d.ts

@@ -9,5 +9,4 @@ export type UrlConfig = {
 export type UrlSearchConfig = Record<string, number | string | boolean>;
 export declare const stringifyUrl: (config: UrlConfig) => string;
 export declare const parseUrl: (url: `${string}://${string}`) => UrlConfig;
-export type Split<STRING, CHARACTER extends string> = STRING extends `${infer S1}${CHARACTER}${infer S2}` ? [S1, S2] : never;
 export type Url = string;

package/error.test.d.ts

@@ -1 +0,0 @@
-export {};

package/error.test.js

@@ -1,72 +0,0 @@
-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');
-});
-test('getErrorMessage stringifies anything else that was thrown', () => {
-    expect(getErrorMessage('a bare string')).toBe('a bare string');
-    expect(getErrorMessage(undefined)).toBe('undefined');
-    expect(getErrorMessage(404)).toBe('404');
-});
-test('getErrorMessage reads a subclass like any other Error', () => {
-    class ParseError extends Error {
-    }
-    expect(getErrorMessage(new ParseError('bad json'))).toBe('bad json');
-});
-test('createCausedError prefixes the message of the error it is given', () => {
-    expect(createCausedError({ message: 'Invalid package.json', cause: new Error('bad json') }).message).toBe('Invalid package.json: bad json');
-});
-test('createCausedError keeps the original as the cause, so the chain survives', () => {
-    const original = new Error('bad json');
-    expect(createCausedError({ message: 'Invalid package.json', cause: original }).cause).toBe(original);
-});
-test('createCausedError works on a non-Error cause without losing it', () => {
-    const caused = createCausedError({ message: 'Invalid package.json', cause: 'thrown string' });
-    expect(caused.message).toBe('Invalid package.json: thrown string');
-    expect(caused.cause).toBe('thrown string');
-});
-test('getThrownError hands back the Error that was thrown, cause and all', () => {
-    const cause = new Error('bad literal');
-    const thrown = getThrownError(() => {
-        throw new Error('Invalid type in store', { cause });
-    });
-    expect(thrown.message).toBe('Invalid type in store');
-    expect(thrown.cause).toBe(cause);
-});
-test('getThrownError fails when nothing is thrown, rather than returning undefined', () => {
-    expect(() => getThrownError(() => 'no throw here')).toThrow('Expected a throw');
-});
-test('getThrownError fails when the thrown value is not an Error', () => {
-    const notAnError = 'a bare string';
-    expect(() => getThrownError(() => {
-        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/event.test.d.ts

@@ -1 +0,0 @@
-export {};

package/event.test.js

@@ -1,22 +0,0 @@
-import { createEventCreators } from './event.js';
-import { expect, expectTypeOf, test } from 'vitest';
-test('DomainEventOf derives the discriminated union from the payload map', () => {
-    expectTypeOf().toEqualTypeOf();
-});
-test('createEventCreators builds a creator that emits its event type and payload', () => {
-    const creators = createEventCreators();
-    expect(creators.greet({ name: 'Ada' })).toEqual({ type: 'greet', payload: { name: 'Ada' } });
-});
-test('createEventCreators converts kebab-case event types to camelCase creator names', () => {
-    const creators = createEventCreators();
-    expect(creators.taskDone({ id: '7' })).toEqual({ type: 'task-done', payload: { id: '7' } });
-});
-test('createEventCreators makes an undefined-payload creator take no argument', () => {
-    const creators = createEventCreators();
-    expect(creators.done()).toEqual({ type: 'done', payload: undefined });
-});
-test('createEventCreators types each creator from the payload map', () => {
-    const creators = createEventCreators();
-    expectTypeOf(creators.taskDone).toEqualTypeOf();
-    expectTypeOf(creators.done).toEqualTypeOf();
-});

package/fake.test.d.ts

@@ -1 +0,0 @@
-export {};

package/fake.test.js

@@ -1,61 +0,0 @@
-import { addErrorMethodsToFake } from './fake.js';
-import { coreMarbles } from '@dungarees/core/marbles-vitest.ts';
-import { of } from 'rxjs';
-import { expect, test } from 'vitest';
-test('Create the original if args are empty', () => {
-    const originalFake = () => ({ method: () => 1 });
-    const fakeCreator = addErrorMethodsToFake(originalFake);
-    const fake = fakeCreator();
-    expect(fake.method).not.toThrow();
-});
-test('Create sync throwing function', () => {
-    const originalFake = () => ({ method: () => 1 });
-    const fakeCreator = addErrorMethodsToFake(originalFake);
-    const error = new Error('test error');
-    const fake = fakeCreator({ method: { type: 'sync', error } });
-    expect(fake.method).toThrow(error);
-});
-test('Create multiple sync throwing function', () => {
-    const originalFake = () => ({ method: () => 1, method2: () => 2 });
-    const fakeCreator = addErrorMethodsToFake(originalFake);
-    const error = new Error('test error');
-    const error2 = new Error('test error2');
-    const fake = fakeCreator({
-        method: { type: 'sync', error },
-        method2: { type: 'sync', error: error2 },
-    });
-    expect(fake.method).toThrow(error);
-    expect(fake.method2).toThrow(error2);
-});
-test('Create async throwing function', async () => {
-    const originalFake = () => ({ method: async () => 1 });
-    const fakeCreator = addErrorMethodsToFake(originalFake);
-    const error = new Error('test error');
-    const fake = fakeCreator({ method: { type: 'async', error } });
-    await expect(fake.method).rejects.toEqual(error);
-});
-test('Create observable throwing function', coreMarbles((m) => {
-    const originalFake = () => ({ method: () => of(1) });
-    const fakeCreator = addErrorMethodsToFake(originalFake);
-    const error = new Error('test error');
-    const fake = fakeCreator({ method: { type: 'observable', error } });
-    m.expect(fake.method()).toBeObservable('-#', {}, error);
-}));
-test('Forwarding constructor paramters', () => {
-    const originalFake = (num1, num2) => ({
-        method: () => num1,
-        method2: () => num2,
-    });
-    const fakeCreator = addErrorMethodsToFake(originalFake);
-    const fake = fakeCreator({}, 1, 2);
-    expect(fake.method()).toBe(1);
-    expect(fake.method2()).toBe(2);
-});
-test('A throwing method stays callable with the arguments the original took', () => {
-    const originalFake = () => ({ method: (_, count) => count });
-    const fakeCreator = addErrorMethodsToFake(originalFake);
-    expect(fakeCreator().method('a', 1)).toBe(1);
-    const error = new Error('boom');
-    const fake = fakeCreator({ method: { type: 'sync', error } });
-    expect(() => fake.method('a', 1)).toThrow(error);
-});

package/marbles-vitest.test.d.ts

@@ -1 +0,0 @@
-export {};

package/marbles-vitest.test.js

@@ -1,116 +0,0 @@
-import { configure, coreMarbles, mtest } from './marbles-vitest.js';
-import { Subject } from 'rxjs';
-import { expect, test } from 'vitest';
-test('it should run a single marble', coreMarbles(({ expect, cold }) => {
-    expect(cold('a')).toBeObservable('a', { a: 'a' });
-}));
-test.each([
-    ['tf', 'tf'],
-    ['ft', 'ft'],
-])('it should work with each', coreMarbles(({ expect, coldBoolean }, a, b) => {
-    expect(coldBoolean(a)).toBeObservableBoolean(b);
-}));
-mtest.each([
-    ['tf', 'tf'],
-    ['ft', 'ft'],
-])('mtest should work with each', ({ expect, coldBoolean }, a, b) => {
-    expect(coldBoolean(a)).toBeObservableBoolean(b);
-});
-mtest('it should run without the wrapper', ({ expect, coldBoolean }) => {
-    expect(coldBoolean('tf')).toBeObservableBoolean('tf');
-});
-mtest('it should run a single function', ({ expect, coldCall }) => {
-    const s = new Subject();
-    coldCall('-cc', {
-        c: () => {
-            s.next('c');
-        },
-    });
-    expect(s).toBeObservable('-cc', { c: 'c' });
-});
-mtest('it should run multiple functions', ({ expect, coldCall }) => {
-    const s = new Subject();
-    coldCall('-cd', {
-        c: () => {
-            s.next('c');
-        },
-        d: () => {
-            s.next('d');
-        },
-    });
-    expect(s).toBeObservable('-cd', { c: 'c', d: 'd' });
-});
-mtest('it should create a boolean marble', ({ expect, coldBoolean }) => {
-    expect(coldBoolean('tf')).toBeObservable('tf', { t: true, f: false });
-});
-mtest('it should assert a boolean marble', ({ expect, cold }) => {
-    expect(cold('tf', { t: true, f: false })).toBeObservableBoolean('tf');
-});
-mtest('it should create a cold marble with a value', ({ expect, coldValue }) => {
-    expect(coldValue('-v', true)).toBeObservableBoolean('-t');
-});
-mtest('it should create a cold marble with a value or undefined', ({ expect, coldValueOrUndefined }) => {
-    expect(coldValueOrUndefined('-v0', true)).toBeObservable('-t0', {
-        t: true,
-        '0': undefined,
-    });
-});
-mtest('it should create a cold marble with a value step', ({ expect, coldStep }) => {
-    expect(coldStep(true)).toBeObservableBoolean('-t');
-    expect(coldStep(true, 2)).toBeObservableBoolean('--t');
-});
-mtest('it should create a cold marble with a value step and close', ({ expect, coldStepAndClose }) => {
-    expect(coldStepAndClose(true)).toBeObservableBoolean('-(t|)');
-    expect(coldStepAndClose(true, 2)).toBeObservableBoolean('--(t|)');
-});
-mtest('it should create a cold marble with an error', ({ expect, coldError }) => {
-    expect(coldError(new Error('test error'))).toBeObservable('-#', {}, new Error('test error'));
-    expect(coldError(new Error('test error'), 2)).toBeObservable('--#', {}, new Error('test error'));
-});
-mtest('it should create a cold marble with a value and error', ({ expect, coldStepAndError }) => {
-    expect(coldStepAndError(true, new Error('test error'))).toBeObservable('-(t#)', { t: true }, new Error('test error'));
-    expect(coldStepAndError(true, new Error('test error'), 2)).toBeObservable('--(t#)', { t: true }, new Error('test error'));
-});
-mtest('it should assert a value marble', ({ expect, coldStep }) => {
-    expect(coldStep(true)).toBeObservableValue('-v', true);
-});
-mtest('it should assert a value marble default pattern', ({ expect, coldStep }) => {
-    expect(coldStep(true, 0)).toBeObservableValue(true);
-});
-mtest('it should assert a value and close marble', ({ expect, coldStepAndClose }) => {
-    expect(coldStepAndClose(true, 0)).toBeObservableValueAndClose(true);
-});
-mtest('it should assert a value and close marble', ({ expect, coldStepAndError }) => {
-    expect(coldStepAndError(true, new Error('test error'), 0)).toBeObservableValueAndError(true, new Error('test error'));
-});
-mtest('it should assert a value marble or undefined', ({ expect, coldValueOrUndefined }) => {
-    expect(coldValueOrUndefined('-v0', true)).toBeObservableValueOrUndefined('-v0', true);
-});
-mtest('it should assert a step', ({ expect, coldStep }) => {
-    expect(coldStep(true)).toBeObservableStep(true);
-    expect(coldStep(true, 2)).toBeObservableStep(true, 2);
-});
-mtest('it should assert a step and close', ({ expect, coldStepAndClose }) => {
-    expect(coldStepAndClose(true)).toBeObservableStepAndClose(true);
-    expect(coldStepAndClose(true, 2)).toBeObservableStepAndClose(true, 2);
-});
-mtest('it should assert an error', ({ expect, coldError }) => {
-    expect(coldError(new Error('test error'))).toBeObservableError(new Error('test error'));
-    expect(coldError(new Error('test error'), 2)).toBeObservableError(new Error('test error'), 2);
-});
-mtest('it should assert a step with an error', ({ expect, coldStepAndError }) => {
-    expect(coldStepAndError(true, new Error('test error'))).toBeObservableStepAndError(true, new Error('test error'));
-    expect(coldStepAndError(true, new Error('test error'), 2)).toBeObservableStepAndError(true, new Error('test error'), 2);
-});
-const { cases } = configure({});
-const casesThatRan = [];
-cases('skip and only flags', (_m, { name }) => {
-    casesThatRan.push(name);
-}, [
-    { name: 'plain case' },
-    { name: 'case flagged skip', skip: true },
-    { name: 'case with skip false', skip: false },
-]);
-test('cases runs every case except the ones flagged skip', () => {
-    expect(casesThatRan).toEqual(['plain case', 'case with skip false']);
-});

package/marbles.test.d.ts

@@ -1 +0,0 @@
-export {};

package/marbles.test.js

@@ -1,36 +0,0 @@
-import { coreMarbles } from '@dungarees/core/marbles.ts';
-import { Subject } from 'rxjs';
-import { test } from 'vitest';
-test('it should run a single function', coreMarbles(({ expect, coldCall }) => {
-    const s = new Subject();
-    coldCall('-cc', {
-        c: () => {
-            s.next('c');
-        },
-    });
-    expect(s).toBeObservable('-cc', { c: 'c' });
-}));
-test('it should run multiple functions', coreMarbles(({ expect, coldCall }) => {
-    const s = new Subject();
-    coldCall('-cd', {
-        c: () => {
-            s.next('c');
-        },
-        d: () => {
-            s.next('d');
-        },
-    });
-    expect(s).toBeObservable('-cd', { c: 'c', d: 'd' });
-}));
-test('it should create a boolean marble', coreMarbles(({ expect, coldBoolean }) => {
-    expect(coldBoolean('tf')).toBeObservable('tf', { t: true, f: false });
-}));
-test('it should assert a boolean marble', coreMarbles(({ expect, cold }) => {
-    expect(cold('tf', { t: true, f: false })).toBeObservableBoolean('tf');
-}));
-test.each([
-    ['tf', 'tf'],
-    ['ft', 'ft'],
-])('it should work with each', coreMarbles(({ expect, coldBoolean }, a, b) => {
-    expect(coldBoolean(a)).toBeObservableBoolean(b);
-}));

package/type-util.test.d.ts

@@ -1 +0,0 @@
-export {};

package/type-util.test.js

@@ -1,147 +0,0 @@
-import { expect, expectTypeOf, test } from 'vitest';
-test('Split<PATH, DELIMITER>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('SplitObjectPath<PATH>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('SplitFilePath<PATH>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('StringLiteral<LITERAL>', () => {
-    const literal = 'asd';
-    expectTypeOf(literal).toEqualTypeOf();
-    // Widened through an annotation rather than an `as` cast, so rule 4 still holds.
-    const widened = 'asd';
-    // @ts-expect-error it has to be a literal
-    const nonLiteral = widened;
-    expectTypeOf(nonLiteral).toEqualTypeOf();
-});
-test('ObjectWithStringLiteralKey<KEY, VALUE>', () => {
-    const obj = {
-        a: 1,
-    };
-    expectTypeOf(obj).toEqualTypeOf();
-    // @ts-expect-error it has to be a literal
-    const nonLiteral = {
-        a: 1,
-    };
-    expectTypeOf(nonLiteral).toEqualTypeOf();
-});
-test('JsonType', () => {
-    const json = {
-        a: 1,
-        b: '2',
-        c: true,
-        d: null,
-        e: [1, '2', true, null, [1, '2', true, null]],
-    };
-    expect(json).toBeDefined();
-    // @ts-expect-error it cannot be a function
-    const nonJson = {
-        f: () => { },
-    };
-    expect(nonJson).toBeDefined();
-});
-test('TokenNonEmptyString<TOKEN>', () => {
-    const token = 'a';
-    expectTypeOf(token).toEqualTypeOf();
-    // @ts-expect-error it cannot be empty
-    const nonToken = '';
-    expectTypeOf(nonToken).toEqualTypeOf();
-});
-test('Guard<TYPE>', () => {
-    const guard = (arg) => arg === 1;
-    expectTypeOf(guard).toEqualTypeOf();
-    // @ts-expect-error it has to be a guard
-    const nonGuard = (arg) => arg === 1;
-    expectTypeOf(nonGuard).toEqualTypeOf();
-});
-test('GetGuarded<GUARD>', () => {
-    const testUnused_guard = (arg) => arg === 1;
-    expectTypeOf().toEqualTypeOf();
-});
-test('EntryTuples', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('FilterRecord<RECORD, TYPE>', () => {
-    expectTypeOf().toEqualTypeOf();
-});
-test('GetAllPaths<OBJECT>', () => {
-    expectTypeOf().toEqualTypeOf();
-});
-test('GetValuesByPath<OBJECT, PATH>', () => {
-    expectTypeOf().toEqualTypeOf();
-});
-test('JoinArray<STRINGS, DELIMITER>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('FromCamelCase<STRING>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('ToCamelCase<STRING[]>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('FromKebabCase<STRING>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('ToKebabCase<STRING[]>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('FromSnakeCase<STRING>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('ToSnakeCase<STRING[]>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('Mutable<TYPE>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('FlattenIntersection<OBJECT>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('PartialBesides<OBJECT, KEYS>', () => {
-    // Flattened first: PartialBesides produces an intersection, and expectTypeOf compares that
-    // by its parts rather than by the object it is equivalent to.
-    expectTypeOf().toEqualTypeOf();
-});
-test('DeepPartial<T> - single level', () => {
-    expectTypeOf().toEqualTypeOf();
-});
-test('DeepPartial<T> - nested props', () => {
-    expectTypeOf().toEqualTypeOf();
-});
-test('SyncFunctionToAsync<FUNC>', () => {
-    expectTypeOf().toEqualTypeOf();
-});
-test('SyncFunctionToAsync<FUNC> accepts every function shape', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});
-test('DetachableMethods<OBJECT>', () => {
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-    expectTypeOf().toEqualTypeOf();
-});

package/url.test.d.ts

@@ -1 +0,0 @@
-export {};

package/url.test.js

@@ -1,48 +0,0 @@
-import { parseUrl, stringifyUrl } from './url.js';
-import { expect, test } from 'vitest';
-test('stringify full url', () => {
-    expect(stringifyUrl({
-        protocol: 'https',
-        hostname: 'localhost',
-        pathname: '/path',
-        port: 8080,
-        search: {
-            a: '1',
-            b: '2',
-        },
-        hash: 'hash',
-    })).toBe('https://localhost:8080/path?a=1&b=2#hash');
-});
-test('stringify partial url', () => {
-    expect(stringifyUrl({
-        protocol: 'https',
-        hostname: 'localhost',
-    })).toBe('https://localhost/');
-});
-test('parse full url', () => {
-    expect(parseUrl('https://localhost:8080/path?a=1&b=2#hash')).toEqual({
-        protocol: 'https',
-        hostname: 'localhost',
-        pathname: '/path',
-        port: 8080,
-        search: {
-            a: '1',
-            b: '2',
-        },
-        hash: 'hash',
-    });
-});
-test('parse full url', () => {
-    expect(parseUrl('https://localhost/')).toEqual({
-        protocol: 'https',
-        hostname: 'localhost',
-        pathname: '/',
-        port: 80,
-        search: {},
-        hash: '',
-    });
-});
-test('Url type', () => {
-    const url = 'https://host:8080/path/subpath/?a=1&b=2#hash';
-    expect(url).toBe(url);
-});

package/util.test.d.ts

@@ -1 +0,0 @@
-export {};

package/util.test.js

@@ -1,419 +0,0 @@
-import { assertDefined, assertImpossible, assertPredicate, assertTypeByGuard, boolFromThrow, boolFromThrowAsync, camelCase2kebabCase, capitalize, deepEqualPartial, findByPattern, isDeepEqual, isDefined, join, kebabCase2camelCase, makeObjectFromStringLiteral, mapConst, mapConstKeysToEntries, mapObjectFromKeys, objectFromConstEntries, optionalPatternToList, pluralize, split, unPrototypeProperties, } from './util.js';
-import { expect, expectTypeOf, test } from 'vitest';
-test('makeObjectFromStringLiteral', () => {
-    const obj = makeObjectFromStringLiteral('key', 1);
-    expect(obj['key']).toBe(1);
-});
-test('split is working in a typesafe way', () => {
-    const splitted = split('a.a.a', '.');
-    expectTypeOf().toEqualTypeOf();
-    expect(splitted).toEqual(['a', 'a', 'a']);
-});
-test('join is working in a typesafe way', () => {
-    const joined = join(['a', 'a', 'a'], '.');
-    expectTypeOf().toEqualTypeOf();
-    expect(joined).toBe('a.a.a');
-});
-test('capitalize', () => {
-    const capitalized = capitalize('apple');
-    expectTypeOf().toEqualTypeOf();
-    expect(capitalized).toBe('Apple');
-});
-test('pluralize', () => {
-    expect(pluralize('dog', -2)).toBe('dogs');
-    expect(pluralize('dog', -1)).toBe('dog');
-    expect(pluralize('dog', 0)).toBe('dogs');
-    expect(pluralize('dog', 1)).toBe('dog');
-    expect(pluralize('dog', 2)).toBe('dogs');
-    expect(pluralize('dog', 1, true)).toBe('1 dog');
-    expect(pluralize('dog', 2, true)).toBe('2 dogs');
-});
-test('kebabCase2camelCase', () => {
-    const kebabCase = 'first-second-third';
-    const camelCase = 'firstSecondThird';
-    const output = kebabCase2camelCase(kebabCase);
-    expect(output).toBe(camelCase);
-    expectTypeOf().toEqualTypeOf();
-});
-test('camelCase2kebabCase', () => {
-    const kebabCase = 'first-second-third';
-    const camelCase = 'firstSecondThird';
-    const output = camelCase2kebabCase(camelCase);
-    expect(output).toBe(kebabCase);
-    expectTypeOf().toEqualTypeOf();
-});
-test('deepEqualPartial', () => {
-    expect(deepEqualPartial({}, {})).toBe(true);
-    expect(deepEqualPartial(true, true)).toBe(true);
-    expect(deepEqualPartial(true, false)).toBe(false);
-    expect(deepEqualPartial({ baz: 54 }, { foo: 'bar', baz: 54 })).toBe(true);
-    expect(deepEqualPartial({ baz: 55 }, { foo: 'bar', baz: 54 })).toBe(false);
-    expect(deepEqualPartial({ foo: { baz: 'bar' } }, { foo: { baz: 'bar' }, quux: 'kill me' })).toBe(true);
-    expect(deepEqualPartial({ foo: { baz: 'baz' } }, { foo: { baz: 'bar' }, quux: 'kill me' })).toBe(false);
-});
-test('deepEqualPartial treats a null expected as unequal rather than throwing', () => {
-    expect(deepEqualPartial({ baz: 54 }, null)).toBe(false);
-    expect(deepEqualPartial({ baz: 54 }, undefined)).toBe(false);
-    expect(deepEqualPartial(null, null)).toBe(true);
-});
-test('findByPattern', () => {
-    const value1 = findByPattern([], '');
-    expectTypeOf().toEqualTypeOf();
-    expect(value1).toBeUndefined();
-    // @ts-expect-error itemToMatch has to follow the pattern type
-    findByPattern([], {});
-    // @ts-expect-error itemToMatch type has to be a serializable type
-    const _ = (findByPattern);
-    expect(_).toBeDefined();
-    const value2 = findByPattern([{ pattern: 'ab', value: 1 }], 'ab');
-    expectTypeOf().toEqualTypeOf();
-    expect(value2).toBe(1);
-    const value3 = findByPattern([{ pattern: 'ab', value: 1 }], 'no-match');
-    expect(value3).toBe(undefined);
-    const value4 = findByPattern([{ pattern: { a: 1 }, value: 1 }], { a: 1 });
-    expect(value4).toBe(1);
-    const value5 = findByPattern([{ value: 1 }], 'ab');
-    expect(value5).toBe(1);
-    const value6 = findByPattern([{ patternPartial: { a: 2 }, value: 1 }], { a: 1, b: 1 });
-    expect(value6).toBe(undefined);
-    const value7 = findByPattern([{ patternPartial: { a: 1 }, value: 1 }], { a: 1, b: 1 });
-    expect(value7).toBe(1);
-    const value8 = findByPattern([
-        {
-            patternPartial: { a: 1 },
-            value: 1,
-        },
-        {
-            pattern: { a: 1, b: 1 },
-            value: 2,
-        },
-    ], { a: 1, b: 1 });
-    expect(value8).toBe(2);
-    const value9 = findByPattern([
-        {
-            value: 1,
-        },
-        {
-            patternPartial: { a: 1 },
-            value: 2,
-        },
-        {
-            pattern: { a: 1, b: 1 },
-            value: 3,
-        },
-    ], { a: 1, b: 1 });
-    expect(value9).toBe(3);
-});
-test('optionalPatternToList', () => {
-    const list1 = optionalPatternToList(1);
-    expectTypeOf().toEqualTypeOf();
-    expect(list1).toEqual([{ value: 1 }]);
-    const list2 = optionalPatternToList([{ value: 1 }]);
-    expectTypeOf().toEqualTypeOf();
-    expect(list2).toEqual([{ value: 1 }]);
-    expectTypeOf().toEqualTypeOf();
-});
-test('isDefined', () => {
-    expect(isDefined(0)).toStrictEqual(true);
-    expect(isDefined('')).toStrictEqual(true);
-    expect(isDefined([])).toStrictEqual(true);
-    expect(isDefined({})).toStrictEqual(true);
-    expect(isDefined(undefined)).toStrictEqual(false);
-    expect(isDefined(null)).toStrictEqual(false);
-});
-test('assertDefined', () => {
-    expect(assertDefined(1, 'oops')).toBe(1);
-    expect(() => assertDefined(undefined, 'oops')).toThrow('oops');
-    expect(() => assertDefined(null, 'oops')).toThrow('oops');
-    expect(() => assertDefined(undefined, (value) => `oops: ${value}`)).toThrow('oops: undefined');
-});
-test('assertTypeByGuard', () => {
-    expect(assertTypeByGuard({
-        value: 1,
-        guard: (value) => typeof value === 'number',
-        message: 'oops',
-    })).toBe(1);
-    expect(() => assertTypeByGuard({
-        value: 'str',
-        guard: (value) => typeof value === 'number',
-        message: 'oops',
-    })).toThrow('oops');
-    expect(() => assertTypeByGuard({
-        value: 'str',
-        guard: (value) => typeof value === 'number',
-        message: (value) => `oops: ${value}`,
-    })).toThrow('oops: str');
-});
-test('assertPredicate', () => {
-    const predicate = (value) => value > 0;
-    expect(assertPredicate({ value: 1, predicate, message: 'oops' })).toBe(1);
-    expect(() => assertPredicate({ value: -1, predicate, message: 'oops' })).toThrow('oops');
-    expect(() => assertPredicate({ value: -1, predicate, message: (value) => `oops: ${value}` })).toThrow('oops: -1');
-});
-test('assertImpossible', () => {
-    expect(() => assertImpossible('some message')).toThrow('some message');
-});
-test('unPrototypeProperties', () => {
-    class Test {
-        constructor(prop) {
-            this.prop = prop;
-        }
-        method() {
-            return this.prop;
-        }
-        method2() {
-            return 'method2';
-        }
-    }
-    const instance = new Test(1);
-    const noPrototype = unPrototypeProperties(instance, ['method']);
-    expectTypeOf().toEqualTypeOf();
-    expect(noPrototype.method()).toBe(1);
-    const method = noPrototype.method;
-    expect(method()).toBe(1);
-    expect(Object.hasOwn(noPrototype, 'method')).toBe(true);
-    expect(Object.hasOwn(noPrototype, 'method2')).toBe(false);
-    const clone = { ...noPrototype };
-    expect(clone.method()).toBe(1);
-    expect(Object.hasOwn(clone, 'method2')).toBe(false);
-    // @ts-expect-error method3 is not a property of clone
-    unPrototypeProperties(clone, ['method3']);
-});
-test('mapConst', () => {
-    const input = ['a', 'b', 'c'];
-    const output = mapConst(input)((value) => `${value}-const`);
-    expectTypeOf().toEqualTypeOf();
-    expect(output).toEqual(['a-const', 'b-const', 'c-const']);
-});
-test('mapConst expets a lambda with a correct return type', () => {
-    const input = ['a', 'b', 'c'];
-    // @ts-expect-error The return type of the lambda should depend on the input value
-    mapConst(input)(() => 1);
-});
-test('mapConst infers input type from array', () => {
-    const input = ['a', 'b', 'c'];
-    const output = [];
-    mapConst(input)((value, index) => {
-        expectTypeOf().toEqualTypeOf();
-        expectTypeOf(index).toEqualTypeOf();
-        output.push(index);
-        return `${value}-const`;
-    });
-    expect(output).toEqual([0, 1, 2]);
-});
-test('mapConst non-curried infers input type from array', () => {
-    const input = ['a', 'b', 'c'];
-    const output = [];
-    const result = mapConst(input, (value, index) => {
-        expectTypeOf().toEqualTypeOf();
-        expectTypeOf(index).toEqualTypeOf();
-        output.push(index);
-        return 1;
-    });
-    expectTypeOf().toEqualTypeOf();
-    expect(result).toEqual([1, 1, 1]);
-    expect(output).toEqual([0, 1, 2]);
-});
-test('mapConstKeysToEntries infers input type from array', () => {
-    const input = ['a', 'b', 'c'];
-    const output = mapConstKeysToEntries(input)((value) => `${value}-const`);
-    expectTypeOf().toEqualTypeOf();
-    expect(output).toEqual([
-        ['a', 'a-const'],
-        ['b', 'b-const'],
-        ['c', 'c-const'],
-    ]);
-});
-test('mapConstKeysToEntries expets a lambda with a correct return type', () => {
-    const input = ['a', 'b', 'c'];
-    // @ts-expect-error The return type of the lambda should depend on the input value
-    mapConstKeysToEntries(input)(() => 1);
-});
-test('mapConstKeysToEntries infers input type from array', () => {
-    const input = ['a', 'b', 'c'];
-    const output = [];
-    const a = mapConstKeysToEntries(input, (value, index) => {
-        expectTypeOf().toEqualTypeOf();
-        expectTypeOf(index).toEqualTypeOf();
-        output.push(index);
-        return 1;
-    });
-    expectTypeOf().toEqualTypeOf();
-    expect(a).toEqual([
-        ['a', 1],
-        ['b', 1],
-        ['c', 1],
-    ]);
-    expect(output).toEqual([0, 1, 2]);
-});
-test('mapConstKeysToEntries infers input type from array', () => {
-    const input = ['a', 'b', 'c'];
-    const output = [];
-    mapConstKeysToEntries(input)((value, index) => {
-        expectTypeOf().toEqualTypeOf();
-        expectTypeOf(index).toEqualTypeOf();
-        output.push(index);
-        return `${value}-const`;
-    });
-    expect(output).toEqual([0, 1, 2]);
-});
-test('objectFromConstEntries', () => {
-    const entries = [
-        ['a', 1],
-        ['b', 2],
-        ['c', 3],
-    ];
-    const obj = objectFromConstEntries(entries);
-    expectTypeOf().toEqualTypeOf();
-    expect(obj).toEqual({ a: 1, b: 2, c: 3 });
-});
-test('mapObjectFromKeys', () => {
-    const keys = ['a', 'b', 'c'];
-    const obj = mapObjectFromKeys(keys)((key, index) => {
-        expectTypeOf().toEqualTypeOf();
-        expectTypeOf(index).toEqualTypeOf();
-        return `${key}-const`;
-    });
-    expectTypeOf().toEqualTypeOf();
-    expect(obj).toEqual({ a: 'a-const', b: 'b-const', c: 'c-const' });
-});
-test('mapObjectFromKeys non-curried infers input type from array', () => {
-    const keys = ['a', 'b', 'c'];
-    const obj = mapObjectFromKeys(keys, (key, index) => {
-        expectTypeOf().toEqualTypeOf();
-        expectTypeOf(index).toEqualTypeOf();
-        return 1;
-    });
-    expectTypeOf().toEqualTypeOf();
-    expect(obj).toEqual({ a: 1, b: 1, c: 1 });
-});
-test('boolFromThrow returns true when function does not throw', () => {
-    expect(boolFromThrow(() => { })).toBe(true);
-});
-test('boolFromThrow returns false when function throws', () => {
-    expect(boolFromThrow(() => {
-        throw new Error('fail');
-    })).toBe(false);
-});
-test('boolFromThrowAsync returns true when async function does not throw', async () => {
-    await expect(boolFromThrowAsync(async () => { })).resolves.toBe(true);
-});
-test('boolFromThrowAsync returns false when async function rejects', async () => {
-    await expect(boolFromThrowAsync(async () => {
-        throw new Error('fail');
-    })).resolves.toBe(false);
-});
-test('isDeepEqual compares primitives by strict equality, with NaN equal to itself', () => {
-    expect(isDeepEqual(1, 1)).toBe(true);
-    expect(isDeepEqual(1, 2)).toBe(false);
-    expect(isDeepEqual('a', 'a')).toBe(true);
-    expect(isDeepEqual(1, '1')).toBe(false);
-    expect(isDeepEqual(NaN, NaN)).toBe(true);
-    expect(isDeepEqual(undefined, undefined)).toBe(true);
-    expect(isDeepEqual(null, null)).toBe(true);
-    expect(isDeepEqual(null, {})).toBe(false);
-    expect(isDeepEqual({}, null)).toBe(false);
-});
-test('isDeepEqual compares plain objects by their own keys', () => {
-    expect(isDeepEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true);
-    expect(isDeepEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false);
-    expect(isDeepEqual({ a: 1, b: 2 }, { a: 1 })).toBe(false);
-    expect(isDeepEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } })).toBe(true);
-    expect(isDeepEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 2 } } })).toBe(false);
-});
-test('isDeepEqual compares arrays element-wise', () => {
-    expect(isDeepEqual([1, 2, 3], [1, 2, 3])).toBe(true);
-    expect(isDeepEqual([1, 2], [1, 2, 3])).toBe(false);
-    expect(isDeepEqual([{ a: 1 }], [{ a: 1 }])).toBe(true);
-    expect(isDeepEqual([{ a: 1 }], [{ a: 2 }])).toBe(false);
-    expect(isDeepEqual([], [])).toBe(true);
-});
-test('isDeepEqual treats a different prototype as unequal', () => {
-    class A {
-        constructor(x) {
-            this.x = x;
-        }
-    }
-    class B {
-        constructor(x) {
-            this.x = x;
-        }
-    }
-    expect(isDeepEqual(new A(1), new B(1))).toBe(false);
-    expect(isDeepEqual([1], { 0: 1 })).toBe(false);
-});
-test('isDeepEqual compares Dates by time', () => {
-    expect(isDeepEqual(new Date(1000), new Date(1000))).toBe(true);
-    expect(isDeepEqual(new Date(1000), new Date(2000))).toBe(false);
-});
-test('isDeepEqual compares RegExps by source and flags', () => {
-    expect(isDeepEqual(/ab+/g, /ab+/g)).toBe(true);
-    expect(isDeepEqual(/ab+/g, /ab+/i)).toBe(false);
-    expect(isDeepEqual(/ab+/g, /ac+/g)).toBe(false);
-});
-test('isDeepEqual compares Sets by size and membership', () => {
-    expect(isDeepEqual(new Set([1, 2]), new Set([1, 2]))).toBe(true);
-    expect(isDeepEqual(new Set([1, 2]), new Set([2, 1]))).toBe(true);
-    expect(isDeepEqual(new Set([1, 2]), new Set([1, 3]))).toBe(false);
-    expect(isDeepEqual(new Set([1]), new Set([1, 2]))).toBe(false);
-});
-test('isDeepEqual compares Maps by size and entries', () => {
-    expect(isDeepEqual(new Map([['a', 1]]), new Map([['a', 1]]))).toBe(true);
-    expect(isDeepEqual(new Map([['a', 1]]), new Map([['a', 2]]))).toBe(false);
-    expect(isDeepEqual(new Map([['a', 1]]), new Map([['b', 1]]))).toBe(false);
-    expect(isDeepEqual(new Map([['a', { b: 1 }]]), new Map([['a', { b: 1 }]]))).toBe(true);
-});
-test('isDeepEqual compares ArrayBuffers and typed arrays byte by byte', () => {
-    const bufferOf = (bytes) => new Uint8Array(bytes).buffer;
-    expect(isDeepEqual(bufferOf([1, 2, 3]), bufferOf([1, 2, 3]))).toBe(true);
-    expect(isDeepEqual(bufferOf([1, 2, 3]), bufferOf([1, 2, 4]))).toBe(false);
-    expect(isDeepEqual(bufferOf([1, 2]), bufferOf([1, 2, 3]))).toBe(false);
-    expect(isDeepEqual(new Uint8Array([1, 2]), new Uint8Array([1, 2]))).toBe(true);
-    expect(isDeepEqual(new Uint8Array([1, 2]), new Uint8Array([1, 3]))).toBe(false);
-    expect(isDeepEqual(new DataView(bufferOf([9])), new DataView(bufferOf([9])))).toBe(true);
-    expect(isDeepEqual(new DataView(bufferOf([9])), new DataView(bufferOf([8])))).toBe(false);
-});
-test('isDeepEqual survives circular references', () => {
-    const a = { name: 'a' };
-    a.self = a;
-    const b = { name: 'a' };
-    b.self = b;
-    expect(isDeepEqual(a, b)).toBe(true);
-    const c = { name: 'c' };
-    c.self = c;
-    expect(isDeepEqual(a, c)).toBe(false);
-});
-test('isDeepEqual prefers a custom valueOf when one is defined', () => {
-    class Money {
-        constructor(cents) {
-            this.cents = cents;
-        }
-        valueOf() {
-            return this.cents;
-        }
-    }
-    expect(isDeepEqual(new Money(100), new Money(100))).toBe(true);
-    expect(isDeepEqual(new Money(100), new Money(200))).toBe(false);
-});
-test('isDeepEqual falls back to a custom toString when one is defined', () => {
-    class Tag {
-        constructor(label) {
-            this.label = label;
-        }
-        toString() {
-            return this.label;
-        }
-    }
-    expect(isDeepEqual(new Tag('x'), new Tag('x'))).toBe(true);
-    expect(isDeepEqual(new Tag('x'), new Tag('y'))).toBe(false);
-});
-test('isDeepEqual compares subclasses of built-ins by their built-in semantics', () => {
-    class MySet extends Set {
-    }
-    class MyMap extends Map {
-    }
-    expect(isDeepEqual(new MySet([1]), new MySet([1]))).toBe(true);
-    expect(isDeepEqual(new MySet([1]), new MySet([2]))).toBe(false);
-    expect(isDeepEqual(new MyMap([['a', 1]]), new MyMap([['a', 1]]))).toBe(true);
-    expect(isDeepEqual(new MyMap([['a', 1]]), new MyMap([['a', 2]]))).toBe(false);
-});