@hamak/microkernel-impl 0.2.1 → 0.2.2

package/.turbo/turbo-build.log

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

package/dist/es2015/index.js

@@ -0,0 +1,5 @@
+export * from './runtime/di';
+export * from './runtime/registries';
+export * from './runtime/loader';
+export * from './runtime/host';
+export * from './ui/adapter';

package/dist/es2015/runtime/di.js

@@ -0,0 +1,38 @@
+const INJECT_KEY = Symbol('di:inject');
+export function Injectable(deps = []) { return (t) => { t[INJECT_KEY] = deps; }; }
+export class Container {
+    constructor(parent) {
+        this.providers = new Map();
+        this.instances = new Map();
+        this.parent = parent;
+    }
+    createChild() { return new Container(this); }
+    provide(prov) { this.providers.set(prov.provide, prov); return this; }
+    resolve(token) {
+        var _a, _b;
+        if (this.instances.has(token))
+            return this.instances.get(token);
+        if (this.providers.has(token)) {
+            const prov = this.providers.get(token);
+            let value;
+            if ('useValue' in prov)
+                value = prov.useValue;
+            else if ('useClass' in prov) {
+                const C = prov.useClass;
+                const deps = C[INJECT_KEY] || [];
+                const args = deps.map((d) => this.resolve(d));
+                value = new C(...args);
+            }
+            else {
+                const deps = prov.deps || [];
+                const args = deps.map((d) => this.resolve(d));
+                value = prov.useFactory(...args);
+            }
+            this.instances.set(token, value);
+            return value;
+        }
+        if (this.parent)
+            return this.parent.resolve(token);
+        throw new Error(`No provider for token: ${(_b = (_a = token.toString) === null || _a === void 0 ? void 0 : _a.call(token)) !== null && _b !== void 0 ? _b : String(token)}`);
+    }
+}

package/dist/es2015/runtime/graph-utils.js

@@ -0,0 +1,36 @@
+/**
+ * Dependency graph utilities for topological sorting
+ */
+/**
+ * Performs topological sort on items based on their dependencies
+ * @param items Items to sort (must have name and optional dependsOn properties)
+ * @returns Sorted items in dependency order
+ * @throws Error if circular dependency is detected
+ */
+export function topologicalSort(items) {
+    const index = new Map(items.map(i => [i.name, i]));
+    const visited = new Set();
+    const result = [];
+    const visit = (item, path = new Set()) => {
+        var _a;
+        if (visited.has(item.name))
+            return;
+        // Cycle detection
+        if (path.has(item.name)) {
+            throw new Error(`Circular dependency detected: ${[...path, item.name].join(' -> ')}`);
+        }
+        path.add(item.name);
+        ((_a = item.dependsOn) !== null && _a !== void 0 ? _a : []).forEach(depName => {
+            const dep = index.get(depName);
+            if (!dep) {
+                console.warn(`Dependency not found: ${depName} (required by ${item.name})`);
+                return;
+            }
+            visit(dep, new Set(path));
+        });
+        visited.add(item.name);
+        result.push(item);
+    };
+    items.forEach(item => visit(item));
+    return result;
+}

package/dist/es2015/runtime/host.js

@@ -0,0 +1,163 @@
+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 { Container } from './di';
+import { createCommandRegistry, createHooks, createViewRegistry } from './registries';
+import { PluginRegistry } from './loader';
+function createSharedRegistries() {
+    return {
+        commands: createCommandRegistry(),
+        views: createViewRegistry(),
+        hooks: createHooks(),
+    };
+}
+function createInitContext(container, registries, env) {
+    return {
+        provide: (prov) => container.provide(prov),
+        resolve: (t) => container.resolve(t),
+        commands: {
+            register: (id, h) => registries.commands.register(id, h)
+        },
+        views: {
+            register: (slot, vf) => registries.views.register(slot, vf)
+        },
+        hooks: {
+            on: (ev, fn) => registries.hooks.on(ev, fn),
+            emit: (ev, ...a) => registries.hooks.emit(ev, ...a)
+        },
+        env,
+    };
+}
+function createActivateContext(container, registries, env) {
+    return {
+        resolve: (t) => container.resolve(t),
+        commands: registries.commands,
+        views: registries.views,
+        hooks: registries.hooks,
+        env,
+    };
+}
+export class Host {
+    constructor(initialProviders = [], env) {
+        this.root = new Container();
+        initialProviders.forEach(p => this.root.provide(p));
+        this._registry = new PluginRegistry();
+        this.env = env;
+    }
+    loadPlugins(manifests) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._registry.loadAllAtRoot(manifests);
+        });
+    }
+    /**
+     * Register a plugin programmatically (useful for testing/inline plugins)
+     * @param name Plugin name
+     * @param manifest Plugin manifest
+     * @param module Plugin module implementation
+     */
+    registerPlugin(name, manifest, module) {
+        this._registry.register(name, manifest, module);
+    }
+    /**
+     * Get plugin manifest by name
+     * @param name Plugin name
+     * @returns Plugin manifest or undefined if not found
+     */
+    getPlugin(name) {
+        var _a;
+        return (_a = this._registry.get(name)) === null || _a === void 0 ? void 0 : _a.manifest;
+    }
+    /**
+     * List all loaded plugins
+     * @returns Array of plugin manifests
+     */
+    listPlugins() {
+        return this._registry.list();
+    }
+    bootstrapAllAtRoot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const registries = createSharedRegistries();
+            const initCtx = createInitContext(this.root, registries, this.env);
+            const mods = this._registry.getModulesInOrder('all');
+            // Initialize phase with error handling
+            for (const m of mods) {
+                try {
+                    yield ((_a = m.initialize) === null || _a === void 0 ? void 0 : _a.call(m, initCtx));
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    const initError = new Error(`Plugin initialization failed: ${err.message}`);
+                    initError.cause = error;
+                    throw initError;
+                }
+            }
+            const actCtx = createActivateContext(this.root, registries, this.env);
+            this.rootActivationCtx = actCtx;
+            // Activation phase with error handling
+            for (const m of mods) {
+                try {
+                    yield ((_b = m.activate) === null || _b === void 0 ? void 0 : _b.call(m, actCtx));
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    console.error(`Plugin activation failed:`, err);
+                    // Continue with other plugins rather than failing completely
+                }
+            }
+            actCtx.hooks.emit('host:activated');
+        });
+    }
+    createChildHost(overrides = [], env) {
+        const child = this.root.createChild();
+        overrides.forEach(p => child.provide(p));
+        const childEnv = Object.assign(Object.assign({}, (this.env || {})), (env || {}));
+        return new ChildHost(child, this._registry, childEnv);
+    }
+}
+class ChildHost {
+    constructor(container, registry, env) {
+        this.container = container;
+        this.registry = registry;
+        this.env = env;
+    }
+    bootstrap() {
+        return __awaiter(this, arguments, void 0, function* (pluginNames = 'all') {
+            var _a, _b;
+            const registries = createSharedRegistries();
+            const initCtx = createInitContext(this.container, registries, this.env);
+            const mods = this.registry.getModulesInOrder(pluginNames);
+            // Initialize phase with error handling
+            for (const m of mods) {
+                try {
+                    yield ((_a = m.initialize) === null || _a === void 0 ? void 0 : _a.call(m, initCtx));
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    const initError = new Error(`Plugin initialization failed: ${err.message}`);
+                    initError.cause = error;
+                    throw initError;
+                }
+            }
+            const actCtx = createActivateContext(this.container, registries, this.env);
+            // Activation phase with error handling
+            for (const m of mods) {
+                try {
+                    yield ((_b = m.activate) === null || _b === void 0 ? void 0 : _b.call(m, actCtx));
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    console.error(`Plugin activation failed:`, err);
+                    // Continue with other plugins rather than failing completely
+                }
+            }
+            actCtx.hooks.emit('child:activated');
+        });
+    }
+}

package/dist/es2015/runtime/loader.js

@@ -0,0 +1,70 @@
+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 { topologicalSort } from './graph-utils';
+class PluginRecord {
+    constructor(manifest, module) {
+        this.manifest = manifest;
+        this.module = module;
+    }
+}
+export class PluginRegistry {
+    constructor() {
+        this.byName = new Map();
+    }
+    /**
+     * Get a plugin record by name
+     */
+    get(name) {
+        return this.byName.get(name);
+    }
+    /**
+     * List all loaded plugin manifests
+     */
+    list() {
+        return [...this.byName.values()].map(r => r.manifest);
+    }
+    /**
+     * Register a plugin programmatically (useful for testing/inline plugins)
+     */
+    register(name, manifest, module) {
+        this.byName.set(name, new PluginRecord(manifest, module));
+    }
+    /**
+     * Load plugins from manifest URLs or objects
+     */
+    loadAllAtRoot(manifestInputs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const mfs = [];
+            for (const m of manifestInputs) {
+                if (typeof m === 'string') {
+                    mfs.push(yield fetch(m).then(r => r.json()));
+                }
+                else {
+                    mfs.push(m);
+                }
+            }
+            const sorted = topologicalSort(mfs);
+            for (const m of sorted) {
+                const url = new URL(m.entry, ((_a = m.baseUrl) !== null && _a !== void 0 ? _a : location.origin) + '/').toString();
+                const mod = yield import(/* @vite-ignore */ url);
+                this.byName.set(m.name, new PluginRecord(m, mod));
+            }
+        });
+    }
+    /**
+     * Get plugin modules in dependency order
+     */
+    getModulesInOrder(names = 'all') {
+        const t = names === 'all' ? [...this.byName.keys()] : names;
+        const order = topologicalSort(t.map(n => this.byName.get(n).manifest));
+        return order.map(m => this.byName.get(m.name).module).filter(Boolean);
+    }
+}

package/dist/es2015/runtime/registries.js

@@ -0,0 +1,6 @@
+export function createHooks() { const map = new Map(); return { on(e, f) { if (!map.has(e))
+        map.set(e, new Set()); map.get(e).add(f); }, off(e, f) { var _a; (_a = map.get(e)) === null || _a === void 0 ? void 0 : _a.delete(f); }, emit(e, ...a) { var _a; for (const fn of (_a = map.get(e)) !== null && _a !== void 0 ? _a : [])
+        fn(...a); } }; }
+export function createCommandRegistry() { const h = new Map(); return { register(id, fn) { h.set(id, fn); }, run(id, ...a) { const fn = h.get(id); if (!fn)
+        throw new Error(`Command not found: ${id}`); return fn(...a); }, has(id) { return h.has(id); } }; }
+export function createViewRegistry() { const s = new Map(); return { register(slot, v) { var _a; const arr = (_a = s.get(slot)) !== null && _a !== void 0 ? _a : []; arr.push(v); s.set(slot, arr); }, list(slot) { var _a; return [...((_a = s.get(slot)) !== null && _a !== void 0 ? _a : [])]; } }; }

package/dist/es2015/ui/adapter.js

@@ -0,0 +1 @@
+export const UI = { registerView(ctx, slot, viewFactory) { ctx.views.register(slot, viewFactory); }, getViews(ctx, slot) { return ctx.views.list(slot); } };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamak/microkernel-impl",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "description": "Microkernel Implementation - Core microkernel functionality",
   "main": "dist/index.js",
@@ -15,17 +15,23 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.lib.json",
+    "build": "tsc -p tsconfig.lib.json && tsc -p tsconfig.lib.es2015.json",
     "clean": "rm -rf dist"
   },
   "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/microkernel-api": "0.2.1",
-    "@hamak/microkernel-spi": "0.2.1"
+    "@hamak/microkernel-api": "0.2.2",
+    "@hamak/microkernel-spi": "0.2.2"
   }
 }

package/tsconfig.lib.es2015.json

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