@virid/core 0.0.1 → 0.1.0

package/dist/index.mjs

@@ -1,674 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// app.ts
-import { Container } from "inversify";
-
-// message/types.ts
-var BaseMessage = class {
-  static {
-    __name(this, "BaseMessage");
-  }
-  static send(...args) {
-    MessageWriter.write(this, ...args);
-  }
-  senderInfo;
-  constructor() {
-  }
-};
-var SingleMessage = class extends BaseMessage {
-  static {
-    __name(this, "SingleMessage");
-  }
-  // @ts-ignore 只用来区分的标识符
-  __kind = "SingleMessage";
-  constructor() {
-    super();
-  }
-};
-var EventMessage = class extends BaseMessage {
-  static {
-    __name(this, "EventMessage");
-  }
-  // @ts-ignore 只用来区分的标识符
-  __kind = "EventMessage";
-  constructor() {
-    super();
-  }
-};
-var ErrorMessage = class extends EventMessage {
-  static {
-    __name(this, "ErrorMessage");
-  }
-  error;
-  context;
-  constructor(error, context) {
-    super(), this.error = error, this.context = context;
-  }
-};
-var WarnMessage = class extends EventMessage {
-  static {
-    __name(this, "WarnMessage");
-  }
-  context;
-  constructor(context) {
-    super(), this.context = context;
-  }
-};
-var AtomicModifyMessage = class extends EventMessage {
-  static {
-    __name(this, "AtomicModifyMessage");
-  }
-  ComponentClass;
-  recipe;
-  label;
-  constructor(ComponentClass, recipe, label) {
-    super(), this.ComponentClass = ComponentClass, this.recipe = recipe, this.label = label;
-  }
-};
-
-// message/io.ts
-var activeInstance = null;
-function activatInstance(instance) {
-  activeInstance = instance;
-}
-__name(activatInstance, "activatInstance");
-var publisher = new Proxy({}, {
-  get(_, prop) {
-    if (prop === "dispatch") {
-      return (message) => {
-        if (!activeInstance) {
-          console.error(`[Virid] Message dispatched before system init: ${message.constructor.name}`);
-          return;
-        }
-        return activeInstance.dispatch(message);
-      };
-    }
-    return Reflect.get(activeInstance || {}, prop);
-  }
-});
-var MessageWriter = class {
-  static {
-    __name(this, "MessageWriter");
-  }
-  /**
-  * 核心入口：无论是类还是实例，统一交给 Internal 处理
-  */
-  static write(target, ...args) {
-    const instance = typeof target === "function" ? new target(...args) : target;
-    publisher.dispatch(instance);
-  }
-  /**
-  * 快捷方式：系统内部常用
-  */
-  static error(e, context) {
-    this.write(new ErrorMessage(e, context));
-  }
-  static warn(context) {
-    this.write(new WarnMessage(context));
-  }
-};
-
-// message/dispatcher.ts
-var ExecutionTask = class {
-  static {
-    __name(this, "ExecutionTask");
-  }
-  fn;
-  priority;
-  message;
-  context;
-  constructor(fn, priority, message, context) {
-    this.fn = fn;
-    this.priority = priority;
-    this.message = message;
-    this.context = context;
-  }
-  triggerHooks(hooks) {
-    const sample = Array.isArray(this.message) ? this.message[0] : this.message;
-    if (!sample) return;
-    for (const hook of hooks) {
-      if (sample instanceof hook.type) {
-        try {
-          const result = hook.handler(this.message, this.context);
-          if (result instanceof Promise) {
-            result.catch((e) => MessageWriter.error(e, `[Virid Hook] Async Hook Error:
-${hook.type.name}`));
-          }
-        } catch (e) {
-          MessageWriter.error(e, `[Virid Hook] Hook Execute Failed:
-Triggered by: ${sample.constructor.name}
- Registered type: ${hook.type.name}`);
-        }
-      }
-    }
-  }
-  execute(beforeHooks, afterHooks) {
-    this.triggerHooks(beforeHooks);
-    const runAfter = /* @__PURE__ */ __name(() => this.triggerHooks(afterHooks), "runAfter");
-    try {
-      const result = this.fn(this.message);
-      if (result instanceof Promise) {
-        return result.finally(() => runAfter());
-      }
-      runAfter();
-      return result;
-    } catch (e) {
-      runAfter();
-      throw e;
-    }
-  }
-};
-var Dispatcher = class {
-  static {
-    __name(this, "Dispatcher");
-  }
-  dirtySignalTypes = /* @__PURE__ */ new Set();
-  eventQueue = [];
-  isRunning = false;
-  tickCount = 0;
-  eventHub;
-  // 使用 MessageIdentifier 允许存入 BaseMessage, SingleMessage 等抽象类
-  beforeHooks = [];
-  afterHooks = [];
-  constructor(eventHub) {
-    this.eventHub = eventHub;
-  }
-  // 添加执行钩子
-  addBefore(type, hook) {
-    this.beforeHooks.push({
-      type,
-      handler: hook
-    });
-  }
-  addAfter(type, hook) {
-    this.afterHooks.push({
-      type,
-      handler: hook
-    });
-  }
-  cleanupHook = /* @__PURE__ */ __name(() => {
-  }, "cleanupHook");
-  setCleanupHook(hook) {
-    this.cleanupHook = hook;
-  }
-  /**
-  * 标记脏数据：根据基类判断进入哪个池子
-  */
-  markDirty(message) {
-    if (message instanceof EventMessage) {
-      this.eventQueue.push(message);
-    } else if (message instanceof SingleMessage) {
-      this.dirtySignalTypes.add(message.constructor);
-    }
-  }
-  tick(interestMap) {
-    if (this.isRunning || this.dirtySignalTypes.size === 0 && this.eventQueue.length === 0) return;
-    if (this.tickCount > 100) {
-      this.tickCount = 0;
-      this.dirtySignalTypes.clear();
-      this.eventQueue = [];
-      this.eventHub.reset();
-      MessageWriter.error(new Error("[Virid Dispatcher] Deadlock: Recursive loop detected."));
-      return;
-    }
-    this.isRunning = true;
-    this.tickCount++;
-    queueMicrotask(() => {
-      try {
-        this.eventHub.flip();
-        const signalSnapshot = new Set(this.dirtySignalTypes);
-        const eventSnapshot = [
-          ...this.eventQueue
-        ];
-        this.dirtySignalTypes.clear();
-        this.eventQueue = [];
-        const tasks = [];
-        for (const msg of eventSnapshot) {
-          const systems = interestMap.get(msg.constructor) || [];
-          systems.forEach((s) => {
-            tasks.push(new ExecutionTask(s.fn, s.priority, msg, s.fn.ccsContext));
-          });
-        }
-        const signalFnSet = /* @__PURE__ */ new Set();
-        for (const type of signalSnapshot) {
-          const systems = interestMap.get(type) || [];
-          systems.forEach((s) => {
-            if (!signalFnSet.has(s.fn)) {
-              tasks.push(new ExecutionTask(s.fn, s.priority, this.eventHub.peekSignal(type), s.fn.ccsContext));
-              signalFnSet.add(s.fn);
-            }
-          });
-        }
-        tasks.sort((a, b) => b.priority - a.priority);
-        for (const task of tasks) {
-          try {
-            const result = task.execute(this.beforeHooks, this.afterHooks);
-            if (result instanceof Promise) {
-              result.catch((e) => MessageWriter.error(e, `[Virid Dispatcher] Async Error:
-targetClass:${task.context.targetClass}
-methodName:${task.context.methodName}
-                `));
-            }
-          } catch (e) {
-            MessageWriter.error(e, `[Virid Dispatcher] Sync Error:
-targetClass:${task.context.targetClass}
-methodName:${task.context.methodName}
-                `);
-          }
-        }
-        const processedTypes = new Set(signalSnapshot);
-        eventSnapshot.forEach((m) => processedTypes.add(m.constructor));
-        this.cleanupHook(processedTypes);
-        this.isRunning = false;
-        if (this.dirtySignalTypes.size > 0 || this.eventQueue.length > 0) {
-          this.tick(interestMap);
-        } else {
-          this.tickCount = 0;
-        }
-      } catch (e) {
-        MessageWriter.error(e, "[Virid Dispatcher] Unhandled Error");
-      }
-    });
-  }
-};
-
-// message/eventHub.ts
-var EventHub = class {
-  static {
-    __name(this, "EventHub");
-  }
-  // --- SIGNAL 存储 (分类池) ---
-  signalActive = /* @__PURE__ */ new Map();
-  signalStaging = /* @__PURE__ */ new Map();
-  // --- EVENT 存储 (顺序流) ---
-  eventActive = [];
-  eventStaging = [];
-  /**
-  * 写入逻辑：根据消息策略分流
-  */
-  push(event) {
-    if (event instanceof SingleMessage) {
-      const type = event.constructor;
-      if (!this.signalStaging.has(type)) this.signalStaging.set(type, []);
-      this.signalStaging.get(type).push(event);
-    } else if (event instanceof EventMessage) {
-      this.eventStaging.push(event);
-    } else {
-      MessageWriter.error(new Error(`[Virid Message] Invalid Message:
-${event.constructor.name} must extend SingleMessage or EventMessage`));
-    }
-  }
-  /**
-  * 翻转缓冲区：在 Dispatcher 的 Tick 开始时调用
-  */
-  flip() {
-    this.signalActive = this.signalStaging;
-    this.signalStaging = /* @__PURE__ */ new Map();
-    this.eventActive = this.eventStaging;
-    this.eventStaging = [];
-  }
-  /**
-  * [SIGNAL专用] 批量读取某种类型的信号
-  */
-  peekSignal(type) {
-    return this.signalActive.get(type) || [];
-  }
-  /**
-  * [EVENT专用] 获取当前所有待处理的事件流
-  */
-  getEventStream() {
-    return this.eventActive;
-  }
-  /**
-  * [新增] 根据索引精准读取 EVENT 里的某个数据
-  * 配合 Dispatcher 逐条分发时使用
-  */
-  peekEventAt(index) {
-    return this.eventActive[index];
-  }
-  /**
-  * 清理已处理的内容
-  */
-  clearSignals(types) {
-    types.forEach((type) => this.signalActive.delete(type));
-  }
-  clearEvents() {
-    this.eventActive = [];
-  }
-  /**
-  * 重置所有池子
-  */
-  reset() {
-    this.signalActive.clear();
-    this.signalStaging.clear();
-    this.eventActive = [];
-    this.eventStaging = [];
-  }
-};
-
-// message/registry.ts
-var MessageRegistry = class {
-  static {
-    __name(this, "MessageRegistry");
-  }
-  interestMap = /* @__PURE__ */ new Map();
-  /**
-  * 注册消息并返回一个卸载函数
-  * 这种模式能完美适配 Controller 的生命周期销毁
-  */
-  register(eventClass, systemFn, priority = 0) {
-    const systems = this.interestMap.get(eventClass) || [];
-    const existingIndex = systems.findIndex((s) => s.fn === systemFn);
-    if (existingIndex === -1) {
-      systems.push({
-        fn: systemFn,
-        priority
-      });
-      systems.sort((a, b) => b.priority - a.priority);
-      this.interestMap.set(eventClass, systems);
-    } else {
-      const funcName = systemFn.name || "Anonymous";
-      MessageWriter.error(new Error(`[Virid Error] System Already Registered:
-Class ${eventClass.name}
-Function ${funcName}`));
-      return () => {
-      };
-    }
-    return () => {
-      const currentSystems = this.interestMap.get(eventClass);
-      if (currentSystems) {
-        const index = currentSystems.findIndex((s) => s.fn === systemFn);
-        if (index !== -1) {
-          currentSystems.splice(index, 1);
-          if (currentSystems.length === 0) {
-            this.interestMap.delete(eventClass);
-          }
-        }
-      }
-    };
-  }
-};
-
-// message/internal.ts
-var MessageInternal = class {
-  static {
-    __name(this, "MessageInternal");
-  }
-  eventHub = new EventHub();
-  dispatcher = new Dispatcher(this.eventHub);
-  registry = new MessageRegistry();
-  middlewares = [];
-  constructor() {
-    this.dispatcher.setCleanupHook((processedTypes) => {
-      this.eventHub.clearSignals(processedTypes);
-      this.eventHub.clearEvents();
-    });
-    activatInstance(this);
-  }
-  useMiddleware(mw) {
-    this.middlewares.push(mw);
-  }
-  onBeforeExecute(type, hook) {
-    this.dispatcher.addBefore(type, hook);
-  }
-  onAfterExecute(type, hook) {
-    this.dispatcher.addAfter(type, hook);
-  }
-  /**
-  * 消息进入系统的唯一入口
-  */
-  dispatch(message) {
-    if (!this.registry.interestMap.has(message.constructor)) {
-      MessageWriter.error(new Error(`[Virid Dispatch] No handler for message: ${message.constructor.name}`));
-      return;
-    }
-    this.pipeline(message, () => {
-      this.eventHub.push(message);
-      this.dispatcher.markDirty(message);
-      this.dispatcher.tick(this.registry.interestMap);
-    });
-  }
-  pipeline(message, finalAction) {
-    let index = 0;
-    const next = /* @__PURE__ */ __name(() => {
-      if (index < this.middlewares.length) {
-        this.middlewares[index++](message, next);
-      } else {
-        finalAction();
-      }
-    }, "next");
-    next();
-  }
-};
-
-// app.ts
-var installedPlugins = /* @__PURE__ */ new Set();
-var ViridApp = class {
-  static {
-    __name(this, "ViridApp");
-  }
-  container = new Container();
-  messageInternal = new MessageInternal();
-  bindBase(identifier) {
-    return this.container.bind(identifier).toSelf();
-  }
-  get(identifier) {
-    return this.container.get(identifier);
-  }
-  bindController(identifier) {
-    return this.bindBase(identifier);
-  }
-  bindComponent(identifier) {
-    return this.bindBase(identifier).inSingletonScope();
-  }
-  useMiddleware(mw) {
-    this.messageInternal.useMiddleware(mw);
-  }
-  onBeforeExecute(type, hook) {
-    this.messageInternal.onBeforeExecute(type, hook);
-  }
-  onAfterExecute(type, hook) {
-    this.messageInternal.onAfterExecute(type, hook);
-  }
-  register(eventClass, systemFn, priority = 0) {
-    return this.messageInternal.registry.register(eventClass, systemFn, priority);
-  }
-  use(plugin, options) {
-    if (installedPlugins.has(plugin.name)) {
-      MessageWriter.warn(`[Virid Plugin] Plugin ${plugin.name} has already been installed.`);
-      return this;
-    }
-    try {
-      plugin.install(this, options);
-      installedPlugins.add(plugin.name);
-    } catch (e) {
-      MessageWriter.error(e, `[Virid Plugin] ${plugin.name}`);
-    }
-    return this;
-  }
-};
-var viridApp = new ViridApp();
-function withContext(params, fn, methodName) {
-  const context = {
-    params,
-    targetClass: Object,
-    methodName,
-    originalMethod: fn
-  };
-  fn.ccsContext = context;
-  return fn;
-}
-__name(withContext, "withContext");
-var clr = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  magenta: "\x1B[35m",
-  cyan: "\x1B[36m",
-  gray: "\x1B[90m",
-  bold: "\x1B[1m"
-};
-var globalErrorHandler = /* @__PURE__ */ __name((err) => {
-  const header = `${clr.red}${clr.bold} \u2716 [Virid Error] ${clr.reset}`;
-  const context = `${clr.magenta}${err.context}${clr.reset}`;
-  console.error(`${header}${clr.gray}Global Error Caught:${clr.reset}
-  ${clr.red}Context:${clr.reset} ${context}
-  ${clr.red}Details:${clr.reset}`, err.error || "Unknown Error");
-}, "globalErrorHandler");
-viridApp.register(ErrorMessage, withContext(ErrorMessage, globalErrorHandler, "GlobalErrorHandler"), -999);
-var globalWarnHandler = /* @__PURE__ */ __name((warn) => {
-  const header = `${clr.yellow}${clr.bold} \u26A0 [Virid Warn] ${clr.reset}`;
-  const context = `${clr.cyan}${warn.context}${clr.reset}`;
-  console.warn(`${header}${clr.gray}Global Warn Caught:${clr.reset}
-  ${clr.yellow}Context:${clr.reset} ${context}`);
-}, "globalWarnHandler");
-viridApp.register(WarnMessage, withContext(WarnMessage, globalWarnHandler, "GlobalWarnHandler"), -999);
-var atomicModifyHandler = /* @__PURE__ */ __name((modifications) => {
-  const rawComponent = viridApp.container.get(modifications.ComponentClass);
-  if (!rawComponent) {
-    console.error(`[Virid Modify] Component Not Found:
- Component ${modifications.ComponentClass.name} not found in Registry.`);
-    return;
-  }
-  try {
-    modifications.recipe(rawComponent);
-    MessageWriter.warn(`[Virid Modify] Successfully:
-Modify on ${modifications.ComponentClass.name}
-label: ${modifications.label}`);
-  } catch (e) {
-    MessageWriter.error(e, `[Virid Error] Modify Failed:
-${modifications.label}`);
-  }
-}, "atomicModifyHandler");
-viridApp.register(AtomicModifyMessage, withContext(AtomicModifyMessage, atomicModifyHandler, "GlobalAtomicModifier"), 1e3);
-
-// decorators/constants.ts
-var virid_METADATA = {
-  SYSTEM: "virid:system_metadata",
-  MESSAGE: "virid:message",
-  CONTROLLER: "virid:controller",
-  COMPONENT: "virid:component"
-};
-
-// decorators/ccs.ts
-import { injectable } from "inversify";
-import "reflect-metadata";
-function System(priority = 0) {
-  return (target, key, descriptor) => {
-    const originalMethod = descriptor.value;
-    const types = Reflect.getMetadata("design:paramtypes", target, key) || [];
-    if (types.length === 0) {
-      MessageWriter.error(new Error(`[Virid System] System Parameter Loss:
-Unable to recognize system parameters, please confirm if import "reflection-metadata" was introduced at the beginning!`));
-    }
-    const readerConfigs = Reflect.getMetadata(virid_METADATA.MESSAGE, target, key) || [];
-    if (readerConfigs.length > 1) {
-      MessageWriter.warn(`[Virid System] Multiple Messages Are Not Allowed: ${key} has multiple @Message() decorators!`);
-      return;
-    }
-    const wrappedSystem = /* @__PURE__ */ __name(function(currentMessage) {
-      const args = types.map((type, index) => {
-        const config = readerConfigs.find((c) => c.index === index);
-        if (config) {
-          const { eventClass, single } = config;
-          const sample = Array.isArray(currentMessage) ? currentMessage[0] : currentMessage;
-          if (!(sample instanceof eventClass)) {
-            MessageWriter.error(new Error(`[Virid System] Type Mismatch: Expected ${eventClass.name}, but received ${sample?.constructor.name}`));
-            return null;
-          }
-          if (sample instanceof SingleMessage) {
-            if (single) {
-              return Array.isArray(currentMessage) ? currentMessage[currentMessage.length - 1] : currentMessage;
-            }
-            return Array.isArray(currentMessage) ? currentMessage : [
-              currentMessage
-            ];
-          }
-          if (sample instanceof EventMessage) {
-            return currentMessage;
-          }
-          return currentMessage;
-        }
-        const param = viridApp.get(type);
-        if (!param) MessageWriter.error(new Error(`[Virid System] Unknown Inject Data Types: ${type.name} is not registered in the container!`));
-        return param;
-      });
-      const result = originalMethod(...args);
-      const handleResult = /* @__PURE__ */ __name((res) => {
-        if (!res) return;
-        const messages = Array.isArray(res) ? res : [
-          res
-        ];
-        messages.forEach((m) => {
-          if (m instanceof BaseMessage) {
-            MessageWriter.write(m);
-          }
-        });
-      }, "handleResult");
-      return result instanceof Promise ? result.then(handleResult) : handleResult(result);
-    }, "wrappedSystem");
-    const taskContext = {
-      params: types,
-      targetClass: target,
-      methodName: key,
-      originalMethod
-    };
-    wrappedSystem.ccsContext = taskContext;
-    descriptor.value = wrappedSystem;
-    readerConfigs.forEach((config) => {
-      viridApp.register(config.eventClass, wrappedSystem, priority);
-    });
-  };
-}
-__name(System, "System");
-function Message(eventClass, single = true) {
-  return (target, key, index) => {
-    const configs = Reflect.getMetadata(virid_METADATA.MESSAGE, target, key) || [];
-    configs.push({
-      index,
-      eventClass,
-      single
-    });
-    Reflect.defineMetadata(virid_METADATA.MESSAGE, configs, target, key);
-  };
-}
-__name(Message, "Message");
-function Controller() {
-  return (target) => {
-    injectable()(target);
-    Reflect.defineMetadata(virid_METADATA.CONTROLLER, true, target);
-  };
-}
-__name(Controller, "Controller");
-function Component() {
-  return (target) => {
-    injectable()(target);
-    Reflect.defineMetadata(virid_METADATA.COMPONENT, true, target);
-  };
-}
-__name(Component, "Component");
-
-// index.ts
-function createVirid() {
-  return viridApp;
-}
-__name(createVirid, "createVirid");
-export {
-  AtomicModifyMessage,
-  BaseMessage,
-  Component,
-  Controller,
-  ErrorMessage,
-  EventMessage,
-  Message,
-  MessageInternal,
-  MessageWriter,
-  SingleMessage,
-  System,
-  WarnMessage,
-  activatInstance,
-  createVirid,
-  publisher
-};