@dungarees/core 0.11.0

package/util.test.js

@@ -0,0 +1,202 @@
+import { assertDefined, assertPredicate, assertTypeByGuard, assertImpossible, camelCase2kebabCase, capitalize, deepEqualPartial, findByPattern, isDefined, join, kebabCase2camelCase, makeObjectFromStringLiteral, mapConst, optionalPatternToList, pluralize, split, unPrototypeProperties, objectFromConstEntries, } from './util.js';
+import { assert } from 'tsafe';
+import { expect, 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', '.');
+    assert();
+    expect(splitted).toEqual(['a', 'a', 'a']);
+});
+test('join is working in a typesafe way', () => {
+    const joined = join(['a', 'a', 'a'], '.');
+    assert();
+    expect(joined).toBe('a.a.a');
+});
+test('capitalize', () => {
+    const capitalized = capitalize('apple');
+    assert();
+    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);
+    assert();
+});
+test('camelCase2kebabCase', () => {
+    const kebabCase = 'first-second-third';
+    const camelCase = 'firstSecondThird';
+    const output = camelCase2kebabCase(camelCase);
+    expect(output).toBe(kebabCase);
+    assert();
+});
+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('findByPattern', () => {
+    // eslint-disable-next-line
+    const value1 = findByPattern([], '');
+    assert();
+    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);
+    assert(_);
+    const value2 = findByPattern([{ pattern: 'ab', value: 1 }], 'ab');
+    assert();
+    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);
+    assert();
+    expect(list1).toEqual([{ value: 1 }]);
+    const list2 = optionalPatternToList([{ value: 1 }]);
+    assert();
+    expect(list2).toEqual([{ value: 1 }]);
+    assert();
+});
+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']);
+    assert();
+    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);
+    // @ts-expect-error method2 is not a property of clone
+    expect(() => clone.method2()).toThrow('method2 is not a function');
+    // @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`);
+    assert();
+    expect(output).toEqual(['a-const', 'b-const', 'c-const']);
+});
+test('mapConst infers input type from array', () => {
+    const input = ['a', 'b', 'c'];
+    mapConst(input)((value) => {
+        assert();
+        return `${value}-const`;
+    });
+});
+test('objectFromConstEntries', () => {
+    const entries = [
+        ['a', 1],
+        ['b', 2],
+        ['c', 3],
+    ];
+    const obj = objectFromConstEntries(entries);
+    assert();
+    expect(obj).toEqual({ a: 1, b: 2, c: 3 });
+});