react-native-fxview 1.0.0 → 1.0.2

package/FXViewController.d.ts

@@ -0,0 +1,115 @@
+import React from "react";
+import { FXComponentController, FXComponentItem } from "./types";
+export declare class FXViewController {
+    fxViewId: string;
+    updateCallback?: () => void;
+    private categoryControllerMap;
+    constructor(fxViewId: string);
+    /**
+     * 创建并显示组件
+     * @param component 组件内容
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     * @param componentId 组件 ID（可选，自动生成）
+     * @returns 组件控制器
+     */
+    add(component: React.ReactNode, categoryId?: string, componentId?: string): FXComponentController;
+    /**
+     * 创建但不显示组件
+     * @param component 组件内容
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     * @param componentId 组件 ID（可选，自动生成）
+     * @returns 组件控制器
+     */
+    build(component: React.ReactNode, categoryId?: string, componentId?: string): FXComponentController;
+    /**
+     * 显示已存在的组件
+     * @param componentId 组件 ID
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    show(componentId: string, categoryId?: string): void;
+    /**
+     * 隐藏但不删除组件
+     * @param componentId 组件 ID
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    hide(componentId: string, categoryId?: string): void;
+    /**
+     * 更新组件内容
+     * @param componentId 组件 ID
+     * @param component 新的组件内容
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    update(componentId: string, component: React.ReactNode, categoryId?: string): void;
+    /**
+     * 彻底删除组件
+     * @param componentId 组件 ID
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    remove(componentId: string, categoryId?: string): void;
+    /**
+     * 移除最后一个组件（向后兼容）
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    removeLast(categoryId?: string): void;
+    /**
+     * 清空所有分类的所有组件
+     */
+    clearAll(): void;
+    /**
+     * 清空指定分类的所有组件
+     * @param categoryId 分类 ID
+     */
+    clearCategory(categoryId?: string): void;
+    /**
+     * 注册更新回调
+     * @param callback 更新回调函数
+     */
+    registerUpdateCallback(callback?: () => void): void;
+    /**
+     * 获取组件列表
+     * @param filterOptions 过滤选项
+     * @returns 组件列表
+     */
+    getComponents(categoryId?: string): FXComponentItem[];
+    /**
+     * 获取总组件数量
+     * @returns 组件数量
+     */
+    getComponentCount(): number;
+    /**
+     * 获取可见组件数量
+     * @returns 可见组件数量
+     */
+    getVisibleComponentCount(): number;
+    /**
+     * 检查组件是否存在
+     * @param componentId 组件 ID
+     * @param categoryId 分类 ID（可选）
+     * @returns 是否存在
+     */
+    hasComponent(componentId: string, categoryId?: string): boolean;
+    /**
+     * 检查组件是否可见
+     * @param componentId 组件 ID
+     * @param categoryId 分类 ID（可选）
+     * @returns 是否可见
+     */
+    isComponentVisible(componentId: string, categoryId?: string): boolean;
+    /**
+     * 获取分类控制器
+     * @param categoryId 分类 ID
+     * @returns 分类控制器或 null
+     */
+    private getCategoryController;
+    /**
+     * 获取或创建分类控制器
+     * @param categoryId 分类 ID
+     * @returns 分类控制器
+     */
+    private getCategoryControllerOrCreate;
+    /**
+     * 删除分类控制器
+     * @param categoryId 分类 ID
+     */
+    private removeCategory;
+}

package/FXViewController.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FXViewController = void 0;
+const FXCategoryController_1 = require("./FXCategoryController");
+class FXViewController {
+    constructor(fxViewId) {
+        // 存储各分类的控制器
+        this.categoryControllerMap = new Map();
+        this.fxViewId = fxViewId;
+    }
+    //#region ========== 主要 API 方法 ==========
+    /**
+     * 创建并显示组件
+     * @param component 组件内容
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     * @param componentId 组件 ID（可选，自动生成）
+     * @returns 组件控制器
+     */
+    add(component, categoryId, componentId) {
+        console.log("FXViewController.add", `[${this.fxViewId}]`, {
+            categoryId,
+            componentId,
+        });
+        const categoryController = this.getCategoryControllerOrCreate(categoryId);
+        return categoryController.add(component, componentId);
+    }
+    /**
+     * 创建但不显示组件
+     * @param component 组件内容
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     * @param componentId 组件 ID（可选，自动生成）
+     * @returns 组件控制器
+     */
+    build(component, categoryId, componentId) {
+        console.log("FXViewController.build", `[${this.fxViewId}]`, {
+            categoryId,
+            componentId,
+        });
+        const categoryController = this.getCategoryControllerOrCreate(categoryId);
+        return categoryController.build(component, componentId);
+    }
+    /**
+     * 显示已存在的组件
+     * @param componentId 组件 ID
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    show(componentId, categoryId) {
+        console.log("FXViewController.show", `[${this.fxViewId}]`, {
+            categoryId,
+            componentId,
+        });
+        const categoryController = this.getCategoryController(categoryId);
+        if (!categoryController) {
+            console.warn(`CategoryController ${categoryId || "default"} not found in view ${this.fxViewId}`);
+            return;
+        }
+        categoryController.show(componentId);
+    }
+    /**
+     * 隐藏但不删除组件
+     * @param componentId 组件 ID
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    hide(componentId, categoryId) {
+        console.log("FXViewController.hide", `[${this.fxViewId}]`, {
+            categoryId,
+            componentId,
+        });
+        const categoryController = this.getCategoryController(categoryId);
+        if (!categoryController) {
+            console.warn(`CategoryController ${categoryId || "default"} not found in view ${this.fxViewId}`);
+            return;
+        }
+        categoryController.hide(componentId);
+    }
+    /**
+     * 更新组件内容
+     * @param componentId 组件 ID
+     * @param component 新的组件内容
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    update(componentId, component, categoryId) {
+        console.log("FXViewController.update", `[${this.fxViewId}]`, {
+            categoryId,
+            componentId,
+        });
+        const categoryController = this.getCategoryController(categoryId);
+        if (!categoryController) {
+            console.warn(`CategoryController ${categoryId || "default"} not found in view ${this.fxViewId}`);
+            return;
+        }
+        categoryController.update(componentId, component);
+    }
+    /**
+     * 彻底删除组件
+     * @param componentId 组件 ID
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    remove(componentId, categoryId) {
+        console.log("FXViewController.remove", `[${this.fxViewId}]`, {
+            categoryId,
+            componentId,
+        });
+        const categoryController = this.getCategoryController(categoryId);
+        if (!categoryController) {
+            console.warn(`CategoryController ${categoryId || "default"} not found in view ${this.fxViewId}`);
+            return;
+        }
+        categoryController.remove(componentId);
+        // 如果该分类没有组件了，删除整个分类控制器
+        if (categoryController.getComponentCount() === 0) {
+            this.removeCategory(categoryId);
+        }
+    }
+    /**
+     * 移除最后一个组件（向后兼容）
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    removeLast(categoryId) {
+        console.log("FXViewController.removeLast", `[${this.fxViewId}]`, {
+            categoryId,
+        });
+        const categoryController = this.getCategoryController(categoryId);
+        if (!categoryController) {
+            console.warn(`CategoryController ${categoryId || "default"} not found in view ${this.fxViewId}`);
+            return;
+        }
+        categoryController.removeLast();
+        // 如果该分类没有组件了，删除整个分类控制器
+        if (categoryController.getComponentCount() === 0) {
+            this.removeCategory(categoryId);
+        }
+    }
+    /**
+     * 清空所有分类的所有组件
+     */
+    clearAll() {
+        console.log("FXViewController.clearAll", `[${this.fxViewId}]`);
+        this.categoryControllerMap.forEach((controller) => {
+            controller.clearAll();
+        });
+        this.categoryControllerMap.clear();
+        console.log("FXViewController.clearAll done", this.categoryControllerMap.size);
+    }
+    /**
+     * 清空指定分类的所有组件
+     * @param categoryId 分类 ID
+     */
+    clearCategory(categoryId) {
+        const finalCategoryId = categoryId || "default";
+        console.log("FXViewController.clearCategory", `[${this.fxViewId}]`, {
+            categoryId: finalCategoryId,
+        });
+        const categoryController = this.getCategoryController(categoryId);
+        if (!categoryController) {
+            console.warn(`CategoryController ${finalCategoryId} not found in view ${this.fxViewId}`);
+            return;
+        }
+        categoryController.clearAll();
+        this.categoryControllerMap.delete(finalCategoryId);
+    }
+    /**
+     * 注册更新回调
+     * @param callback 更新回调函数
+     */
+    registerUpdateCallback(callback) {
+        this.updateCallback = callback;
+        // 将回调传递给所有已存在的分类控制器
+        this.categoryControllerMap.forEach((controller) => {
+            controller.registerUpdateCallback(callback);
+        });
+    }
+    /**
+     * 获取组件列表
+     * @param filterOptions 过滤选项
+     * @returns 组件列表
+     */
+    getComponents(categoryId) {
+        const result = [];
+        this.categoryControllerMap.forEach((categoryController, category) => {
+            // 如果指定了类别，只处理指定类别
+            if (categoryId && categoryId !== category) {
+                return;
+            }
+            const categoryComponents = categoryController.getComponents();
+            result.push(...categoryComponents);
+        });
+        return result;
+    }
+    /**
+     * 获取总组件数量
+     * @returns 组件数量
+     */
+    getComponentCount() {
+        let count = 0;
+        this.categoryControllerMap.forEach((controller) => {
+            count += controller.getComponentCount();
+        });
+        return count;
+    }
+    /**
+     * 获取可见组件数量
+     * @returns 可见组件数量
+     */
+    getVisibleComponentCount() {
+        let count = 0;
+        this.categoryControllerMap.forEach((controller) => {
+            count += controller.getVisibleComponentCount();
+        });
+        return count;
+    }
+    /**
+     * 检查组件是否存在
+     * @param componentId 组件 ID
+     * @param categoryId 分类 ID（可选）
+     * @returns 是否存在
+     */
+    hasComponent(componentId, categoryId) {
+        var _a;
+        if (categoryId) {
+            const controller = this.getCategoryController(categoryId);
+            return (_a = controller === null || controller === void 0 ? void 0 : controller.hasComponent(componentId)) !== null && _a !== void 0 ? _a : false;
+        }
+        // 如果没有指定分类，搜索所有分类
+        for (const controller of this.categoryControllerMap.values()) {
+            if (controller.hasComponent(componentId)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 检查组件是否可见
+     * @param componentId 组件 ID
+     * @param categoryId 分类 ID（可选）
+     * @returns 是否可见
+     */
+    isComponentVisible(componentId, categoryId) {
+        var _a;
+        if (categoryId) {
+            const controller = this.getCategoryController(categoryId);
+            return (_a = controller === null || controller === void 0 ? void 0 : controller.isVisible(componentId)) !== null && _a !== void 0 ? _a : false;
+        }
+        // 如果没有指定分类，搜索所有分类
+        for (const controller of this.categoryControllerMap.values()) {
+            if (controller.hasComponent(componentId)) {
+                return controller.isVisible(componentId);
+            }
+        }
+        return false;
+    }
+    //#endregion
+    //#region ========== 私有方法 ==========
+    /**
+     * 获取分类控制器
+     * @param categoryId 分类 ID
+     * @returns 分类控制器或 null
+     */
+    getCategoryController(categoryId) {
+        const finalCategoryId = categoryId || "default";
+        return this.categoryControllerMap.get(finalCategoryId) || null;
+    }
+    /**
+     * 获取或创建分类控制器
+     * @param categoryId 分类 ID
+     * @returns 分类控制器
+     */
+    getCategoryControllerOrCreate(categoryId) {
+        const finalCategoryId = categoryId || "default";
+        let categoryController = this.categoryControllerMap.get(finalCategoryId);
+        if (!categoryController) {
+            categoryController = new FXCategoryController_1.FXCategoryController(this.fxViewId, finalCategoryId, this.updateCallback);
+            this.categoryControllerMap.set(finalCategoryId, categoryController);
+        }
+        return categoryController;
+    }
+    /**
+     * 删除分类控制器
+     * @param categoryId 分类 ID
+     */
+    removeCategory(categoryId) {
+        const finalCategoryId = categoryId || "default";
+        console.log("FXViewController.removeCategory", `[${this.fxViewId}]`, {
+            categoryId: finalCategoryId,
+        });
+        this.categoryControllerMap.delete(finalCategoryId);
+    }
+}
+exports.FXViewController = FXViewController;

package/FXViewController.ts

@@ -1,14 +1,13 @@
 import React from "react";
-import { ComponentController, ComponentItem } from "./types";
-import { FXViewCategoryController } from "./FXViewCategoryController";
+import { FXComponentController, FXComponentItem } from "./types";
+import { FXCategoryController } from "./FXCategoryController";
 
 export class FXViewController {
   public fxViewId: string;
   public updateCallback?: () => void;
 
   // 存储各分类的控制器
-  private categoryControllerMap: Map<string, FXViewCategoryController> =
-    new Map();
+  private categoryControllerMap: Map<string, FXCategoryController> = new Map();
 
   constructor(fxViewId: string) {
     this.fxViewId = fxViewId;
@@ -27,7 +26,7 @@ export class FXViewController {
     component: React.ReactNode,
     categoryId?: string,
     componentId?: string,
-  ): ComponentController {
+  ): FXComponentController {
     console.log("FXViewController.add", `[${this.fxViewId}]`, {
       categoryId,
       componentId,
@@ -48,7 +47,7 @@ export class FXViewController {
     component: React.ReactNode,
     categoryId?: string,
     componentId?: string,
-  ): ComponentController {
+  ): FXComponentController {
     console.log("FXViewController.build", `[${this.fxViewId}]`, {
       categoryId,
       componentId,
@@ -191,6 +190,10 @@ export class FXViewController {
       controller.clearAll();
     });
     this.categoryControllerMap.clear();
+    console.log(
+      "FXViewController.clearAll done",
+      this.categoryControllerMap.size,
+    );
   }
 
   /**
@@ -233,8 +236,8 @@ export class FXViewController {
    * @param filterOptions 过滤选项
    * @returns 组件列表
    */
-  getComponents(categoryId?: string): ComponentItem[] {
-    const result: ComponentItem[] = [];
+  getComponents(categoryId?: string): FXComponentItem[] {
+    const result: FXComponentItem[] = [];
 
     this.categoryControllerMap.forEach((categoryController, category) => {
       // 如果指定了类别，只处理指定类别
@@ -325,7 +328,7 @@ export class FXViewController {
    */
   private getCategoryController(
     categoryId?: string,
-  ): FXViewCategoryController | null {
+  ): FXCategoryController | null {
     const finalCategoryId = categoryId || "default";
     return this.categoryControllerMap.get(finalCategoryId) || null;
   }
@@ -337,13 +340,13 @@ export class FXViewController {
    */
   private getCategoryControllerOrCreate(
     categoryId?: string,
-  ): FXViewCategoryController {
+  ): FXCategoryController {
     const finalCategoryId = categoryId || "default";
 
     let categoryController = this.categoryControllerMap.get(finalCategoryId);
 
     if (!categoryController) {
-      categoryController = new FXViewCategoryController(
+      categoryController = new FXCategoryController(
         this.fxViewId,
         finalCategoryId,
         this.updateCallback,

package/FXViewManager.d.ts

@@ -0,0 +1,146 @@
+import React from "react";
+import { FXComponentController, FXComponentItem, FXLifecycleCallbacks } from "./types";
+import { FXViewController } from "./FXViewController";
+export declare class FXViewManager {
+    private static instance;
+    private viewControllerMap;
+    private fxViewIdQueue;
+    private viewLifecycleCallbacks;
+    static getInstance(): FXViewManager;
+    /**
+     * 创建并显示组件
+     * @param component 组件内容
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     * @param componentId 组件 ID（可选，自动生成）
+     * @returns 组件控制器
+     */
+    add(component: React.ReactNode, fxViewId?: string, categoryId?: string, componentId?: string): FXComponentController;
+    /**
+     * 创建但不显示组件
+     * @param component 组件内容
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     * @param componentId 组件 ID（可选，自动生成）
+     * @returns 组件控制器
+     */
+    build(component: React.ReactNode, fxViewId?: string, categoryId?: string, componentId?: string): FXComponentController;
+    /**
+     * 显示已存在的组件
+     * @param componentId 组件 ID
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    show(componentId: string, fxViewId?: string, categoryId?: string): void;
+    /**
+     * 隐藏但不删除组件
+     * @param componentId 组件 ID
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    hide(componentId: string, fxViewId?: string, categoryId?: string): void;
+    /**
+     * 更新组件内容
+     * @param componentId 组件 ID
+     * @param component 新的组件内容
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    update(componentId: string, component: React.ReactNode, fxViewId?: string, categoryId?: string): void;
+    /**
+     * 彻底删除组件
+     * @param componentId 组件 ID
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    remove(componentId: string, fxViewId?: string, categoryId?: string): void;
+    /**
+     * 移除最后一个组件（向后兼容）
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @param categoryId 分类 ID（可选，默认 "default"）
+     */
+    removeLast(fxViewId?: string, categoryId?: string): void;
+    /**
+     * 清空指定视图的所有组件
+     * @param fxViewId 视图 ID（可选，清空所有视图）
+     */
+    clearAll(fxViewId?: string): void;
+    /**
+     * 清空指定分类的所有组件
+     * @param categoryId 分类 ID
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     */
+    clearCategory(categoryId: string, fxViewId?: string): void;
+    /**
+     * 注册视图（FXView 挂载时调用）
+     * @param fxViewId 视图 ID
+     * @param updateCallback 更新回调函数
+     * @returns 视图控制器
+     */
+    registerView(fxViewId: string, updateCallback: () => void): FXViewController;
+    /**
+     * 注销视图（FXView 卸载时调用）
+     * @param fxViewId 视图 ID
+     * @returns 是否成功注销
+     */
+    unregisterView(fxViewId: string): boolean;
+    registerLifecycleCallbacks(callbacks: FXLifecycleCallbacks): void;
+    unregisterLifecycleCallbacks(callbacks: FXLifecycleCallbacks): void;
+    /**
+     * 获取最近使用的视图 ID（栈顶）
+     * @returns 最近的视图 ID 或 null
+     */
+    getLatestFXViewId(): string | null;
+    /**
+     * 获取组件列表
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @param categoryId 分类 ID（可选）
+     * @returns 组件列表
+     */
+    getComponents(fxViewId?: string, categoryId?: string): FXComponentItem[];
+    /**
+     * 获取组件数量
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @returns 组件数量
+     */
+    getComponentCount(fxViewId?: string): number;
+    /**
+     * 获取可见组件数量
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @returns 可见组件数量
+     */
+    getVisibleComponentCount(fxViewId?: string): number;
+    /**
+     * 检查组件是否存在
+     * @param componentId 组件 ID
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @param categoryId 分类 ID（可选）
+     * @returns 是否存在
+     */
+    hasComponent(componentId: string, fxViewId?: string, categoryId?: string): boolean;
+    /**
+     * 检查组件是否可见
+     * @param componentId 组件 ID
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @param categoryId 分类 ID（可选）
+     * @returns 是否可见
+     */
+    isComponentVisible(componentId: string, fxViewId?: string, categoryId?: string): boolean;
+    /**
+     * 获取视图控制器
+     * @param fxViewId 视图 ID（可选，使用最近的视图）
+     * @returns 视图控制器或 null
+     */
+    private getViewController;
+    /**
+     * 获取或创建视图控制器
+     * @param fxViewId 视图 ID（可选，使用最近的视图或创建新的）
+     * @returns 视图控制器
+     */
+    private getViewControllerOrCreate;
+    /**
+     * 自动生成 fxViewId
+     * @returns 生成的 fxViewId
+     */
+    private autoFXViewId;
+}