@dungarees/core 0.11.5 → 0.12.0

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