@hadss/hmrouter-plugin 1.1.0-beta.0 → 1.1.1-alpha.0

package/dist/Index.js

@@ -1,129 +1,49 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.harPlugin = exports.hspPlugin = exports.hapPlugin = void 0;
-const hvigor_1 = require("@ohos/hvigor");
 const hvigor_ohos_plugin_1 = require("@ohos/hvigor-ohos-plugin");
-const Logger_1 = require("./common/Logger");
-const CommonConstants_1 = __importDefault(require("./constants/CommonConstants"));
-const TsAstUtil_1 = require("./utils/TsAstUtil");
-const FileUtil_1 = __importDefault(require("./utils/FileUtil"));
-const HMRouterPluginHandle_1 = require("./HMRouterPluginHandle");
-const PluginStore_1 = __importDefault(require("./store/PluginStore"));
-class HMRouterPluginMgr {
-    constructor() {
-        this.hmRouterPluginSet = new Set();
-        hvigor_1.hvigor.nodesEvaluated(() => {
-            this.hmRouterPluginSet.forEach((pluginHandle) => {
-                pluginHandle.start();
-            });
-        });
-        hvigor_1.hvigor.buildFinished(() => {
-            Logger_1.Logger.info('buildFinished deleteFile exec...');
-            this.hmRouterPluginSet.forEach((pluginHandle) => {
-                if (pluginHandle.config.saveGeneratedFile) {
-                    Logger_1.Logger.info(pluginHandle.config.moduleName + ' saveGeneratedFile is true, skip deleting');
-                    return;
-                }
-                this.deleteRouterMapFile(pluginHandle);
-                this.deleteRawFile(pluginHandle);
-                this.deleteGeneratorFile(pluginHandle);
-                if (pluginHandle.config.autoObfuscation) {
-                    this.deleteObfuscationFile(pluginHandle);
-                }
-            });
-            HMRouterPluginMgrInstance = null;
-            TsAstUtil_1.TsAstUtil.clearProject();
-        });
-    }
-    registerHMRouterPlugin(node, pluginId) {
-        const moduleContext = node.getContext(pluginId);
-        if (!moduleContext) {
-            Logger_1.Logger.error(Logger_1.PluginError.ERR_ERROR_CONFIG, node.getNodePath());
-            throw new Error('moduleContext is null');
-        }
-        let pluginHandle = new HMRouterPluginHandle_1.HMRouterPluginHandle(node, moduleContext);
-        let packageJson = FileUtil_1.default.readJson5(FileUtil_1.default.pathResolve(node.getNodePath(), 'oh-package.json5'));
-        if (pluginId === hvigor_ohos_plugin_1.OhosPluginId.OHOS_HAP_PLUGIN) {
-            pluginHandle.config.moduleName = packageJson.name;
-        }
-        if (pluginId === hvigor_ohos_plugin_1.OhosPluginId.OHOS_HSP_PLUGIN) {
-            PluginStore_1.default.getInstance().hspModuleNames.push(packageJson.name);
-        }
-        this.hmRouterPluginSet.add(pluginHandle);
-    }
-    deleteGeneratorFile(pluginHandle) {
-        let builderDirPath = pluginHandle.config.getBuilderDir();
-        if (FileUtil_1.default.exist(builderDirPath)) {
-            FileUtil_1.default.rmSync(builderDirPath, {
-                recursive: true
-            });
-            Logger_1.Logger.info(pluginHandle.config.modulePath + ' delete builder dir');
-        }
-    }
-    deleteRouterMapFile(pluginHandle) {
-        let routerMapDirPath = pluginHandle.config.getRouterMapDir();
-        if (FileUtil_1.default.exist(routerMapDirPath)) {
-            FileUtil_1.default.unlinkSync(routerMapDirPath);
-            Logger_1.Logger.info(routerMapDirPath + ' delete hm_router_map.json');
-        }
-    }
-    deleteRawFile(pluginHandle) {
-        let rawFilePath = pluginHandle.config.getRawFilePath();
-        if (FileUtil_1.default.exist(rawFilePath)) {
-            FileUtil_1.default.unlinkSync(rawFilePath);
-            Logger_1.Logger.info(pluginHandle.config.modulePath + ' delete rawfile hm_router_map.json');
-        }
-    }
-    deleteObfuscationFile(pluginHandle) {
-        let obfuscationFilePath = pluginHandle.config.getObfuscationFilePath();
-        if (FileUtil_1.default.exist(obfuscationFilePath)) {
-            FileUtil_1.default.unlinkSync(obfuscationFilePath);
-            Logger_1.Logger.info(pluginHandle.config.modulePath + ' delete obfuscation hmrouter-obfuscation-rules.txt');
-        }
-        let consumerRulesPath = pluginHandle.config.getConsumerRulesFilePath();
-        if (FileUtil_1.default.exist(consumerRulesPath)) {
-            FileUtil_1.default.unlinkSync(consumerRulesPath);
-            Logger_1.Logger.info(pluginHandle.config.modulePath + ' delete hmrouter-consumer-rules.txt');
-        }
-    }
-}
-let HMRouterPluginMgrInstance = null;
-function hapPlugin() {
+const constants_1 = require("./hmrouter_extension/constants");
+const HMRouterPluginManager_1 = require("./HMRouterPluginManager");
+__exportStar(require("./framework/utils"), exports);
+__exportStar(require("./framework/extension"), exports);
+function hapPlugin(options = {}) {
     return {
-        pluginId: CommonConstants_1.default.HAP_PLUGIN_ID,
+        pluginId: constants_1.PluginConstants.HAP_PLUGIN_ID,
         apply(node) {
-            if (!HMRouterPluginMgrInstance) {
-                HMRouterPluginMgrInstance = new HMRouterPluginMgr();
-            }
-            HMRouterPluginMgrInstance.registerHMRouterPlugin(node, hvigor_ohos_plugin_1.OhosPluginId.OHOS_HAP_PLUGIN);
-        }
+            HMRouterPluginManager_1.HMRouterPluginManager.getInstance().registerPlugin(node, hvigor_ohos_plugin_1.OhosPluginId.OHOS_HAP_PLUGIN, options);
+        },
     };
 }
 exports.hapPlugin = hapPlugin;
-function hspPlugin() {
+function hspPlugin(options = {}) {
     return {
-        pluginId: CommonConstants_1.default.HSP_PLUGIN_ID,
+        pluginId: constants_1.PluginConstants.HSP_PLUGIN_ID,
         apply(node) {
-            if (!HMRouterPluginMgrInstance) {
-                HMRouterPluginMgrInstance = new HMRouterPluginMgr();
-            }
-            HMRouterPluginMgrInstance.registerHMRouterPlugin(node, hvigor_ohos_plugin_1.OhosPluginId.OHOS_HSP_PLUGIN);
-        }
+            HMRouterPluginManager_1.HMRouterPluginManager.getInstance().registerPlugin(node, hvigor_ohos_plugin_1.OhosPluginId.OHOS_HSP_PLUGIN, options);
+        },
     };
 }
 exports.hspPlugin = hspPlugin;
-function harPlugin() {
+function harPlugin(options = {}) {
     return {
-        pluginId: CommonConstants_1.default.HAR_PLUGIN_ID,
+        pluginId: constants_1.PluginConstants.HAR_PLUGIN_ID,
         apply(node) {
-            if (!HMRouterPluginMgrInstance) {
-                HMRouterPluginMgrInstance = new HMRouterPluginMgr();
-            }
-            HMRouterPluginMgrInstance.registerHMRouterPlugin(node, hvigor_ohos_plugin_1.OhosPluginId.OHOS_HAR_PLUGIN);
-        }
+            HMRouterPluginManager_1.HMRouterPluginManager.getInstance().registerPlugin(node, hvigor_ohos_plugin_1.OhosPluginId.OHOS_HAR_PLUGIN, options);
+        },
     };
 }
 exports.harPlugin = harPlugin;

package/dist/framework/constants/TaskConstants.d.ts

@@ -0,0 +1,8 @@
+export declare class TaskConstants {
+    static readonly PRE_BUILD = "@PreBuild";
+    static readonly PROCESS_ROUTER_MAP = "@ProcessRouterMap";
+    static readonly PROCESS_RESOURCE = "@ProcessResource";
+    static readonly PLUGIN_TASK = "@HMRouterPluginTask";
+    static readonly COPY_ROUTER_MAP_TASK = "@HMRouterCopyRouterMapToRawFileTask";
+    static readonly GENERATE_OBFUSCATION_TASK = "@HMRouterGenerateObfuscationFileTask";
+}

package/dist/framework/constants/TaskConstants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskConstants = void 0;
+class TaskConstants {
+}
+exports.TaskConstants = TaskConstants;
+TaskConstants.PRE_BUILD = '@PreBuild';
+TaskConstants.PROCESS_ROUTER_MAP = '@ProcessRouterMap';
+TaskConstants.PROCESS_RESOURCE = '@ProcessResource';
+TaskConstants.PLUGIN_TASK = '@HMRouterPluginTask';
+TaskConstants.COPY_ROUTER_MAP_TASK = '@HMRouterCopyRouterMapToRawFileTask';
+TaskConstants.GENERATE_OBFUSCATION_TASK = '@HMRouterGenerateObfuscationFileTask';

package/dist/framework/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './TaskConstants';

package/dist/framework/constants/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./TaskConstants"), exports);

package/dist/framework/core/PluginExecutionController.d.ts

@@ -0,0 +1,15 @@
+import { HvigorNode } from '@ohos/hvigor';
+import { OhosModuleContext } from '@ohos/hvigor-ohos-plugin/src/plugin/context/plugin-context';
+import { PluginExtension } from '../extension';
+export declare class PluginExecutionController {
+    private readonly node;
+    private readonly moduleContext;
+    private readonly taskManager;
+    private readonly baseContext;
+    private extensionContextCache;
+    constructor(node: HvigorNode, moduleContext: OhosModuleContext, moduleExtensions?: PluginExtension[]);
+    start(): void;
+    complete(): void;
+    private initializeContext;
+    private registerHvigorTasks;
+}

package/dist/framework/core/PluginExecutionController.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginExecutionController = void 0;
+const TaskManager_1 = require("./TaskManager");
+const TaskStage_1 = require("./TaskStage");
+const constants_1 = require("../constants");
+const extension_1 = require("../extension");
+class PluginExecutionController {
+    constructor(node, moduleContext, moduleExtensions) {
+        this.extensionContextCache = new Map();
+        this.node = node;
+        this.moduleContext = moduleContext;
+        this.baseContext = this.initializeContext();
+        this.taskManager = new TaskManager_1.TaskManager(this.baseContext, moduleExtensions);
+    }
+    start() {
+        this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_INITIALIZE);
+        this.registerHvigorTasks();
+    }
+    complete() {
+        this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_COMPLETION);
+    }
+    initializeContext() {
+        const context = new extension_1.ExtensionContextImpl(this.node, this.moduleContext);
+        context.scanFiles = [];
+        return context;
+    }
+    registerHvigorTasks() {
+        this.moduleContext.targets((target) => {
+            const targetName = target.getTargetName();
+            this.node.registerTask({
+                name: targetName + constants_1.TaskConstants.PLUGIN_TASK,
+                run: () => {
+                    this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_ANNOTATION_ANALYSIS);
+                    this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_CODE_GENERATION);
+                    this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_ROUTER_MAP_BUILDING);
+                    this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_CONFIG_UPDATE);
+                },
+                dependencies: [],
+                postDependencies: [targetName + constants_1.TaskConstants.PRE_BUILD],
+            });
+            this.node.registerTask({
+                name: targetName + constants_1.TaskConstants.GENERATE_OBFUSCATION_TASK,
+                run: () => {
+                    this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_OBFUSCATION_PROCESS);
+                },
+                dependencies: [targetName + constants_1.TaskConstants.PLUGIN_TASK],
+                postDependencies: [targetName + constants_1.TaskConstants.PRE_BUILD],
+            });
+            this.node.registerTask({
+                name: targetName + constants_1.TaskConstants.COPY_ROUTER_MAP_TASK,
+                run: () => {
+                    this.taskManager.context.currentTarget = target;
+                    this.taskManager.executeStage(TaskStage_1.TaskStage.AFTER_RESOURCE_PROCESS);
+                },
+                dependencies: [targetName + constants_1.TaskConstants.PROCESS_ROUTER_MAP],
+                postDependencies: [targetName + constants_1.TaskConstants.PROCESS_RESOURCE],
+            });
+        });
+    }
+}
+exports.PluginExecutionController = PluginExecutionController;

package/dist/framework/core/TaskManager.d.ts

@@ -0,0 +1,12 @@
+import { ExtensionContext, PluginExtension } from '../extension';
+import { TaskStage } from './TaskStage';
+export declare class TaskManager {
+    private extensionManager;
+    private readonly moduleExtensions;
+    context: ExtensionContext;
+    constructor(context: ExtensionContext, moduleExtensions?: PluginExtension[]);
+    executeStage(stage: TaskStage): void;
+    private executeAnnotationAnalysis;
+    private getExtensions;
+    private validateTemplateData;
+}

package/dist/framework/core/TaskManager.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskManager = void 0;
+const extension_1 = require("../extension");
+const utils_1 = require("../utils");
+const TaskStage_1 = require("./TaskStage");
+class TaskManager {
+    constructor(context, moduleExtensions) {
+        this.extensionManager = extension_1.ExtensionManager.getInstance();
+        this.moduleExtensions = moduleExtensions || [];
+        this.context = context;
+    }
+    executeStage(stage) {
+        switch (stage) {
+            case TaskStage_1.TaskStage.AFTER_ANNOTATION_ANALYSIS:
+                this.executeAnnotationAnalysis();
+                break;
+            default:
+                this.getExtensions().forEach((extension) => {
+                    const methodName = stage.toString();
+                    extension[methodName]?.(this.context);
+                });
+                break;
+        }
+    }
+    executeAnnotationAnalysis() {
+        const analyzers = this.getExtensions()
+            .map((extension) => extension.afterAnnotationAnalysis || null);
+        this.context.scanFiles.forEach((file) => {
+            this.context.setCurrentFilePath(file);
+            const sourceFile = utils_1.TsAstUtil.getSourceFile(file);
+            for (const analyzer of analyzers) {
+                analyzer?.(sourceFile, file, this.context);
+            }
+        });
+        this.context.setCurrentFilePath('');
+        this.validateTemplateData();
+    }
+    getExtensions() {
+        const globalExtensions = this.extensionManager.getExtensions();
+        const allExtensions = globalExtensions.concat(this.moduleExtensions);
+        return allExtensions.sort((a, b) => {
+            const aIsHMRouter = a.name?.includes('HMRouter') || false;
+            const bIsHMRouter = b.name?.includes('HMRouter') || false;
+            if (aIsHMRouter && !bIsHMRouter)
+                return -1;
+            if (!aIsHMRouter && bIsHMRouter)
+                return 1;
+            return 0;
+        });
+    }
+    validateTemplateData() {
+        const componentNames = new Set();
+        this.context.getAnalyzeResults().forEach((result) => {
+            if (result.name) {
+                componentNames.add(result.name);
+            }
+        });
+        const templateComponentNames = new Set(this.context.getTemplateDataMap().keys());
+        templateComponentNames.forEach((name) => {
+            if (!componentNames.has(name)) {
+                utils_1.Logger.warn(this.context.node.getNodeName(), `Component ${name} has template data but was not found in analyze results.`);
+            }
+        });
+    }
+}
+exports.TaskManager = TaskManager;

package/dist/framework/core/TaskStage.d.ts

@@ -0,0 +1,10 @@
+export declare enum TaskStage {
+    AFTER_INITIALIZE = "afterInitialize",
+    AFTER_ANNOTATION_ANALYSIS = "afterAnnotationAnalysis",
+    AFTER_CODE_GENERATION = "afterCodeGeneration",
+    AFTER_ROUTER_MAP_BUILDING = "afterRouterMapBuilding",
+    AFTER_CONFIG_UPDATE = "afterConfigUpdate",
+    AFTER_OBFUSCATION_PROCESS = "afterObfuscationProcess",
+    AFTER_RESOURCE_PROCESS = "afterResourceProcess",
+    AFTER_COMPLETION = "afterCompletion"
+}

package/dist/framework/core/TaskStage.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskStage = void 0;
+var TaskStage;
+(function (TaskStage) {
+    TaskStage["AFTER_INITIALIZE"] = "afterInitialize";
+    TaskStage["AFTER_ANNOTATION_ANALYSIS"] = "afterAnnotationAnalysis";
+    TaskStage["AFTER_CODE_GENERATION"] = "afterCodeGeneration";
+    TaskStage["AFTER_ROUTER_MAP_BUILDING"] = "afterRouterMapBuilding";
+    TaskStage["AFTER_CONFIG_UPDATE"] = "afterConfigUpdate";
+    TaskStage["AFTER_OBFUSCATION_PROCESS"] = "afterObfuscationProcess";
+    TaskStage["AFTER_RESOURCE_PROCESS"] = "afterResourceProcess";
+    TaskStage["AFTER_COMPLETION"] = "afterCompletion";
+})(TaskStage = exports.TaskStage || (exports.TaskStage = {}));

package/dist/framework/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from './TaskManager';
+export * from './TaskStage';
+export * from './PluginExecutionController';

package/dist/framework/core/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./TaskManager"), exports);
+__exportStar(require("./TaskStage"), exports);
+__exportStar(require("./PluginExecutionController"), exports);

package/dist/framework/extension/ExtensionManager.d.ts

@@ -0,0 +1,11 @@
+import { PluginExtension } from './PluginExtension';
+export declare class ExtensionManager {
+    private static instance;
+    private extensions;
+    static getInstance(): ExtensionManager;
+    static destroy(): void;
+    registerExtension(extension: PluginExtension): void;
+    getExtensions(): PluginExtension[];
+    private clear;
+}
+export declare function registerPluginExtension(extension: PluginExtension): void;

package/dist/framework/extension/ExtensionManager.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPluginExtension = exports.ExtensionManager = void 0;
+class ExtensionManager {
+    constructor() {
+        this.extensions = [];
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new ExtensionManager();
+        }
+        return this.instance;
+    }
+    static destroy() {
+        this.instance = null;
+        this.getInstance().clear();
+    }
+    registerExtension(extension) {
+        this.extensions.push(extension);
+    }
+    getExtensions() {
+        return this.extensions;
+    }
+    clear() {
+        this.extensions = [];
+    }
+}
+exports.ExtensionManager = ExtensionManager;
+ExtensionManager.instance = null;
+function registerPluginExtension(extension) {
+    ExtensionManager.getInstance().registerExtension(extension);
+}
+exports.registerPluginExtension = registerPluginExtension;

package/dist/framework/extension/PluginExtension.d.ts

@@ -0,0 +1,13 @@
+import { ExtensionContext } from '../extension';
+import { SourceFile } from 'ts-morph';
+export declare abstract class PluginExtension<T extends ExtensionContext = ExtensionContext> {
+    abstract get name(): string;
+    afterInitialize?(context: T): void;
+    afterAnnotationAnalysis?(sourceFile: SourceFile, filePath: string, context: T): void;
+    afterCodeGeneration?(context: T): void;
+    afterRouterMapBuilding?(context: T): void;
+    afterConfigUpdate?(context: T): void;
+    afterObfuscationProcess?(context: T): void;
+    afterResourceProcess?(context: T): void;
+    afterCompletion?(context: T): void;
+}

package/dist/framework/extension/PluginExtension.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginExtension = void 0;
+class PluginExtension {
+}
+exports.PluginExtension = PluginExtension;

package/dist/framework/extension/context/ExtensionContextImpl.d.ts

@@ -0,0 +1,23 @@
+import { HvigorNode } from '@ohos/hvigor';
+import { OhosModuleContext, Target } from '@ohos/hvigor-ohos-plugin/src/plugin/context/plugin-context';
+import { BaseAnalyzeResult, ExtensionContext } from './Interface';
+export declare class ExtensionContextImpl implements ExtensionContext {
+    node: HvigorNode;
+    moduleContext: OhosModuleContext;
+    currentTarget?: Target;
+    scanFiles: string[];
+    private templateMetadata;
+    private analyzeResults;
+    private _currentView;
+    private _currentFilePath?;
+    constructor(node: HvigorNode, moduleContext: OhosModuleContext);
+    get currentView(): ReadonlyArray<BaseAnalyzeResult>;
+    addAnalyzeResults(results: BaseAnalyzeResult | BaseAnalyzeResult[]): void;
+    getAnalyzeResults<T extends BaseAnalyzeResult = BaseAnalyzeResult>(): Set<T>;
+    getTemplateData(componentName: string): Record<string, any> | undefined;
+    getTemplateDataMap(): Map<string, Record<string, any>>;
+    addTemplateData(componentName: string, data: Record<string, any>): void;
+    private validateAnalyzeResult;
+    private syncToCurrentView;
+    setCurrentFilePath(filePath: string): void;
+}

package/dist/framework/extension/context/ExtensionContextImpl.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionContextImpl = void 0;
+const TemplateMetadataImpl_1 = require("./TemplateMetadataImpl");
+const utils_1 = require("../../utils");
+class ExtensionContextImpl {
+    constructor(node, moduleContext) {
+        this.scanFiles = [];
+        this.analyzeResults = new Set();
+        this._currentView = [];
+        this.node = node;
+        this.moduleContext = moduleContext;
+        this.templateMetadata = new TemplateMetadataImpl_1.TemplateMetadataImpl();
+    }
+    get currentView() {
+        return this._currentView;
+    }
+    addAnalyzeResults(results) {
+        if (Array.isArray(results)) {
+            results.forEach((result) => {
+                if (!this.validateAnalyzeResult(result)) {
+                    utils_1.Logger.warn(this.node.getNodeName(), `Invalid analyze result: ${JSON.stringify(result)}`);
+                    return;
+                }
+                this.analyzeResults.add(result);
+            });
+        }
+        else {
+            if (!this.validateAnalyzeResult(results)) {
+                utils_1.Logger.warn(this.node.getNodeName(), `Invalid analyze result: ${JSON.stringify(results)}`);
+                return;
+            }
+            this.analyzeResults.add(results);
+        }
+        this.syncToCurrentView(results);
+    }
+    getAnalyzeResults() {
+        return this.analyzeResults;
+    }
+    getTemplateData(componentName) {
+        return this.templateMetadata.getTemplateData(componentName);
+    }
+    getTemplateDataMap() {
+        return this.templateMetadata.templateDataMap;
+    }
+    addTemplateData(componentName, data) {
+        this.templateMetadata.addTemplateData(componentName, data);
+    }
+    validateAnalyzeResult(result) {
+        return result.name !== undefined && result.sourceFilePath !== undefined && result.annotation !== undefined;
+    }
+    syncToCurrentView(results) {
+        if (!this._currentFilePath)
+            return;
+        const resultsArray = Array.isArray(results) ? results : [results];
+        const currentFileResults = resultsArray.filter(result => result.sourceFilePath === this._currentFilePath);
+        this._currentView.push(...currentFileResults);
+    }
+    setCurrentFilePath(filePath) {
+        this._currentFilePath = filePath;
+        this._currentView = [];
+    }
+}
+exports.ExtensionContextImpl = ExtensionContextImpl;

package/dist/framework/extension/context/Interface.d.ts

@@ -0,0 +1,21 @@
+import { HvigorNode } from '@ohos/hvigor';
+import { OhosModuleContext, Target } from '@ohos/hvigor-ohos-plugin/src/plugin/context/plugin-context';
+export interface BaseAnalyzeResult {
+    name: string;
+    annotation: string;
+    sourceFilePath: string;
+}
+export interface BaseExtensionContext {
+    readonly node: HvigorNode;
+    readonly moduleContext: OhosModuleContext;
+    readonly currentView: ReadonlyArray<BaseAnalyzeResult>;
+    currentTarget?: Target;
+    scanFiles: string[];
+}
+export interface ExtensionContext extends BaseExtensionContext {
+    getAnalyzeResults<T extends BaseAnalyzeResult = BaseAnalyzeResult>(): Set<T>;
+    addAnalyzeResults(results: BaseAnalyzeResult | BaseAnalyzeResult[]): void;
+    getTemplateData(componentName: string): Record<string, any> | undefined;
+    getTemplateDataMap(): Map<string, Record<string, any>>;
+    addTemplateData(componentName: string, data: Record<string, any>): void;
+}

package/dist/framework/extension/context/Interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/framework/extension/context/TemplateMetadataImpl.d.ts

@@ -0,0 +1,12 @@
+export interface TemplateMetadata {
+    currentFilePath: string;
+    templateDataMap: Map<string, Record<string, any>>;
+    addTemplateData(componentName: string, data: Record<string, any>): void;
+    getTemplateData(componentName: string): Record<string, any> | undefined;
+}
+export declare class TemplateMetadataImpl implements TemplateMetadata {
+    currentFilePath: string;
+    templateDataMap: Map<string, Record<string, any>>;
+    addTemplateData(componentName: string, data: Record<string, any>): void;
+    getTemplateData(componentName: string): Record<string, any> | undefined;
+}

package/dist/framework/extension/context/TemplateMetadataImpl.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateMetadataImpl = void 0;
+class TemplateMetadataImpl {
+    constructor() {
+        this.currentFilePath = '';
+        this.templateDataMap = new Map();
+    }
+    addTemplateData(componentName, data) {
+        if (this.templateDataMap.has(componentName)) {
+            const existing = this.templateDataMap.get(componentName) || {};
+            this.templateDataMap.set(componentName, { ...existing, ...data });
+        }
+        else {
+            this.templateDataMap.set(componentName, data);
+        }
+    }
+    getTemplateData(componentName) {
+        return this.templateDataMap.get(componentName);
+    }
+}
+exports.TemplateMetadataImpl = TemplateMetadataImpl;

package/dist/framework/extension/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ExtensionManager';
+export * from './PluginExtension';
+export * from './context/Interface';
+export * from './context/ExtensionContextImpl';