@quark-fw/core 0.0.1

package/dist/ee/createEventIterator.d.ts

@@ -0,0 +1,4 @@
+import { EventMap, TypedEventEmitter } from "./types.js";
+export default function createEventIterator<Events extends EventMap, EventName extends keyof Events>(ee: TypedEventEmitter<Events>, eventName: EventName, signal: AbortSignal): {
+    [Symbol.asyncIterator](): AsyncGenerator<Parameters<Events[EventName]>[0], void, unknown>;
+};

package/dist/ee/createEventIterator.js

@@ -0,0 +1,36 @@
+export default function createEventIterator(ee, eventName, signal) {
+    return {
+        async *[Symbol.asyncIterator]() {
+            const queue = [];
+            let resolve;
+            const handler = (data) => {
+                queue.push(data);
+                if (resolve) {
+                    resolve();
+                    resolve = undefined;
+                }
+            };
+            ee.on(eventName, handler);
+            // будим ожидающий цикл, чтобы он увидел signal.aborted и завершился
+            signal.addEventListener("abort", () => {
+                if (resolve) {
+                    resolve();
+                    resolve = undefined;
+                }
+            }, { once: true });
+            try {
+                while (!signal.aborted) {
+                    if (!queue.length) {
+                        await new Promise((r) => (resolve = r));
+                    }
+                    while (queue.length) {
+                        yield queue.shift();
+                    }
+                }
+            }
+            finally {
+                ee.off(eventName, handler);
+            }
+        },
+    };
+}

package/dist/ee/createTypedEventEmitter.d.ts

@@ -0,0 +1,4 @@
+import { EventMapFromArgs, TypedEventEmitter } from "./types.js";
+export declare function createTypedEventEmitter<T extends Record<string, unknown[]>>({ debug, }?: {
+    debug?: boolean;
+}): TypedEventEmitter<EventMapFromArgs<T>>;

package/dist/ee/createTypedEventEmitter.js

@@ -0,0 +1,40 @@
+import { EventEmitter } from "node:events";
+export function createTypedEventEmitter({ debug, } = {
+    debug: false,
+}) {
+    const ee = new EventEmitter();
+    if (!debug)
+        return ee;
+    // Оборачиваем в Proxy для логирования
+    return new Proxy(ee, {
+        get(target, prop, receiver) {
+            const original = Reflect.get(target, prop, receiver);
+            // Логируем emit
+            if (prop === "emit") {
+                return (event, ...args) => {
+                    console.log(`[emit] ${event}`, ...args);
+                    return original.call(target, event, ...args);
+                };
+            }
+            // Логируем подписки
+            if (prop === "on" ||
+                prop === "addListener" ||
+                prop === "once" ||
+                prop === "prependListener" ||
+                prop === "prependOnceListener") {
+                return (event, listener) => {
+                    console.log(`[on] ${event}`, listener.toString());
+                    return original.call(target, event, listener);
+                };
+            }
+            // Логируем удаление подписок
+            if (prop === "off" || prop === "removeListener") {
+                return (event, listener) => {
+                    console.log(`[off] ${event}`, listener.toString());
+                    return original.call(target, event, listener);
+                };
+            }
+            return original;
+        },
+    });
+}

package/dist/ee/defaultEvents.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ee/defaultEvents.js

@@ -0,0 +1 @@
+export {};

package/dist/ee/types.d.ts

@@ -0,0 +1,34 @@
+export type ArgsToFn<T> = T extends unknown[] ? (...args: T) => void : never;
+/**
+ * Ограничение для карты событий.
+ *
+ * Здесь `any` обязателен: EventMapFromArgs строит обработчики с конкретными
+ * кортежами аргументов, и удовлетворить ограничение они могут только через
+ * двусторонне совместимый `any`. С `unknown[]` не проходит присваивание
+ * параметров, с `never[]` — компилятор не сводит обобщённый `T[K]`.
+ * Конкретные типы событий задаются в EventMapFromArgs, здесь их нет.
+ */
+export type EventMap = {
+    [K in string]: (...args: any[]) => void;
+};
+export type EventMapFromArgs<T extends Record<string, unknown[]>> = {
+    [K in keyof T]: (...args: T[K]) => void;
+};
+export interface TypedEventEmitter<Events extends EventMap> {
+    addListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    on<E extends keyof Events>(event: E, listener: Events[E]): this;
+    once<E extends keyof Events>(event: E, listener: Events[E]): this;
+    prependListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    prependOnceListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    off<E extends keyof Events>(event: E, listener: Events[E]): this;
+    removeAllListeners<E extends keyof Events>(event?: E): this;
+    removeListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    emit<E extends keyof Events>(event: E, ...args: Parameters<Events[E]>): boolean;
+    eventNames(): (keyof Events | string | symbol)[];
+    rawListeners<E extends keyof Events>(event: E): Events[E][];
+    listeners<E extends keyof Events>(event: E): Events[E][];
+    listenerCount<E extends keyof Events>(event: E): number;
+    getMaxListeners(): number;
+    setMaxListeners(maxListeners: number): this;
+}
+export type PickEvent<Events extends EventMap, E extends keyof Events> = Events[E];

package/dist/ee/types.js

@@ -0,0 +1 @@
+export {};

package/dist/global.d.ts

@@ -0,0 +1,27 @@
+import { TypedEventEmitter, EventMapFromArgs } from "./ee/types.js";
+import { Atom } from "@quark-fw/atom";
+import { QuarkPlugin } from "@quark-fw/plugin";
+
+export {};
+
+declare global {
+	interface Events {
+		"lifecycle:init": [string];
+		"plugin:init": [QuarkPlugin];
+		"atom:update": [{ key: string; value: unknown }];
+	}
+
+	type EventsMap = EventMapFromArgs<Events>;
+
+	type QuarkEE = TypedEventEmitter<EventsMap>;
+
+	interface Quark {
+		ee: Atom<QuarkEE>;
+		plugins: QuarkPlugin[];
+		registerPlugin: (plugin: QuarkPlugin) => Promise<void>;
+		ready: () => Promise<void>;
+		destroy: () => Promise<void>;
+	}
+
+	var quark: Quark;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="global.d.ts" />
+export {};

package/dist/index.js

@@ -0,0 +1,71 @@
+import atom from "@quark-fw/atom";
+import { createTypedEventEmitter } from "./ee/createTypedEventEmitter.js";
+// создаём emitter
+const eeAtom = atom("ee", createTypedEventEmitter());
+const loaded = new Set();
+// Регистрации сериализуются: при top-level await соседние модули
+// выполняются конкурентно, и без очереди проверка dependsOn гонится
+// с ещё не завершённой регистрацией предыдущего плагина.
+let registrationQueue = Promise.resolve();
+const register = async (plugin) => {
+    if (loaded.has(plugin.name))
+        return;
+    // зависимости: должны быть зарегистрированы раньше
+    if (plugin.dependsOn) {
+        for (const dep of plugin.dependsOn) {
+            if (!loaded.has(dep))
+                throw new Error(`Plugin ${plugin.name} depends on plugin ${dep}, which is not registered yet — import it first`);
+        }
+    }
+    // Атомы. Имена приходят от плагина в рантайме, а их объявление живёт в
+    // аугментации интерфейса Quark — статически связать одно с другим нельзя.
+    if (plugin.atoms) {
+        const target = quark;
+        for (const [key, atom] of Object.entries(plugin.atoms)) {
+            target[key] = atom;
+        }
+    }
+    // методы
+    plugin.extend?.(quark);
+    // подписки на события
+    if (plugin.onEvent) {
+        for (const [event, handler] of Object.entries(plugin.onEvent)) {
+            // имя события — строка из объекта плагина, соответствие ключам
+            // EventsMap проверить статически здесь нельзя
+            quark.ee.value.on(event, handler);
+        }
+    }
+    // lifecycle init
+    await plugin.onInit?.(quark);
+    quark.ee.value.emit("plugin:init", plugin);
+    loaded.add(plugin.name);
+    quark.plugins.push(plugin);
+    await plugin.onReady?.(quark);
+};
+// создаём глобальный quark
+global.quark =
+    global.quark ||
+        {
+            ee: eeAtom,
+            plugins: [],
+            registerPlugin: (plugin) => {
+                const task = registrationQueue.then(() => register(plugin));
+                // ошибка одной регистрации не должна блокировать очередь
+                registrationQueue = task.catch(() => { });
+                return task;
+            },
+            // дождаться завершения всех уже поставленных в очередь регистраций —
+            // нужно модулям приложения, выполняющимся конкурентно с плагинами
+            ready: () => registrationQueue,
+            destroy: async () => {
+                // в обратном порядке регистрации
+                for (const plugin of [...quark.plugins].reverse()) {
+                    await plugin.onDestroy?.(quark);
+                }
+                quark.plugins.length = 0;
+                loaded.clear();
+            },
+            // Quark дополняется плагинами через declaration merging,
+            // поэтому базовый объект заведомо неполон
+        };
+quark.ee.value.emit("lifecycle:init", "app started");

package/dist/systemEventEmitter.d.ts

@@ -0,0 +1,3 @@
+export declare const systemEventEmitter: import("./ee/types.js").TypedEventEmitter<import("./ee/types.js").EventMapFromArgs<{
+    asd: [boolean];
+}>>;

package/dist/systemEventEmitter.js

@@ -0,0 +1,2 @@
+import { createTypedEventEmitter } from "./ee/createTypedEventEmitter.js";
+export const systemEventEmitter = createTypedEventEmitter();

package/package.json

@@ -0,0 +1,32 @@
+{
+	"name": "@quark-fw/core",
+	"version": "0.0.1",
+	"description": "Core runtime of the Quark framework: global quark object, lifecycle and typed event emitter",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"./package.json": "./package.json",
+		"./src/*": "./dist/*",
+		"./*": "./dist/*"
+	},
+	"files": ["dist"],
+	"scripts": {
+		"dev": "tsx watch src/index.ts",
+		"build": "tsc -p tsconfig.build.json && node ../../scripts/postbuild.mjs"
+	},
+	"keywords": ["quark"],
+	"author": "",
+	"license": "ISC",
+	"publishConfig": {
+		"access": "public"
+	},
+	"dependencies": {
+		"@quark-fw/atom": "0.0.1",
+		"@quark-fw/plugin": "0.0.1"
+	}
+}