@micro-cms/core 1.0.6 → 1.0.8

package/dist/index.d.mts

@@ -0,0 +1,28 @@
+import { CmsModule } from '@micro-cms/types';
+
+declare class RouteRegistry {
+    private routes;
+    register(moduleName: string, routes: any[]): void;
+    getAllRoutes(): any[];
+}
+declare class App {
+    private modules;
+    private eventBus;
+    private stateManager;
+    private routeRegistry;
+    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;
+        getRoutes: () => any[];
+    };
+    start(): Promise<void>;
+}
+declare function createApp(): App;
+
+export { App, RouteRegistry, createApp };

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 import { CmsModule } from '@micro-cms/types';
-export declare class RouteRegistry {
+
+declare class RouteRegistry {
     private routes;
     register(moduleName: string, routes: any[]): void;
     getAllRoutes(): any[];
 }
-export declare class App {
+declare class App {
     private modules;
     private eventBus;
     private stateManager;
@@ -22,5 +23,6 @@ export declare class App {
     };
     start(): Promise<void>;
 }
-export declare function createApp(): App;
-//# sourceMappingURL=index.d.ts.map
+declare function createApp(): App;
+
+export { App, RouteRegistry, createApp };

package/dist/index.js

@@ -1,129 +1,156 @@
-class EventBus {
-    constructor() {
-        this.listeners = {};
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  App: () => App,
+  RouteRegistry: () => RouteRegistry,
+  createApp: () => createApp
+});
+module.exports = __toCommonJS(index_exports);
+var EventBus = class {
+  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: []
+      };
     }
-    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);
+    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);
+      for (const handler of sequentialHandlers) {
+        await handler.callback(payload);
+      }
+      if (parallelHandlers.length > 0) {
+        await Promise.all(parallelHandlers.map((h) => h.callback(payload)));
+      }
     }
-    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 RouteRegistry {
-    constructor() {
-        this.routes = {};
+  }
+};
+var StateManager = class {
+  constructor() {
+    this.state = {};
+    this.subscribers = {};
+  }
+  publish(key, value) {
+    this.state[key] = value;
+    if (this.subscribers[key]) {
+      this.subscribers[key].forEach((cb) => cb(value));
     }
-    register(moduleName, routes) {
-        this.routes[moduleName] = routes;
-    }
-    getAllRoutes() {
-        return Object.values(this.routes).flat();
-    }
-}
-export class App {
-    constructor() {
-        this.modules = [];
-        this.eventBus = new EventBus();
-        this.stateManager = new StateManager();
-        this.routeRegistry = new RouteRegistry();
-        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],
-            getRoutes: () => this.routeRegistry.getAllRoutes()
-        };
-    }
-    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;
-                        // Special handling for route-provider
-                        if (cap === 'route-provider' && typeof impl.getRoutes === 'function') {
-                            this.routeRegistry.register(mod.manifest.name, impl.getRoutes());
-                        }
-                    },
-                    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.');
+  }
+  get(key) {
+    return this.state[key];
+  }
+  subscribe(key, callback) {
+    if (!this.subscribers[key]) this.subscribers[key] = [];
+    this.subscribers[key].push(callback);
+  }
+};
+var RouteRegistry = class {
+  constructor() {
+    this.routes = {};
+  }
+  register(moduleName, routes) {
+    this.routes[moduleName] = routes;
+  }
+  getAllRoutes() {
+    return Object.values(this.routes).flat();
+  }
+};
+var App = class {
+  constructor() {
+    this.modules = [];
+    this.eventBus = new EventBus();
+    this.stateManager = new StateManager();
+    this.routeRegistry = new RouteRegistry();
+    this.capabilities = {};
+    this.configs = {};
+  }
+  use(module2, config = {}) {
+    this.modules.push(module2);
+    this.configs[module2.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],
+      getRoutes: () => this.routeRegistry.getAllRoutes()
+    };
+  }
+  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;
+            if (cap === "route-provider" && typeof impl.getRoutes === "function") {
+              this.routeRegistry.register(mod.manifest.name, impl.getRoutes());
+            }
+          },
+          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.");
+  }
+};
+function createApp() {
+  return new App();
 }
-export function createApp() {
-    return new App();
-}
-//# sourceMappingURL=index.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  App,
+  RouteRegistry,
+  createApp
+});

package/dist/index.mjs

@@ -0,0 +1,129 @@
+// src/index.ts
+var EventBus = class {
+  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);
+      for (const handler of sequentialHandlers) {
+        await handler.callback(payload);
+      }
+      if (parallelHandlers.length > 0) {
+        await Promise.all(parallelHandlers.map((h) => h.callback(payload)));
+      }
+    }
+  }
+};
+var StateManager = class {
+  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);
+  }
+};
+var RouteRegistry = class {
+  constructor() {
+    this.routes = {};
+  }
+  register(moduleName, routes) {
+    this.routes[moduleName] = routes;
+  }
+  getAllRoutes() {
+    return Object.values(this.routes).flat();
+  }
+};
+var App = class {
+  constructor() {
+    this.modules = [];
+    this.eventBus = new EventBus();
+    this.stateManager = new StateManager();
+    this.routeRegistry = new RouteRegistry();
+    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],
+      getRoutes: () => this.routeRegistry.getAllRoutes()
+    };
+  }
+  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;
+            if (cap === "route-provider" && typeof impl.getRoutes === "function") {
+              this.routeRegistry.register(mod.manifest.name, impl.getRoutes());
+            }
+          },
+          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.");
+  }
+};
+function createApp() {
+  return new App();
+}
+export {
+  App,
+  RouteRegistry,
+  createApp
+};

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@micro-cms/core",
-  "version": "1.0.6",
-  "type": "module",
+  "version": "1.0.8",
   "main": "dist/index.js",
-  "module": "dist/index.js",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "files": [
     "dist"
@@ -11,18 +10,20 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
       "default": "./dist/index.js"
     }
   },
   "dependencies": {
-    "@micro-cms/types": "1.0.6"
+    "@micro-cms/types": "^1.0.8"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsup src/index.ts --format cjs,esm --dts",
     "prepare": "pnpm build"
   },
   "devDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "tsup": "^8.0.2"
   }
 }