@virid/vue 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,63 @@
+import { SingleMessage, ViridPlugin } from '@virid/core';
+export { CCSSystemContext } from '@virid/core';
+import { WatchOptions } from 'vue';
+
+declare abstract class ControllerMessage extends SingleMessage {
+}
+
+/**
+ * @description:实现Watch
+ * 用法：@Watch('a.b.c') 或 @Watch(instance => instance.a.b.c)
+ */
+declare function Watch<T>(source: (instance: T) => any, options?: WatchOptions): any;
+declare function Watch<C>(component: new (...args: any[]) => C, source: (comp: C) => any, options?: WatchOptions): any;
+/**
+ * @description: 实现数据投影
+ * 用法：@Project() 或 @Project('a.b.c')
+ */
+declare function Project<T>(source: (instance: T) => any): any;
+declare function Project<C>(component: new (...args: any[]) => C, source: (comp: C) => any): any;
+/**
+ * @description: 给数据增加响应式
+ * 用法：@Responsive()
+ */
+declare function Responsive(shallow?: boolean): (target: any, propertyKey: string) => void;
+/**
+ * @description: 声明式生命周期钩子
+ * 用法：@OnHook("onMounted")
+ */
+declare function OnHook(hookName: "onMounted" | "onUnmounted" | "onUpdated" | "onActivated" | "onDeactivated" | "onSetup"): (target: any, methodName: string) => void;
+/**
+ * @description: 万能 Hook 注入装饰器
+ * 用法：@Use(() => useRoute()) public route!: RouteLocationNormalized
+ */
+declare function Use(hookFactory: () => any): (target: any, propertyKey: string) => void;
+/**
+ * @description: Inherit注入装饰器
+ * 用法：@Inherit(Contronller,(instance) => instance.xxxx) public data!: SomeType
+ */
+declare function Inherit<T>(token: new (...args: any[]) => T, id: string, selector?: (instance: T) => any): (target: any, propertyKey: string) => void;
+/**
+ * @description: 标记一个属性是从外部环境(context)注入的
+ * 纯元数据标记，什么也不干，方便后期做自动化文档或 TS 类型提示
+ */
+declare function Env(): (_target: any, _propertyKey: string) => void;
+/**
+ * @description: Listener 装饰器 - 标记 Controller 的成员方法为消息监听器
+ * 模仿 Bevy 的即时响应机制，但严格限制其只能处理 UI 逻辑
+ */
+declare function Listener<T extends ControllerMessage>(eventClass: new (...args: any[]) => T, priority?: number, single?: boolean): (target: any, propertyKey: string) => void;
+
+/**
+ * @description: vue的hooks适配器，注入IOC容器中的Controller实例，并挂在vue的各种方法
+ * @param token
+ * @return {*}
+ */
+declare function useController<T>(token: new (...args: any[]) => T, options?: {
+    id?: string;
+    context?: any;
+}): T;
+
+declare const VuePlugin: ViridPlugin;
+
+export { ControllerMessage, Env, Inherit, Listener, OnHook, Project, Responsive, Use, VuePlugin, Watch, useController };

package/dist/index.js

@@ -0,0 +1,559 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  ControllerMessage: () => ControllerMessage,
+  Env: () => Env,
+  Inherit: () => Inherit,
+  Listener: () => Listener,
+  OnHook: () => OnHook,
+  Project: () => Project,
+  Responsive: () => Responsive,
+  Use: () => Use,
+  VuePlugin: () => VuePlugin,
+  Watch: () => Watch,
+  useController: () => useController
+});
+module.exports = __toCommonJS(index_exports);
+
+// decorators/constants.ts
+var virid_METADATA = {
+  COMPONENT: "virid:component",
+  CONTROLLER: "virid:controller",
+  PROJECT: "virid:project_metadata",
+  WATCH: "virid:watch_metadata",
+  MESSAGE: "virid:message",
+  RESPONSIVE: "virid:responsive",
+  LIFE_CRICLE: "virid:life_cricle",
+  USE_HOOKS: "virid:use_hooks",
+  CONTROLLER_LISTENERS: "virid:controller_listeners",
+  INHERIT: "virid:inherit",
+  ATTR: "virid:attr"
+};
+
+// decorators/vue.ts
+function Watch(arg1, arg2, arg3) {
+  return (target, methodName) => {
+    const existing = Reflect.getMetadata(virid_METADATA.WATCH, target) || [];
+    if (typeof arg2 === "function") {
+      existing.push({
+        type: "component",
+        componentClass: arg1,
+        source: arg2,
+        options: arg3,
+        methodName
+      });
+    } else {
+      existing.push({
+        type: "local",
+        source: arg1,
+        options: arg2,
+        methodName
+      });
+    }
+    Reflect.defineMetadata(virid_METADATA.WATCH, existing, target);
+  };
+}
+__name(Watch, "Watch");
+function Project(arg1, arg2) {
+  return (target, propertyKey, descriptor) => {
+    const existing = Reflect.getMetadata(virid_METADATA.PROJECT, target) || [];
+    const metadata = {
+      propertyKey,
+      isAccessor: !!(descriptor?.get || descriptor?.set),
+      // 这里的逻辑和 Watch 保持高度一致
+      type: typeof arg2 === "function" ? "component" : "local",
+      componentClass: typeof arg2 === "function" ? arg1 : null,
+      source: typeof arg2 === "function" ? arg2 : arg1
+    };
+    existing.push(metadata);
+    Reflect.defineMetadata(virid_METADATA.PROJECT, existing, target);
+  };
+}
+__name(Project, "Project");
+function Responsive(shallow = false) {
+  return (target, propertyKey) => {
+    const props = Reflect.getMetadata(virid_METADATA.RESPONSIVE, target) || [];
+    props.push({
+      propertyKey,
+      shallow
+    });
+    Reflect.defineMetadata(virid_METADATA.RESPONSIVE, props, target);
+  };
+}
+__name(Responsive, "Responsive");
+function OnHook(hookName) {
+  return (target, methodName) => {
+    const existing = Reflect.getMetadata(virid_METADATA.LIFE_CRICLE, target) || [];
+    existing.push({
+      hookName,
+      methodName
+    });
+    Reflect.defineMetadata(virid_METADATA.LIFE_CRICLE, existing, target);
+  };
+}
+__name(OnHook, "OnHook");
+function Use(hookFactory) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata(virid_METADATA.USE_HOOKS, target) || [];
+    existing.push({
+      propertyKey,
+      hookFactory
+    });
+    Reflect.defineMetadata(virid_METADATA.USE_HOOKS, existing, target);
+  };
+}
+__name(Use, "Use");
+function Inherit(token, id, selector) {
+  return (target, propertyKey) => {
+    const metadata = Reflect.getMetadata(virid_METADATA.INHERIT, target) || [];
+    metadata.push({
+      propertyKey,
+      token,
+      id,
+      selector
+    });
+    Reflect.defineMetadata(virid_METADATA.INHERIT, metadata, target);
+  };
+}
+__name(Inherit, "Inherit");
+function Env() {
+  return (_target, _propertyKey) => {
+  };
+}
+__name(Env, "Env");
+function Listener(eventClass, priority = 0, single = true) {
+  return (target, propertyKey) => {
+    const listeners = Reflect.getMetadata(virid_METADATA.CONTROLLER_LISTENERS, target) || [];
+    listeners.push({
+      propertyKey,
+      eventClass,
+      priority,
+      single
+    });
+    Reflect.defineMetadata(virid_METADATA.CONTROLLER_LISTENERS, listeners, target);
+  };
+}
+__name(Listener, "Listener");
+
+// decorators/types.ts
+var import_core = require("@virid/core");
+var ControllerMessage = class extends import_core.SingleMessage {
+  static {
+    __name(this, "ControllerMessage");
+  }
+};
+
+// adapters/bind.ts
+var import_vue = require("vue");
+var import_core2 = require("@virid/core");
+
+// app.ts
+var activeApp = null;
+function activateApp(instance) {
+  activeApp = instance;
+}
+__name(activateApp, "activateApp");
+var viridApp = new Proxy({}, {
+  get(_, prop) {
+    return (...args) => {
+      if (!activeApp) {
+        console.warn(`[Virid Vue] App method "${String(prop)}" called before initialization.`);
+        if (prop === "register") {
+          return () => {
+            console.warn("[Virid Vue] Cleanup ignored: source listener was never registered.");
+          };
+        }
+        return void 0;
+      }
+      const targetMethod = activeApp[prop];
+      if (typeof targetMethod === "function") {
+        return targetMethod.apply(activeApp, args);
+      }
+    };
+  }
+});
+
+// adapters/bind.ts
+var GlobalRegistry = class {
+  static {
+    __name(this, "GlobalRegistry");
+  }
+  static globalRegistry = (0, import_vue.shallowReactive)(/* @__PURE__ */ new Map());
+  static set(id, instance) {
+    if (!this.globalRegistry.has(id)) {
+      this.globalRegistry.set(id, instance);
+      return () => {
+        this.globalRegistry.delete(id);
+        return true;
+      };
+    } else {
+      import_core2.MessageWriter.error(new Error(`[Virid UseController] Duplicate ID: Controller ${id} already exists`));
+      return () => false;
+    }
+  }
+  static get(id) {
+    if (!this.globalRegistry.has(id)) {
+      import_core2.MessageWriter.error(new Error(`[Virid UseController] ID Not Found: No Controller found with ID: ${id}`));
+      return null;
+    }
+    return this.globalRegistry.get(id);
+  }
+};
+function bindProject(proto, instance, rawDeps) {
+  const projects = Reflect.getMetadata(virid_METADATA.PROJECT, proto);
+  projects?.forEach((config) => {
+    const { propertyKey, isAccessor, type, componentClass, source } = config;
+    let c;
+    let setter = /* @__PURE__ */ __name(() => {
+      import_core2.MessageWriter.error(new Error(`[Virid Shield] Property "${propertyKey}" is read-only.
+If you need to mutate, define an explicit setter and ensure the dependency is injected.`));
+    }, "setter");
+    const getTarget = /* @__PURE__ */ __name(() => {
+      const target = type === "component" ? viridApp.get(componentClass) : instance;
+      if (target && !target.__ccs_processed__) {
+        bindResponsive(target);
+      }
+      return target;
+    }, "getTarget");
+    if (isAccessor) {
+      const rawDescriptor = Object.getOwnPropertyDescriptor(proto, propertyKey);
+      if (rawDescriptor?.set) {
+        import_core2.MessageWriter.warn(`[Virid Project] Possible Implicit Modification:
+Manual Set on "${propertyKey}".If this is not intentional, please do not use set.`);
+        setter = /* @__PURE__ */ __name((val) => {
+          const elevatedContext = new Proxy(instance, {
+            get(target, key) {
+              if (typeof key === "string" && rawDeps[key]) {
+                return rawDeps[key];
+              }
+              return Reflect.get(target, key);
+            }
+          });
+          rawDescriptor?.set?.call(elevatedContext, val);
+        }, "setter");
+      }
+      c = (0, import_vue.computed)({
+        get: /* @__PURE__ */ __name(() => {
+          return rawDescriptor?.get?.call(instance);
+        }, "get"),
+        set: setter
+      });
+    } else {
+      c = (0, import_vue.computed)(() => {
+        const target = getTarget();
+        return source(target);
+      });
+    }
+    const currentDescriptor = Object.getOwnPropertyDescriptor(instance, propertyKey);
+    if (currentDescriptor && currentDescriptor.configurable === false) return;
+    Object.defineProperty(instance, propertyKey, {
+      get: /* @__PURE__ */ __name(() => c.value, "get"),
+      set: /* @__PURE__ */ __name((val) => c.value = val, "set"),
+      enumerable: true,
+      configurable: true
+    });
+  });
+}
+__name(bindProject, "bindProject");
+function bindWatch(proto, instance) {
+  const watches = Reflect.getMetadata(virid_METADATA.WATCH, proto) || [];
+  const stops = [];
+  watches.forEach((config) => {
+    const { type, source, methodName, options, componentClass } = config;
+    const target = type === "component" ? viridApp.get(componentClass) : instance;
+    if (target && !target.__ccs_processed__) {
+      bindResponsive(target);
+    }
+    const getter = /* @__PURE__ */ __name(() => {
+      try {
+        return source(target);
+      } catch (e) {
+        import_core2.MessageWriter.error(e, `[Virid Watch] Getter error in ${methodName}`);
+        return void 0;
+      }
+    }, "getter");
+    const callback = instance[methodName].bind(instance);
+    const stop = (0, import_vue.watch)(getter, (newVal, oldVal) => {
+      callback(newVal, oldVal);
+    }, {
+      ...options
+    });
+    stops.push(stop);
+  });
+  return stops;
+}
+__name(bindWatch, "bindWatch");
+function bindResponsive(instance) {
+  if (!instance || typeof instance !== "object") return;
+  if (Object.prototype.hasOwnProperty.call(instance, "__ccs_processed__")) return;
+  Object.defineProperty(instance, "__ccs_processed__", {
+    value: true,
+    enumerable: false
+  });
+  const props = Reflect.getMetadata(virid_METADATA.RESPONSIVE, instance) || [];
+  props.forEach((config) => {
+    const key = config.propertyKey;
+    const rawValue = instance[key];
+    const descriptor = Object.getOwnPropertyDescriptor(instance, key);
+    if (descriptor && descriptor.get) return;
+    const internalState = config.shallow ? (0, import_vue.shallowRef)(rawValue) : (0, import_vue.ref)(rawValue);
+    Object.defineProperty(instance, key, {
+      get: /* @__PURE__ */ __name(() => internalState.value, "get"),
+      set: /* @__PURE__ */ __name((val) => {
+        internalState.value = val;
+      }, "set"),
+      enumerable: true,
+      configurable: true
+    });
+  });
+  Reflect.ownKeys(instance).forEach((key) => {
+    if (key === "__ccs_processed__") return;
+    const val = instance[key];
+    if (val && typeof val === "object" && !(0, import_vue.isRef)(val)) {
+      bindResponsive(val);
+    }
+  });
+}
+__name(bindResponsive, "bindResponsive");
+function createDeepShield(target, rootName, path = "") {
+  if (target === null || typeof target !== "object") {
+    return target;
+  }
+  if (target.__ccs_shield__) return target;
+  return new Proxy(target, {
+    get(obj, prop) {
+      if (prop === "__ccs_shield__") return true;
+      if (prop === "__raw__") return obj;
+      const value = Reflect.get(obj, prop);
+      const currentPath = path ? `${path}.${String(prop)}` : String(prop);
+      return createDeepShield(value, rootName, currentPath);
+    },
+    set(_obj, prop) {
+      const currentPath = path ? `${path}.${String(prop)}` : String(prop);
+      const errorMsg = [
+        `[Virid DeepShield]`,
+        `------------------------------------------------`,
+        `Component: ${rootName}`,
+        `Code: this.${rootName}.${currentPath}`,
+        `Result: Rejected`,
+        `Repair suggestion: Please use @ Project (${currentPath}) to create a projection in the Controller.`,
+        `------------------------------------------------`
+      ].join("\n");
+      import_core2.MessageWriter.error(new Error(errorMsg));
+      return false;
+    },
+    deleteProperty(_obj, prop) {
+      import_core2.MessageWriter.error(new Error(`[Virid DeepShield] Physical Protection:
+Prohibit Deletion of Component Attributes ${String(prop)}`));
+      return false;
+    },
+    // 拦截 Object.defineProperty 等底层操作
+    defineProperty() {
+      import_core2.MessageWriter.error(new Error(`[Virid DeepShield] Physical Protection:
+Prohibit redefining component attribute structure`));
+      return false;
+    }
+  });
+}
+__name(createDeepShield, "createDeepShield");
+function bindHooks(proto, instance) {
+  const hooks = Reflect.getMetadata(virid_METADATA.LIFE_CRICLE, proto);
+  hooks?.forEach((config) => {
+    const { hookName, methodName } = config;
+    const fn = instance[methodName].bind(instance);
+    switch (hookName) {
+      case "onMounted":
+        (0, import_vue.onMounted)(fn);
+        break;
+      case "onUnmounted":
+        (0, import_vue.onUnmounted)(fn);
+        break;
+      case "onUpdated":
+        (0, import_vue.onUpdated)(fn);
+        break;
+      case "onActivated":
+        (0, import_vue.onActivated)(fn);
+        break;
+      case "onDeactivated":
+        (0, import_vue.onDeactivated)(fn);
+        break;
+      case "onSetup":
+        fn();
+        break;
+    }
+  });
+}
+__name(bindHooks, "bindHooks");
+function bindUseHooks(proto, instance) {
+  const hooks = Reflect.getMetadata(virid_METADATA.USE_HOOKS, proto);
+  hooks?.forEach((config) => {
+    const hookResult = config.hookFactory();
+    instance[config.propertyKey] = hookResult;
+  });
+}
+__name(bindUseHooks, "bindUseHooks");
+function bindListener(proto, instance) {
+  const listenerConfigs = Reflect.getMetadata(virid_METADATA.CONTROLLER_LISTENERS, proto) || [];
+  const unbindFunctions = [];
+  listenerConfigs.forEach(({ propertyKey, eventClass, priority, single }) => {
+    const originalMethod = instance[propertyKey];
+    const wrappedHandler = /* @__PURE__ */ __name(function(msgs) {
+      const message = single && Array.isArray(msgs) ? msgs[msgs.length - 1] : msgs;
+      if (msgs.length > 0) {
+        originalMethod.apply(instance, [
+          message
+        ]);
+      }
+    }, "wrappedHandler");
+    const taskContext = {
+      params: eventClass,
+      targetClass: instance.constructor,
+      methodName: propertyKey,
+      originalMethod
+    };
+    wrappedHandler.ccsContext = taskContext;
+    const unregister = viridApp.register(eventClass, wrappedHandler, priority);
+    unbindFunctions.push(unregister);
+  });
+  return unbindFunctions;
+}
+__name(bindListener, "bindListener");
+function bindInherit(proto, instance) {
+  const inherits = Reflect.getMetadata(virid_METADATA.INHERIT, proto);
+  if (!inherits) return;
+  inherits.forEach(({ propertyKey, token, id, selector }) => {
+    const tunnel = (0, import_vue.computed)(() => {
+      const target = GlobalRegistry.get(id);
+      if (!target) {
+        import_core2.MessageWriter.warn(`[Virid Inherit] Warning:
+ Inherit target not found: ${id}`);
+        return null;
+      }
+      return selector ? selector(target) : target;
+    });
+    Object.defineProperty(instance, propertyKey, {
+      get: /* @__PURE__ */ __name(() => {
+        const val = tunnel.value;
+        return val ? createDeepShield(val, propertyKey, "") : null;
+      }, "get"),
+      set: /* @__PURE__ */ __name(() => {
+        import_core2.MessageWriter.error(new Error(`[Virid Inherit] No Modification:
+Attempted to set read-only Inherit property: ${propertyKey}`));
+      }, "set"),
+      enumerable: true,
+      configurable: true
+    });
+  });
+}
+__name(bindInherit, "bindInherit");
+
+// adapters/hooks.ts
+var import_vue2 = require("vue");
+var import_core3 = require("@virid/core");
+function useController(token, options) {
+  const instance = viridApp.get(token);
+  bindResponsive(instance);
+  const reactiveContext = options?.context || (0, import_vue2.useAttrs)();
+  if (reactiveContext) {
+    injectContext(reactiveContext, instance);
+  }
+  const isController = Reflect.hasMetadata(virid_METADATA.CONTROLLER, token);
+  const rawDeps = {};
+  if (isController) {
+    Object.keys(instance).forEach((key) => {
+      const dep = instance[key];
+      if (dep && typeof dep === "object" && dep.constructor) {
+        if (Reflect.hasMetadata(virid_METADATA.COMPONENT, dep.constructor)) {
+          rawDeps[key] = dep;
+        }
+      }
+    });
+  }
+  const proto = Object.getPrototypeOf(instance);
+  bindProject(proto, instance, rawDeps);
+  bindUseHooks(proto, instance);
+  const stops = bindWatch(proto, instance);
+  const unbindList = bindListener(proto, instance);
+  if (isController) {
+    Object.keys(rawDeps).forEach((key) => {
+      instance[key] = createDeepShield(rawDeps[key], key, "");
+    });
+  }
+  bindHooks(proto, instance);
+  bindInherit(proto, instance);
+  let unbindRegister = /* @__PURE__ */ __name(() => true, "unbindRegister");
+  if (options?.id) {
+    unbindRegister = GlobalRegistry.set(options?.id, instance);
+  }
+  (0, import_vue2.onUnmounted)(() => {
+    stops.forEach((stop) => stop());
+    unbindList.forEach((unreg) => unreg());
+    unbindRegister();
+  });
+  return instance;
+}
+__name(useController, "useController");
+function injectContext(context, instance) {
+  if (context && typeof context === "object") {
+    Object.keys(context).forEach((key) => {
+      Object.defineProperty(instance, key, {
+        // Getter 确保了 @Watch 的依赖收集能一路穿透到 Vue 源头
+        get: /* @__PURE__ */ __name(() => context[key], "get"),
+        // 处理写入逻辑
+        set: /* @__PURE__ */ __name((val) => {
+          if (context[key] === val) return;
+          try {
+            context[key] = val;
+          } catch (e) {
+            import_core3.MessageWriter.error(e, `[Virid Context] Set Failed:
+ "${key}" is only readable.`);
+          }
+        }, "set"),
+        enumerable: true,
+        configurable: true
+      });
+    });
+  }
+}
+__name(injectContext, "injectContext");
+
+// index.ts
+var VuePlugin = {
+  name: "@virid/vue",
+  install(app, _options) {
+    activateApp(app);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ControllerMessage,
+  Env,
+  Inherit,
+  Listener,
+  OnHook,
+  Project,
+  Responsive,
+  Use,
+  VuePlugin,
+  Watch,
+  useController
+});