@hamak/ui-store-impl 0.4.6 → 0.4.16

package/src/core/reducer-registry.test.ts

@@ -1,215 +0,0 @@
-/**
- * ReducerRegistry Tests
- */
-
-import { describe, test, expect, beforeEach, vi } from 'vitest';
-import { ReducerRegistry } from './reducer-registry';
-import type { Reducer } from 'redux';
-
-describe('ReducerRegistry', () => {
-  let registry: ReducerRegistry;
-  let onReducerChange: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    onReducerChange = vi.fn(() => {});
-    registry = new ReducerRegistry(onReducerChange);
-  });
-
-  describe('register', () => {
-    test('should register a reducer', () => {
-      const reducer: Reducer = (state = {}) => state;
-
-      registry.register('test', reducer);
-
-      expect(registry.has('test')).toBe(true);
-    });
-
-    test('should call onReducerChange when reducer is registered', () => {
-      const reducer: Reducer = (state = {}) => state;
-
-      registry.register('test', reducer);
-
-      expect(onReducerChange).toHaveBeenCalled();
-    });
-
-    test('should replace existing reducer when replace flag is true', () => {
-      const reducer1: Reducer = (state = { value: 1 }) => state;
-      const reducer2: Reducer = (state = { value: 2 }) => state;
-
-      registry.register('test', reducer1);
-      registry.register('test', reducer2, true);
-
-      expect(registry.has('test')).toBe(true);
-      expect(onReducerChange).toHaveBeenCalledTimes(2);
-    });
-
-    test('should warn when replacing without replace flag', () => {
-      const reducer1: Reducer = (state = {}) => state;
-      const reducer2: Reducer = (state = {}) => state;
-
-      registry.register('test', reducer1);
-
-      // Should not replace - just warn
-      registry.register('test', reducer2, false);
-
-      // Reducer should still be the first one
-      const info = registry.getInfo('test');
-      expect(info?.reducer).toBe(reducer1);
-    });
-
-    test('should not call onReducerChange when no callback provided', () => {
-      const registryWithoutCallback = new ReducerRegistry();
-      const reducer: Reducer = (state = {}) => state;
-
-      expect(() => registryWithoutCallback.register('test', reducer)).not.toThrow();
-    });
-  });
-
-  describe('unregister', () => {
-    test('should unregister a reducer', () => {
-      const reducer: Reducer = (state = {}) => state;
-      registry.register('test', reducer);
-
-      registry.unregister('test');
-
-      expect(registry.has('test')).toBe(false);
-    });
-
-    test('should call onReducerChange when reducer is unregistered', () => {
-      const reducer: Reducer = (state = {}) => state;
-      registry.register('test', reducer);
-      onReducerChange.mockClear();
-
-      registry.unregister('test');
-
-      expect(onReducerChange).toHaveBeenCalled();
-    });
-
-    test('should not throw when unregistering non-existent reducer', () => {
-      expect(() => registry.unregister('non-existent')).not.toThrow();
-    });
-  });
-
-  describe('has', () => {
-    test('should return false for non-existent reducer', () => {
-      expect(registry.has('non-existent')).toBe(false);
-    });
-
-    test('should return true for registered reducer', () => {
-      const reducer: Reducer = (state = {}) => state;
-      registry.register('test', reducer);
-
-      expect(registry.has('test')).toBe(true);
-    });
-  });
-
-  describe('getInfo', () => {
-    test('should return undefined for non-existent reducer', () => {
-      expect(registry.getInfo('non-existent')).toBeUndefined();
-    });
-
-    test('should return registration info for existing key', () => {
-      const reducer: Reducer = (state = {}) => state;
-      registry.register('test', reducer);
-
-      const info = registry.getInfo('test');
-      expect(info?.reducer).toBe(reducer);
-      expect(info?.key).toBe('test');
-      expect(info?.registeredAt).toBeInstanceOf(Date);
-    });
-  });
-
-  describe('getAll', () => {
-    test('should return empty object when no reducers registered', () => {
-      expect(registry.getAll()).toEqual({});
-    });
-
-    test('should return all reducers as an object', () => {
-      const reducer1: Reducer = (state = {}) => state;
-      const reducer2: Reducer = (state = {}) => state;
-
-      registry.register('first', reducer1);
-      registry.register('second', reducer2);
-
-      const all = registry.getAll();
-
-      expect(all).toEqual({
-        first: reducer1,
-        second: reducer2,
-      });
-    });
-  });
-
-  describe('getAllRegistrations', () => {
-    test('should return empty array when no reducers registered', () => {
-      expect(registry.getAllRegistrations()).toEqual([]);
-    });
-
-    test('should return all registrations with metadata', () => {
-      const reducer1: Reducer = (state = {}) => state;
-      const reducer2: Reducer = (state = {}) => state;
-
-      registry.register('first', reducer1);
-      registry.register('second', reducer2);
-
-      const registrations = registry.getAllRegistrations();
-
-      expect(registrations.length).toBe(2);
-      expect(registrations[0]).toHaveProperty('key');
-      expect(registrations[0]).toHaveProperty('reducer');
-      expect(registrations[0]).toHaveProperty('registeredAt');
-      expect(registrations[0].registeredAt).toBeInstanceOf(Date);
-    });
-  });
-
-  describe('getCombinedReducer', () => {
-    test('should return identity reducer when no reducers registered', () => {
-      const combined = registry.getCombinedReducer();
-      const state = { test: 'value' };
-
-      expect(combined(state, { type: 'TEST' })).toEqual(state);
-    });
-
-    test('should combine multiple reducers', () => {
-      const counterReducer: Reducer = (state = 0, action: any) => {
-        if (action.type === 'INCREMENT') return state + 1;
-        return state;
-      };
-
-      const nameReducer: Reducer = (state = '', action: any) => {
-        if (action.type === 'SET_NAME') return action.payload;
-        return state;
-      };
-
-      registry.register('counter', counterReducer);
-      registry.register('name', nameReducer);
-
-      const combined = registry.getCombinedReducer();
-      let state = combined(undefined, { type: '@@INIT' });
-
-      expect(state).toEqual({ counter: 0, name: '' });
-
-      state = combined(state, { type: 'INCREMENT' });
-      expect(state).toEqual({ counter: 1, name: '' });
-
-      state = combined(state, { type: 'SET_NAME', payload: 'Test' });
-      expect(state).toEqual({ counter: 1, name: 'Test' });
-    });
-
-    test('should update combined reducer when new reducer is registered', () => {
-      const reducer1: Reducer = (state = 1) => state;
-      registry.register('first', reducer1);
-
-      const combined1 = registry.getCombinedReducer();
-      const state1 = combined1(undefined, { type: '@@INIT' });
-      expect(state1).toEqual({ first: 1 });
-
-      const reducer2: Reducer = (state = 2) => state;
-      registry.register('second', reducer2);
-
-      const combined2 = registry.getCombinedReducer();
-      const state2 = combined2(undefined, { type: '@@INIT' });
-      expect(state2).toEqual({ first: 1, second: 2 });
-    });
-  });
-});

package/src/core/reducer-registry.ts

@@ -1,71 +0,0 @@
-/**
- * Reducer Registry Implementation
- */
-
-import { combineReducers, type Reducer } from 'redux';
-import type { IReducerRegistry, ReducerMap, ReducerRegistration } from '@hamak/ui-store-api';
-
-export class ReducerRegistry implements IReducerRegistry {
-  private reducers = new Map<string, ReducerRegistration>();
-  private onReducerChange?: (rootReducer: Reducer) => void;
-
-  constructor(onReducerChange?: (rootReducer: Reducer) => void) {
-    this.onReducerChange = onReducerChange;
-  }
-
-  register(key: string, reducer: Reducer, replace = false): void {
-    if (!replace && this.reducers.has(key)) {
-      console.warn(`[ReducerRegistry] Reducer "${key}" already registered. Use replace=true to override.`);
-      return;
-    }
-
-    this.reducers.set(key, {
-      key,
-      reducer,
-      registeredAt: new Date(),
-    });
-
-    // Notify about reducer change for hot replacement
-    if (this.onReducerChange) {
-      this.onReducerChange(this.getCombinedReducer());
-    }
-  }
-
-  unregister(key: string): void {
-    this.reducers.delete(key);
-
-    if (this.onReducerChange) {
-      this.onReducerChange(this.getCombinedReducer());
-    }
-  }
-
-  getAll(): ReducerMap {
-    const map: ReducerMap = {};
-    this.reducers.forEach((registration, key) => {
-      map[key] = registration.reducer;
-    });
-    return map;
-  }
-
-  getCombinedReducer(): Reducer {
-    const reducerMap = this.getAll();
-
-    if (Object.keys(reducerMap).length === 0) {
-      return (state = {}) => state;
-    }
-
-    return combineReducers(reducerMap);
-  }
-
-  has(key: string): boolean {
-    return this.reducers.has(key);
-  }
-
-  getInfo(key: string): ReducerRegistration | undefined {
-    return this.reducers.get(key);
-  }
-
-  getAllRegistrations(): ReducerRegistration[] {
-    return Array.from(this.reducers.values());
-  }
-}

package/src/core/store-manager.test.ts

@@ -1,288 +0,0 @@
-/**
- * StoreManager Tests
- */
-
-import { describe, test, expect, beforeEach, vi } from 'vitest';
-import { StoreManager } from './store-manager';
-import type { Middleware, Reducer } from 'redux';
-
-describe('StoreManager', () => {
-  let manager: StoreManager;
-
-  beforeEach(() => {
-    manager = new StoreManager();
-  });
-
-  describe('initialization', () => {
-    test('should not be initialized by default', () => {
-      expect(manager.isInitialized()).toBe(false);
-    });
-
-    test('should throw error when getting store before initialization', () => {
-      expect(() => manager.getStore()).toThrow(
-        /Store not initialized/
-      );
-    });
-
-    test('should initialize store', () => {
-      const store = manager.initialize();
-
-      expect(manager.isInitialized()).toBe(true);
-      expect(store).toBeDefined();
-      expect(store.getState).toBeDefined();
-      expect(store.dispatch).toBeDefined();
-    });
-
-    test('should throw error when initializing twice', () => {
-      manager.initialize();
-
-      expect(() => manager.initialize()).toThrow(
-        /Store already initialized/
-      );
-    });
-
-    test('should lock middleware registry after initialization', () => {
-      const middleware: Middleware = () => (next) => (action) => next(action);
-
-      manager.initialize();
-
-      expect(() =>
-        manager.getMiddlewareRegistry().register({
-          id: 'test',
-          middleware,
-        })
-      ).toThrow(/store already created/);
-    });
-  });
-
-  describe('middleware registration', () => {
-    test('should register middleware before initialization', () => {
-      const middleware: Middleware = () => (next) => (action) => next(action);
-
-      manager.getMiddlewareRegistry().register({
-        id: 'test',
-        middleware,
-        priority: 100,
-      });
-
-      expect(manager.getMiddlewareRegistry().has('test')).toBe(true);
-    });
-
-    test('should apply middleware in priority order', () => {
-      const callOrder: string[] = [];
-
-      const middleware1: Middleware = () => (next) => (action: any) => {
-        callOrder.push('middleware1');
-        return next(action);
-      };
-
-      const middleware2: Middleware = () => (next) => (action: any) => {
-        callOrder.push('middleware2');
-        return next(action);
-      };
-
-      const middleware3: Middleware = () => (next) => (action: any) => {
-        callOrder.push('middleware3');
-        return next(action);
-      };
-
-      manager.getMiddlewareRegistry().register({
-        id: 'low',
-        middleware: middleware1,
-        priority: 10,
-      });
-
-      manager.getMiddlewareRegistry().register({
-        id: 'high',
-        middleware: middleware2,
-        priority: 100,
-      });
-
-      manager.getMiddlewareRegistry().register({
-        id: 'medium',
-        middleware: middleware3,
-        priority: 50,
-      });
-
-      const store = manager.initialize();
-      store.dispatch({ type: 'TEST' });
-
-      expect(callOrder).toEqual(['middleware2', 'middleware3', 'middleware1']);
-    });
-  });
-
-  describe('reducer registration', () => {
-    test('should register reducers', () => {
-      const reducer: Reducer = (state = {}) => state;
-
-      manager.getReducerRegistry().register('test', reducer);
-
-      expect(manager.getReducerRegistry().has('test')).toBe(true);
-    });
-
-    test('should combine multiple reducers', () => {
-      const counterReducer: Reducer = (state = 0, action: any) => {
-        if (action.type === 'INCREMENT') return state + 1;
-        return state;
-      };
-
-      const nameReducer: Reducer = (state = 'initial', action: any) => {
-        if (action.type === 'SET_NAME') return action.payload;
-        return state;
-      };
-
-      manager.getReducerRegistry().register('counter', counterReducer);
-      manager.getReducerRegistry().register('name', nameReducer);
-
-      const store = manager.initialize();
-
-      expect(store.getState()).toEqual({ counter: 0, name: 'initial' });
-
-      store.dispatch({ type: 'INCREMENT' });
-      expect(store.getState()).toEqual({ counter: 1, name: 'initial' });
-
-      store.dispatch({ type: 'SET_NAME', payload: 'Updated' });
-      expect(store.getState()).toEqual({ counter: 1, name: 'Updated' });
-    });
-
-    test('should support hot reducer replacement', () => {
-      const reducer1: Reducer = (state = { version: 1 }) => state;
-      manager.getReducerRegistry().register('feature', reducer1);
-
-      const store = manager.initialize();
-      expect(store.getState()).toEqual({ feature: { version: 1 } });
-
-      // Hot replace reducer
-      const reducer2: Reducer = (state = { version: 2 }, action: any) => {
-        // If state is provided from previous reducer, keep it
-        // Only use new initial state if state is undefined
-        if (state === undefined) return { version: 2 };
-        return state;
-      };
-      manager.getReducerRegistry().register('feature', reducer2, true);
-
-      // The state won't automatically reset - hot replacement keeps existing state
-      // unless we dispatch an action that changes it
-      expect(store.getState().feature).toEqual({ version: 1 });
-    });
-  });
-
-  describe('store operations', () => {
-    test('should dispatch actions', () => {
-      const reducer: Reducer = (state = 0, action: any) => {
-        if (action.type === 'INCREMENT') return state + 1;
-        return state;
-      };
-
-      manager.getReducerRegistry().register('counter', reducer);
-      manager.initialize();
-
-      const action = { type: 'INCREMENT' };
-      const result = manager.dispatch(action);
-
-      expect(result).toEqual(action);
-      expect(manager.getState()).toEqual({ counter: 1 });
-    });
-
-    test('should get state', () => {
-      const reducer: Reducer = (state = { test: 'value' }) => state;
-
-      manager.getReducerRegistry().register('data', reducer);
-      manager.initialize();
-
-      expect(manager.getState()).toEqual({ data: { test: 'value' } });
-    });
-
-    test('should subscribe to changes', () => {
-      const reducer: Reducer = (state = 0, action: any) => {
-        if (action.type === 'INCREMENT') return state + 1;
-        return state;
-      };
-
-      manager.getReducerRegistry().register('counter', reducer);
-      manager.initialize();
-
-      const listener = vi.fn(() => {});
-      const unsubscribe = manager.subscribe(listener);
-
-      manager.dispatch({ type: 'INCREMENT' });
-      expect(listener).toHaveBeenCalled();
-
-      listener.mockClear();
-      unsubscribe();
-      manager.dispatch({ type: 'INCREMENT' });
-      expect(listener).not.toHaveBeenCalled();
-    });
-
-    test('should replace reducer', () => {
-      const reducer1: Reducer = (state = { value: 1 }) => state;
-      manager.getReducerRegistry().register('data', reducer1);
-      manager.initialize();
-
-      expect(manager.getState()).toEqual({ data: { value: 1 } });
-
-      // Use combineReducers to create a proper reducer function
-      const { combineReducers } = require('redux');
-      const reducer2: Reducer = (state = { value: 2 }) => state;
-      const combined = combineReducers({ data: reducer2 });
-      manager.replaceReducer(combined);
-
-      // State is preserved unless reducer explicitly changes it
-      // The existing state is passed to the new reducer
-      expect(manager.getState().data.value).toBe(1);
-    });
-  });
-
-  describe('preloaded state', () => {
-    test('should initialize with preloaded state', () => {
-      const reducer: Reducer = (state = 0) => state;
-      manager.getReducerRegistry().register('counter', reducer);
-
-      const preloadedState = { counter: 42 };
-      manager.initialize({ preloadedState });
-
-      expect(manager.getState()).toEqual({ counter: 42 });
-    });
-  });
-
-  describe('destroy', () => {
-    test('should destroy store', () => {
-      manager.initialize();
-      manager.destroy();
-
-      expect(manager.isInitialized()).toBe(false);
-      expect(() => manager.getStore()).toThrow(/Store not initialized/);
-    });
-
-    test('should allow re-initialization after destroy', () => {
-      manager.initialize();
-      manager.destroy();
-
-      // Should be able to initialize again
-      expect(() => manager.initialize()).not.toThrow();
-      expect(manager.isInitialized()).toBe(true);
-    });
-  });
-
-  describe('DevTools configuration', () => {
-    test('should accept devTools configuration', () => {
-      // Should not throw with devTools config
-      expect(() => manager.initialize({ devTools: false })).not.toThrow();
-    });
-
-    test('should accept enhancers', () => {
-      const enhancer = (next: any) => (reducer: any, initialState: any) => {
-        const store = next(reducer, initialState);
-        return {
-          ...store,
-          customMethod: () => 'enhanced',
-        };
-      };
-
-      const store = manager.initialize({ enhancers: [enhancer] }) as any;
-
-      expect(store.customMethod).toBeDefined();
-      expect(store.customMethod()).toBe('enhanced');
-    });
-  });
-});

package/src/core/store-manager.ts

@@ -1,125 +0,0 @@
-/**
- * Store Manager Implementation
- */
-
-import { createStore, applyMiddleware, compose, type Store, type Reducer } from 'redux';
-import type { IStoreManager, StoreConfig, RootState, AppAction } from '@hamak/ui-store-api';
-import { MiddlewareRegistry } from './middleware-registry';
-import { ReducerRegistry } from './reducer-registry';
-
-export class StoreManager implements IStoreManager {
-  private store: Store<RootState, AppAction> | null = null;
-  private middlewareRegistry: MiddlewareRegistry;
-  private reducerRegistry: ReducerRegistry;
-  private initialized = false;
-  private config: StoreConfig | null = null;
-
-  constructor() {
-    this.middlewareRegistry = new MiddlewareRegistry();
-    this.reducerRegistry = new ReducerRegistry((rootReducer: any) => {
-      // Hot replacement callback
-      if (this.store) {
-        this.store.replaceReducer(rootReducer);
-      }
-    });
-  }
-
-  getMiddlewareRegistry() {
-    return this.middlewareRegistry;
-  }
-
-  getReducerRegistry() {
-    return this.reducerRegistry;
-  }
-
-  isInitialized(): boolean {
-    return this.initialized;
-  }
-
-  initialize(config: StoreConfig = {}): Store<RootState, AppAction> {
-    if (this.initialized) {
-      throw new Error('[StoreManager] Store already initialized');
-    }
-
-    this.config = config;
-
-    // Get all middleware in priority order
-    const middleware = this.middlewareRegistry.getAll();
-
-    // Lock the middleware registry
-    this.middlewareRegistry.lock();
-
-    // Get combined reducer
-    const rootReducer = this.reducerRegistry.getCombinedReducer();
-
-    // Create enhancers
-    const enhancers = config.enhancers || [];
-
-    // Setup Redux DevTools
-    let composeEnhancers = compose;
-    if (config.devTools !== false && typeof window !== 'undefined') {
-      const devToolsExtension = (window as any).__REDUX_DEVTOOLS_EXTENSION_COMPOSE__;
-      if (devToolsExtension) {
-        composeEnhancers = devToolsExtension({
-          trace: true,
-          traceLimit: 25,
-        });
-      }
-    }
-
-    // Create store
-    const enhancer = composeEnhancers(
-      applyMiddleware(...middleware),
-      ...enhancers
-    ) as any;
-
-    this.store = createStore(
-      rootReducer as any,
-      config.preloadedState,
-      enhancer
-    );
-
-    this.initialized = true;
-
-    console.log('[StoreManager] Store initialized with:', {
-      reducers: this.reducerRegistry.getAllRegistrations().map(r => r.key),
-      middleware: this.middlewareRegistry.getAllRegistrations().map(m => ({
-        id: m.id,
-        priority: m.priority,
-        plugin: m.plugin,
-      })),
-      devTools: config.devTools !== false,
-    });
-
-    return this.store;
-  }
-
-  getStore(): Store<RootState, AppAction> {
-    if (!this.store) {
-      throw new Error('[StoreManager] Store not initialized. Call initialize() first.');
-    }
-    return this.store;
-  }
-
-  dispatch<A extends AppAction>(action: A): A {
-    return this.getStore().dispatch(action);
-  }
-
-  getState<S = RootState>(): S {
-    return this.getStore().getState() as S;
-  }
-
-  subscribe(listener: () => void): () => void {
-    return this.getStore().subscribe(listener);
-  }
-
-  replaceReducer(nextReducer: Reducer<RootState, AppAction>): void {
-    this.getStore().replaceReducer(nextReducer);
-  }
-
-  destroy(): void {
-    this.store = null;
-    this.initialized = false;
-    console.log('[StoreManager] Store destroyed');
-  }
-}