@hamak/ui-store-impl 0.2.1 → 0.2.3

package/.turbo/turbo-build.log

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

package/.turbo/turbo-test.log

@@ -0,0 +1,115 @@
+$ vitest run
+
+ RUN  v2.1.9 /Users/amah/Devs/projects/app-framework/packages/ui-store/ui-store-impl
+
+stderr | src/core/middleware-registry.test.ts > MiddlewareRegistry > register > should replace existing middleware with same id
+[MiddlewareRegistry] Middleware "test-middleware" already registered, overwriting.
+
+ ✓ src/core/middleware-registry.test.ts (20 tests) 16ms
+stdout | src/core/store-manager.test.ts > StoreManager > initialization > should initialize store
+[StoreManager] Store initialized with: { reducers: [], middleware: [], devTools: true }
+
+stdout | src/core/store-manager.test.ts > StoreManager > initialization > should throw error when initializing twice
+[StoreManager] Store initialized with: { reducers: [], middleware: [], devTools: true }
+
+stdout | src/core/store-manager.test.ts > StoreManager > initialization > should lock middleware registry after initialization
+[StoreManager] Store initialized with: { reducers: [], middleware: [], devTools: true }
+
+stdout | src/core/store-manager.test.ts > StoreManager > middleware registration > should apply middleware in priority order
+[StoreManager] Store initialized with: {
+  reducers: [],
+  middleware: [
+    { id: 'high', priority: 100, plugin: undefined },
+    { id: 'medium', priority: 50, plugin: undefined },
+    { id: 'low', priority: 10, plugin: undefined }
+  ],
+  devTools: true
+}
+
+stdout | src/core/store-manager.test.ts > StoreManager > reducer registration > should combine multiple reducers
+[StoreManager] Store initialized with: { reducers: [ 'counter', 'name' ], middleware: [], devTools: true }
+
+stdout | src/core/store-manager.test.ts > StoreManager > reducer registration > should support hot reducer replacement
+[StoreManager] Store initialized with: { reducers: [ 'feature' ], middleware: [], devTools: true }
+
+stdout | src/core/store-manager.test.ts > StoreManager > store operations > should dispatch actions
+[StoreManager] Store initialized with: { reducers: [ 'counter' ], middleware: [], devTools: true }
+
+stdout | src/core/store-manager.test.ts > StoreManager > store operations > should get state
+[StoreManager] Store initialized with: { reducers: [ 'data' ], middleware: [], devTools: true }
+
+stdout | src/core/store-manager.test.ts > StoreManager > store operations > should subscribe to changes
+[StoreManager] Store initialized with: { reducers: [ 'counter' ], middleware: [], devTools: true }
+
+stdout | src/core/store-manager.test.ts > StoreManager > store operations > should replace reducer
+[StoreManager] Store initialized with: { reducers: [ 'data' ], middleware: [], devTools: true }
+
+stdout | src/core/store-manager.test.ts > StoreManager > preloaded state > should initialize with preloaded state
+[StoreManager] Store initialized with: { reducers: [ 'counter' ], middleware: [], devTools: true }
+
+stdout | src/core/store-manager.test.ts > StoreManager > destroy > should destroy store
+[StoreManager] Store initialized with: { reducers: [], middleware: [], devTools: true }
+[StoreManager] Store destroyed
+
+stdout | src/core/store-manager.test.ts > StoreManager > destroy > should allow re-initialization after destroy
+[StoreManager] Store initialized with: { reducers: [], middleware: [], devTools: true }
+[StoreManager] Store destroyed
+[StoreManager] Store initialized with: { reducers: [], middleware: [], devTools: true }
+
+stdout | src/core/store-manager.test.ts > StoreManager > DevTools configuration > should accept devTools configuration
+[StoreManager] Store initialized with: { reducers: [], middleware: [], devTools: false }
+
+stdout | src/core/store-manager.test.ts > StoreManager > DevTools configuration > should accept enhancers
+[StoreManager] Store initialized with: { reducers: [], middleware: [], devTools: true }
+
+ ✓ src/core/store-manager.test.ts (19 tests) 229ms
+stderr | src/core/reducer-registry.test.ts > ReducerRegistry > register > should warn when replacing without replace flag
+[ReducerRegistry] Reducer "test" already registered. Use replace=true to override.
+
+ ✓ src/core/reducer-registry.test.ts (19 tests) 130ms
+stdout | src/middleware/logger-middleware.test.ts > createLoggerMiddleware > should log actions with type
+[Redux] INCREMENT
+  Prev State: { count: 0 }
+  Action: { type: 'INCREMENT' }
+  Next State: { count: 1 }
+
+stdout | src/middleware/logger-middleware.test.ts > createLoggerMiddleware > should pass action through middleware chain
+[Redux] TEST
+  Prev State: {}
+  Action: { type: 'TEST' }
+  Next State: {}
+
+stdout | src/middleware/logger-middleware.test.ts > createLoggerMiddleware > should return action result
+[Redux] TEST
+  Prev State: {}
+  Action: { type: 'TEST', payload: 123 }
+  Next State: {}
+
+stdout | src/middleware/logger-middleware.test.ts > createLoggerMiddleware > should log state before and after action
+[Redux] SET_VALUE
+  Prev State: { value: 0 }
+  Action: { type: 'SET_VALUE', payload: 42 }
+  Next State: { value: 42 }
+
+stdout | src/middleware/logger-middleware.test.ts > createLoggerMiddleware > should work with multiple actions
+[Redux] INCREMENT
+  Prev State: { count: 0 }
+  Action: { type: 'INCREMENT' }
+  Next State: { count: 1 }
+[Redux] INCREMENT
+  Prev State: { count: 1 }
+  Action: { type: 'INCREMENT' }
+  Next State: { count: 2 }
+[Redux] DECREMENT
+  Prev State: { count: 2 }
+  Action: { type: 'DECREMENT' }
+  Next State: { count: 1 }
+
+ ✓ src/middleware/logger-middleware.test.ts (8 tests) 160ms
+ ✓ src/middleware/event-bridge-middleware.test.ts (8 tests) 73ms
+
+ Test Files  5 passed (5)
+      Tests  74 passed (74)
+   Start at  21:18:15
+   Duration  3.29s (transform 279ms, setup 0ms, collect 376ms, tests 608ms, environment 1ms, prepare 2.75s)
+

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/extensions/store-extensions.js

@@ -0,0 +1,61 @@
+/**
+ * Store extensions collector
+ */
+/**
+ * Collects middleware and reducer contributions until the store boots
+ */
+export class StoreExtensionsCollector {
+    constructor() {
+        this.entries = [];
+    }
+    register(source, extensions) {
+        var _a;
+        const hasMiddleware = Boolean((_a = extensions.middleware) === null || _a === void 0 ? void 0 : _a.length);
+        const hasReducers = Boolean(extensions.reducers && Object.keys(extensions.reducers).length);
+        if (!hasMiddleware && !hasReducers) {
+            return;
+        }
+        this.entries.push({
+            source,
+            extensions: {
+                middleware: extensions.middleware,
+                reducers: extensions.reducers,
+            },
+        });
+    }
+    /**
+     * Drain collected extensions (used internally by the plugin)
+     */
+    drain() {
+        const snapshot = this.entries;
+        this.entries = [];
+        return snapshot;
+    }
+}
+function withSourceMetadata(middleware, source) {
+    var _a;
+    if (!middleware) {
+        return undefined;
+    }
+    return Object.assign({ plugin: (_a = middleware.plugin) !== null && _a !== void 0 ? _a : source }, middleware);
+}
+export function applyStoreExtensions(collector, middlewareRegistry, reducerRegistry) {
+    const entries = collector.drain();
+    entries.forEach(({ source, extensions }) => {
+        var _a;
+        (_a = extensions.middleware) === null || _a === void 0 ? void 0 : _a.forEach((mw) => {
+            const middleware = withSourceMetadata(mw, source);
+            if (middleware) {
+                middlewareRegistry.register(middleware);
+            }
+        });
+        if (extensions.reducers) {
+            Object.entries(extensions.reducers).forEach(([key, reducer]) => {
+                reducerRegistry.register(key, reducer);
+            });
+        }
+    });
+}
+export function createStoreExtensionsCollector() {
+    return new StoreExtensionsCollector();
+}

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,112 @@
+/**
+ * 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, STORE_EXTENSIONS_TOKEN, } from '@hamak/ui-store-api';
+import { StoreManager } from '../core/store-manager';
+import { createEventBridgeMiddleware, createLoggerMiddleware, } from '../middleware';
+import { applyStoreExtensions, createStoreExtensionsCollector, } from '../extensions/store-extensions';
+export function createStorePlugin(config = {}) {
+    const storeManager = new StoreManager();
+    const middlewareRegistry = storeManager.getMiddlewareRegistry();
+    const reducerRegistry = storeManager.getReducerRegistry();
+    const extensionsCollector = createStoreExtensionsCollector();
+    const registerDefaultMiddleware = (hooks) => {
+        extensionsCollector.register('ui-store:event-bridge', {
+            middleware: [
+                {
+                    id: 'event-bridge',
+                    middleware: createEventBridgeMiddleware(hooks),
+                    priority: 1000,
+                    plugin: 'ui-store',
+                    description: 'Bridges Redux actions to microkernel events',
+                },
+            ],
+        });
+        if (config.logger !== false &&
+            process.env.NODE_ENV === 'development') {
+            extensionsCollector.register('ui-store:logger', {
+                middleware: [
+                    {
+                        id: 'logger',
+                        middleware: createLoggerMiddleware(),
+                        priority: -1000,
+                        plugin: 'ui-store',
+                        description: 'Development logger',
+                    },
+                ],
+            });
+        }
+    };
+    const registerConfigExtensions = () => {
+        var _a;
+        if ((_a = config.middleware) === null || _a === void 0 ? void 0 : _a.length) {
+            const middleware = config.middleware.map((mw) => {
+                var _a;
+                return (Object.assign(Object.assign({}, mw), { plugin: (_a = mw.plugin) !== null && _a !== void 0 ? _a : 'ui-store-config' }));
+            });
+            extensionsCollector.register('ui-store-config:middleware', {
+                middleware,
+            });
+        }
+        if (config.reducers && Object.keys(config.reducers).length) {
+            extensionsCollector.register('ui-store-config:reducers', {
+                reducers: config.reducers,
+            });
+        }
+    };
+    return {
+        initialize(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                // 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,
+                });
+                ctx.provide({
+                    provide: STORE_EXTENSIONS_TOKEN,
+                    useValue: extensionsCollector,
+                });
+                registerDefaultMiddleware(ctx.hooks);
+                registerConfigExtensions();
+                console.log('[ui-store] Plugin initialized');
+            });
+        },
+        activate(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                applyStoreExtensions(extensionsCollector, middlewareRegistry, reducerRegistry);
+                // 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/dist/extensions/store-extensions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Store extensions collector
+ */
+import type { IMiddlewareRegistry, IReducerRegistry, StoreExtensionsRegistry, StorePluginExtensions } from '@hamak/ui-store-api';
+interface StoreExtensionsEntry {
+    source: string;
+    extensions: StorePluginExtensions;
+}
+/**
+ * Collects middleware and reducer contributions until the store boots
+ */
+export declare class StoreExtensionsCollector implements StoreExtensionsRegistry {
+    private entries;
+    register(source: string, extensions: StorePluginExtensions): void;
+    /**
+     * Drain collected extensions (used internally by the plugin)
+     */
+    drain(): StoreExtensionsEntry[];
+}
+export declare function applyStoreExtensions(collector: StoreExtensionsCollector, middlewareRegistry: IMiddlewareRegistry, reducerRegistry: IReducerRegistry): void;
+export declare function createStoreExtensionsCollector(): StoreExtensionsCollector;
+export {};
+//# sourceMappingURL=store-extensions.d.ts.map

package/dist/extensions/store-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-extensions.d.ts","sourceRoot":"","sources":["../../src/extensions/store-extensions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EAChB,uBAAuB,EACvB,qBAAqB,EAEtB,MAAM,qBAAqB,CAAC;AAE7B,UAAU,oBAAoB;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,qBAAqB,CAAC;CACnC;AAED;;GAEG;AACH,qBAAa,wBAAyB,YAAW,uBAAuB;IACtE,OAAO,CAAC,OAAO,CAA8B;IAE7C,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,qBAAqB,GAAG,IAAI;IAiBjE;;OAEG;IACH,KAAK,IAAI,oBAAoB,EAAE;CAKhC;AAgBD,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,wBAAwB,EACnC,kBAAkB,EAAE,mBAAmB,EACvC,eAAe,EAAE,gBAAgB,GAChC,IAAI,CAiBN;AAED,wBAAgB,8BAA8B,IAAI,wBAAwB,CAEzE"}

package/dist/extensions/store-extensions.js

@@ -0,0 +1,61 @@
+/**
+ * Store extensions collector
+ */
+/**
+ * Collects middleware and reducer contributions until the store boots
+ */
+export class StoreExtensionsCollector {
+    constructor() {
+        this.entries = [];
+    }
+    register(source, extensions) {
+        const hasMiddleware = Boolean(extensions.middleware?.length);
+        const hasReducers = Boolean(extensions.reducers && Object.keys(extensions.reducers).length);
+        if (!hasMiddleware && !hasReducers) {
+            return;
+        }
+        this.entries.push({
+            source,
+            extensions: {
+                middleware: extensions.middleware,
+                reducers: extensions.reducers,
+            },
+        });
+    }
+    /**
+     * Drain collected extensions (used internally by the plugin)
+     */
+    drain() {
+        const snapshot = this.entries;
+        this.entries = [];
+        return snapshot;
+    }
+}
+function withSourceMetadata(middleware, source) {
+    if (!middleware) {
+        return undefined;
+    }
+    return {
+        plugin: middleware.plugin ?? source,
+        ...middleware,
+    };
+}
+export function applyStoreExtensions(collector, middlewareRegistry, reducerRegistry) {
+    const entries = collector.drain();
+    entries.forEach(({ source, extensions }) => {
+        extensions.middleware?.forEach((mw) => {
+            const middleware = withSourceMetadata(mw, source);
+            if (middleware) {
+                middlewareRegistry.register(middleware);
+            }
+        });
+        if (extensions.reducers) {
+            Object.entries(extensions.reducers).forEach(([key, reducer]) => {
+                reducerRegistry.register(key, reducer);
+            });
+        }
+    });
+}
+export function createStoreExtensionsCollector() {
+    return new StoreExtensionsCollector();
+}

package/dist/plugin/store-plugin-factory.d.ts

@@ -3,20 +3,12 @@
  * Creates a microkernel plugin for Redux store management
  */
 import type { PluginModule } from '@hamak/microkernel-spi';
-import type { Reducer } from 'redux';
-export interface StorePluginConfig {
+import { type StorePluginExtensions } from '@hamak/ui-store-api';
+export interface StorePluginConfig extends StorePluginExtensions {
     /** Enable Redux DevTools integration */
     devTools?: boolean;
     /** Enable logger middleware in development */
     logger?: boolean;
-    /** Initial middleware to register */
-    middleware?: Array<{
-        id: string;
-        middleware: any;
-        priority?: number;
-    }>;
-    /** Initial reducers to register */
-    reducers?: Record<string, Reducer>;
 }
 export declare function createStorePlugin(config?: StorePluginConfig): PluginModule;
 //# sourceMappingURL=store-plugin-factory.d.ts.map

package/dist/plugin/store-plugin-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-plugin-factory.d.ts","sourceRoot":"","sources":["../../src/plugin/store-plugin-factory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAYrC,MAAM,WAAW,iBAAiB;IAChC,wCAAwC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,8CAA8C;IAC9C,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB,qCAAqC;IACrC,UAAU,CAAC,EAAE,KAAK,CAAC;QACjB,EAAE,EAAE,MAAM,CAAC;QACX,UAAU,EAAE,GAAG,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC,CAAC;IAEH,mCAAmC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,GAAE,iBAAsB,GAC7B,YAAY,CAqFd"}
+{"version":3,"file":"store-plugin-factory.d.ts","sourceRoot":"","sources":["../../src/plugin/store-plugin-factory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAML,KAAK,qBAAqB,EAC3B,MAAM,qBAAqB,CAAC;AAW7B,MAAM,WAAW,iBAAkB,SAAQ,qBAAqB;IAC9D,wCAAwC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,8CAA8C;IAC9C,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,GAAE,iBAAsB,GAC7B,YAAY,CA2Gd"}

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

@@ -2,13 +2,58 @@
  * Store Plugin Factory
  * Creates a microkernel plugin for Redux store management
  */
-import { STORE_MANAGER_TOKEN, MIDDLEWARE_REGISTRY_TOKEN, REDUCER_REGISTRY_TOKEN, } from '@hamak/ui-store-api';
+import { STORE_MANAGER_TOKEN, MIDDLEWARE_REGISTRY_TOKEN, REDUCER_REGISTRY_TOKEN, STORE_EXTENSIONS_TOKEN, } from '@hamak/ui-store-api';
 import { StoreManager } from '../core/store-manager';
 import { createEventBridgeMiddleware, createLoggerMiddleware, } from '../middleware';
+import { applyStoreExtensions, createStoreExtensionsCollector, } from '../extensions/store-extensions';
 export function createStorePlugin(config = {}) {
     const storeManager = new StoreManager();
     const middlewareRegistry = storeManager.getMiddlewareRegistry();
     const reducerRegistry = storeManager.getReducerRegistry();
+    const extensionsCollector = createStoreExtensionsCollector();
+    const registerDefaultMiddleware = (hooks) => {
+        extensionsCollector.register('ui-store:event-bridge', {
+            middleware: [
+                {
+                    id: 'event-bridge',
+                    middleware: createEventBridgeMiddleware(hooks),
+                    priority: 1000,
+                    plugin: 'ui-store',
+                    description: 'Bridges Redux actions to microkernel events',
+                },
+            ],
+        });
+        if (config.logger !== false &&
+            process.env.NODE_ENV === 'development') {
+            extensionsCollector.register('ui-store:logger', {
+                middleware: [
+                    {
+                        id: 'logger',
+                        middleware: createLoggerMiddleware(),
+                        priority: -1000,
+                        plugin: 'ui-store',
+                        description: 'Development logger',
+                    },
+                ],
+            });
+        }
+    };
+    const registerConfigExtensions = () => {
+        if (config.middleware?.length) {
+            const middleware = config.middleware.map((mw) => ({
+                ...mw,
+                plugin: mw.plugin ?? 'ui-store-config',
+            }));
+            extensionsCollector.register('ui-store-config:middleware', {
+                middleware,
+            });
+        }
+        if (config.reducers && Object.keys(config.reducers).length) {
+            extensionsCollector.register('ui-store-config:reducers', {
+                reducers: config.reducers,
+            });
+        }
+    };
     return {
         async initialize(ctx) {
             // Register services via DI
@@ -21,46 +66,16 @@ export function createStorePlugin(config = {}) {
                 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
-            config.middleware?.forEach((mw) => {
-                middlewareRegistry.register({
-                    ...mw,
-                    plugin: 'ui-store-config',
-                });
+            ctx.provide({
+                provide: STORE_EXTENSIONS_TOKEN,
+                useValue: extensionsCollector,
             });
-            // 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');
-            }
+            registerDefaultMiddleware(ctx.hooks);
+            registerConfigExtensions();
             console.log('[ui-store] Plugin initialized');
         },
         async activate(ctx) {
+            applyStoreExtensions(extensionsCollector, middlewareRegistry, reducerRegistry);
             // Initialize the store after all plugins have registered middleware/reducers
             const store = storeManager.initialize({
                 devTools: config.devTools,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamak/ui-store-impl",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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.2.1",
-    "@hamak/ui-store-spi": "0.2.1",
-    "@hamak/microkernel-api": "0.2.1",
-    "@hamak/microkernel-spi": "0.2.1",
+    "@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/src/core/middleware-registry.test.ts

@@ -2,7 +2,7 @@
  * MiddlewareRegistry Tests
  */
 
-import { describe, test, expect, beforeEach } from 'bun:test';
+import { describe, test, expect, beforeEach, vi } from 'vitest';
 import { MiddlewareRegistry } from './middleware-registry';
 import type { Middleware } from 'redux';
 import type { MiddlewareRegistration } from '@hamak/ui-store-api';

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

@@ -2,16 +2,16 @@
  * ReducerRegistry Tests
  */
 
-import { describe, test, expect, beforeEach, mock } from 'bun:test';
+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 mock>;
+  let onReducerChange: ReturnType<typeof vi.fn>;
 
   beforeEach(() => {
-    onReducerChange = mock(() => {});
+    onReducerChange = vi.fn(() => {});
     registry = new ReducerRegistry(onReducerChange);
   });
 

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

@@ -2,7 +2,7 @@
  * StoreManager Tests
  */
 
-import { describe, test, expect, beforeEach, mock } from 'bun:test';
+import { describe, test, expect, beforeEach, vi } from 'vitest';
 import { StoreManager } from './store-manager';
 import type { Middleware, Reducer } from 'redux';
 
@@ -202,7 +202,7 @@ describe('StoreManager', () => {
       manager.getReducerRegistry().register('counter', reducer);
       manager.initialize();
 
-      const listener = mock(() => {});
+      const listener = vi.fn(() => {});
       const unsubscribe = manager.subscribe(listener);
 
       manager.dispatch({ type: 'INCREMENT' });

package/src/extensions/store-extensions.ts

@@ -0,0 +1,90 @@
+/**
+ * Store extensions collector
+ */
+
+import type {
+  IMiddlewareRegistry,
+  IReducerRegistry,
+  StoreExtensionsRegistry,
+  StorePluginExtensions,
+  StoreMiddlewareExtension,
+} from '@hamak/ui-store-api';
+
+interface StoreExtensionsEntry {
+  source: string;
+  extensions: StorePluginExtensions;
+}
+
+/**
+ * Collects middleware and reducer contributions until the store boots
+ */
+export class StoreExtensionsCollector implements StoreExtensionsRegistry {
+  private entries: StoreExtensionsEntry[] = [];
+
+  register(source: string, extensions: StorePluginExtensions): void {
+    const hasMiddleware = Boolean(extensions.middleware?.length);
+    const hasReducers = Boolean(extensions.reducers && Object.keys(extensions.reducers).length);
+
+    if (!hasMiddleware && !hasReducers) {
+      return;
+    }
+
+    this.entries.push({
+      source,
+      extensions: {
+        middleware: extensions.middleware,
+        reducers: extensions.reducers,
+      },
+    });
+  }
+
+  /**
+   * Drain collected extensions (used internally by the plugin)
+   */
+  drain(): StoreExtensionsEntry[] {
+    const snapshot = this.entries;
+    this.entries = [];
+    return snapshot;
+  }
+}
+
+function withSourceMetadata(
+  middleware: StoreMiddlewareExtension | undefined,
+  source: string
+): StoreMiddlewareExtension | undefined {
+  if (!middleware) {
+    return undefined;
+  }
+
+  return {
+    plugin: middleware.plugin ?? source,
+    ...middleware,
+  };
+}
+
+export function applyStoreExtensions(
+  collector: StoreExtensionsCollector,
+  middlewareRegistry: IMiddlewareRegistry,
+  reducerRegistry: IReducerRegistry
+): void {
+  const entries = collector.drain();
+
+  entries.forEach(({ source, extensions }) => {
+    extensions.middleware?.forEach((mw) => {
+      const middleware = withSourceMetadata(mw, source);
+      if (middleware) {
+        middlewareRegistry.register(middleware);
+      }
+    });
+
+    if (extensions.reducers) {
+      Object.entries(extensions.reducers).forEach(([key, reducer]) => {
+        reducerRegistry.register(key, reducer);
+      });
+    }
+  });
+}
+
+export function createStoreExtensionsCollector(): StoreExtensionsCollector {
+  return new StoreExtensionsCollector();
+}

package/src/middleware/event-bridge-middleware.test.ts

@@ -2,13 +2,13 @@
  * Event Bridge Middleware Tests
  */
 
-import { describe, test, expect, mock } from 'bun:test';
+import { describe, test, expect, vi } from 'vitest';
 import { createEventBridgeMiddleware } from './event-bridge-middleware';
 import { createStore, applyMiddleware } from 'redux';
 
 describe('createEventBridgeMiddleware', () => {
   test('should create middleware', () => {
-    const hooks = { emit: mock(() => {}) };
+    const hooks = { emit: vi.fn(() => {}) };
     const middleware = createEventBridgeMiddleware(hooks);
 
     expect(middleware).toBeDefined();
@@ -16,7 +16,7 @@ describe('createEventBridgeMiddleware', () => {
   });
 
   test('should emit before and after action events', () => {
-    const hooks = { emit: mock(() => {}) };
+    const hooks = { emit: vi.fn(() => {}) };
     const middleware = createEventBridgeMiddleware(hooks);
 
     const reducer = (state = {}) => state;
@@ -37,7 +37,7 @@ describe('createEventBridgeMiddleware', () => {
   });
 
   test('should emit specific action type event', () => {
-    const hooks = { emit: mock(() => {}) };
+    const hooks = { emit: vi.fn(() => {}) };
     const middleware = createEventBridgeMiddleware(hooks);
 
     const reducer = (state = {}) => state;
@@ -64,10 +64,10 @@ describe('createEventBridgeMiddleware', () => {
   });
 
   test('should pass action through middleware chain', () => {
-    const hooks = { emit: mock(() => {}) };
+    const hooks = { emit: vi.fn(() => {}) };
     const middleware = createEventBridgeMiddleware(hooks);
 
-    const reducer = mock((state = { count: 0 }, action: any) => {
+    const reducer = vi.fn((state = { count: 0 }, action: any) => {
       if (action.type === 'INCREMENT') {
         return { count: state.count + 1 };
       }
@@ -85,7 +85,7 @@ describe('createEventBridgeMiddleware', () => {
   test('should emit events in correct order', () => {
     const eventOrder: string[] = [];
     const hooks = {
-      emit: mock((event: string) => {
+      emit: vi.fn((event: string) => {
         eventOrder.push(event);
       }),
     };
@@ -104,7 +104,7 @@ describe('createEventBridgeMiddleware', () => {
   });
 
   test('should include state in before/after events', () => {
-    const hooks = { emit: mock(() => {}) };
+    const hooks = { emit: vi.fn(() => {}) };
     const middleware = createEventBridgeMiddleware(hooks);
 
     const reducer = (state = { value: 0 }, action: any) => {

package/src/middleware/logger-middleware.test.ts

@@ -2,7 +2,7 @@
  * Logger Middleware Tests
  */
 
-import { describe, test, expect, mock, spyOn } from 'bun:test';
+import { describe, test, expect, vi } from 'vitest';
 import { createLoggerMiddleware } from './logger-middleware';
 import { createStore, applyMiddleware } from 'redux';
 
@@ -15,9 +15,9 @@ describe('createLoggerMiddleware', () => {
   });
 
   test('should log actions with type', () => {
-    const consoleGroupSpy = spyOn(console, 'group');
-    const consoleLogSpy = spyOn(console, 'log');
-    const consoleGroupEndSpy = spyOn(console, 'groupEnd');
+    const consoleGroupSpy = vi.spyOn(console, 'group');
+    const consoleLogSpy = vi.spyOn(console, 'log');
+    const consoleGroupEndSpy = vi.spyOn(console, 'groupEnd');
 
     const middleware = createLoggerMiddleware();
     const reducer = (state = { count: 0 }, action: any) => {
@@ -42,7 +42,7 @@ describe('createLoggerMiddleware', () => {
   });
 
   test('should not log actions without string type', () => {
-    const consoleGroupSpy = spyOn(console, 'group');
+    const consoleGroupSpy = vi.spyOn(console, 'group');
     const middleware = createLoggerMiddleware();
 
     const reducer = (state = {}) => state;
@@ -56,7 +56,7 @@ describe('createLoggerMiddleware', () => {
 
   test('should pass action through middleware chain', () => {
     const middleware = createLoggerMiddleware();
-    const reducer = mock((state = {}) => state);
+    const reducer = vi.fn((state = {}) => state);
 
     const store = createStore(reducer, applyMiddleware(middleware));
     store.dispatch({ type: 'TEST' });
@@ -81,7 +81,7 @@ describe('createLoggerMiddleware', () => {
   });
 
   test('should log state before and after action', () => {
-    const consoleLogSpy = spyOn(console, 'log');
+    const consoleLogSpy = vi.spyOn(console, 'log');
     const middleware = createLoggerMiddleware();
 
     const reducer = (state = { value: 0 }, action: any) => {
@@ -101,7 +101,7 @@ describe('createLoggerMiddleware', () => {
   });
 
   test('should work with multiple actions', () => {
-    const consoleGroupSpy = spyOn(console, 'group');
+    const consoleGroupSpy = vi.spyOn(console, 'group');
     const middleware = createLoggerMiddleware();
 
     const reducer = (state = { count: 0 }, action: any) => {

package/src/plugin/store-plugin-factory.ts

@@ -4,34 +4,30 @@
  */
 
 import type { PluginModule } from '@hamak/microkernel-spi';
-import type { Reducer } from 'redux';
 import {
   STORE_MANAGER_TOKEN,
   MIDDLEWARE_REGISTRY_TOKEN,
   REDUCER_REGISTRY_TOKEN,
+  STORE_EXTENSIONS_TOKEN,
+  type StoreMiddlewareExtension,
+  type StorePluginExtensions,
 } from '@hamak/ui-store-api';
 import { StoreManager } from '../core/store-manager';
 import {
   createEventBridgeMiddleware,
   createLoggerMiddleware,
 } from '../middleware';
+import {
+  applyStoreExtensions,
+  createStoreExtensionsCollector,
+} from '../extensions/store-extensions';
 
-export interface StorePluginConfig {
+export interface StorePluginConfig extends StorePluginExtensions {
   /** Enable Redux DevTools integration */
   devTools?: boolean;
 
   /** Enable logger middleware in development */
   logger?: boolean;
-
-  /** Initial middleware to register */
-  middleware?: Array<{
-    id: string;
-    middleware: any;
-    priority?: number;
-  }>;
-
-  /** Initial reducers to register */
-  reducers?: Record<string, Reducer>;
 }
 
 export function createStorePlugin(
@@ -40,6 +36,57 @@ export function createStorePlugin(
   const storeManager = new StoreManager();
   const middlewareRegistry = storeManager.getMiddlewareRegistry();
   const reducerRegistry = storeManager.getReducerRegistry();
+  const extensionsCollector = createStoreExtensionsCollector();
+
+  const registerDefaultMiddleware = (hooks: any) => {
+    extensionsCollector.register('ui-store:event-bridge', {
+      middleware: [
+        {
+          id: 'event-bridge',
+          middleware: createEventBridgeMiddleware(hooks),
+          priority: 1000,
+          plugin: 'ui-store',
+          description: 'Bridges Redux actions to microkernel events',
+        },
+      ],
+    });
+
+    if (
+      config.logger !== false &&
+      process.env.NODE_ENV === 'development'
+    ) {
+      extensionsCollector.register('ui-store:logger', {
+        middleware: [
+          {
+            id: 'logger',
+            middleware: createLoggerMiddleware(),
+            priority: -1000,
+            plugin: 'ui-store',
+            description: 'Development logger',
+          },
+        ],
+      });
+    }
+  };
+
+  const registerConfigExtensions = () => {
+    if (config.middleware?.length) {
+      const middleware: StoreMiddlewareExtension[] = config.middleware.map((mw) => ({
+        ...mw,
+        plugin: mw.plugin ?? 'ui-store-config',
+      }));
+
+      extensionsCollector.register('ui-store-config:middleware', {
+        middleware,
+      });
+    }
+
+    if (config.reducers && Object.keys(config.reducers).length) {
+      extensionsCollector.register('ui-store-config:reducers', {
+        reducers: config.reducers,
+      });
+    }
+  };
 
   return {
     async initialize(ctx) {
@@ -53,53 +100,24 @@ export function createStorePlugin(
         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
-      config.middleware?.forEach((mw) => {
-        middlewareRegistry.register({
-          ...mw,
-          plugin: 'ui-store-config',
-        });
+      ctx.provide({
+        provide: STORE_EXTENSIONS_TOKEN,
+        useValue: extensionsCollector,
       });
 
-      // 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');
-      }
+      registerDefaultMiddleware(ctx.hooks);
+      registerConfigExtensions();
 
       console.log('[ui-store] Plugin initialized');
     },
 
     async activate(ctx) {
+      applyStoreExtensions(
+        extensionsCollector,
+        middlewareRegistry,
+        reducerRegistry
+      );
+
       // Initialize the store after all plugins have registered middleware/reducers
       const store = storeManager.initialize({
         devTools: config.devTools,

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"
+  ]
+}