@webpieces/core-mock 0.4.449

package/README.md

@@ -0,0 +1,30 @@
+# @webpieces/core-mock
+
+Typed mock framework for webpieces feature tests — the TypeScript port of Java
+webpieces' `core-mock` (`MockSuperclass`).
+
+Where Java requires a hand-written mock subclass per api, `createMock<T>()`
+returns a `Proxy` implementing the api with the identical prime/assert
+vocabulary:
+
+```typescript
+const mockRemote = createMock<RemoteApi>('RemoteApi');
+
+// prime
+mockRemote.mock.addValueToReturn('fetchValue', { value: 'primed' });
+mockRemote.mock.addExceptionToThrow('fetchValue', () => new Error('boom'));
+mockRemote.mock.setDefaultReturnValue('fetchValue', { value: 'default' });
+
+// rebind in the test container
+rebind(TYPES.RemoteApi).toConstantValue(mockRemote);
+
+// assert
+const requests = mockRemote.mock.getSingleRequestList<FetchValueRequest>('fetchValue');
+expect(requests[0].name).toBe('two-hop');
+```
+
+Semantics (matching Java `MockSuperclass`):
+- Primed values form a queue per method; each call dequeues one.
+- Empty queue falls back to the default value; no default → throws
+  "test did not add enough return values".
+- `getCalledMethodList`/`getSingleRequestList` DRAIN the recorded calls.

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@webpieces/core-mock",
+    "version": "0.4.449",
+    "description": "Typed mock framework for webpieces feature tests (port of Java core-mock MockSuperclass)",
+    "type": "commonjs",
+    "main": "./src/index.js",
+    "types": "./src/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./src/index.d.ts",
+            "default": "./src/index.js"
+        }
+    },
+    "author": "Dean Hiller",
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/deanhiller/webpieces-ts.git",
+        "directory": "packages/core/core-mock"
+    },
+    "keywords": [
+        "webpieces",
+        "mock",
+        "testing"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {}
+}

package/src/MockHandler.d.ts

@@ -0,0 +1,75 @@
+/**
+ * ParametersPassedIn - The arguments captured from one mock invocation.
+ * Per CLAUDE.md: data-only structure = class.
+ */
+export declare class ParametersPassedIn {
+    readonly args: unknown[];
+    constructor(args: unknown[]);
+}
+/**
+ * ValueToReturn - One primed response: either a value supplier or an error
+ * supplier (port of Java ValueToReturn).
+ */
+export declare class ValueToReturn {
+    private readonly valueSupplier?;
+    private readonly errorSupplier?;
+    constructor(valueSupplier?: (() => unknown) | undefined, errorSupplier?: (() => Error) | undefined);
+    /**
+     * Resolve the primed entry: throws if primed as an exception, else returns.
+     */
+    returnOrThrowValue(): unknown;
+}
+/**
+ * MockHandler - The mock engine (port of Java MockSuperclass), keyed by
+ * method name.
+ *
+ * Semantics identical to Java:
+ * - Primed values form a QUEUE per method; each call dequeues one.
+ * - Empty queue falls back to the method's default value.
+ * - No queue entry and no default -> throws "test did not add enough return values".
+ * - getCalledMethodList/getSingleRequestList DRAIN the recorded calls.
+ *
+ * Usually consumed through createMock<T>() which wraps this in a typed Proxy;
+ * use directly only when hand-writing a mock class.
+ */
+export declare class MockHandler {
+    private returnValues;
+    private defaultReturnValues;
+    private calledMethods;
+    /**
+     * Queue a value to return on the next call to method.
+     */
+    addValueToReturn(method: string, value: unknown): void;
+    /**
+     * Queue a computed value (supplier runs at call time).
+     */
+    addCalculateRetValue(method: string, supplier: () => unknown): void;
+    /**
+     * Queue an exception to throw on the next call to method.
+     */
+    addExceptionToThrow(method: string, errorSupplier: () => Error): void;
+    /**
+     * Fallback value returned when the queue for method is empty.
+     */
+    setDefaultReturnValue(method: string, value: unknown): void;
+    /**
+     * Record a call and resolve its response (queue -> default -> throw).
+     * Called by the createMock proxy for every api-method invocation.
+     */
+    calledMethod(method: string, args: unknown[]): unknown;
+    /**
+     * DRAIN and return all recorded invocations of method (Java parity: the
+     * list resets so a second assertion sees only new calls).
+     */
+    getCalledMethodList(method: string): ParametersPassedIn[];
+    /**
+     * DRAIN and return the FIRST argument of each recorded invocation - the
+     * common single-request-DTO shape.
+     */
+    getSingleRequestList<R>(method: string): R[];
+    /**
+     * Reset all primed values, defaults, and recorded calls.
+     */
+    clear(): void;
+    private queueFor;
+}

package/src/MockHandler.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockHandler = exports.ValueToReturn = exports.ParametersPassedIn = void 0;
+/**
+ * ParametersPassedIn - The arguments captured from one mock invocation.
+ * Per CLAUDE.md: data-only structure = class.
+ */
+class ParametersPassedIn {
+    args;
+    // webpieces-disable no-any-unknown -- mock captures arbitrary api arguments
+    constructor(args) {
+        this.args = args;
+    }
+}
+exports.ParametersPassedIn = ParametersPassedIn;
+/**
+ * ValueToReturn - One primed response: either a value supplier or an error
+ * supplier (port of Java ValueToReturn).
+ */
+class ValueToReturn {
+    valueSupplier;
+    errorSupplier;
+    constructor(
+    // webpieces-disable no-any-unknown -- primed values are api-specific, erased here
+    valueSupplier, errorSupplier) {
+        this.valueSupplier = valueSupplier;
+        this.errorSupplier = errorSupplier;
+    }
+    /**
+     * Resolve the primed entry: throws if primed as an exception, else returns.
+     */
+    // webpieces-disable no-any-unknown -- primed values are api-specific, erased here
+    returnOrThrowValue() {
+        if (this.errorSupplier) {
+            throw this.errorSupplier();
+        }
+        return this.valueSupplier ? this.valueSupplier() : undefined;
+    }
+}
+exports.ValueToReturn = ValueToReturn;
+/**
+ * MockHandler - The mock engine (port of Java MockSuperclass), keyed by
+ * method name.
+ *
+ * Semantics identical to Java:
+ * - Primed values form a QUEUE per method; each call dequeues one.
+ * - Empty queue falls back to the method's default value.
+ * - No queue entry and no default -> throws "test did not add enough return values".
+ * - getCalledMethodList/getSingleRequestList DRAIN the recorded calls.
+ *
+ * Usually consumed through createMock<T>() which wraps this in a typed Proxy;
+ * use directly only when hand-writing a mock class.
+ */
+class MockHandler {
+    returnValues = new Map();
+    defaultReturnValues = new Map();
+    calledMethods = new Map();
+    /**
+     * Queue a value to return on the next call to method.
+     */
+    // webpieces-disable no-any-unknown -- primed values are api-specific, erased here
+    addValueToReturn(method, value) {
+        this.queueFor(method).push(new ValueToReturn(() => value));
+    }
+    /**
+     * Queue a computed value (supplier runs at call time).
+     */
+    // webpieces-disable no-any-unknown -- primed values are api-specific, erased here
+    addCalculateRetValue(method, supplier) {
+        this.queueFor(method).push(new ValueToReturn(supplier));
+    }
+    /**
+     * Queue an exception to throw on the next call to method.
+     */
+    addExceptionToThrow(method, errorSupplier) {
+        this.queueFor(method).push(new ValueToReturn(undefined, errorSupplier));
+    }
+    /**
+     * Fallback value returned when the queue for method is empty.
+     */
+    // webpieces-disable no-any-unknown -- primed values are api-specific, erased here
+    setDefaultReturnValue(method, value) {
+        this.defaultReturnValues.set(method, new ValueToReturn(() => value));
+    }
+    /**
+     * Record a call and resolve its response (queue -> default -> throw).
+     * Called by the createMock proxy for every api-method invocation.
+     */
+    // webpieces-disable no-any-unknown -- mock engine handles type-erased calls; createMock adds typing
+    calledMethod(method, args) {
+        const calls = this.calledMethods.get(method) ?? [];
+        calls.push(new ParametersPassedIn(args));
+        this.calledMethods.set(method, calls);
+        const queue = this.returnValues.get(method);
+        if (queue && queue.length > 0) {
+            const next = queue.shift();
+            return next.returnOrThrowValue();
+        }
+        const defaultValue = this.defaultReturnValues.get(method);
+        if (defaultValue) {
+            return defaultValue.returnOrThrowValue();
+        }
+        throw new Error(`The test did not add enough return values to mocked method '${method}'. ` +
+            `Prime it with addValueToReturn('${method}', ...) or setDefaultReturnValue('${method}', ...).`);
+    }
+    /**
+     * DRAIN and return all recorded invocations of method (Java parity: the
+     * list resets so a second assertion sees only new calls).
+     */
+    getCalledMethodList(method) {
+        const calls = this.calledMethods.get(method) ?? [];
+        this.calledMethods.delete(method);
+        return calls;
+    }
+    /**
+     * DRAIN and return the FIRST argument of each recorded invocation - the
+     * common single-request-DTO shape.
+     */
+    getSingleRequestList(method) {
+        return this.getCalledMethodList(method).map((p) => p.args[0]);
+    }
+    /**
+     * Reset all primed values, defaults, and recorded calls.
+     */
+    clear() {
+        this.returnValues.clear();
+        this.defaultReturnValues.clear();
+        this.calledMethods.clear();
+    }
+    queueFor(method) {
+        const queue = this.returnValues.get(method) ?? [];
+        this.returnValues.set(method, queue);
+        return queue;
+    }
+}
+exports.MockHandler = MockHandler;
+//# sourceMappingURL=MockHandler.js.map

package/src/MockHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockHandler.js","sourceRoot":"","sources":["../../../../../packages/core/core-mock/src/MockHandler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ParametersPassedIn - The arguments captured from one mock invocation.\n * Per CLAUDE.md: data-only structure = class.\n */\nexport class ParametersPassedIn {\n    // webpieces-disable no-any-unknown -- mock captures arbitrary api arguments\n    constructor(public readonly args: unknown[]) {}\n}\n\n/**\n * ValueToReturn - One primed response: either a value supplier or an error\n * supplier (port of Java ValueToReturn).\n */\nexport class ValueToReturn {\n    constructor(\n        // webpieces-disable no-any-unknown -- primed values are api-specific, erased here\n        private readonly valueSupplier?: () => unknown,\n        private readonly errorSupplier?: () => Error,\n    ) {}\n\n    /**\n     * Resolve the primed entry: throws if primed as an exception, else returns.\n     */\n    // webpieces-disable no-any-unknown -- primed values are api-specific, erased here\n    returnOrThrowValue(): unknown {\n        if (this.errorSupplier) {\n            throw this.errorSupplier();\n        }\n        return this.valueSupplier ? this.valueSupplier() : undefined;\n    }\n}\n\n/**\n * MockHandler - The mock engine (port of Java MockSuperclass), keyed by\n * method name.\n *\n * Semantics identical to Java:\n * - Primed values form a QUEUE per method; each call dequeues one.\n * - Empty queue falls back to the method's default value.\n * - No queue entry and no default -> throws \"test did not add enough return values\".\n * - getCalledMethodList/getSingleRequestList DRAIN the recorded calls.\n *\n * Usually consumed through createMock<T>() which wraps this in a typed Proxy;\n * use directly only when hand-writing a mock class.\n */\nexport class MockHandler {\n    private returnValues: Map<string, ValueToReturn[]> = new Map();\n    private defaultReturnValues: Map<string, ValueToReturn> = new Map();\n    private calledMethods: Map<string, ParametersPassedIn[]> = new Map();\n\n    /**\n     * Queue a value to return on the next call to method.\n     */\n    // webpieces-disable no-any-unknown -- primed values are api-specific, erased here\n    addValueToReturn(method: string, value: unknown): void {\n        this.queueFor(method).push(new ValueToReturn(() => value));\n    }\n\n    /**\n     * Queue a computed value (supplier runs at call time).\n     */\n    // webpieces-disable no-any-unknown -- primed values are api-specific, erased here\n    addCalculateRetValue(method: string, supplier: () => unknown): void {\n        this.queueFor(method).push(new ValueToReturn(supplier));\n    }\n\n    /**\n     * Queue an exception to throw on the next call to method.\n     */\n    addExceptionToThrow(method: string, errorSupplier: () => Error): void {\n        this.queueFor(method).push(new ValueToReturn(undefined, errorSupplier));\n    }\n\n    /**\n     * Fallback value returned when the queue for method is empty.\n     */\n    // webpieces-disable no-any-unknown -- primed values are api-specific, erased here\n    setDefaultReturnValue(method: string, value: unknown): void {\n        this.defaultReturnValues.set(method, new ValueToReturn(() => value));\n    }\n\n    /**\n     * Record a call and resolve its response (queue -> default -> throw).\n     * Called by the createMock proxy for every api-method invocation.\n     */\n    // webpieces-disable no-any-unknown -- mock engine handles type-erased calls; createMock adds typing\n    calledMethod(method: string, args: unknown[]): unknown {\n        const calls = this.calledMethods.get(method) ?? [];\n        calls.push(new ParametersPassedIn(args));\n        this.calledMethods.set(method, calls);\n\n        const queue = this.returnValues.get(method);\n        if (queue && queue.length > 0) {\n            const next = queue.shift()!;\n            return next.returnOrThrowValue();\n        }\n\n        const defaultValue = this.defaultReturnValues.get(method);\n        if (defaultValue) {\n            return defaultValue.returnOrThrowValue();\n        }\n\n        throw new Error(\n            `The test did not add enough return values to mocked method '${method}'. ` +\n            `Prime it with addValueToReturn('${method}', ...) or setDefaultReturnValue('${method}', ...).`,\n        );\n    }\n\n    /**\n     * DRAIN and return all recorded invocations of method (Java parity: the\n     * list resets so a second assertion sees only new calls).\n     */\n    getCalledMethodList(method: string): ParametersPassedIn[] {\n        const calls = this.calledMethods.get(method) ?? [];\n        this.calledMethods.delete(method);\n        return calls;\n    }\n\n    /**\n     * DRAIN and return the FIRST argument of each recorded invocation - the\n     * common single-request-DTO shape.\n     */\n    getSingleRequestList<R>(method: string): R[] {\n        return this.getCalledMethodList(method).map((p: ParametersPassedIn) => p.args[0] as R);\n    }\n\n    /**\n     * Reset all primed values, defaults, and recorded calls.\n     */\n    clear(): void {\n        this.returnValues.clear();\n        this.defaultReturnValues.clear();\n        this.calledMethods.clear();\n    }\n\n    private queueFor(method: string): ValueToReturn[] {\n        const queue = this.returnValues.get(method) ?? [];\n        this.returnValues.set(method, queue);\n        return queue;\n    }\n}\n"]}

package/src/createMock.d.ts

@@ -0,0 +1,41 @@
+import { ParametersPassedIn } from './MockHandler';
+/**
+ * TypedMockControls - The typed prime/assert facade exposed on mock.mock.
+ * Method names are constrained to keyof T; primed values to the method's
+ * awaited return type.
+ */
+export interface TypedMockControls<T> {
+    addValueToReturn<K extends keyof T & string>(method: K, value: T[K] extends (...args: never[]) => unknown ? Awaited<ReturnType<T[K]>> : never): void;
+    addCalculateRetValue<K extends keyof T & string>(method: K, supplier: () => unknown): void;
+    addExceptionToThrow<K extends keyof T & string>(method: K, errorSupplier: () => Error): void;
+    setDefaultReturnValue<K extends keyof T & string>(method: K, value: T[K] extends (...args: never[]) => unknown ? Awaited<ReturnType<T[K]>> : never): void;
+    getCalledMethodList<K extends keyof T & string>(method: K): ParametersPassedIn[];
+    getSingleRequestList<R, K extends keyof T & string = keyof T & string>(method: K): R[];
+    clear(): void;
+}
+/**
+ * MockedApi - The mock: implements T (every method resolves via MockHandler)
+ * plus a typed `mock` control facade.
+ */
+export type MockedApi<T> = T & {
+    mock: TypedMockControls<T>;
+};
+/**
+ * createMock - Build a typed mock for an api interface/abstract class.
+ *
+ * Port of Java core-mock, minus the boilerplate: where Java requires a
+ * hand-written `MockRemoteService extends MockSuperclass implements RemoteApi`
+ * per api, a JS Proxy implements every method generically while keeping the
+ * identical prime/assert vocabulary.
+ *
+ * ```typescript
+ * const mockRemote = createMock<RemoteApi>('RemoteApi');
+ * mockRemote.mock.addValueToReturn('fetchValue', { value: 'primed' });
+ * rebind(TYPES.RemoteApi).toConstantValue(mockRemote);
+ * // ... run the test ...
+ * const reqs = mockRemote.mock.getSingleRequestList<FetchValueRequest>('fetchValue');
+ * ```
+ *
+ * Every api method returns a Promise (webpieces apis are async by convention).
+ */
+export declare function createMock<T extends object>(apiName: string): MockedApi<T>;

package/src/createMock.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMock = createMock;
+const MockHandler_1 = require("./MockHandler");
+/**
+ * createMock - Build a typed mock for an api interface/abstract class.
+ *
+ * Port of Java core-mock, minus the boilerplate: where Java requires a
+ * hand-written `MockRemoteService extends MockSuperclass implements RemoteApi`
+ * per api, a JS Proxy implements every method generically while keeping the
+ * identical prime/assert vocabulary.
+ *
+ * ```typescript
+ * const mockRemote = createMock<RemoteApi>('RemoteApi');
+ * mockRemote.mock.addValueToReturn('fetchValue', { value: 'primed' });
+ * rebind(TYPES.RemoteApi).toConstantValue(mockRemote);
+ * // ... run the test ...
+ * const reqs = mockRemote.mock.getSingleRequestList<FetchValueRequest>('fetchValue');
+ * ```
+ *
+ * Every api method returns a Promise (webpieces apis are async by convention).
+ */
+function createMock(apiName) {
+    const handler = new MockHandler_1.MockHandler();
+    // Properties that must NOT become mocked api methods
+    const passthrough = new Set(['mock', 'then', 'catch', 'finally', 'constructor', 'toJSON']);
+    return new Proxy({}, {
+        // webpieces-disable no-any-unknown -- Proxy get trap returns heterogeneous members
+        get(target, prop) {
+            if (typeof prop !== 'string') {
+                return undefined;
+            }
+            if (prop === 'mock') {
+                return handler;
+            }
+            if (passthrough.has(prop)) {
+                return undefined;
+            }
+            // Any other property access is treated as an api method
+            // webpieces-disable no-any-unknown -- api method args/returns are type-erased in the proxy
+            return async (...args) => {
+                return handler.calledMethod(prop, args);
+            };
+        },
+    });
+}
+//# sourceMappingURL=createMock.js.map

package/src/createMock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMock.js","sourceRoot":"","sources":["../../../../../packages/core/core-mock/src/createMock.ts"],"names":[],"mappings":";;AAoDA,gCAyBC;AA7ED,+CAAgE;AAkChE;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,UAAU,CAAmB,OAAe;IACxD,MAAM,OAAO,GAAG,IAAI,yBAAW,EAAE,CAAC;IAElC,qDAAqD;IACrD,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,CAAC,CAAC,CAAC;IAE3F,OAAO,IAAI,KAAK,CAAC,EAAkB,EAAE;QACjC,mFAAmF;QACnF,GAAG,CAAC,MAAoB,EAAE,IAAqB;YAC3C,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC3B,OAAO,SAAS,CAAC;YACrB,CAAC;YACD,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;gBAClB,OAAO,OAAO,CAAC;YACnB,CAAC;YACD,IAAI,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACxB,OAAO,SAAS,CAAC;YACrB,CAAC;YACD,wDAAwD;YACxD,2FAA2F;YAC3F,OAAO,KAAK,EAAE,GAAG,IAAe,EAAoB,EAAE;gBAClD,OAAO,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAC5C,CAAC,CAAC;QACN,CAAC;KACJ,CAAC,CAAC;AACP,CAAC","sourcesContent":["import { MockHandler, ParametersPassedIn } from './MockHandler';\n\n/**\n * TypedMockControls - The typed prime/assert facade exposed on mock.mock.\n * Method names are constrained to keyof T; primed values to the method's\n * awaited return type.\n */\nexport interface TypedMockControls<T> {\n    // webpieces-disable no-any-unknown -- conditional type extracts the method's awaited return type\n    addValueToReturn<K extends keyof T & string>(\n        method: K,\n        // webpieces-disable no-any-unknown -- conditional type extracts the method's awaited return type\n        value: T[K] extends (...args: never[]) => unknown ? Awaited<ReturnType<T[K]>> : never,\n    ): void;\n    // webpieces-disable no-any-unknown -- supplier computes api-specific values at call time\n    addCalculateRetValue<K extends keyof T & string>(method: K, supplier: () => unknown): void;\n    addExceptionToThrow<K extends keyof T & string>(method: K, errorSupplier: () => Error): void;\n    // webpieces-disable no-any-unknown -- conditional type extracts the method's awaited return type\n    setDefaultReturnValue<K extends keyof T & string>(\n        method: K,\n        // webpieces-disable no-any-unknown -- conditional type extracts the method's awaited return type\n        value: T[K] extends (...args: never[]) => unknown ? Awaited<ReturnType<T[K]>> : never,\n    ): void;\n    getCalledMethodList<K extends keyof T & string>(method: K): ParametersPassedIn[];\n    getSingleRequestList<R, K extends keyof T & string = keyof T & string>(method: K): R[];\n    clear(): void;\n}\n\n/**\n * MockedApi - The mock: implements T (every method resolves via MockHandler)\n * plus a typed `mock` control facade.\n */\nexport type MockedApi<T> = T & { mock: TypedMockControls<T> };\n\n/**\n * createMock - Build a typed mock for an api interface/abstract class.\n *\n * Port of Java core-mock, minus the boilerplate: where Java requires a\n * hand-written `MockRemoteService extends MockSuperclass implements RemoteApi`\n * per api, a JS Proxy implements every method generically while keeping the\n * identical prime/assert vocabulary.\n *\n * ```typescript\n * const mockRemote = createMock<RemoteApi>('RemoteApi');\n * mockRemote.mock.addValueToReturn('fetchValue', { value: 'primed' });\n * rebind(TYPES.RemoteApi).toConstantValue(mockRemote);\n * // ... run the test ...\n * const reqs = mockRemote.mock.getSingleRequestList<FetchValueRequest>('fetchValue');\n * ```\n *\n * Every api method returns a Promise (webpieces apis are async by convention).\n */\nexport function createMock<T extends object>(apiName: string): MockedApi<T> {\n    const handler = new MockHandler();\n\n    // Properties that must NOT become mocked api methods\n    const passthrough = new Set(['mock', 'then', 'catch', 'finally', 'constructor', 'toJSON']);\n\n    return new Proxy({} as MockedApi<T>, {\n        // webpieces-disable no-any-unknown -- Proxy get trap returns heterogeneous members\n        get(target: MockedApi<T>, prop: string | symbol): unknown {\n            if (typeof prop !== 'string') {\n                return undefined;\n            }\n            if (prop === 'mock') {\n                return handler;\n            }\n            if (passthrough.has(prop)) {\n                return undefined;\n            }\n            // Any other property access is treated as an api method\n            // webpieces-disable no-any-unknown -- api method args/returns are type-erased in the proxy\n            return async (...args: unknown[]): Promise<unknown> => {\n                return handler.calledMethod(prop, args);\n            };\n        },\n    });\n}\n"]}

package/src/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @webpieces/core-mock
+ *
+ * Typed mock framework for feature tests - the TypeScript port of Java
+ * webpieces core-mock (MockSuperclass).
+ *
+ * - createMock<T>(name): Proxy-based mock implementing T + typed .mock controls
+ * - MockHandler: the queue/default/drain engine, for hand-written mock classes
+ */
+export { createMock, MockedApi, TypedMockControls } from './createMock';
+export { MockHandler, ValueToReturn, ParametersPassedIn } from './MockHandler';

package/src/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParametersPassedIn = exports.ValueToReturn = exports.MockHandler = exports.createMock = void 0;
+/**
+ * @webpieces/core-mock
+ *
+ * Typed mock framework for feature tests - the TypeScript port of Java
+ * webpieces core-mock (MockSuperclass).
+ *
+ * - createMock<T>(name): Proxy-based mock implementing T + typed .mock controls
+ * - MockHandler: the queue/default/drain engine, for hand-written mock classes
+ */
+var createMock_1 = require("./createMock");
+Object.defineProperty(exports, "createMock", { enumerable: true, get: function () { return createMock_1.createMock; } });
+var MockHandler_1 = require("./MockHandler");
+Object.defineProperty(exports, "MockHandler", { enumerable: true, get: function () { return MockHandler_1.MockHandler; } });
+Object.defineProperty(exports, "ValueToReturn", { enumerable: true, get: function () { return MockHandler_1.ValueToReturn; } });
+Object.defineProperty(exports, "ParametersPassedIn", { enumerable: true, get: function () { return MockHandler_1.ParametersPassedIn; } });
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/core/core-mock/src/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;GAQG;AACH,2CAAwE;AAA/D,wGAAA,UAAU,OAAA;AACnB,6CAA+E;AAAtE,0GAAA,WAAW,OAAA;AAAE,4GAAA,aAAa,OAAA;AAAE,iHAAA,kBAAkB,OAAA","sourcesContent":["/**\n * @webpieces/core-mock\n *\n * Typed mock framework for feature tests - the TypeScript port of Java\n * webpieces core-mock (MockSuperclass).\n *\n * - createMock<T>(name): Proxy-based mock implementing T + typed .mock controls\n * - MockHandler: the queue/default/drain engine, for hand-written mock classes\n */\nexport { createMock, MockedApi, TypedMockControls } from './createMock';\nexport { MockHandler, ValueToReturn, ParametersPassedIn } from './MockHandler';\n"]}