@micro-cms/core 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { CmsModule } from '@micro-cms/types';
+export declare class App {
+    private modules;
+    private eventBus;
+    private stateManager;
+    private capabilities;
+    private configs;
+    use(module: CmsModule, config?: Record<string, any>): this;
+    get context(): {
+        get: (k: string) => any;
+        subscribe: (k: string, c: Function) => void;
+    };
+    get runtime(): {
+        getCapability: <T = any>(cap: string) => T | undefined;
+    };
+    start(): Promise<void>;
+}
+export declare function createApp(): App;

package/dist/index.js

@@ -0,0 +1,109 @@
+class EventBus {
+    constructor() {
+        this.listeners = {};
+    }
+    subscribe(event, callback, options = {}) {
+        const stage = options.stage || 'default';
+        const priority = options.priority || 0;
+        const parallel = options.parallel || false;
+        if (!this.listeners[event]) {
+            this.listeners[event] = {
+                validation: [],
+                processing: [],
+                notification: [],
+                default: []
+            };
+        }
+        this.listeners[event][stage].push({ callback, priority, parallel });
+        this.listeners[event][stage].sort((a, b) => b.priority - a.priority);
+    }
+    async emit(event, payload) {
+        if (!this.listeners[event])
+            return;
+        const stages = ['validation', 'processing', 'notification', 'default'];
+        for (const stage of stages) {
+            const handlers = this.listeners[event][stage];
+            const parallelHandlers = handlers.filter(h => h.parallel);
+            const sequentialHandlers = handlers.filter(h => !h.parallel);
+            // Run sequential first (or in order of priority)
+            for (const handler of sequentialHandlers) {
+                await handler.callback(payload);
+            }
+            // Run parallel
+            if (parallelHandlers.length > 0) {
+                await Promise.all(parallelHandlers.map(h => h.callback(payload)));
+            }
+        }
+    }
+}
+class StateManager {
+    constructor() {
+        this.state = {};
+        this.subscribers = {};
+    }
+    publish(key, value) {
+        this.state[key] = value;
+        if (this.subscribers[key]) {
+            this.subscribers[key].forEach(cb => cb(value));
+        }
+    }
+    get(key) {
+        return this.state[key];
+    }
+    subscribe(key, callback) {
+        if (!this.subscribers[key])
+            this.subscribers[key] = [];
+        this.subscribers[key].push(callback);
+    }
+}
+export class App {
+    constructor() {
+        this.modules = [];
+        this.eventBus = new EventBus();
+        this.stateManager = new StateManager();
+        this.capabilities = {};
+        this.configs = {};
+    }
+    use(module, config = {}) {
+        this.modules.push(module);
+        this.configs[module.manifest.name] = config;
+        return this;
+    }
+    get context() {
+        return {
+            get: (k) => this.stateManager.get(k),
+            subscribe: (k, c) => this.stateManager.subscribe(k, c)
+        };
+    }
+    get runtime() {
+        return {
+            getCapability: (cap) => this.capabilities[cap]
+        };
+    }
+    async start() {
+        for (const mod of this.modules) {
+            console.log(`Loading module: ${mod.manifest.name} (v${mod.manifest.version})`);
+            const context = {
+                runtime: {
+                    register: (cap, impl) => { this.capabilities[cap] = impl; },
+                    getCapability: (cap) => this.capabilities[cap]
+                },
+                events: {
+                    emit: (e, p) => this.eventBus.emit(e, p),
+                    subscribe: (e, c, o) => this.eventBus.subscribe(e, c, o)
+                },
+                context: {
+                    publish: (k, v) => this.stateManager.publish(k, v),
+                    get: (k) => this.stateManager.get(k),
+                    subscribe: (k, c) => this.stateManager.subscribe(k, c)
+                },
+                config: this.configs[mod.manifest.name] || {}
+            };
+            await mod.load(context);
+        }
+        console.log('App started with all modules loaded.');
+    }
+}
+export function createApp() {
+    return new App();
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@micro-cms/core",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+        "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@micro-cms/types": "workspace:*"
+  },
+  "scripts": {
+  "devDependencies": {},
+    "typescript": "^5.0.0",
+
+    "build": "tsc",
+    "prepare": "pnpm build"
+  }
+}