@sladg/apex-state 3.1.0 → 3.2.1

package/dist/testing/index.d.ts

@@ -0,0 +1,113 @@
+import { D as DeepKey, a as DeepValue, G as GenericMeta, g as ConcernType, y as defaultConcerns, q as StoreConfig, a2 as GenericStoreApi } from '../apply-changes-C2oP5CnU.js';
+export { _, w as applyChangesToObject, z as dot, H as evaluateBoolLogic, I as extractPlaceholders, J as findConcern, M as hashKey, N as interpolateTemplate, Q as is, R as prebuilts, U as registerFlipPair, W as registerListenerLegacy, X as registerSideEffects, Y as registerSyncPairsBatch, Z as useBufferedField, $ as useKeyboardSelect, a0 as useThrottledField, a1 as useTransformedField } from '../apply-changes-C2oP5CnU.js';
+import 'react/jsx-runtime';
+import 'react';
+
+/**
+ * @sladg/apex-state/testing
+ *
+ * Lightweight mock of the main module for consumer tests.
+ * No real pipeline, no WASM, no concerns — just bare-bones
+ * reactive state with call tracking.
+ *
+ * Consumer setup:
+ *   __mocks__/@sladg/apex-state.ts:
+ *     export * from '@sladg/apex-state/testing'
+ *
+ * Then in tests:
+ *   vi.mock('@sladg/apex-state')
+ *   import { __mocked } from '@sladg/apex-state/testing'
+ *
+ *   // Inspect state, calls, effects
+ *   expect(__mocked.state.calls).toHaveLength(1)
+ *   // Programmatically set values
+ *   __mocked.set('user.email', 'hello@example.com')
+ *   // Reset between tests
+ *   __mocked.reset()
+ */
+
+interface MockCall {
+    path: string;
+    value: unknown;
+    meta?: unknown;
+}
+interface MockEffect {
+    id: string;
+    type: 'concerns' | 'sideEffects';
+    registration: unknown;
+}
+declare const __state: {
+    /** Current store state (reactive valtio proxy) */
+    value: Record<string, unknown>;
+    /** Log of all setValue / setChanges calls */
+    calls: MockCall[];
+    /** Log of all useConcerns / useSideEffects registrations */
+    effects: MockEffect[];
+};
+/** Typed chainable returned by `__mocked.set<T>()` — path+value pairs are type-checked */
+interface TypedMock<T extends object> {
+    set: <P extends DeepKey<T>>(path: P, value: DeepValue<T, P>) => TypedMock<T>;
+    state: typeof __state;
+    getState: () => T;
+    flush: () => Promise<void>;
+    reset: () => void;
+}
+/**
+ * Mock control object for test assertions and state manipulation.
+ *
+ * @example
+ * ```ts
+ * import { __mocked } from '@sladg/apex-state/testing'
+ *
+ * beforeEach(() => __mocked.reset())
+ *
+ * // First .set<T>() seeds data and returns typed chainable
+ * __mocked.set<MyState>({ email: '' })
+ *   .set('email', 'a@b.com')   // DeepKey<MyState> — autocomplete + type-checked
+ *   .set('name', 'Alice')
+ *
+ * // Or just establish the type without seeding
+ * __mocked.set<MyState>()
+ *   .set('email', 'a@b.com')
+ *
+ * // Assertions
+ * expect(__mocked.state.calls).toHaveLength(1)
+ * expect(__mocked.getState()).toEqual({ ... })
+ * ```
+ */
+declare const __mocked: {
+    /** Reactive proxy — access .value, .calls, .effects for assertions */
+    state: {
+        /** Current store state (reactive valtio proxy) */
+        value: Record<string, unknown>;
+        /** Log of all setValue / setChanges calls */
+        calls: MockCall[];
+        /** Log of all useConcerns / useSideEffects registrations */
+        effects: MockEffect[];
+    };
+    /**
+     * Seed mock state and return typed chainable.
+     * - `set<T>()` — establish type, no seeding
+     * - `set<T>(data)` — merge data into state, establish type
+     * Subsequent `.set(path, value)` calls are type-safe against T.
+     */
+    set: <T extends object>(data?: Partial<T>) => TypedMock<T>;
+    /** Get an immutable snapshot of the current state */
+    getState: () => {
+        readonly [x: string]: unknown;
+    };
+    /** Flush pending valtio-triggered React renders */
+    flush: () => Promise<void>;
+    /** Reset all mock state between tests */
+    reset: () => void;
+};
+/**
+ * Mock version of createGenericStore.
+ *
+ * Returns the same API shape as the real module but backed by a shared
+ * module-level valtio proxy (__mocked.state). No pipeline, no WASM,
+ * no concerns evaluation — just reactive state with call tracking.
+ */
+declare const createGenericStore: <DATA extends object, META extends GenericMeta = GenericMeta, CONCERNS extends readonly ConcernType<string, any, any>[] = typeof defaultConcerns>(_config?: StoreConfig) => GenericStoreApi<DATA, META, CONCERNS>;
+
+export { __mocked, createGenericStore, defaultConcerns };