@dungarees/core 0.11.1 → 0.11.3

package/application.d.ts

@@ -1,12 +1,15 @@
+import type { JsonType } from './type-util.ts';
 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>;
+    run: (...args: RunArgs<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>>;
+type RunArgs<CONFIG extends Partial<ApplicationTypeConfig>> = undefined extends CONFIG['identity'] ? [identity?: CONFIG['identity'], overrides?: RunOverrides<CONFIG>] : [identity: CONFIG['identity'], overrides?: RunOverrides<CONFIG>];
+type RunOverrides<CONFIG extends Partial<ApplicationTypeConfig>> = Partial<SingleApplicationArgs<ApplicationTypeConfigWithDefaults<CONFIG>>>;
 export type SingleApplicationArgs<CONFIG extends Partial<ApplicationTypeConfig>> = {
-    getExternalServices: GetExternalServices<CONFIG>;
-    getInternalServices: GetInternalServices<CONFIG>;
+    getServices: GetServices<CONFIG>;
+    getBehaviors: GetBehaviors<CONFIG>;
     preMain: PreMain<CONFIG>;
     getDelivery: GetDelivery<CONFIG>;
     main: Main<CONFIG>;
@@ -19,45 +22,48 @@ 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;
+    services: Record<string, unknown>;
+    behaviors: Record<string, unknown>;
+    delivery: Record<string, unknown>;
+    output: unknown;
+    identity: JsonType;
+    exportState: unknown;
 };
 type DefaultApplicationTypeConfig = {
-    externalServices: Record<string, never>;
-    internalServices: Record<string, never>;
+    services: Record<string, never>;
+    behaviors: 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 GetServices<CONFIG extends Partial<ApplicationTypeConfig>> = (identity: CONFIG['identity']) => CONFIG['services'];
+type GetBehaviors<CONFIG extends Partial<ApplicationTypeConfig>> = (services: CONFIG['services'], identity: CONFIG['identity']) => CONFIG['behaviors'];
+type PreMain<CONFIG extends Partial<ApplicationTypeConfig>> = (behaviors: CONFIG['behaviors'], identity: CONFIG['identity']) => void;
 type GetDelivery<CONFIG extends Partial<ApplicationTypeConfig>> = (injected: {
-    internalServices: CONFIG['internalServices'];
+    services: CONFIG['services'];
+    behaviors: CONFIG['behaviors'];
     exportState: () => CONFIG['exportState'];
 }, identity: CONFIG['identity']) => CONFIG['delivery'];
 type Main<CONFIG extends Partial<ApplicationTypeConfig>> = (injected: {
-    internalServices: CONFIG['internalServices'];
+    services: CONFIG['services'];
+    behaviors: CONFIG['behaviors'];
     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 ExportState<CONFIG extends Partial<ApplicationTypeConfig>> = (behaviors: CONFIG['behaviors']) => CONFIG['exportState'];
+type ImportState<CONFIG extends Partial<ApplicationTypeConfig>> = (behaviors: CONFIG['behaviors'], newState: CONFIG['exportState']) => void;
+type RecordShapedKey = 'services' | 'behaviors' | 'delivery';
 type ApplicationTypeConfigWithDefaults<CONFIG extends Partial<ApplicationTypeConfig>> = {
-    [KEY in keyof DefaultApplicationTypeConfig]: CONFIG[KEY] extends ApplicationTypeConfig[KEY] ? CONFIG[KEY] : DefaultApplicationTypeConfig[KEY];
+    [KEY in keyof DefaultApplicationTypeConfig]: KEY extends RecordShapedKey ? CONFIG[KEY] extends ApplicationTypeConfig[KEY] ? CONFIG[KEY] : DefaultApplicationTypeConfig[KEY] : CONFIG[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'];
+    services: CONFIG['services'];
+    behaviors: CONFIG['behaviors'];
     delivery: CONFIG['delivery'];
     output: CONFIG['output'];
     importState: (newState: CONFIG['exportState']) => void;

package/application.js

@@ -1,8 +1,8 @@
 import { assertDefined, findByPattern, optionalPatternToList, } from './util.js';
 export const createApplication = (appArgs = {}, otherApp) => {
     const DEFAULTS = {
-        getExternalServices: () => ({}),
-        getInternalServices: () => ({}),
+        getServices: () => ({}),
+        getBehaviors: () => ({}),
         preMain: () => { },
         getDelivery: () => ({}),
         main: () => { },
@@ -23,7 +23,6 @@ export const createApplication = (appArgs = {}, otherApp) => {
     }));
     const registerArg = (config, key, argPatternLists) => {
         if (config[key] !== undefined) {
-            const oldArgPatterns = argPatternLists[key];
             argPatternLists[key] = [
                 ...argPatternLists[key],
                 ...optionalPatternToList(config[key]),
@@ -37,33 +36,33 @@ export const createApplication = (appArgs = {}, otherApp) => {
         return argPatternLists;
     };
     const app = {
-        run: (runIdentity, overrides = {}) => {
+        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, } = {
+            const { getServices, getBehaviors, 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);
+                const services = getServices(runIdentity);
+                const behaviors = getBehaviors(services, runIdentity);
+                preMain(behaviors, runIdentity);
+                const exportState = () => exportStateOriginal(behaviors);
+                const delivery = getDelivery({ services, behaviors, exportState }, runIdentity);
+                const output = main({ services, delivery, behaviors }, runIdentity);
                 return {
-                    externalServices,
-                    internalServices,
+                    services,
+                    behaviors,
                     delivery,
                     output,
                     exportState,
                     importState: (newState) => {
-                        importState(internalServices, newState);
+                        importState(behaviors, newState);
                     },
                 };
             }
@@ -73,7 +72,7 @@ export const createApplication = (appArgs = {}, otherApp) => {
             }
         },
         getArgs: () => {
-            return (otherApp !== undefined ? [...otherApp().getArgs(), appArgs] : [appArgs]);
+            return otherApp !== undefined ? [...otherApp().getArgs(), appArgs] : [appArgs];
         },
     };
     return app;

package/error.d.ts

@@ -0,0 +1,8 @@
+export declare const getErrorMessage: (cause: unknown) => string;
+export declare const createCausedError: ({ message, cause }: {
+    message: string;
+    cause: unknown;
+}) => Error;
+export declare const getThrownError: (run: () => unknown) => Error;
+export declare const isAbortError: (cause: unknown) => boolean;
+export declare const isNetworkError: (cause: unknown) => boolean;

package/error.js

@@ -0,0 +1,31 @@
+export const getErrorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+export const createCausedError = ({ message, cause }) => new Error(`${message}: ${getErrorMessage(cause)}`, { cause });
+export const getThrownError = (run) => {
+    try {
+        run();
+    }
+    catch (cause) {
+        if (cause instanceof Error) {
+            return cause;
+        }
+        throw new Error(`Expected an Error to be thrown, got: ${getErrorMessage(cause)}`);
+    }
+    throw new Error('Expected a throw, but nothing was thrown');
+};
+// Reads the property without asserting a shape, so a rejection carrying a plain object is treated
+// the same as one carrying an Error.
+const readStringProperty = (value, property) => {
+    if (typeof value !== 'object' || value === null || !(property in value)) {
+        return undefined;
+    }
+    const read = Reflect.get(value, property);
+    return typeof read === 'string' ? read : undefined;
+};
+// The message is checked as well as the name because a cancelled request is often re-thrown
+// wrapped, which keeps the reason in the message but resets the name to plain 'Error'.
+export const isAbortError = (cause) => readStringProperty(cause, 'name') === 'AbortError' ||
+    /AbortError/i.test(readStringProperty(cause, 'message') ?? '');
+// A fetch that never reached the network rejects with a TypeError whose message is the only thing
+// distinguishing it from a programming error, and each engine words it differently.
+const NETWORK_FAILURE_MESSAGE = /Load failed/i;
+export const isNetworkError = (cause) => cause instanceof TypeError && NETWORK_FAILURE_MESSAGE.test(cause.message);

package/error.test.d.ts

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

package/error.test.js

@@ -0,0 +1,72 @@
+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.d.ts

@@ -0,0 +1,12 @@
+import type { FromKebabCase, Serializable, ToCamelCase } from './type-util.ts';
+export type DomainEvent<TYPE extends string = string, PAYLOAD extends Serializable = Serializable> = {
+    type: TYPE;
+    payload: PAYLOAD;
+};
+export type DomainEventOf<PAYLOADS extends Record<string, Serializable>> = {
+    [TYPE in keyof PAYLOADS & string]: DomainEvent<TYPE, PAYLOADS[TYPE]>;
+}[keyof PAYLOADS & string];
+export type EventCreators<PAYLOADS extends Record<string, Serializable>> = {
+    [TYPE in keyof PAYLOADS & string as ToCamelCase<FromKebabCase<TYPE>>]: undefined extends PAYLOADS[TYPE] ? () => DomainEvent<TYPE, PAYLOADS[TYPE]> : (payload: PAYLOADS[TYPE]) => DomainEvent<TYPE, PAYLOADS[TYPE]>;
+};
+export declare const createEventCreators: <PAYLOADS extends Record<string, Serializable>>() => EventCreators<PAYLOADS>;

package/event.js

@@ -0,0 +1,8 @@
+import { camelCase2kebabCase } from './util.js';
+// The cast is unavoidable: a Proxy target cannot be statically typed as the generated shape,
+// and no type-safe construction of a dynamic keyed object exists.
+export const createEventCreators = () => new Proxy({}, {
+    get: (_target, name) => typeof name === 'string'
+        ? (payload) => ({ type: camelCase2kebabCase(name), payload })
+        : undefined,
+});

package/event.test.d.ts

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

package/event.test.js

@@ -0,0 +1,22 @@
+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.d.ts

@@ -8,10 +8,10 @@ type FakeConfig = {
     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];
+    [KEY in keyof FAKE]: KEY extends keyof FAKE_CONFIGS ? FAKE[KEY] extends (...args: never[]) => Observable<unknown> ? ThrowingObservable : FAKE[KEY] extends (...args: never[]) => Promise<unknown> ? ThrowingAsync : FAKE[KEY] extends (...args: never[]) => unknown ? 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>>;
+type ThrowingSync = (...args: unknown[]) => never;
+type ThrowingAsync = (...args: unknown[]) => Promise<never>;
+type ThrowingObservable = (...args: unknown[]) => Observable<never>;
+export declare const addErrorMethodsToFake: <T extends object, ARGS extends unknown[]>(originalFake: (...args: ARGS) => T) => (configs?: FakeConfigs<T>, ...restArgs: ARGS) => FakeWithThrowingMethods<T, typeof configs>;
 export {};

package/fake.js

@@ -3,12 +3,9 @@ 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 merged = { ...fake, ...throwingMethods };
+    // Narrowing to the more specific type: the throwing methods replace the ones they shadow.
+    return merged;
 };
 const THROWING_METOD_GENERATORS = {
     sync: (error) => () => {
@@ -21,9 +18,7 @@ const THROWING_METOD_GENERATORS = {
 };
 const generateThrowingMethods = (configs) => {
     const entries = Object.entries(configs);
-    const throwingMethods = entries.map(([method, { error, type }]) => [
-        method,
-        THROWING_METOD_GENERATORS[type](error),
-    ]);
+    const throwingMethods = entries.map(([method, { error, type }]) => [method, THROWING_METOD_GENERATORS[type](error)]);
+    // The generated values are checked; only their keys cannot be tied back to FAKE at runtime.
     return Object.fromEntries(throwingMethods);
 };

package/fake.test.js

@@ -51,3 +51,11 @@ test('Forwarding constructor paramters', () => {
     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.d.ts

@@ -1,3 +1,4 @@
+import type { DetachableMethods } from './type-util.ts';
 import type { Observable } from 'rxjs';
 import { type NamedCase, type UnnamedCase } from 'rxjs-marbles/cases.js';
 import { type Configuration } from 'rxjs-marbles/configuration.js';
@@ -17,19 +18,19 @@ 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 Runner<ARGS extends unknown[] = []> = (m: MarblesExtensions, ...args: ARGS) => void | Promise<void>;
 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;
+    coldValue: <T = unknown>(marble: string, value: T) => TestObservableLike<T>;
+    coldValueOrUndefined: <T = unknown>(marble: string, value: T) => TestObservableLike<T | undefined>;
+    coldStep: <T = unknown>(value: T, steps?: number) => TestObservableLike<T>;
+    coldStepAndClose: <T = unknown>(value: T, steps?: number) => TestObservableLike<T>;
+    coldError: (error: unknown, steps?: number) => TestObservableLike<never>;
+    coldStepAndError: <T = unknown>(value: T, error: unknown, steps?: number) => TestObservableLike<T>;
+    expect: <T = unknown>(actual: Observable<T>, subscription?: string) => ExtendedExpect<T>;
+} & DetachableMethods<MarblesParam>;
 declare class ExtendedExpect<T> extends Expect<T> {
     readonly actual_: Observable<T>;
     readonly helpers_: ExpectHelpers;
@@ -39,17 +40,20 @@ declare class ExtendedExpect<T> extends Expect<T> {
     toBeObservableValue(value: T): void;
     toBeObservableValue(marble: string, value: T): void;
     toBeObservableValueAndClose(value: T): void;
-    toBeObservableValueAndError(value: T, error: any): void;
+    toBeObservableValueAndError(value: T, error: unknown): 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;
+    toBeObservableError(error: unknown, steps?: number): void;
+    toBeObservableStepAndError(value: T, error: unknown, steps?: number): void;
 }
-export declare const coreMarbles: (runner: Runner) => (() => void);
+export declare const coreMarbles: <ARGS extends unknown[] = []>(runner: Runner<ARGS>) => ((...args: ARGS) => void | Promise<void>);
 export declare const MARBLES_BOOLEAN: {
     t: boolean;
     f: boolean;
 };
-export declare const mtest: (name: string, runner: Runner) => void;
+export declare const mtest: {
+    (name: string, runner: Runner): void;
+    each<T extends unknown[]>(cases: T[]): ((name: string, runner: Runner<T>) => void);
+};
 export {};

package/marbles-vitest.js

@@ -15,7 +15,7 @@ export function configure(configuration) {
     function cases(name, func, cases) {
         describe(name, () => {
             _cases((c) => {
-                const t = c?.only !== undefined ? test.only : c?.skip === undefined ? test.skip : test;
+                const t = c.only === true ? test.only : c.skip === true ? test.skip : test;
                 if (func.length > 2) {
                     t(c.name, marbles((m, second, ...rest) => func(m, c, second, ...rest)));
                 }
@@ -39,8 +39,7 @@ class ExtendedExpect extends Expect {
         this.toBeObservable(marble, MARBLES_BOOLEAN);
     }
     toBeObservableValue(...args) {
-        const value = args.length === 1 ? args[0] : args[1];
-        const marble = args.length === 1 ? 'v' : args[0];
+        const [marble, value] = args.length === 1 ? ['v', args[0]] : args;
         this.toBeObservable(marble, { v: value });
     }
     toBeObservableValueAndClose(value) {
@@ -59,7 +58,7 @@ class ExtendedExpect extends Expect {
     }
     toBeObservableStepAndClose(value, steps = 1) {
         const marble = `-`.repeat(steps) + '(v|)';
-        this.toBeObservable(marble, { v: value });
+        return this.toBeObservable(marble, { v: value });
     }
     toBeObservableError(error, steps = 1) {
         const marble = `-`.repeat(steps) + '#';
@@ -70,54 +69,57 @@ class ExtendedExpect extends Expect {
         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 coreMarbles = (runner) => (...args) => {
+    const runInMarbles = 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);
+    });
+    return runInMarbles();
+};
 export const MARBLES_BOOLEAN = {
     t: true,
     f: false,
@@ -125,3 +127,6 @@ export const MARBLES_BOOLEAN = {
 export const mtest = (name, runner) => {
     test(name, coreMarbles((m) => runner(m)));
 };
+mtest.each = (cases) => {
+    return (name, runner) => test.each(cases)(name, coreMarbles(runner));
+};