@virid/vue 0.0.1

package/dist/index.mjs

@@ -0,0 +1,525 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// 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
+import { SingleMessage } from "@virid/core";
+var ControllerMessage = class extends SingleMessage {
+  static {
+    __name(this, "ControllerMessage");
+  }
+};
+
+// adapters/bind.ts
+import { watch, computed, isRef, ref, shallowReactive, onMounted, onUnmounted, onUpdated, onActivated, onDeactivated, shallowRef } from "vue";
+import { MessageWriter } from "@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 = 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 {
+      MessageWriter.error(new Error(`[Virid UseController] Duplicate ID: Controller ${id} already exists`));
+      return () => false;
+    }
+  }
+  static get(id) {
+    if (!this.globalRegistry.has(id)) {
+      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(() => {
+      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) {
+        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 = computed({
+        get: /* @__PURE__ */ __name(() => {
+          return rawDescriptor?.get?.call(instance);
+        }, "get"),
+        set: setter
+      });
+    } else {
+      c = 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) {
+        MessageWriter.error(e, `[Virid Watch] Getter error in ${methodName}`);
+        return void 0;
+      }
+    }, "getter");
+    const callback = instance[methodName].bind(instance);
+    const stop = 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 ? shallowRef(rawValue) : 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" && !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");
+      MessageWriter.error(new Error(errorMsg));
+      return false;
+    },
+    deleteProperty(_obj, prop) {
+      MessageWriter.error(new Error(`[Virid DeepShield] Physical Protection:
+Prohibit Deletion of Component Attributes ${String(prop)}`));
+      return false;
+    },
+    // 拦截 Object.defineProperty 等底层操作
+    defineProperty() {
+      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":
+        onMounted(fn);
+        break;
+      case "onUnmounted":
+        onUnmounted(fn);
+        break;
+      case "onUpdated":
+        onUpdated(fn);
+        break;
+      case "onActivated":
+        onActivated(fn);
+        break;
+      case "onDeactivated":
+        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 = computed(() => {
+      const target = GlobalRegistry.get(id);
+      if (!target) {
+        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(() => {
+        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
+import { onUnmounted as onUnmounted2, useAttrs } from "vue";
+import { MessageWriter as MessageWriter2 } from "@virid/core";
+function useController(token, options) {
+  const instance = viridApp.get(token);
+  bindResponsive(instance);
+  const reactiveContext = options?.context || 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);
+  }
+  onUnmounted2(() => {
+    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) {
+            MessageWriter2.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);
+  }
+};
+export {
+  ControllerMessage,
+  Env,
+  Inherit,
+  Listener,
+  OnHook,
+  Project,
+  Responsive,
+  Use,
+  VuePlugin,
+  Watch,
+  useController
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@virid/vue",
+  "version": "0.0.1",
+  "description": "Vue adapter for virid, projecting logic sovereignty to reactive UI",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@virid/core": "0.0.1"
+  },
+  "peerDependencies": {
+    "vue": "^3.0.0",
+    "inversify": "^7.11.0"
+  },
+  "peerDependenciesMeta": {
+    "inversify": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsup index.ts --format esm,cjs --dts --clean --external vue --external @virid/core --external reflect-metadata --external inversify"
+  }
+}