@dungarees/core 0.11.5 → 0.12.0

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);
-});