@kkarum/framework 2.3.17

package/Framework.ts

@@ -0,0 +1,337 @@
+import "reflect-metadata";
+import { Container, interfaces } from "inversify";
+
+export class Framework implements FW.Framework {
+  private container: Container;
+  private registry: Map<string, new () => FW.Registry>;
+  private registeredComponents: Map<string, FW.RegisterFramework[]> = new Map();
+
+  initialize() {
+    this.container = new Container({
+      defaultScope: "Singleton",
+      autoBindInjectable: true,
+    });
+    this.registry = new Map<string, new () => FW.Registry>();
+    this.registeredComponents.clear();
+  }
+
+  public getContainer(): Container {
+    return this.container;
+  }
+
+  /** 获取组件 */
+  public getComponent<T>(serviceIdentifier: FW.ServiceIdentifier<T>): T {
+    if (typeof serviceIdentifier === "string") {
+      if (this.container.isBound(serviceIdentifier)) {
+        return this.container.get<T>(serviceIdentifier);
+      }
+    } else if (typeof serviceIdentifier === "function") {
+      const className = serviceIdentifier?.name;
+
+      if (this.container.isBound(serviceIdentifier)) {
+        return this.container.get<T>(serviceIdentifier);
+      }
+
+      const suffixMap = {
+        Logic: FW.SystemDefine.FWBindTag.LOGIC,
+        Data: FW.SystemDefine.FWBindTag.DATA,
+        Config: FW.SystemDefine.FWBindTag.CONFIG,
+        Sender: FW.SystemDefine.FWBindTag.SENDER,
+        Handle: FW.SystemDefine.FWBindTag.HANDLE,
+      };
+
+      const [suffix] =
+        Object.entries(suffixMap).find(([key]) => className.endsWith(key)) ||
+        [];
+
+      if (suffix) {
+        const bundleName = FW.Entry.bundleName;
+        const tag = suffixMap[suffix as keyof typeof suffixMap];
+        const bindingKey = this.getKey(bundleName, tag);
+        if (this.container.isBound(bindingKey)) {
+          return this.container.get<T>(bindingKey);
+        }
+      }
+      return this.getComponents(serviceIdentifier)[0];
+    }
+  }
+
+  /** 获取所有组件 */
+  public getComponents<T>(serviceIdentifier: FW.ServiceIdentifier<T>): T[] {
+    const instances: T[] = [];
+
+    if (typeof serviceIdentifier === "string") {
+      if (this.container.isBound(serviceIdentifier)) {
+        instances.push(this.container.get<T>(serviceIdentifier));
+      }
+      return instances;
+    }
+
+    if (typeof serviceIdentifier === "function") {
+      for (const registrations of this.registeredComponents.values()) {
+        for (const data of registrations) {
+          const classes = [
+            data.logic,
+            data.data,
+            data.config,
+            data.sender,
+            data.handle,
+          ];
+
+          for (const cls of classes) {
+            if (!cls) continue;
+
+            if (!this.isSubclassOf(cls, serviceIdentifier)) continue;
+
+            try {
+              const instance = this.getComponent<T>(cls as any);
+              if (instance && !instances.includes(instance)) {
+                instances.push(instance);
+              }
+            } catch (e) {
+              FW.Log.warn(
+                `Error getting component instance for ${cls.name}:`,
+                e,
+              );
+            }
+          }
+        }
+      }
+    }
+
+    return instances;
+  }
+
+  /**
+   * 是否已经注册注册表
+   * @param bundleName
+   * @returns
+   */
+  hasRegistry(bundleName: string) {
+    return this.registry.has(bundleName);
+  }
+
+  /**
+   * 添加进注册表
+   * @param bundleName
+   * @param registry
+   */
+  addRegistry(bundleName: string, registry: new () => FW.Registry) {
+    this.registry.set(bundleName, registry);
+  }
+
+  /**
+   * 获取注册表
+   * @param bundleName
+   */
+  getRegistry(bundleName: string): FW.Registry {
+    if (this.registry.has(bundleName)) {
+      return this.container.get(this.registry.get(bundleName));
+    }
+    return undefined;
+  }
+
+  /**
+   * 创建注册表实例
+   */
+  createRegistry(bundleName: string): FW.Registry {
+    if (!this.registry.has(bundleName)) return;
+    this.container
+      .bind(this.registry.get(bundleName))
+      .toSelf()
+      .inSingletonScope();
+    return this.getRegistry(bundleName);
+  }
+
+  /**
+   * 销毁注册表实例
+   * @param bundleName
+   */
+  destroyRegistry(bundleName: string) {
+    if (!this.registry.has(bundleName)) return;
+    this.container.unbind(this.registry.get(bundleName));
+  }
+
+  /**
+   * 注册数据
+   * @param data
+   */
+  register(data: FW.RegisterFramework) {
+    const classes = [
+      data.logic,
+      data.data,
+      data.config,
+      data.sender,
+      data.handle,
+    ];
+    classes.forEach((cls, index) => {
+      if (cls && !this.container.isBound(cls)) {
+        this.container.bind(cls).toSelf().inSingletonScope();
+        this.container.bind(this.getKey(data.bundleName, index)).toService(cls);
+      }
+    });
+
+    this.recordRegistration(data);
+
+    classes.forEach((cls) => {
+      if (cls && this.container.isBound(cls)) {
+        try {
+          const instance = this.container.get(cls) as FW.FrameworkBase;
+          instance?.initializeDependencies?.();
+        } catch (error) {
+          FW.Log.warn(
+            `Error initializing dependencies for ${cls.name}:`,
+            error,
+          );
+        }
+      }
+    });
+  }
+
+  /**
+   * 注销数据
+   * @param data
+   * @returns
+   */
+  unRegister(data: FW.RegisterFramework) {
+    const classes = [
+      data.logic,
+      data.data,
+      data.config,
+      data.sender,
+      data.handle,
+    ];
+    classes.forEach((cls, index) => {
+      const key = this.getKey(data.bundleName, index);
+      if (cls && this.container.isBound(cls)) {
+        this.container.get(key)?.["onDestroy"]?.();
+        this.container.unbind(cls);
+      }
+      if (this.container.isBound(key)) {
+        this.container.get(key)?.["onDestroy"]?.();
+        this.container.unbind(this.getKey(data.bundleName, index));
+      }
+    });
+    this.removeRegistration(data);
+  }
+  /**
+   * 获取注册表
+   * @param bundleName
+   * @param tag
+   * @returns
+   */
+  private recordRegistration(data: FW.RegisterFramework) {
+    const bundleName = data.bundleName;
+    if (!this.registeredComponents.has(bundleName)) {
+      this.registeredComponents.set(bundleName, []);
+    }
+
+    const registrations = this.registeredComponents.get(bundleName)!;
+
+    if (!registrations) return;
+
+    const exists = registrations.some(
+      (reg) =>
+        reg.logic === data.logic &&
+        reg.data === data.data &&
+        reg.config === data.config &&
+        reg.sender === data.sender &&
+        reg.handle === data.handle,
+    );
+
+    if (!exists) {
+      registrations.push({ ...data });
+    }
+  }
+
+  private removeRegistration(data: FW.RegisterFramework) {
+    const bundleName = data.bundleName;
+    if (this.registeredComponents.has(bundleName)) {
+      const registrations = this.registeredComponents.get(bundleName)!;
+      const index = registrations.findIndex(
+        (reg) =>
+          reg.logic === data.logic &&
+          reg.data === data.data &&
+          reg.config === data.config &&
+          reg.sender === data.sender &&
+          reg.handle === data.handle,
+      );
+
+      if (index !== -1) {
+        registrations.splice(index, 1);
+      }
+
+      if (registrations.length === 0) {
+        this.registeredComponents.delete(bundleName);
+      }
+    }
+  }
+
+  public restart(): void {
+    this.destroyAllComponents();
+    this.container.unbindAll();
+    this.container = new Container({
+      defaultScope: "Singleton",
+      autoBindInjectable: true,
+    });
+    this.reregisterAllComponents();
+  }
+
+  private destroyAllComponents(): void {
+    const binder = (this.container as any)._bindingDictionary;
+    const map = binder._map;
+
+    for (const [key, bindings] of map.entries()) {
+      for (const binding of bindings) {
+        try {
+          if (this.container.isBound(binding.serviceIdentifier)) {
+            const instance = this.container.get(binding.serviceIdentifier);
+            instance?.["onDestroy"]?.();
+          }
+        } catch (e) {
+          FW.Log.warn(`Error destroying component ${key}:`, e);
+        }
+      }
+    }
+  }
+
+  private reregisterAllComponents(): void {
+    for (const [
+      bundleName,
+      registrations,
+    ] of this.registeredComponents.entries()) {
+      for (const data of registrations) {
+        try {
+          this.register(data);
+        } catch (e) {
+          console.error(
+            `Error re-registering component for bundle ${bundleName}:`,
+            e,
+          );
+        }
+      }
+    }
+  }
+
+  public getRegisteredComponents(): Map<string, FW.RegisterFramework[]> {
+    return new Map(this.registeredComponents);
+  }
+
+  private getKey(bundleName: string, tag: FW.SystemDefine.FWBindTag) {
+    return `${bundleName}${tag}`;
+  }
+
+  private isSubclassOf(child: any, parent: any): boolean {
+    if (typeof child !== "function" || typeof parent !== "function") {
+      return false;
+    }
+    let current = child;
+    while (current) {
+      if (current === parent) {
+        return true;
+      }
+      current = Object.getPrototypeOf(current);
+    }
+    return false;
+  }
+}

package/Framework.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "6bdfdbc1-c1fe-463c-a55f-b5880e026610",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/FrameworkBase.ts

@@ -0,0 +1,207 @@
+import { injectable } from "inversify";
+
+@injectable()
+export abstract class FrameworkBase {
+  public _logic?: FW.Logic;
+  public data?: FW.Data;
+  public config?: FW.AssetConfig;
+  public sender?: FW.Sender;
+  public handle?: FW.Handle;
+  private dependenciesInjected: boolean = false;
+  private isInitialized: boolean = false;
+  protected abstract initialize?(): void;
+  protected abstract onDestroy?(): void;
+  protected onRestart?(): void;
+  get entry() {
+    return FW.Entry;
+  }
+
+  get logic() {
+    return this._logic;
+  }
+
+  set logic(value: FW.Logic) {
+    this._logic = value;
+  }
+
+  constructor() {
+    this.initialize?.();
+    this.entry.evtMgr.register(
+      FW.EventDefine.SystemEvent.SYSTEM_RESTART,
+      this.onRestart,
+      this,
+    );
+  }
+
+  protected get moduleName(): string {
+    return cc.js.getClassName(this);
+  }
+
+  public getLogic<T extends FW.Logic = FW.Logic>() {
+    return this.logic as T;
+  }
+
+  public getData<T extends FW.Data = FW.Data>() {
+    return this.data as T;
+  }
+
+  public getSender<T extends FW.Sender>() {
+    return this.sender as T;
+  }
+
+  public getHandle<T extends FW.Handle>() {
+    return this.handle as T;
+  }
+
+  public getConfig<T extends FW.AssetConfig>() {
+    return this.config as T;
+  }
+
+  public initializeDependencies(): void {
+    if (this.dependenciesInjected || this.isInitialized) return;
+
+    const bundleName = this.findBundleNameByClassName();
+    if (!bundleName) {
+      if (FW.Entry?.engineMgr?.debug) {
+        FW.Log.warn(
+          `[FrameworkBase] 未能根据类名 "${this.moduleName}" 推断出 bundleName，跳过依赖注入`,
+        );
+      }
+      return;
+    }
+
+    const tag = this.getClassTag();
+    if (tag === undefined) {
+      if (FW.Entry?.engineMgr?.debug) {
+        FW.Log.warn(
+          `[FrameworkBase] 未能根据类名 "${this.moduleName}" 推断出绑定类型（Logic/Data/Config/Sender/Handle），跳过依赖注入`,
+        );
+      }
+      return;
+    }
+
+    // 只有在 bundleName / tag 均解析成功时，才标记为已初始化，避免无效的“锁死”状态
+    this.dependenciesInjected = true;
+    this.isInitialized = true;
+
+    if (tag !== FW.SystemDefine.FWBindTag.LOGIC) {
+      this.logic = FW.Entry.getComponent<FW.Logic>(
+        `${bundleName}${FW.SystemDefine.FWBindTag.LOGIC}`,
+      );
+    }
+
+    if (tag !== FW.SystemDefine.FWBindTag.DATA) {
+      this.data = FW.Entry.getComponent<FW.Data>(
+        `${bundleName}${FW.SystemDefine.FWBindTag.DATA}`,
+      );
+    }
+
+    if (tag !== FW.SystemDefine.FWBindTag.CONFIG) {
+      this.config = FW.Entry.getComponent<FW.AssetConfig>(
+        `${bundleName}${FW.SystemDefine.FWBindTag.CONFIG}`,
+      );
+    }
+
+    if (tag !== FW.SystemDefine.FWBindTag.SENDER) {
+      this.sender = FW.Entry.getComponent<FW.Sender>(
+        `${bundleName}${FW.SystemDefine.FWBindTag.SENDER}`,
+      );
+    }
+
+    if (tag !== FW.SystemDefine.FWBindTag.HANDLE) {
+      this.handle = FW.Entry.getComponent<FW.Handle>(
+        `${bundleName}${FW.SystemDefine.FWBindTag.HANDLE}`,
+      );
+    }
+  }
+
+  protected async invoke<T>(
+    operation: Promise<T>,
+    operationName: string = "unknown",
+  ): Promise<T> {
+    const startTime = this.getCurrentTime();
+
+    try {
+      const result = await operation;
+      const duration = this.getCurrentTime() - startTime;
+      this.recordPerformanceMetric(operationName, duration);
+      return result;
+    } catch (error) {
+      this.handleError(operationName, error);
+      return undefined;
+    }
+  }
+
+  private recordPerformanceMetric(
+    operationName: string,
+    duration: number,
+  ): void {
+    if (FW.Entry.performanceMgr) {
+      FW.Entry.performanceMgr.recordOperationMetric(
+        this.moduleName,
+        operationName,
+        duration,
+      );
+    }
+
+    const shouldWarn = duration > 1000;
+
+    if (FW.Entry.engineMgr.debug || shouldWarn) {
+      const log = shouldWarn ? FW.Log.warn : FW.Log.debug;
+      log(
+        `[${this.moduleName?.toUpperCase()}] Operation ${operationName} took ${duration}ms`,
+      );
+    }
+  }
+
+  protected handleError(operation: string, error: any): void {
+    const errorInfo = {
+      type: this.moduleName,
+      operation,
+      error: error?.message || error,
+      stack: error?.stack,
+    };
+
+    FW.Log.error(`Error in ${this.moduleName}.${operation}:`, errorInfo);
+  }
+
+  protected getCurrentTime(): number {
+    return Date.now();
+  }
+
+  private findBundleNameByClassName(): string | undefined {
+    const registeredComponents = FW.Framework.getRegisteredComponents();
+
+    const bundleNames = Array.from(registeredComponents.keys());
+
+    for (const bundleName of bundleNames) {
+      if (this.doesClassNameContainBundleName(this.moduleName, bundleName)) {
+        return bundleName;
+      }
+    }
+
+    return undefined;
+  }
+
+  private doesClassNameContainBundleName(
+    className: string,
+    bundleName: string,
+  ): boolean {
+    const bundleNameLower = bundleName.toLowerCase();
+    const classNameLower = className.toLowerCase();
+    return classNameLower.includes(bundleNameLower);
+  }
+
+  private getClassTag(): FW.SystemDefine.FWBindTag {
+    const className = this.moduleName;
+    if (className.endsWith("Logic")) return FW.SystemDefine.FWBindTag.LOGIC;
+    if (className.endsWith("Data")) return FW.SystemDefine.FWBindTag.DATA;
+    if (className.endsWith("Config") || className.endsWith("AssetConfig"))
+      return FW.SystemDefine.FWBindTag.CONFIG;
+    if (className.endsWith("Sender") || className.endsWith("SocketSender"))
+      return FW.SystemDefine.FWBindTag.SENDER;
+    if (className.endsWith("Handle") || className.endsWith("SocketHandle"))
+      return FW.SystemDefine.FWBindTag.HANDLE;
+    return;
+  }
+}

package/FrameworkBase.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "abc42759-95e6-4156-a144-7ef424305eb6",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/FrameworkInitialize.ts

@@ -0,0 +1,79 @@
+export function initializeFramework() {
+  const WD = window as any;
+  const SD = require("./define/FWSystemDefine");
+  const ED = require("./define/FWEventDefine");
+
+  // 防止重复初始化导致状态错乱（例如热重载或多次调用）
+  if (WD.FW && WD.FW.Framework && WD.FW.Entry) {
+    return;
+  }
+
+  WD.FW = {};
+
+  globalThis.FWPropertyNode = require("./expand/FWDecorator").FWPropertyNode;
+  globalThis.searchChild = require("./expand/FWDecorator").searchChild;
+  globalThis.FWPropertyNode = require("./expand/FWDecorator").FWPropertyNode;
+  globalThis.FWPropertyNodes = require("./expand/FWDecorator").FWPropertyNodes;
+  globalThis.FWPropertyComponent =
+    require("./expand/FWDecorator").FWPropertyComponent;
+  globalThis.FWPropertyComponents =
+    require("./expand/FWDecorator").FWPropertyComponents;
+  globalThis.PerformanceMonitor =
+    require("./expand/FWDecorator").PerformanceMonitor;
+  globalThis.FWDeprecated = require("./expand/FWDecorator").FWDeprecated;
+  globalThis.FWSocketAutoProcessPause =
+    require("./expand/FWDecorator").FWSocketAutoProcessPause;
+  globalThis.FWSocketAutoProcessResume =
+    require("./expand/FWDecorator").FWSocketAutoProcessResume;
+  globalThis.RegisterEvents = require("./expand/FWDecorator").RegisterEvents;
+  globalThis.AutoRegisterCCEvent =
+    require("./expand/FWDecorator").AutoRegisterCCEvent;
+  globalThis.AutoRegisterFWEvent =
+    require("./expand/FWDecorator").AutoRegisterFWEvent;
+  globalThis.launchScene = "";
+
+  (FW.SystemDefine as any) = {};
+  (FW.EventDefine as any) = {};
+
+  FW.EventDefine.CCEvent = new ED.CCEvent();
+  FW.EventDefine.LanguageEvent = new ED.LanguageEvent();
+  FW.EventDefine.SystemEvent = new ED.SystemEvent();
+  FW.EventDefine.TaskEvent = new ED.TaskEvent();
+  FW.SystemDefine.FWBindTag = new SD.FWBindTag();
+  FW.SystemDefine.FWObjectType = new SD.FWObjectType();
+  FW.SystemDefine.FWLayerRenderOrder = new SD.FWLayerRenderOrder();
+  FW.SystemDefine.FWLayerType = new SD.FWLayerType();
+  FW.SystemDefine.FWTaskStatus = new SD.FWTaskStatus();
+  FW.SystemDefine.FWPriorityOrder = new SD.FWPriorityOrder();
+  FW.SystemDefine.FWLogType = new SD.FWLogType();
+  FW.SystemDefine.FWHttpRequestType = new SD.FWHttpRequestType();
+  FW.SystemDefine.FWAnimationMachineType = new SD.FWAnimationMachineType();
+  FW.SystemDefine.FWScrollViewTemplateType = new SD.FWScrollViewTemplateType();
+  FW.SystemDefine.FWScrollViewSlideType = new SD.FWScrollViewSlideType();
+  FW.SystemDefine.FWScrollViewSelectedType = new SD.FWScrollViewSelectedType();
+  FW.SystemDefine.FWLanguageAssetType = new SD.FWLanguageAssetType();
+  FW.SystemDefine.FWPromiseStatus = new SD.FWPromiseStatus();
+  FW.SystemDefine.FWLayerState = new SD.FWLayerState();
+  FW.SystemDefine.FWAudioType = new SD.FWAudioType();
+  FW.Service = require("./service/FWService").FWService;
+  FW.Http = require("./service/http/FWHttp").FWHttp;
+  FW.Registry = require("./registry/FWRegistry").FWRegistry;
+  FW.Framework = new (require("./Framework").Framework)();
+  FW.FrameworkBase = require("./FrameworkBase").FrameworkBase;
+  FW.Object = require("./utils/FWObject").FWObject;
+  FW.Entry = new (require("./entry/FWEntry").FWEntry)();
+  FW.Scene = require("./scene/FWScene").FWScene;
+  FW.Logic = require("./logic/FWLogic").FWLogic;
+  FW.Data = require("./data/FWData").FWData;
+  FW.Sender = require("./service/socket/FWSocketSender").FWSocketSender;
+  FW.Handle = require("./service/socket/FWSocketHandle").FWSocketHandle;
+  FW.AssetConfig = require("./config/FWAssetConfig").FWAssetConfig;
+  FW.Log = new (require("./log/FWLog").FWLog)();
+  FW.Layer = require("./layer/FWLayer").FWLayer;
+  FW.LayerController =
+    require("./controller/FWLayerController").FWLayerController;
+  FW.SocketMock =
+    new (require("./service/socket/mock/FWSocketMock").FWSocketMock)();
+  FW.Framework.initialize();
+  FW.Entry.initialize();
+}

package/FrameworkInitialize.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "b1d4b4b3-2ea2-47b3-a76d-95a406ae7cb6",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}