@dungarees/core 0.11.0

package/application.d.ts

@@ -0,0 +1,66 @@
+import { type OptionalPatternList } from './util.ts';
+export type Application<CONFIG extends Partial<ApplicationTypeConfig> = DefaultApplicationTypeConfig> = {
+    run: (identity?: CONFIG['identity'], overrides?: Partial<SingleApplicationArgs<ApplicationTypeConfigWithDefaults<CONFIG>>>) => ApplicationRunReturn<CONFIG>;
+    getArgs: () => Array<Partial<CreateApplicationArgs<CONFIG>>>;
+};
+export declare const createApplication: <const CONFIG extends Partial<ApplicationTypeConfig> = DefaultApplicationTypeConfig>(appArgs?: Partial<CreateApplicationArgs<ApplicationTypeConfigWithDefaults<CONFIG>>>, otherApp?: () => Application<ApplicationTypeConfigWithDefaults<CONFIG>>) => Application<ApplicationTypeConfigWithDefaults<CONFIG>>;
+export type SingleApplicationArgs<CONFIG extends Partial<ApplicationTypeConfig>> = {
+    getExternalServices: GetExternalServices<CONFIG>;
+    getInternalServices: GetInternalServices<CONFIG>;
+    preMain: PreMain<CONFIG>;
+    getDelivery: GetDelivery<CONFIG>;
+    main: Main<CONFIG>;
+    onError: OnError;
+    topLevelErrorHandling: TopLevelErrorHandling;
+    exportState: ExportState<CONFIG>;
+    importState: ImportState<CONFIG>;
+};
+export type CreateApplicationArgs<CONFIG extends Partial<ApplicationTypeConfig>> = {
+    [KEY in keyof SingleApplicationArgs<CONFIG>]: OptionalPatternList<SingleApplicationArgs<CONFIG>[KEY], CONFIG['identity']>;
+};
+export type ApplicationTypeConfig = {
+    externalServices: Record<string, any>;
+    internalServices: Record<string, any>;
+    delivery: Record<string, any>;
+    output: any;
+    identity: any;
+    exportState: any;
+};
+type DefaultApplicationTypeConfig = {
+    externalServices: Record<string, never>;
+    internalServices: Record<string, never>;
+    delivery: Record<string, never>;
+    output: undefined;
+    identity: undefined;
+    exportState: undefined;
+};
+type GetExternalServices<CONFIG extends Partial<ApplicationTypeConfig>> = (identity: CONFIG['identity']) => CONFIG['externalServices'];
+type GetInternalServices<CONFIG extends Partial<ApplicationTypeConfig>> = (externalServices: CONFIG['externalServices'], identity: CONFIG['identity']) => CONFIG['internalServices'];
+type PreMain<CONFIG extends Partial<ApplicationTypeConfig>> = (internalServices: CONFIG['internalServices'], identity: CONFIG['identity']) => void;
+type GetDelivery<CONFIG extends Partial<ApplicationTypeConfig>> = (injected: {
+    internalServices: CONFIG['internalServices'];
+    exportState: () => CONFIG['exportState'];
+}, identity: CONFIG['identity']) => CONFIG['delivery'];
+type Main<CONFIG extends Partial<ApplicationTypeConfig>> = (injected: {
+    internalServices: CONFIG['internalServices'];
+    delivery: CONFIG['delivery'];
+}, identity: CONFIG['identity']) => CONFIG['output'];
+type OnError = (error: unknown) => void;
+type TopLevelErrorHandling = (onError: (error: unknown) => void) => void;
+type ExportState<CONFIG extends Partial<ApplicationTypeConfig>> = (internalServices: CONFIG['internalServices']) => CONFIG['exportState'];
+type ImportState<CONFIG extends Partial<ApplicationTypeConfig>> = (internalServices: CONFIG['internalServices'], newState: CONFIG['exportState']) => void;
+type ApplicationTypeConfigWithDefaults<CONFIG extends Partial<ApplicationTypeConfig>> = {
+    [KEY in keyof DefaultApplicationTypeConfig]: CONFIG[KEY] extends ApplicationTypeConfig[KEY] ? CONFIG[KEY] : DefaultApplicationTypeConfig[KEY];
+};
+export type ApplicationTypeConfigWithAnys<CONFIG extends Partial<ApplicationTypeConfig>> = {
+    [KEY in keyof ApplicationTypeConfig]: CONFIG[KEY] extends ApplicationTypeConfig[KEY] ? CONFIG[KEY] : ApplicationTypeConfig[KEY];
+};
+export type ApplicationRunReturn<CONFIG extends Partial<ApplicationTypeConfig>> = {
+    externalServices: CONFIG['externalServices'];
+    internalServices: CONFIG['internalServices'];
+    delivery: CONFIG['delivery'];
+    output: CONFIG['output'];
+    importState: (newState: CONFIG['exportState']) => void;
+    exportState: () => CONFIG['exportState'];
+};
+export {};

package/application.js

@@ -0,0 +1,80 @@
+import { assertDefined, findByPattern, optionalPatternToList, } from './util.js';
+export const createApplication = (appArgs = {}, otherApp) => {
+    const DEFAULTS = {
+        getExternalServices: () => ({}),
+        getInternalServices: () => ({}),
+        preMain: () => { },
+        getDelivery: () => ({}),
+        main: () => { },
+        onError: () => { },
+        topLevelErrorHandling: () => { },
+        exportState: () => { },
+        importState: () => { },
+    };
+    const toPatternLists = (defaults) => Object.fromEntries(Object.entries(defaults).map(([key, value]) => {
+        return [key, optionalPatternToList(value)];
+    }));
+    const getArg = (patternLists, key, runIdentity) => {
+        const arg = findByPattern(patternLists[key], runIdentity);
+        return assertDefined(arg, `No matching identity for "${key}"`);
+    };
+    const getDefaultedArgs = (patternLists, identity) => Object.fromEntries(Object.entries(patternLists).map(([key]) => {
+        return [key, getArg(patternLists, key, identity)];
+    }));
+    const registerArg = (config, key, argPatternLists) => {
+        if (config[key] !== undefined) {
+            const oldArgPatterns = argPatternLists[key];
+            argPatternLists[key] = [
+                ...argPatternLists[key],
+                ...optionalPatternToList(config[key]),
+            ];
+        }
+    };
+    const register = (config, argPatternLists) => {
+        Object.keys(argPatternLists).forEach((argName) => {
+            registerArg(config, argName, argPatternLists);
+        });
+        return argPatternLists;
+    };
+    const app = {
+        run: (runIdentity, overrides = {}) => {
+            const [baseArg, ...restArgs] = app.getArgs();
+            const firstArgsWithDefaults = {
+                ...DEFAULTS,
+                ...baseArg,
+            };
+            const argPatternLists = restArgs.reduce((list, config) => register(config, list), toPatternLists(firstArgsWithDefaults));
+            const { getExternalServices, getInternalServices, preMain, getDelivery, main, onError, topLevelErrorHandling, exportState: exportStateOriginal, importState, } = {
+                ...getDefaultedArgs(argPatternLists, runIdentity),
+                ...overrides,
+            };
+            try {
+                topLevelErrorHandling(onError);
+                const externalServices = getExternalServices(runIdentity);
+                const internalServices = getInternalServices(externalServices, runIdentity);
+                preMain(internalServices, runIdentity);
+                const exportState = () => exportStateOriginal(internalServices);
+                const delivery = getDelivery({ internalServices, exportState }, runIdentity);
+                const output = main({ delivery, internalServices }, runIdentity);
+                return {
+                    externalServices,
+                    internalServices,
+                    delivery,
+                    output,
+                    exportState,
+                    importState: (newState) => {
+                        importState(internalServices, newState);
+                    },
+                };
+            }
+            catch (e) {
+                onError(e);
+                throw new Error('Could not run application', { cause: e });
+            }
+        },
+        getArgs: () => {
+            return (otherApp !== undefined ? [...otherApp().getArgs(), appArgs] : [appArgs]);
+        },
+    };
+    return app;
+};

package/fake.d.ts

@@ -0,0 +1,17 @@
+import type { Observable } from 'rxjs';
+type MethodTypes = 'sync' | 'async' | 'observable';
+export type FakeConfigs<FAKE extends object> = {
+    [KEY in keyof Partial<FAKE>]: FakeConfig;
+};
+type FakeConfig = {
+    type: MethodTypes;
+    error: Error;
+};
+type FakeWithThrowingMethods<FAKE extends object, FAKE_CONFIGS extends FakeConfigs<FAKE>> = {
+    [KEY in keyof FAKE]: KEY extends keyof FAKE_CONFIGS ? FAKE[KEY] extends (...args: any[]) => Observable<any> ? ThrowingObservable : FAKE[KEY] extends (...args: any[]) => Promise<any> ? ThrowingAsync : FAKE[KEY] extends (...args: any[]) => any ? ThrowingSync : FAKE[KEY] : FAKE[KEY];
+};
+type ThrowingSync = (...args: any[]) => never;
+type ThrowingAsync = (...args: any[]) => Promise<never>;
+type ThrowingObservable = (...args: any[]) => Observable<never>;
+export declare const addErrorMethodsToFake: <T extends object, ARGS extends any[]>(originalFake: (...args: ARGS) => T) => (configs?: FakeConfigs<T>, ...restArgs: any[]) => FakeWithThrowingMethods<T, FakeConfigs<T>>;
+export {};

package/fake.js

@@ -0,0 +1,29 @@
+import { throwError, timer } from 'rxjs';
+import { mergeMap } from 'rxjs/operators';
+export const addErrorMethodsToFake = (originalFake) => (configs = {}, ...restArgs) => {
+    const fake = originalFake(...restArgs);
+    const throwingMethods = generateThrowingMethods(configs);
+    // It is a valid cast to more specific tpye
+    // eslint-disable-next-line
+    return {
+        ...fake,
+        ...throwingMethods,
+    };
+};
+const THROWING_METOD_GENERATORS = {
+    sync: (error) => () => {
+        throw error;
+    },
+    async: (error) => async () => {
+        throw error;
+    },
+    observable: (error) => () => timer(1).pipe(mergeMap(() => throwError(() => error))),
+};
+const generateThrowingMethods = (configs) => {
+    const entries = Object.entries(configs);
+    const throwingMethods = entries.map(([method, { error, type }]) => [
+        method,
+        THROWING_METOD_GENERATORS[type](error),
+    ]);
+    return Object.fromEntries(throwingMethods);
+};

package/fake.test.d.ts

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

package/fake.test.js

@@ -0,0 +1,53 @@
+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);
+});

package/marbles-vitest.d.ts

@@ -0,0 +1,55 @@
+import type { Observable } from 'rxjs';
+import { type NamedCase, type UnnamedCase } from 'rxjs-marbles/cases.js';
+import { type Configuration } from 'rxjs-marbles/configuration.js';
+import { type Context } from 'rxjs-marbles/context.js';
+import { Expect } from 'rxjs-marbles/expect.js';
+import { type MarblesFunction } from 'rxjs-marbles/marbles.js';
+import type { ExpectHelpers, TestObservableLike } from 'rxjs-marbles/types.js';
+export type CasesFunction = {
+    <T extends UnnamedCase>(name: string, func: (context: Context, _case: T) => void, cases: Record<string, T>): void;
+    <T extends NamedCase>(name: string, func: (context: Context, _case: T) => void, cases: T[]): void;
+};
+export declare function configure(configuration: Configuration): {
+    cases: CasesFunction;
+    marbles: MarblesFunction;
+};
+declare const marbles: MarblesFunction;
+type Marbles = typeof marbles;
+type MarblesRunner = Parameters<Marbles>[0];
+type MarblesParam = Parameters<MarblesRunner>[0];
+type Runner = (m: MarblesExtensions, ...args: any[]) => ReturnType<MarblesRunner>;
+type MarbleFunctions = Record<string, () => void>;
+type MarblesExtensions = {
+    coldCall: (marble: string, functions: MarbleFunctions) => void;
+    coldBoolean: (marble: string) => TestObservableLike<boolean>;
+    coldValue: <T = any>(marble: string, value: T) => TestObservableLike<T>;
+    coldValueOrUndefined: <T = any>(marble: string, value: T) => TestObservableLike<T | undefined>;
+    coldStep: <T = any>(value: T, steps?: number) => TestObservableLike<T>;
+    coldStepAndClose: <T = any>(value: T, steps?: number) => TestObservableLike<T>;
+    coldError: (error: any, steps?: number) => TestObservableLike<any>;
+    coldStepAndError: <T = any>(value: any, error: any, steps?: number) => TestObservableLike<T>;
+    expect: <T = any>(actual: Observable<T>, subscription?: string) => ExtendedExpect<T>;
+} & MarblesParam;
+declare class ExtendedExpect<T> extends Expect<T> {
+    readonly actual_: Observable<T>;
+    readonly helpers_: ExpectHelpers;
+    readonly subscription_?: string;
+    constructor(actual_: Observable<T>, helpers_: ExpectHelpers, subscription_?: string);
+    toBeObservableBoolean(marble: string): void;
+    toBeObservableValue(value: T): void;
+    toBeObservableValue(marble: string, value: T): void;
+    toBeObservableValueAndClose(value: T): void;
+    toBeObservableValueAndError(value: T, error: any): void;
+    toBeObservableValueOrUndefined(marble: string, value: T): void;
+    toBeObservableStep(value: T, steps?: number): void;
+    toBeObservableStepAndClose(value: T, steps?: number): void;
+    toBeObservableError(error: any, steps?: number): void;
+    toBeObservableStepAndError(value: T, error: any, steps?: number): void;
+}
+export declare const coreMarbles: (runner: Runner) => (() => void);
+export declare const MARBLES_BOOLEAN: {
+    t: boolean;
+    f: boolean;
+};
+export declare const mtest: (name: string, runner: Runner) => void;
+export {};

package/marbles-vitest.js

@@ -0,0 +1,127 @@
+import { _cases } from 'rxjs-marbles/cases.js';
+import { defaults } from 'rxjs-marbles/configuration.js';
+import { Expect } from 'rxjs-marbles/expect.js';
+import { configure as _configure } from 'rxjs-marbles/marbles.js';
+import { describe, expect, test } from 'vitest';
+export function configure(configuration) {
+    const { marbles } = _configure({
+        ...defaults(),
+        assertDeepEqual: (a, e) => {
+            expect(a).toStrictEqual(e);
+        },
+        frameworkMatcher: true,
+        ...configuration,
+    });
+    function cases(name, func, cases) {
+        describe(name, () => {
+            _cases((c) => {
+                const t = c?.only !== undefined ? test.only : c?.skip === undefined ? test.skip : test;
+                if (func.length > 2) {
+                    t(c.name, marbles((m, second, ...rest) => func(m, c, second, ...rest)));
+                }
+                else {
+                    t(c.name, marbles((m, ...rest) => func(m, c, ...rest)));
+                }
+            }, cases);
+        });
+    }
+    return { cases, marbles };
+}
+const { marbles } = configure({});
+class ExtendedExpect extends Expect {
+    constructor(actual_, helpers_, subscription_) {
+        super(actual_, helpers_, subscription_);
+        this.actual_ = actual_;
+        this.helpers_ = helpers_;
+        this.subscription_ = subscription_;
+    }
+    toBeObservableBoolean(marble) {
+        this.toBeObservable(marble, MARBLES_BOOLEAN);
+    }
+    toBeObservableValue(...args) {
+        const value = args.length === 1 ? args[0] : args[1];
+        const marble = args.length === 1 ? 'v' : args[0];
+        this.toBeObservable(marble, { v: value });
+    }
+    toBeObservableValueAndClose(value) {
+        this.toBeObservable('(v|)', { v: value });
+    }
+    toBeObservableValueAndError(value, error) {
+        const marble = '(v#)';
+        this.toBeObservable(marble, { v: value }, error);
+    }
+    toBeObservableValueOrUndefined(marble, value) {
+        this.toBeObservable(marble, { v: value, '0': undefined });
+    }
+    toBeObservableStep(value, steps = 1) {
+        const marble = `-`.repeat(steps) + 'v';
+        this.toBeObservable(marble, { v: value });
+    }
+    toBeObservableStepAndClose(value, steps = 1) {
+        const marble = `-`.repeat(steps) + '(v|)';
+        this.toBeObservable(marble, { v: value });
+    }
+    toBeObservableError(error, steps = 1) {
+        const marble = `-`.repeat(steps) + '#';
+        this.toBeObservable(marble, {}, error);
+    }
+    toBeObservableStepAndError(value, error, steps = 1) {
+        const marble = `-`.repeat(steps) + '(v#)';
+        this.toBeObservable(marble, { v: value }, error);
+    }
+}
+export const coreMarbles = (runner) => (...args) => marbles((m) => {
+    const coldCall = (marble, functions) => {
+        const marbleDefinition = Object.fromEntries(Object.keys(functions).map((key) => [key, key]));
+        m.cold(marble, marbleDefinition).subscribe((key) => {
+            functions[key]?.();
+        });
+    };
+    const coldBoolean = (marble) => m.cold(marble, MARBLES_BOOLEAN);
+    const coldValue = (marble, value) => m.cold(marble, { v: value });
+    const coldValueOrUndefined = (marble, value) => m.cold(marble, { v: value, 0: undefined });
+    const coldStep = (value, steps = 1) => m.cold(`-`.repeat(steps) + 'v', { v: value });
+    const coldStepAndClose = (value, steps = 1) => m.cold(`-`.repeat(steps) + '(v|)', { v: value });
+    const coldError = (error, steps = 1) => m.cold(`-`.repeat(steps) + '#', {}, error);
+    const coldStepAndError = (value, error, steps = 1) => m.cold(`-`.repeat(steps) + '(v#)', { v: value }, error);
+    // This function and the ExtendedExpect depends on internals of the `rxjs-marbles` library
+    // potentially not future proof
+    const expect = (actual, subscription) => {
+        const { helpers_ } = m;
+        return new ExtendedExpect(actual, helpers_, subscription);
+    };
+    // The methods on `m` (the RunContext) are on the prototype, so we have to bind the original
+    // ones to be able to use destructuring
+    return runner({
+        get autoFlush() {
+            return m.autoFlush;
+        },
+        coldCall,
+        coldBoolean,
+        coldValue,
+        coldValueOrUndefined,
+        coldStep,
+        coldStepAndClose,
+        coldError,
+        coldStepAndError,
+        expect,
+        equal: m.equal.bind(m),
+        cold: m.cold.bind(m),
+        bind: m.bind.bind(m),
+        configure: m.configure.bind(m),
+        flush: m.flush.bind(m),
+        has: m.has.bind(m),
+        hot: m.hot.bind(m),
+        reframe: m.reframe.bind(m),
+        scheduler: m.scheduler,
+        teardown: m.teardown.bind(m),
+        time: m.time.bind(m),
+    }, ...args);
+})();
+export const MARBLES_BOOLEAN = {
+    t: true,
+    f: false,
+};
+export const mtest = (name, runner) => {
+    test(name, coreMarbles((m) => runner(m)));
+};

package/marbles-vitest.test.d.ts

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

package/marbles-vitest.test.js

@@ -0,0 +1,104 @@
+import { coreMarbles, mtest } from './marbles-vitest.js';
+import { Subject } from 'rxjs';
+import { 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('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);
+});

package/marbles.d.ts

@@ -0,0 +1,27 @@
+import type { Observable } from 'rxjs';
+import { Expect } from 'rxjs-marbles/expect.js';
+import { marbles } from 'rxjs-marbles/jest/index.js';
+import type { ExpectHelpers, TestObservableLike } from 'rxjs-marbles/types.js';
+type Marbles = typeof marbles;
+type MarblesRunner = Parameters<Marbles>[0];
+type MarblesParam = Parameters<MarblesRunner>[0];
+type Runner = (m: MarblesExtensions, ...args: any[]) => ReturnType<MarblesRunner>;
+type MarbleFunctions = Record<string, () => void>;
+type MarblesExtensions = {
+    coldCall: (marble: string, functions: MarbleFunctions) => void;
+    coldBoolean: (marble: string) => TestObservableLike<boolean>;
+    expect: <T = any>(actual: Observable<T>, subscription?: string) => ExtendedExpect<T>;
+} & MarblesParam;
+declare class ExtendedExpect<T> extends Expect<T> {
+    readonly actual_: Observable<T>;
+    readonly helpers_: ExpectHelpers;
+    readonly subscription_?: string;
+    constructor(actual_: Observable<T>, helpers_: ExpectHelpers, subscription_?: string);
+    toBeObservableBoolean(marble: string): void;
+}
+export declare const coreMarbles: (runner: Runner) => (() => void);
+export declare const MARBLES_BOOLEAN: {
+    t: boolean;
+    f: boolean;
+};
+export {};

package/marbles.js

@@ -0,0 +1,53 @@
+import { Expect } from 'rxjs-marbles/expect.js';
+import { marbles } from 'rxjs-marbles/jest/index.js';
+class ExtendedExpect extends Expect {
+    constructor(actual_, helpers_, subscription_) {
+        super(actual_, helpers_, subscription_);
+        this.actual_ = actual_;
+        this.helpers_ = helpers_;
+        this.subscription_ = subscription_;
+    }
+    toBeObservableBoolean(marble) {
+        this.toBeObservable(marble, MARBLES_BOOLEAN);
+    }
+}
+export const coreMarbles = (runner) => (...args) => marbles((m) => {
+    const coldCall = (marble, functions) => {
+        const marbleDefinition = Object.fromEntries(Object.keys(functions).map((key) => [key, key]));
+        m.cold(marble, marbleDefinition).subscribe((key) => {
+            functions[key]?.();
+        });
+    };
+    const coldBoolean = (marble) => m.cold(marble, MARBLES_BOOLEAN);
+    // This function and the ExtendedExpect depends on internals of the `rxjs-marbles` library
+    // potentially not future proof
+    const expect = (actual, subscription) => {
+        const { helpers_ } = m;
+        return new ExtendedExpect(actual, helpers_, subscription);
+    };
+    // The methods on `m` (the RunContext) are on the prototype, so we have to bind the original
+    // ones to be able to use destructuring
+    return runner({
+        get autoFlush() {
+            return m.autoFlush;
+        },
+        coldCall,
+        coldBoolean,
+        expect,
+        equal: m.equal.bind(m),
+        cold: m.cold.bind(m),
+        bind: m.bind.bind(m),
+        configure: m.configure.bind(m),
+        flush: m.flush.bind(m),
+        has: m.has.bind(m),
+        hot: m.hot.bind(m),
+        reframe: m.reframe.bind(m),
+        scheduler: m.scheduler,
+        teardown: m.teardown.bind(m),
+        time: m.time.bind(m),
+    }, ...args);
+})();
+export const MARBLES_BOOLEAN = {
+    t: true,
+    f: false,
+};

package/marbles.test.d.ts

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

package/marbles.test.js

@@ -0,0 +1,36 @@
+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);
+}));