@hadss/hmrouter-plugin 1.0.0-rc.9 → 1.1.1-alpha.0

package/dist/hmrouter_extension/processor/ObfuscationProcessor.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObfuscationProcessor = void 0;
+const framework_1 = require("../../framework");
+const constants_1 = require("../constants");
+class ObfuscationProcessor {
+    constructor(context) {
+        this.context = context;
+    }
+    execute() {
+        framework_1.Logger.debug(this.context.node.getNodeName(), `Start to obfuscation...`);
+        if (!this.checkObfuscationEnabled()) {
+            framework_1.Logger.info(this.context.node.getNodeName(), 'This compilation does not turn on code obfuscation, skip hmrouter_obfuscation_rules.txt file generation');
+            return;
+        }
+        const obfuscationString = this.generateObfuscationRuleFile();
+        this.handleHarPackageLogic(obfuscationString);
+    }
+    checkObfuscationEnabled() {
+        return this.isEnableObfuscation();
+    }
+    generateObfuscationRuleFile() {
+        const obfuscationFilePath = framework_1.PluginFileUtil.pathResolve(this.context.config.modulePath, constants_1.FilePathConstants.OBFUSCATION_FILE_NAME);
+        const routerMap = JSON.parse(framework_1.PluginFileUtil.readFileSync(this.context.config.getRouterMapDir()).toString()).routerMap;
+        const obfuscationString = this.buildObfuscatedStrings(routerMap);
+        framework_1.PluginFileUtil.ensureFileSync(obfuscationFilePath);
+        framework_1.PluginFileUtil.writeFileSync(obfuscationFilePath, obfuscationString);
+        framework_1.Logger.info(this.context.node.getNodeName(), `Generate obfuscation rule file successfully, filePath: ${obfuscationFilePath}`);
+        return obfuscationString;
+    }
+    handleHarPackageLogic(obfuscationString) {
+        if (this.context.moduleContext.getModuleType() === constants_1.PluginConstants.HAR_MODULE_NAME) {
+            const consumerRulesPath = framework_1.PluginFileUtil.pathResolve(this.context.config.modulePath, constants_1.FilePathConstants.CONSUMER_FILE_NAME);
+            framework_1.PluginFileUtil.ensureFileSync(consumerRulesPath);
+            framework_1.PluginFileUtil.writeFileSync(consumerRulesPath, obfuscationString);
+        }
+    }
+    isEnableObfuscation() {
+        const currentBuildMode = framework_1.PluginStore.getInstance().get('buildMode');
+        const buildOption = this.context.moduleContext
+            ?.getBuildProfileOpt()
+            .buildOptionSet?.find((item) => item.name === currentBuildMode);
+        if (!buildOption) {
+            return false;
+        }
+        const arkOptions = framework_1.ObjectUtils.ensureNestedObject(buildOption, ['arkOptions']);
+        const obfuscationOptions = framework_1.ObjectUtils.ensureNestedObject(arkOptions, ['obfuscation']);
+        const ruleOptions = framework_1.ObjectUtils.ensureNestedObject(obfuscationOptions, ['ruleOptions']);
+        const isObfuscationEnabled = !!ruleOptions.enable;
+        if (!isObfuscationEnabled) {
+            return false;
+        }
+        if (this.context.config?.autoObfuscation) {
+            this.addHMRouterObfuscationRules(ruleOptions, obfuscationOptions);
+        }
+        return true;
+    }
+    addHMRouterObfuscationRules(ruleOptions, obfuscationOptions) {
+        const obfuscationFilePath = constants_1.FilePathConstants.CURRENT_DELIMITER + constants_1.FilePathConstants.OBFUSCATION_FILE_NAME;
+        ruleOptions.files = this.appendFilePathSafely(ruleOptions.files, obfuscationFilePath);
+        if (this.context.moduleContext.getModuleType() === constants_1.PluginConstants.HAR_MODULE_NAME) {
+            const consumerRulesPath = constants_1.FilePathConstants.CURRENT_DELIMITER + constants_1.FilePathConstants.CONSUMER_FILE_NAME;
+            obfuscationOptions.consumerFiles = this.appendFilePathSafely(obfuscationOptions.consumerFiles, consumerRulesPath);
+        }
+    }
+    appendFilePathSafely(target, filePath) {
+        if (typeof target === 'string') {
+            return target === filePath ? [target] : [target, filePath];
+        }
+        else if (Array.isArray(target)) {
+            if (!target.includes(filePath)) {
+                target.push(filePath);
+            }
+            return target;
+        }
+        else {
+            return [filePath];
+        }
+    }
+    buildObfuscatedStrings(routerMap) {
+        let srcPathArr = [
+            ...new Set(routerMap.map((routerInfo) => {
+                return constants_1.FilePathConstants.CURRENT_DELIMITER + routerInfo.pageSourceFile;
+            })),
+        ];
+        let classNameArr = [
+            ...new Set(routerMap
+                .filter((routerInfo) => {
+                return routerInfo.name.includes('__');
+            })
+                .map((routerInfo) => {
+                return routerInfo.customData.className;
+            })),
+        ];
+        let functionName = [
+            ...new Set(routerMap
+                .filter((routerInfo) => {
+                return routerInfo.name.includes(constants_1.PrefixConstants.SERVICE_PREFIX);
+            })
+                .map((routerInfo) => {
+                return routerInfo.customData.functionName;
+            })),
+        ];
+        let watchFunctionName = [
+            ...new Set(routerMap
+                .filter((routerInfo) => {
+                return routerInfo.buildFunction;
+            })
+                .map((routerInfo) => {
+                return routerInfo.buildFunction + constants_1.TemplateConstants.WARP_BUILDER;
+            })),
+        ];
+        return (constants_1.ObfuscationConstants.KEEP_FILE_NAME +
+            constants_1.FilePathConstants.LINE_BREAK +
+            srcPathArr
+                .concat(constants_1.ObfuscationConstants.KEEP_PROPERTY_NAME, functionName)
+                .concat(constants_1.ObfuscationConstants.KEEP_GLOBAL_NAME, classNameArr, watchFunctionName)
+                .join(constants_1.FilePathConstants.LINE_BREAK));
+    }
+}
+exports.ObfuscationProcessor = ObfuscationProcessor;

package/dist/hmrouter_extension/processor/ResourceProcessor.d.ts

@@ -0,0 +1,9 @@
+import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
+export declare class ResourceProcessProcessor {
+    private context;
+    constructor(context: HMRouterExtensionContext);
+    execute(): void;
+    private copyRouterMapToRawFile;
+    private processHspModuleName;
+    private getRemoteHspModuleNames;
+}

package/dist/hmrouter_extension/processor/ResourceProcessor.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceProcessProcessor = void 0;
+const framework_1 = require("../../framework");
+const constants_1 = require("../constants");
+class ResourceProcessProcessor {
+    constructor(context) {
+        this.context = context;
+    }
+    execute() {
+        framework_1.Logger.debug(this.context.node.getNodeName(), `Start to copy router map to raw file...`);
+        this.copyRouterMapToRawFile();
+        this.processHspModuleName();
+    }
+    copyRouterMapToRawFile() {
+        let routerMapFilePath = framework_1.PluginFileUtil.pathResolve(this.context.currentTarget?.getBuildTargetOutputPath(), constants_1.FilePathConstants.TEMP_ROUTER_MAP_PATH, this.context.currentTarget?.getTargetName(), constants_1.RouterMapConstants.ROUTER_MAP_NAME);
+        let rawFilePath = this.context.config.getRawFilePath();
+        framework_1.PluginFileUtil.ensureFileSync(rawFilePath);
+        framework_1.PluginFileUtil.copyFileSync(routerMapFilePath, rawFilePath);
+        framework_1.Logger.info(this.context.node.getNodeName(), `Copy router map to raw file successfully, filePath: ${rawFilePath}`);
+    }
+    processHspModuleName() {
+        if (!(0, framework_1.isHapModule)(this.context.node)) {
+            return;
+        }
+        let rawFilePath = this.context.config.getRawFilePath();
+        let rawFileRouterMap = JSON.parse(framework_1.PluginFileUtil.readFileSync(rawFilePath).toString());
+        rawFileRouterMap.hspModuleNames = [...new Set(framework_1.PluginStore.getInstance().get('hspModuleNames'))];
+        rawFileRouterMap.hspModuleNames.push(...this.getRemoteHspModuleNames(this.context.node.getAllPluginIds()));
+        framework_1.PluginFileUtil.writeFileSync(rawFilePath, JSON.stringify(rawFileRouterMap));
+    }
+    getRemoteHspModuleNames(pluginIds) {
+        let remoteHspModuleNames = [];
+        try {
+            pluginIds.forEach((id) => {
+                let context = this.context.node.getContext(id);
+                let signedHspObj = context.getOhpmRemoteHspDependencyInfo(true);
+                let remoteHspObj = context.getOhpmRemoteHspDependencyInfo(false);
+                for (const key in signedHspObj) {
+                    remoteHspModuleNames.push(signedHspObj[key].name);
+                }
+                for (const key in remoteHspObj) {
+                    remoteHspModuleNames.push(remoteHspObj[key].name);
+                }
+            });
+        }
+        catch (error) {
+            framework_1.Logger.warn(this.context.node.getNodeName(), 'Your DevEco Studio version less than 5.0.3.800, may cause remote hsp dependencies get failed');
+        }
+        return remoteHspModuleNames;
+    }
+}
+exports.ResourceProcessProcessor = ResourceProcessProcessor;

package/dist/hmrouter_extension/processor/RouterMapBuildingProcessor.d.ts

@@ -0,0 +1,9 @@
+import { HMRouterExtensionContext } from '../HMRouterExtensionContext';
+export declare class RouterMapBuildingProcessor {
+    private context;
+    constructor(context: HMRouterExtensionContext);
+    execute(): void;
+    private buildRouterMap;
+    private generateRouterMapFile;
+    private readExistingRouterMap;
+}

package/dist/hmrouter_extension/processor/RouterMapBuildingProcessor.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterMapBuildingProcessor = void 0;
+const framework_1 = require("../../framework");
+const constants_1 = require("../constants");
+const AnnotationAnalyzerRegistry_1 = require("../analyzer/AnnotationAnalyzerRegistry");
+const ConstantAnalyzer_1 = require("../analyzer/utils/ConstantAnalyzer");
+const PluginError_1 = require("../error/PluginError");
+class RouterMapBuildingProcessor {
+    constructor(context) {
+        this.context = context;
+    }
+    execute() {
+        framework_1.Logger.debug(this.context.node.getNodeName(), `Start to build router map...`);
+        this.readExistingRouterMap();
+        const constantResolver = AnnotationAnalyzerRegistry_1.AnnotationAnalyzerRegistry.getInstance().getConstantResolver();
+        const constantAnalyzer = new ConstantAnalyzer_1.ConstantAnalyzer(constantResolver);
+        constantAnalyzer.parseConstants(this.context.getAnalyzeResults());
+        for (const result of this.context.getAnalyzeResults()) {
+            this.buildRouterMap(result);
+        }
+        this.generateRouterMapFile();
+    }
+    buildRouterMap(result) {
+        if (!result.sourceFilePath) {
+            throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.ERROR_PAGE_SOURCE_FILE, this.context.config.moduleName, result.sourceFilePath);
+        }
+        let pageSourceFile = this.context.config
+            .getRelativeSourcePath(result.sourceFilePath)
+            .replaceAll(constants_1.FilePathConstants.FILE_SEPARATOR, constants_1.FilePathConstants.DELIMITER);
+        if (result.annotation === constants_1.AnnotationConstants.ROUTER_ANNOTATION) {
+            let pageUrl = result.pageUrl;
+            let builderPath = this.context.generatedPaths.get(result.name) || '';
+            this.context.routerMap.push({
+                name: pageUrl,
+                pageSourceFile: builderPath,
+                buildFunction: result.name + 'Builder',
+                customData: result,
+            });
+            return;
+        }
+        const annotationConfig = {
+            [constants_1.AnnotationConstants.ANIMATOR_ANNOTATION]: {
+                prefix: constants_1.PrefixConstants.ANIMATOR_PREFIX,
+                propertyName: 'animatorName',
+                resultType: 'HMAnimatorResult',
+            },
+            [constants_1.AnnotationConstants.INTERCEPTOR_ANNOTATION]: {
+                prefix: constants_1.PrefixConstants.INTERCEPTOR_PREFIX,
+                propertyName: 'interceptorName',
+                resultType: 'HMInterceptorResult',
+            },
+            [constants_1.AnnotationConstants.LIFECYCLE_ANNOTATION]: {
+                prefix: constants_1.PrefixConstants.LIFECYCLE_PREFIX,
+                propertyName: 'lifecycleName',
+                resultType: 'HMLifecycleResult',
+            },
+            [constants_1.AnnotationConstants.SERVICE_ANNOTATION]: {
+                prefix: constants_1.PrefixConstants.SERVICE_PREFIX,
+                propertyName: 'serviceName',
+                resultType: 'HMServiceResult',
+            },
+            [constants_1.AnnotationConstants.SERVICE_PROVIDE_ANNOTATION]: {
+                prefix: constants_1.PrefixConstants.SERVICE_PROVIDE_PREFIX,
+                propertyName: 'serviceName',
+                resultType: 'HMServiceResult',
+            },
+        };
+        const config = annotationConfig[result.annotation];
+        const nameValue = result[config.propertyName];
+        const fullName = config.prefix + nameValue;
+        this.context.routerMap.push({
+            name: fullName,
+            pageSourceFile: pageSourceFile,
+            buildFunction: '',
+            customData: result,
+        });
+    }
+    generateRouterMapFile() {
+        let set = new Set();
+        this.context.routerMap.forEach((item) => {
+            if (set.has(item.name)) {
+                throw PluginError_1.PluginError.create(PluginError_1.ErrorCode.DUPLICATE_NAME, this.context.config.moduleName, item.name);
+            }
+            set.add(item.name);
+        });
+        let routerMap = {
+            routerMap: this.context.routerMap.map((item) => {
+                if (item.customData && item.customData.annotation) {
+                    delete item.customData.annotation;
+                    delete item.customData.sourceFilePath;
+                    delete item.customData.isDefaultExport;
+                    delete item.customData.templateData;
+                }
+                return item;
+            }),
+        };
+        const routerMapJsonStr = JSON.stringify(routerMap, null, 2);
+        const routerMapFilePath = this.context.config.getRouterMapDir();
+        framework_1.PluginFileUtil.ensureFileSync(routerMapFilePath);
+        framework_1.PluginFileUtil.writeFileSync(routerMapFilePath, routerMapJsonStr);
+        framework_1.Logger.info(this.context.node.getNodeName(), `hm_router_map.json has been generated in ${routerMapFilePath}`);
+    }
+    readExistingRouterMap() {
+        const moduleJsonOpt = this.context.moduleContext.getModuleJsonOpt();
+        if (!moduleJsonOpt?.module.routerMap) {
+            framework_1.Logger.debug(this.context.node.getNodeName(), `No routerMap found in the module configuration`);
+            return;
+        }
+        const routerMapFileName = moduleJsonOpt.module.routerMap.split(':')[1];
+        if (routerMapFileName !== 'hm_router_map') {
+            const routerMapFilePath = this.context.config.getModuleRouterMapFilePath(routerMapFileName);
+            const routerMapObj = framework_1.PluginFileUtil.readJson5(routerMapFilePath);
+            const systemRouterMap = routerMapObj[constants_1.RouterMapConstants.ROUTER_MAP_KEY];
+            if (systemRouterMap && systemRouterMap.length > 0) {
+                this.context.routerMap.unshift(...systemRouterMap);
+                framework_1.Logger.debug(this.context.node.getNodeName(), `System routerMap added to the current routerMap`);
+            }
+        }
+    }
+}
+exports.RouterMapBuildingProcessor = RouterMapBuildingProcessor;

package/dist/hmrouter_extension/processor/index.d.ts

@@ -0,0 +1,7 @@
+export * from './CodeGenerationProcessor';
+export * from './CompletionProcessor';
+export * from './ConfigUpdateProcessor';
+export * from './ObfuscationProcessor';
+export * from './InitializerProcessor';
+export * from './RouterMapBuildingProcessor';
+export * from './ResourceProcessor';

package/dist/hmrouter_extension/processor/index.js

@@ -0,0 +1,23 @@
+"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("./CodeGenerationProcessor"), exports);
+__exportStar(require("./CompletionProcessor"), exports);
+__exportStar(require("./ConfigUpdateProcessor"), exports);
+__exportStar(require("./ObfuscationProcessor"), exports);
+__exportStar(require("./InitializerProcessor"), exports);
+__exportStar(require("./RouterMapBuildingProcessor"), exports);
+__exportStar(require("./ResourceProcessor"), exports);

package/dist/store/PluginStore.d.ts

@@ -0,0 +1,14 @@
+export default class PluginStore implements IPluginStore {
+    private static instance;
+    variableCache: Map<string, Map<string, string[]>>;
+    projectFilePath: string;
+    hspModuleNames: string[];
+    static clear(): void;
+    static getInstance(): IPluginStore;
+}
+interface IPluginStore {
+    variableCache: Map<string, Map<string, string[]>>;
+    projectFilePath: string;
+    hspModuleNames: string[];
+}
+export {};

package/dist/store/PluginStore.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PluginStore {
+    constructor() {
+        this.variableCache = new Map();
+        this.projectFilePath = '';
+        this.hspModuleNames = [];
+    }
+    static clear() {
+        this.instance = null;
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new PluginStore();
+        }
+        return this.instance;
+    }
+}
+exports.default = PluginStore;
+PluginStore.instance = null;

package/dist/utils/FileUtil.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import { FileUtil } from '@ohos/hvigor';
 import fs from 'fs';
 export default class HMFileUtil extends FileUtil {

package/dist/utils/ObfuscationUtil.js

@@ -19,8 +19,14 @@ class ObfuscationUtil {
             }).map((routerInfo) => {
                 return routerInfo.customData.functionName;
             }))];
+        let watchFunctionName = [...new Set(routerMap.filter((routerInfo) => {
+                return routerInfo.buildFunction;
+            }).map((routerInfo) => {
+                return routerInfo.buildFunction + CommonConstants_1.default.WARP_BUILDER;
+            }))];
         return CommonConstants_1.default.KEEP_FILE_NAME + CommonConstants_1.default.LINE_BREAK +
-            srcPathArr.concat(CommonConstants_1.default.KEEP_PROPERTY_NAME, classNameArr, functionName)
+            srcPathArr.concat(CommonConstants_1.default.KEEP_PROPERTY_NAME, functionName)
+                .concat(CommonConstants_1.default.KEEP_GLOBAL_NAME, classNameArr, watchFunctionName)
                 .join(CommonConstants_1.default.LINE_BREAK);
     }
 }

package/dist/utils/TsAstUtil.d.ts

@@ -1,8 +1,9 @@
 import { Project, SourceFile } from 'ts-morph';
 export declare let project: Project | null;
-export declare const importVariableCache: Map<string, string>;
 export declare class TsAstUtil {
-    static getSourceFile(filePath: string): SourceFile | null;
+    static getSourceFile(filePath: string): SourceFile;
     static clearProject(): void;
     static parseConstantValue(sourceFile: SourceFile, variableName: string, propertyName?: string): string;
+    static parseCrossModuleVariable(scanDir: string): Map<string, string[]>;
+    private static getExportedVariables;
 }

package/dist/utils/TsAstUtil.js

@@ -1,15 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TsAstUtil = exports.importVariableCache = exports.project = void 0;
+exports.TsAstUtil = exports.project = void 0;
 const ts_morph_1 = require("ts-morph");
 const hvigor_1 = require("@ohos/hvigor");
 const Logger_1 = require("../common/Logger");
 exports.project = null;
-exports.importVariableCache = new Map();
 class TsAstUtil {
     static getSourceFile(filePath) {
         if (!hvigor_1.FileUtil.exist(filePath)) {
-            return null;
+            Logger_1.Logger.warn(`File not found: ${filePath}`);
+            const normalizedPath = filePath.replace(/\.+\/+/g, './');
+            if (normalizedPath !== filePath && hvigor_1.FileUtil.exist(normalizedPath)) {
+                Logger_1.Logger.info(`Using normalized path instead: ${normalizedPath}`);
+                filePath = normalizedPath;
+            }
+            else {
+                throw new Error(`File not found: ${filePath}`);
+            }
         }
         if (!exports.project) {
             exports.project = new ts_morph_1.Project({
@@ -24,24 +31,24 @@ class TsAstUtil {
     static parseConstantValue(sourceFile, variableName, propertyName) {
         let result;
         if (propertyName) {
-            let classInstance = sourceFile.getClasses().filter((classes) => {
+            let classInstance = sourceFile.getClasses().find((classes) => {
                 return classes.getName() === variableName;
             });
-            if (classInstance.length === 0) {
+            if (!classInstance) {
                 throw new Error(`Unknown class '${variableName}'`);
             }
-            let property = classInstance[0].getProperties().filter((properties) => {
+            let property = classInstance.getProperties().find((properties) => {
                 return properties.getName() === propertyName;
             });
-            if (property.length === 0) {
+            if (!property) {
                 throw new Error(`Unknown property '${propertyName}'`);
             }
-            result = property[0].getInitializer();
+            result = property.getInitializer();
         }
         else {
-            let constant = sourceFile.getVariableDeclarations().filter(declaration => {
+            let constant = sourceFile.getVariableDeclarations().find(declaration => {
                 return declaration.getName() === variableName;
-            })[0];
+            });
             if (!constant) {
                 throw new Error(`Unknown constant '${variableName}'`);
             }
@@ -49,9 +56,42 @@ class TsAstUtil {
         }
         if (result.getKind() !== ts_morph_1.SyntaxKind.StringLiteral) {
             Logger_1.Logger.error(Logger_1.PluginError.ERR_INVALID_STRING_VALUE, variableName);
-            throw new Error('Invalid constant value');
+            throw new Error('Invalid constants value, only string literal is supported, variableName:' + variableName);
         }
         return result.asKind(ts_morph_1.SyntaxKind.StringLiteral)?.getLiteralValue();
     }
+    static parseCrossModuleVariable(scanDir) {
+        let sourceFiles = exports.project.addSourceFilesAtPaths(`${scanDir}/**/*.ets`);
+        const exportMap = new Map();
+        for (let sourceFile of sourceFiles) {
+            const exportedNames = this.getExportedVariables(sourceFile);
+            if (exportedNames.length > 0) {
+                exportMap.set(sourceFile.getFilePath(), exportedNames);
+            }
+        }
+        return exportMap;
+    }
+    static getExportedVariables(sourceFile) {
+        const exportSymbols = [];
+        let exportKeywordNodes = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ExportKeyword);
+        exportKeywordNodes.forEach((node) => {
+            let parentNodeKind = node.getParent()?.getKind();
+            switch (parentNodeKind) {
+                case ts_morph_1.SyntaxKind.VariableStatement:
+                    let variableStatement = node.getParent()?.asKind(ts_morph_1.SyntaxKind.VariableStatement);
+                    let variableNames = variableStatement.getDeclarationList().getDeclarations().map((declaration) => {
+                        return declaration.getName();
+                    });
+                    exportSymbols.push(...variableNames);
+                    break;
+                case ts_morph_1.SyntaxKind.ClassDeclaration:
+                    let classDeclaration = node.getParent();
+                    let className = classDeclaration?.asKind(ts_morph_1.SyntaxKind.ClassDeclaration)?.getName();
+                    exportSymbols.push(className);
+                    break;
+            }
+        });
+        return exportSymbols;
+    }
 }
 exports.TsAstUtil = TsAstUtil;