@hamak/ui-store-impl 0.2.0 → 0.2.2

package/.turbo/turbo-build.log

@@ -1 +1,2 @@
-$ tsc -p tsconfig.json
+
+$ tsc -p tsconfig.json && tsc -p tsconfig.es2015.json

package/dist/es2015/core/index.js

@@ -0,0 +1,3 @@
+export * from './store-manager';
+export * from './middleware-registry';
+export * from './reducer-registry';

package/dist/es2015/core/middleware-registry.js

@@ -0,0 +1,47 @@
+/**
+ * Middleware Registry Implementation
+ */
+export class MiddlewareRegistry {
+    constructor() {
+        this.registrations = new Map();
+        this.locked = false;
+    }
+    register(registration) {
+        if (this.locked) {
+            throw new Error(`Cannot register middleware "${registration.id}" - store already created. ` +
+                `Register middleware during plugin initialization phase.`);
+        }
+        if (this.registrations.has(registration.id)) {
+            console.warn(`[MiddlewareRegistry] Middleware "${registration.id}" already registered, overwriting.`);
+        }
+        this.registrations.set(registration.id, Object.assign({ priority: 0 }, registration));
+    }
+    unregister(id) {
+        if (this.locked) {
+            throw new Error(`Cannot unregister middleware after store creation`);
+        }
+        this.registrations.delete(id);
+    }
+    getAll() {
+        const sorted = Array.from(this.registrations.values())
+            .sort((a, b) => (b.priority || 0) - (a.priority || 0));
+        return sorted.map(reg => reg.middleware);
+    }
+    has(id) {
+        return this.registrations.has(id);
+    }
+    getInfo(id) {
+        return this.registrations.get(id);
+    }
+    getAllRegistrations() {
+        return Array.from(this.registrations.values())
+            .sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    }
+    /**
+     * Lock the registry (called when store is created)
+     * @internal
+     */
+    lock() {
+        this.locked = true;
+    }
+}

package/dist/es2015/core/reducer-registry.js

@@ -0,0 +1,54 @@
+/**
+ * Reducer Registry Implementation
+ */
+import { combineReducers } from 'redux';
+export class ReducerRegistry {
+    constructor(onReducerChange) {
+        this.reducers = new Map();
+        this.onReducerChange = onReducerChange;
+    }
+    register(key, reducer, replace = false) {
+        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) {
+        this.reducers.delete(key);
+        if (this.onReducerChange) {
+            this.onReducerChange(this.getCombinedReducer());
+        }
+    }
+    getAll() {
+        const map = {};
+        this.reducers.forEach((registration, key) => {
+            map[key] = registration.reducer;
+        });
+        return map;
+    }
+    getCombinedReducer() {
+        const reducerMap = this.getAll();
+        if (Object.keys(reducerMap).length === 0) {
+            return (state = {}) => state;
+        }
+        return combineReducers(reducerMap);
+    }
+    has(key) {
+        return this.reducers.has(key);
+    }
+    getInfo(key) {
+        return this.reducers.get(key);
+    }
+    getAllRegistrations() {
+        return Array.from(this.reducers.values());
+    }
+}

package/dist/es2015/core/store-manager.js

@@ -0,0 +1,91 @@
+/**
+ * Store Manager Implementation
+ */
+import { createStore, applyMiddleware, compose } from 'redux';
+import { MiddlewareRegistry } from './middleware-registry';
+import { ReducerRegistry } from './reducer-registry';
+export class StoreManager {
+    constructor() {
+        this.store = null;
+        this.initialized = false;
+        this.config = null;
+        this.middlewareRegistry = new MiddlewareRegistry();
+        this.reducerRegistry = new ReducerRegistry((rootReducer) => {
+            // Hot replacement callback
+            if (this.store) {
+                this.store.replaceReducer(rootReducer);
+            }
+        });
+    }
+    getMiddlewareRegistry() {
+        return this.middlewareRegistry;
+    }
+    getReducerRegistry() {
+        return this.reducerRegistry;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    initialize(config = {}) {
+        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.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__;
+            if (devToolsExtension) {
+                composeEnhancers = devToolsExtension({
+                    trace: true,
+                    traceLimit: 25,
+                });
+            }
+        }
+        // Create store
+        const enhancer = composeEnhancers(applyMiddleware(...middleware), ...enhancers);
+        this.store = createStore(rootReducer, 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() {
+        if (!this.store) {
+            throw new Error('[StoreManager] Store not initialized. Call initialize() first.');
+        }
+        return this.store;
+    }
+    dispatch(action) {
+        return this.getStore().dispatch(action);
+    }
+    getState() {
+        return this.getStore().getState();
+    }
+    subscribe(listener) {
+        return this.getStore().subscribe(listener);
+    }
+    replaceReducer(nextReducer) {
+        this.getStore().replaceReducer(nextReducer);
+    }
+    destroy() {
+        this.store = null;
+        this.initialized = false;
+        console.log('[StoreManager] Store destroyed');
+    }
+}

package/dist/es2015/index.js

@@ -0,0 +1,7 @@
+/**
+ * UI Store Implementation
+ * Concrete implementations of Redux store management
+ */
+export * from './core';
+export * from './middleware';
+export * from './plugin';

package/dist/es2015/middleware/event-bridge-middleware.js

@@ -0,0 +1,19 @@
+/**
+ * Event Bridge Middleware
+ * Bridges Redux actions to microkernel event bus
+ */
+export function createEventBridgeMiddleware(hooks) {
+    return (store) => (next) => (action) => {
+        // Emit before action
+        hooks === null || hooks === void 0 ? void 0 : hooks.emit('redux:action:before', { action, state: store.getState() });
+        // Execute action
+        const result = next(action);
+        // Emit after action
+        hooks === null || hooks === void 0 ? void 0 : hooks.emit('redux:action:after', { action, state: store.getState() });
+        // Emit specific action type event
+        if (action === null || action === void 0 ? void 0 : action.type) {
+            hooks === null || hooks === void 0 ? void 0 : hooks.emit(`redux:action:${action.type}`, action);
+        }
+        return result;
+    };
+}

package/dist/es2015/middleware/index.js

@@ -0,0 +1,5 @@
+/**
+ * Middleware Export
+ */
+export * from './event-bridge-middleware';
+export * from './logger-middleware';

package/dist/es2015/middleware/logger-middleware.js

@@ -0,0 +1,18 @@
+/**
+ * Logger Middleware
+ * Development logger for Redux actions
+ */
+export function createLoggerMiddleware() {
+    return (store) => (next) => (action) => {
+        if (typeof (action === null || action === void 0 ? void 0 : action.type) === 'string') {
+            console.group(`[Redux] ${action.type}`);
+            console.log('Prev State:', store.getState());
+            console.log('Action:', action);
+            const result = next(action);
+            console.log('Next State:', store.getState());
+            console.groupEnd();
+            return result;
+        }
+        return next(action);
+    };
+}

package/dist/es2015/plugin/index.js

@@ -0,0 +1,4 @@
+/**
+ * Plugin Export
+ */
+export * from './store-plugin-factory';

package/dist/es2015/plugin/store-plugin-factory.js

@@ -0,0 +1,94 @@
+/**
+ * Store Plugin Factory
+ * Creates a microkernel plugin for Redux store management
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { STORE_MANAGER_TOKEN, MIDDLEWARE_REGISTRY_TOKEN, REDUCER_REGISTRY_TOKEN, } from '@hamak/ui-store-api';
+import { StoreManager } from '../core/store-manager';
+import { createEventBridgeMiddleware, createLoggerMiddleware, } from '../middleware';
+export function createStorePlugin(config = {}) {
+    const storeManager = new StoreManager();
+    const middlewareRegistry = storeManager.getMiddlewareRegistry();
+    const reducerRegistry = storeManager.getReducerRegistry();
+    return {
+        initialize(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                // Register services via DI
+                ctx.provide({ provide: STORE_MANAGER_TOKEN, useValue: storeManager });
+                ctx.provide({
+                    provide: MIDDLEWARE_REGISTRY_TOKEN,
+                    useValue: middlewareRegistry,
+                });
+                ctx.provide({
+                    provide: REDUCER_REGISTRY_TOKEN,
+                    useValue: reducerRegistry,
+                });
+                // Register event bridge middleware (high priority)
+                middlewareRegistry.register({
+                    id: 'event-bridge',
+                    middleware: createEventBridgeMiddleware(ctx.hooks),
+                    priority: 1000,
+                    plugin: 'ui-store',
+                    description: 'Bridges Redux actions to microkernel events',
+                });
+                // Register logger middleware in development (low priority - runs last)
+                if (config.logger !== false &&
+                    process.env.NODE_ENV === 'development') {
+                    middlewareRegistry.register({
+                        id: 'logger',
+                        middleware: createLoggerMiddleware(),
+                        priority: -1000,
+                        plugin: 'ui-store',
+                        description: 'Development logger',
+                    });
+                }
+                // Register user-provided middleware
+                (_a = config.middleware) === null || _a === void 0 ? void 0 : _a.forEach((mw) => {
+                    middlewareRegistry.register(Object.assign(Object.assign({}, mw), { plugin: 'ui-store-config' }));
+                });
+                // Register user-provided reducers
+                if (config.reducers) {
+                    console.log('[ui-store] Registering reducers:', Object.keys(config.reducers));
+                    Object.entries(config.reducers).forEach(([key, reducer]) => {
+                        reducerRegistry.register(key, reducer);
+                        console.log('[ui-store] Registered reducer:', key);
+                    });
+                }
+                else {
+                    console.log('[ui-store] No reducers provided in config');
+                }
+                console.log('[ui-store] Plugin initialized');
+            });
+        },
+        activate(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                // Initialize the store after all plugins have registered middleware/reducers
+                const store = storeManager.initialize({
+                    devTools: config.devTools,
+                });
+                // Bridge Redux state changes to microkernel events
+                store.subscribe(() => {
+                    ctx.hooks.emit('redux:state-changed', store.getState());
+                });
+                // Emit ready event
+                ctx.hooks.emit('ui-store:ready', { store });
+                console.log('[ui-store] Plugin activated');
+            });
+        },
+        deactivate() {
+            return __awaiter(this, void 0, void 0, function* () {
+                storeManager.destroy();
+                console.log('[ui-store] Plugin deactivated');
+            });
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamak/ui-store-impl",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "private": false,
   "type": "module",
   "description": "UI Store Implementation - Redux store implementation with middleware",
@@ -16,7 +16,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.es2015.json",
     "clean": "rm -rf dist",
     "test": "vitest run",
     "test:watch": "vitest"
@@ -24,14 +24,20 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js",
+      "legacy": "./dist/es2015/index.js"
+    },
+    "./es2015": {
+      "import": "./dist/es2015/index.js",
+      "default": "./dist/es2015/index.js"
     }
   },
   "dependencies": {
-    "@hamak/ui-store-api": "0.1.0",
-    "@hamak/ui-store-spi": "0.1.0",
-    "@hamak/microkernel-api": "0.1.0",
-    "@hamak/microkernel-spi": "0.1.0",
+    "@hamak/ui-store-api": "0.2.2",
+    "@hamak/ui-store-spi": "0.2.2",
+    "@hamak/microkernel-api": "0.2.2",
+    "@hamak/microkernel-spi": "0.2.2",
     "redux": "^5.0.1",
     "redux-thunk": "^3.1.0"
   },

package/tsconfig.es2015.json

@@ -0,0 +1,24 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "target": "ES2015",
+    "lib": [
+      "ES2015",
+      "DOM"
+    ],
+    "outDir": "./dist/es2015",
+    "declaration": false,
+    "declarationMap": false,
+    "sourceMap": false,
+    "downlevelIteration": true,
+    "composite": false
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts"
+  ]
+}