@c-a-f/testing 1.0.1

package/.build/src/vue/waitForPlocState.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Wait for a Ploc to reach a state that matches a predicate. Useful in Vue tests
+ * after triggering an action that updates the Ploc asynchronously.
+ *
+ * @example
+ * ```ts
+ * import { mountWithCAF, createTestPloc, waitForPlocState } from '@c-a-f/testing/vue';
+ *
+ * const ploc = createTestPloc({ loading: true, items: [] });
+ * mountWithCAF(ListComponent, { plocs: { list: ploc } });
+ * ploc.changeState({ loading: false, items: [{ id: '1' }] });
+ * await waitForPlocState(ploc, (state) => !state.loading && state.items.length > 0);
+ * ```
+ */
+import type { Ploc } from '@c-a-f/core';
+/**
+ * Wait until the Ploc's state satisfies the predicate (or timeout).
+ */
+export declare function waitForPlocState<S>(ploc: Ploc<S>, predicate: (state: S) => boolean, timeoutMs?: number): Promise<S>;

package/.build/src/vue/waitForPlocState.js

@@ -0,0 +1,21 @@
+/**
+ * Wait for a Ploc to reach a state that matches a predicate. Useful in Vue tests
+ * after triggering an action that updates the Ploc asynchronously.
+ *
+ * @example
+ * ```ts
+ * import { mountWithCAF, createTestPloc, waitForPlocState } from '@c-a-f/testing/vue';
+ *
+ * const ploc = createTestPloc({ loading: true, items: [] });
+ * mountWithCAF(ListComponent, { plocs: { list: ploc } });
+ * ploc.changeState({ loading: false, items: [{ id: '1' }] });
+ * await waitForPlocState(ploc, (state) => !state.loading && state.items.length > 0);
+ * ```
+ */
+import { waitForStateChange } from '../core/PlocTestHelpers';
+/**
+ * Wait until the Ploc's state satisfies the predicate (or timeout).
+ */
+export function waitForPlocState(ploc, predicate, timeoutMs = 5000) {
+    return waitForStateChange(ploc, predicate, timeoutMs);
+}

package/.build/src/workflow/WorkflowTestHelpers.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Test helpers for Workflow.
+ *
+ * Provides utilities for testing WorkflowManager instances.
+ *
+ * @example
+ * ```ts
+ * import { createWorkflowTester, waitForWorkflowState } from '@c-a-f/testing/workflow';
+ * import { WorkflowManager, WorkflowDefinition } from '@c-a-f/workflow';
+ *
+ * const workflow = new WorkflowManager(definition);
+ * const tester = createWorkflowTester(workflow);
+ *
+ * await tester.dispatch('approve');
+ * await waitForWorkflowState(workflow, 'approved');
+ * ```
+ */
+import type { WorkflowManager, WorkflowStateId, WorkflowStateSnapshot } from '@c-a-f/workflow';
+/**
+ * Workflow tester utility.
+ */
+export declare class WorkflowTester {
+    readonly workflow: WorkflowManager;
+    private stateHistory;
+    private listener;
+    constructor(workflow: WorkflowManager);
+    /**
+     * Get the current state snapshot.
+     */
+    getState(): WorkflowStateSnapshot;
+    /**
+     * Get the current state ID.
+     */
+    getCurrentState(): WorkflowStateId;
+    /**
+     * Get the state history.
+     */
+    getStateHistory(): WorkflowStateSnapshot[];
+    /**
+     * Dispatch an event and wait for transition.
+     */
+    dispatch(event: string, payload?: unknown): Promise<boolean>;
+    /**
+     * Check if a transition is available.
+     */
+    canTransition(event: string): boolean;
+    /**
+     * Reset the workflow.
+     */
+    reset(): Promise<void>;
+    /**
+     * Update workflow context.
+     */
+    updateContext(context: Record<string, unknown>): void;
+    /**
+     * Get available transitions from current state.
+     */
+    getAvailableTransitions(): Record<string, unknown>;
+    /**
+     * Cleanup: unsubscribe from state changes.
+     */
+    cleanup(): void;
+}
+/**
+ * Create a Workflow tester instance.
+ */
+export declare function createWorkflowTester(workflow: WorkflowManager): WorkflowTester;
+/**
+ * Wait for workflow to reach a specific state.
+ */
+export declare function waitForWorkflowState(workflow: WorkflowManager, targetState: WorkflowStateId, timeout?: number): Promise<WorkflowStateSnapshot>;
+/**
+ * Wait for workflow to reach a final state.
+ */
+export declare function waitForFinalState(workflow: WorkflowManager, timeout?: number): Promise<WorkflowStateSnapshot>;

package/.build/src/workflow/WorkflowTestHelpers.js

@@ -0,0 +1,146 @@
+/**
+ * Test helpers for Workflow.
+ *
+ * Provides utilities for testing WorkflowManager instances.
+ *
+ * @example
+ * ```ts
+ * import { createWorkflowTester, waitForWorkflowState } from '@c-a-f/testing/workflow';
+ * import { WorkflowManager, WorkflowDefinition } from '@c-a-f/workflow';
+ *
+ * const workflow = new WorkflowManager(definition);
+ * const tester = createWorkflowTester(workflow);
+ *
+ * await tester.dispatch('approve');
+ * await waitForWorkflowState(workflow, 'approved');
+ * ```
+ */
+/**
+ * Workflow tester utility.
+ */
+export class WorkflowTester {
+    workflow;
+    stateHistory = [];
+    listener = null;
+    constructor(workflow) {
+        this.workflow = workflow;
+        this.stateHistory.push(workflow.getState());
+        this.listener = (snapshot) => {
+            this.stateHistory.push(snapshot);
+        };
+        workflow.subscribe(this.listener);
+    }
+    /**
+     * Get the current state snapshot.
+     */
+    getState() {
+        return this.workflow.getState();
+    }
+    /**
+     * Get the current state ID.
+     */
+    getCurrentState() {
+        return this.workflow.getState().currentState;
+    }
+    /**
+     * Get the state history.
+     */
+    getStateHistory() {
+        return [...this.stateHistory];
+    }
+    /**
+     * Dispatch an event and wait for transition.
+     */
+    async dispatch(event, payload) {
+        return await this.workflow.dispatch(event, payload);
+    }
+    /**
+     * Check if a transition is available.
+     */
+    canTransition(event) {
+        return this.workflow.canTransition(event);
+    }
+    /**
+     * Reset the workflow.
+     */
+    async reset() {
+        await this.workflow.reset();
+    }
+    /**
+     * Update workflow context.
+     */
+    updateContext(context) {
+        this.workflow.updateContext(context);
+    }
+    /**
+     * Get available transitions from current state.
+     */
+    getAvailableTransitions() {
+        return this.workflow.getAvailableTransitions();
+    }
+    /**
+     * Cleanup: unsubscribe from state changes.
+     */
+    cleanup() {
+        if (this.listener) {
+            this.workflow.unsubscribe(this.listener);
+            this.listener = null;
+        }
+    }
+}
+/**
+ * Create a Workflow tester instance.
+ */
+export function createWorkflowTester(workflow) {
+    return new WorkflowTester(workflow);
+}
+/**
+ * Wait for workflow to reach a specific state.
+ */
+export function waitForWorkflowState(workflow, targetState, timeout = 5000) {
+    return new Promise((resolve, reject) => {
+        // Check current state first
+        const currentState = workflow.getState();
+        if (currentState.currentState === targetState) {
+            resolve(currentState);
+            return;
+        }
+        const listener = (snapshot) => {
+            if (snapshot.currentState === targetState) {
+                clearTimeout(timer);
+                workflow.unsubscribe(listener);
+                resolve(snapshot);
+            }
+        };
+        const timer = setTimeout(() => {
+            workflow.unsubscribe(listener);
+            reject(new Error(`Timeout waiting for workflow state '${targetState}' (${timeout}ms)`));
+        }, timeout);
+        workflow.subscribe(listener);
+    });
+}
+/**
+ * Wait for workflow to reach a final state.
+ */
+export function waitForFinalState(workflow, timeout = 5000) {
+    return new Promise((resolve, reject) => {
+        // Check current state first
+        const currentState = workflow.getState();
+        if (currentState.isFinal) {
+            resolve(currentState);
+            return;
+        }
+        const listener = (snapshot) => {
+            if (snapshot.isFinal) {
+                clearTimeout(timer);
+                workflow.unsubscribe(listener);
+                resolve(snapshot);
+            }
+        };
+        const timer = setTimeout(() => {
+            workflow.unsubscribe(listener);
+            reject(new Error(`Timeout waiting for final state (${timeout}ms)`));
+        }, timeout);
+        workflow.subscribe(listener);
+    });
+}

package/.build/src/workflow/index.d.ts

@@ -0,0 +1 @@
+export * from './WorkflowTestHelpers';

package/.build/src/workflow/index.js

@@ -0,0 +1 @@
+export * from './WorkflowTestHelpers';

package/.build/vitest.config.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    test: {
+        environment: string;
+        include: string[];
+    };
+};
+export default _default;

package/.build/vitest.config.js

@@ -0,0 +1,6 @@
+export default {
+    test: {
+        environment: 'happy-dom',
+        include: ['**/*.spec.ts', '**/*.spec.tsx'],
+    },
+};