memorio 4.9.10 → 4.9.31

package/modules/redux.d.ts

@@ -0,0 +1,119 @@
+/**
+ * MEMORIO REDUX ADAPTER TYPES (hand-written, mirrors modules/redux.ts)
+ *
+ * `memorio/redux` is an OPTIONAL integration layer. It does not import `redux`
+ * or React; Redux-like stores are accepted by structural typing, so `redux`
+ * is never a dependency of Memorio (#4, #13).
+ */
+
+import type { MemoryEntry, MemoryType, MemoryScope } from '../types/memory'
+
+export interface MemorioReduxAction {
+  type: unknown
+  [key: string]: unknown
+}
+
+export interface MemorioReduxStoreLike<
+  S = unknown,
+  A extends MemorioReduxAction = MemorioReduxAction
+> {
+  getState(): S
+  subscribe(listener: () => void): () => void
+  dispatch(action: A): unknown
+}
+
+export type MemorioReduxMiddleware<
+  S = unknown,
+  A extends MemorioReduxAction = MemorioReduxAction
+> = (
+  api: { getState: () => S; dispatch: (action: A) => unknown }
+) => (next: (action: A) => any) => (action: A) => any
+
+export interface MemorioMapping<S = any> {
+  selector: (state: S) => unknown
+  type?: MemoryType
+  confidence?: number
+  scope?: MemoryScope
+  ttl?: number | null
+  tags?: string | string[]
+  source?: string
+  ignoreActions?: unknown[]
+}
+
+export interface MemorioReduxOptions<
+  S = any,
+  A extends MemorioReduxAction = MemorioReduxAction
+> {
+  mappings?: Record<string, MemorioMapping<S> | ((state: S) => unknown)>
+  whitelist?: unknown[]
+  blacklist?: unknown[]
+  failSoft?: boolean
+  onError?: (err: unknown, context: 'persist' | 'hydrate') => void
+  debug?: boolean
+}
+
+export interface MemorioMiddlewareHandle<
+  S = unknown,
+  A extends MemorioReduxAction = MemorioReduxAction
+> {
+  middleware: MemorioReduxMiddleware<S, A>
+  cache: Record<string, unknown>
+  setHydrating: (v: boolean) => void
+  flush: () => Promise<void>
+}
+
+export interface MemorioReduxBridge<
+  S = unknown,
+  A extends MemorioReduxAction = MemorioReduxAction
+> {
+  readonly middleware: MemorioReduxMiddleware<S, A>
+  hydrate: (
+    store: MemorioReduxStoreLike<S, A>,
+    opts?: { onHydration?: (values: Record<string, unknown>) => void }
+  ) => Promise<{ values: Record<string, unknown>; ok: boolean }>
+  flush: () => Promise<void>
+  disconnect: () => void
+  readonly cache: Record<string, unknown>
+}
+
+export interface HydrateOptions<S>
+  extends Pick<MemorioReduxOptions<S>, 'failSoft' | 'onError' | 'debug'> {
+  onHydration?: (values: Record<string, unknown>) => void
+}
+
+export interface HydrationResult {
+  values: Record<string, unknown>
+  ok: boolean
+}
+
+export interface HydrateBridge<S> {
+  cache: Record<string, unknown>
+  setHydrating: (v: boolean) => void
+  getState: () => S
+}
+
+export declare function createMemorioMiddleware<
+  S = any,
+  A extends MemorioReduxAction = MemorioReduxAction
+>(opts?: MemorioReduxOptions<S, A>): MemorioMiddlewareHandle<S, A>
+
+export declare function hydrateMemorio<S>(
+  mappings: Record<string, MemorioMapping<S> | ((state: S) => unknown)>,
+  opts?: HydrateOptions<S>,
+  bridge?: HydrateBridge<S>
+): Promise<HydrationResult>
+
+export declare function createMemorioReduxBridge<
+  S = any,
+  A extends MemorioReduxAction = MemorioReduxAction
+>(opts?: MemorioReduxOptions<S, A>): MemorioReduxBridge<S, A>
+
+export declare function normalizeMappings<S>(mappings: MemorioReduxOptions<S>['mappings']): Record<string, MemorioMapping<S>>
+export declare function selectValues<S>(state: S, mappings: Record<string, MemorioMapping<S>>): Record<string, unknown>
+export declare function deepEqual(a: unknown, b: unknown): boolean
+export declare function shouldIgnoreAction(action: MemorioReduxAction, opts: MemorioReduxOptions, mapping?: MemorioMapping): boolean
+export declare function actionType(action: MemorioReduxAction): unknown
+
+export { type MemoryEntry, type MemoryType, type MemoryScope }
+
+export default createMemorioReduxBridge